Olá Comunidade Dev!

Hoje vamos explorar um projeto muito interessante para quem está começando no mundo da programação: a criação de um comparador de hashes em Python, com interface gráfica usando a biblioteca Tkinter . Se você já ouviu falar sobre hashes e quer entender melhor como eles funcionam, ou está curioso para ver como criar uma interface simples para seus projetos, este artigo é para você!

O que são Hashes? 🤔

Antes de mais nada, vamos entender o que são hashes. Pense no hash como uma impressão digital de um arquivo. Assim como uma pessoa tem uma impressão digital única, um arquivo também pode ter uma “impressão” única, gerada a partir de seu conteúdo. Isso é muito útil para comparar arquivos, pois se as receitas (ou hashes) de dois arquivos forem diferentes, você sabe que esses arquivos também são diferentes.

Imagine que você tem dois presentes embrulhados. Você não pode ver o que tem dentro, mas se pesar ambos e perceber que um tem peso diferente do outro, você já sabe que eles não são iguais. O hash funciona mais ou menos assim: ele gera um "peso" (um código) baseado no conteúdo do arquivo. Se os pesos (hashes) forem diferentes, os arquivos também são!

Como funciona o Código?

Agora que entendemos a ideia básica por trás dos hashes, vamos ver como o nosso código funciona, dividido em algumas partes simples para ficar fácil de entender.

1. Seleção dos Arquivos

Primeiro, nosso código permite que você escolha dois arquivos para comparar. Imagine que você tem dois arquivos de texto e quer saber se eles são exatamente iguais. Para isso, você pode usar os botões para selecionar os arquivos no seu computador.

def selecionar_primeiro_arquivo():
  global primeiro_arquivo
  primeiro_arquivo = filedialog.askopenfilename()
  if primeiro_arquivo:
      nome_primeiro_arquivo.set(os.path.basename(primeiro_arquivo))

def selecionar_segundo_arquivo():
  global segundo_arquivo
  segundo_arquivo = filedialog.askopenfilename()
  if segundo_arquivo:
      nome_segundo_arquivo.set(os.path.basename(segundo_arquivo))

Aqui, temos duas funções para abrir uma janela e deixar você escolher o primeiro arquivo e o segundo arquivo . Assim que você selecionar, o código captura o caminho do arquivo e exibe o nome dele na interface.

2. Comparação dos Arquivos 🔍

Depois de escolher os arquivos, o próximo passo é comparar seus hashes. Lembra da analogia da impressão digital? É aqui que isso acontece. Vamos calcular o hash de cada arquivo e verificar se eles são iguais ou diferentes.

def comparar_hashes():
  if not primeiro_arquivo or not segundo_arquivo:
      resultado_texto.insert(tk.END, "Selecione ambos os arquivos.\n")
      return

  hash1 = hashlib.new("ripemd160")
  hash1.update(open(primeiro_arquivo, "rb").read())

  hash2 = hashlib.new("ripemd160")
  hash2.update(open(segundo_arquivo, "rb").read())

  nome1 = os.path.basename(primeiro_arquivo)
  nome2 = os.path.basename(segundo_arquivo)

  if hash1.digest() != hash2.digest():
      resultado_texto.insert(tk.END, f"O arquivo {nome1} é diferente do arquivo {nome2}.\n")
      resultado_texto.insert(tk.END, f"O Hash do {nome1} é: {hash1.hexdigest()}\n")
      resultado_texto.insert(tk.END, f"O Hash do {nome2} é: {hash2.hexdigest()}\n")
  else:
      resultado_texto.insert(tk.END, f"O arquivo {nome1} é igual ao arquivo {nome2}.\n")
      resultado_texto.insert(tk.END, f"O Hash do {nome1} é: {hash1.hexdigest()}\n")
      resultado_texto.insert(tk.END, f"O Hash do {nome2} é: {hash2.hexdigest()}\n")

Aqui, o código usa a função hashlib.new("ripemd160") para calcular o hash de cada arquivo. A função update() lê o conteúdo do arquivo e cria um hash exclusivo para ele. Depois, comparamos os dois hashes para ver se são iguais ou diferentes.

Se os hashes forem diferentes, quero dizer que os arquivos não são iguais . Se os hashes são iguais, então os arquivos também são. É bem simples: hash igual, arquivos iguais; hash diferente, arquivos diferentes .

3. A Interface Gráfica 🎨

Agora vamos falar sobre a parte visual do nosso programa. Usamos a biblioteca Tkinter para criar uma interface gráfica onde você pode selecionar os arquivos e ver os resultados.

# Inicialização da interface
root = tk.Tk()
root.title("Comparador de Hashes - CGS")
root.configure(bg="darkgreen")

# Botões e labels
tk.Label(root, text="Primeiro Arquivo:", bg="darkgreen", fg="white").pack(pady=5)
tk.Entry(root, textvariable=nome_primeiro_arquivo, state="readonly", bg="lightgreen").pack(pady=5)
tk.Button(root, text="Selecionar Primeiro Arquivo", command=selecionar_primeiro_arquivo, bg="green", fg="white").pack(pady=5)

tk.Label(root, text="Segundo Arquivo:", bg="darkgreen", fg="white").pack(pady=5)
tk.Entry(root, textvariable=nome_segundo_arquivo, state="readonly", bg="lightgreen").pack(pady=5)
tk.Button(root, text="Selecionar Segundo Arquivo", command=selecionar_segundo_arquivo, bg="green", fg="white").pack(pady=5)

tk.Button(root, text="Comparar Hashes", command=comparar_hashes, bg="green", fg="white").pack(pady=10)

# Campo de texto para os resultados
resultado_texto = scrolledtext.ScrolledText(root, wrap=tk.WORD, width=50, height=10, bg="lightgreen")
resultado_texto.pack(pady=10)

root.mainloop()

Este trecho de código cria uma janela onde você pode interagir com o programa. Aqui estão os elementos principais:

• Tags : Exibem o texto "Primeiro Arquivo" e "Segundo Arquivo".
• Entradas de Texto : Mostramos os nomes dos arquivos que você selecionou.
• Botões : Para selecionar os arquivos e iniciar a comparação.
• Campo de Resultados : Onde o programa exibe o resultado da comparação dos hashes.

Tudo isso acontece dentro de uma janela que fica aberta até você fechá-la. Este é o Tkinter em ação, uma ferramenta poderosa para criar interfaces simples de maneira rápida.

Conclusão 🎯

Neste projeto, mostro de forma facil como criar um comparador de arquivos, usando a ideia de hashes e uma interface gráfica em Python. O código é simples, mas poderoso, pois usa conceitos importantes de criptografia para verificar a integridade dos arquivos. Além disso, uma interface gráfica facilita a utilização do programa, tornando-o acessível até para quem não tem tanta experiência em programação.

Para quem está começando, é uma ótima oportunidade de entender o que são hashes e como podemos usá-los no dia a dia. E como bônus, você já deu seus primeiros passos na criação de interfaces gráficas com Tkinter!

Segue o link do meu GitHub contendo o respositório com este código, assim como um arquivo executável desta aplicação, caso deseje utilizar em seu dia a dia: https://github.com/Carlos-CGS/ProjetosPython/tree/main/Hashes%20Comparador

Espero que este artigo tenha ajudado a desmistificar o uso de hashes e a criar soluções práticas com Python. Agora, mãos à obra e vamos explorar ainda mais o potencial que o Python oferece! 🚀

"Vamos Disseminar os Conhecimentos e Transbordar Tudo o que Aprendemos!"

Segue lá no LinkedIn: https://www.linkedin.com/in/carlos-cgs/

Segue lá no GitHub: https://github.com/Carlos-CGS