Autenticação de Mensagens com HMAC em Criptografia

Introdução

No mundo da comunicação digital, é crucial garantir que as mensagens não sejam apenas mantidas em privado, mas também que não tenham sido adulteradas durante a transmissão (integridade) e que realmente venham do remetente alegado (autenticidade). Embora funções hash simples possam verificar a corrupção acidental de dados, elas não conseguem impedir a adulteração maliciosa, pois qualquer pessoa pode recalcular o hash de uma mensagem modificada.

É aqui que entra o HMAC (Hash-based Message Authentication Code - Código de Autenticação de Mensagem baseado em Hash). O HMAC é um tipo específico de MAC (Message Authentication Code) que combina uma função hash criptográfica (como SHA-256) com uma chave secreta. Apenas as partes que possuem a chave secreta podem gerar e verificar o HMAC para uma determinada mensagem. Este processo fornece tanto a integridade dos dados quanto a autenticidade.

Neste laboratório, você terá experiência prática com HMAC. Você começará entendendo o conceito e, em seguida, usará a poderosa ferramenta de linha de comando openssl para gerar chaves e calcular HMACs. Finalmente, você verá como implementar o HMAC em um script Python, uma tarefa comum no desenvolvimento de aplicações.

Introdução ao HMAC

Nesta etapa, abordaremos o conceito fundamental de HMAC e por que ele é essencial para a comunicação segura.

Uma função hash padrão, como a SHA-256, recebe uma mensagem de entrada e produz uma sequência de caracteres de tamanho fixo, conhecida como hash ou digest. Se mesmo um único bit da mensagem for alterado, o hash resultante será completamente diferente. Isso é ótimo para verificar a integridade dos dados. No entanto, não fornece autenticidade. Se um invasor interceptar e modificar uma mensagem, ele pode simplesmente calcular um novo hash para a mensagem adulterada e enviá-la junto. O receptor não teria como saber que a mensagem foi alterada.

O HMAC resolve esse problema introduzindo uma chave simétrica secreta no processo de hashing. Uma chave simétrica é uma informação secreta compartilhada apenas entre o remetente e o destinatário pretendido.

O processo HMAC funciona aproximadamente da seguinte forma:

1. O remetente combina a chave secreta com a mensagem.
2. Uma função hash (por exemplo, SHA-256) é aplicada a essa combinação.
3. O hash resultante, agora chamado de HMAC, é enviado junto com a mensagem original.

Quando o receptor recebe a mensagem e o HMAC, ele realiza o mesmo cálculo usando sua cópia da chave secreta.

• Se o HMAC calculado corresponder ao HMAC recebido, o receptor sabe que a mensagem não foi alterada (integridade) e que ela veio de alguém que possui a chave secreta (autenticidade).
• Se os HMACs não corresponderem, a mensagem é considerada comprometida e deve ser descartada.

Esta etapa é puramente conceitual. Nas etapas seguintes, você colocará essa teoria em prática.

Gerar Chave Secreta HMAC

Nesta etapa, você gerará uma chave secreta aleatória e segura, que é a base da segurança do HMAC. Uma chave previsível permitiria a um invasor forjar HMACs. Usaremos a ferramenta openssl, um utilitário de linha de comando de criptografia versátil.

Usaremos o comando openssl rand para gerar dados aleatórios.

• -hex: Esta opção instrui o openssl a exibir os dados aleatórios como uma string hexadecimal.
• 32: Isso especifica o número de bytes aleatórios a serem gerados. 32 bytes são equivalentes a 256 bits, que é um comprimento de chave forte e comumente usado, especialmente quando emparelhado com o algoritmo hash SHA-256.

Para facilitar o uso da chave nos comandos subsequentes, a geraremos e a armazenaremos em uma variável de ambiente chamada HMAC_KEY. Execute o seguinte comando no seu terminal:

export HMAC_KEY=$(openssl rand -hex 32)

Este comando executa openssl rand -hex 32, e sua saída (a chave hex) é capturada e atribuída à variável HMAC_KEY.

Você pode visualizar a chave que acabou de gerar usando o comando echo:

echo $HMAC_KEY

Você deverá ver uma longa sequência de caracteres hexadecimais. Sua chave será única.

0db348c78473ce8460416f875cd87239d0f5f66fbe5103ba4b5c84cf2cd76914

Agora que você tem uma chave secreta, está pronto para criar um HMAC.

Calcular HMAC-SHA256

Nesta etapa, você calculará um HMAC para uma mensagem de exemplo usando a chave que gerou. Primeiro, vamos criar um arquivo contendo nossa mensagem.

Usaremos o comando echo para criar um arquivo chamado message.txt. O flag -n é importante, pois impede que o echo adicione um caractere de nova linha ao final da string, o que alteraria o conteúdo e, consequentemente, o HMAC final.

echo -n "This is a secret message." > message.txt

Agora, com a mensagem e a chave, podemos calcular o HMAC. Usaremos o comando openssl dgst, que é usado para calcular digests de mensagens (hashes).

• -sha256: Especifica que queremos usar o algoritmo hash SHA-256.
• -mac hmac: Especifica que queremos calcular um Código de Autenticação de Mensagem (Message Authentication Code - MAC) usando o método HMAC.
• -macopt hexkey:$HMAC_KEY: Isso fornece as opções para o algoritmo MAC. Aqui, especificamos que nossa chave está em formato hexadecimal (hexkey) e passamos a própria chave usando a variável de ambiente $HMAC_KEY que criamos anteriormente.
• message.txt: O arquivo de entrada contendo os dados a serem autenticados.

Execute o seguinte comando para gerar o HMAC:

openssl dgst -sha256 -mac hmac -macopt hexkey:$HMAC_KEY message.txt

A saída será o digest HMAC para sua mensagem, calculado com sua chave secreta. O formato da saída mostrará o algoritmo usado e o valor HMAC resultante.

HMAC-SHA2-256(message.txt)= 214fbb56f716dfe1c2f4a60615a5b901b263fd74c9678b2aef4f01779b34dea8

Este valor HMAC é o que você enviaria junto com sua mensagem para um destinatário que também possui a chave secreta.

Verificar Integridade do HMAC

Nesta etapa, você verá o processo de verificação do HMAC em ação. Você observará como o uso da chave correta é bem-sucedido, enquanto o uso de uma chave incorreta ou uma mensagem modificada resulta em falha.

Verificação com a Chave Correta

A verificação não é um comando especial; é simplesmente o ato do receptor recalcular o HMAC por conta própria e compará-lo com o que recebeu. Se você executar novamente o comando da etapa anterior, obterá exatamente o mesmo valor de HMAC. Isso confirma que, desde que a chave e a mensagem não sejam alteradas, o HMAC é consistente.

Observando a Falha com uma Chave Incorreta

Agora, vamos simular um invasor ou uma configuração incorreta tentando verificar a mensagem com uma chave diferente. Primeiro, gere uma nova chave, "incorreta":

export WRONG_KEY=$(openssl rand -hex 32)

Agora, tente calcular o HMAC para o message.txt original, mas usando esta WRONG_KEY:

openssl dgst -sha256 -mac hmac -macopt hexkey:$WRONG_KEY message.txt

Você verá um novo valor de HMAC na saída:

HMAC-SHA2-256(message.txt)= 781729497e89f3f9cb1d8c7ab632e22753062ac39cd64de0e5b81a45de245d78

Note que este HMAC é completamente diferente daquele que você gerou com a $HMAC_KEY correta. Isso demonstra que, sem a chave secreta correta, não é possível produzir um HMAC válido para a mensagem, garantindo assim a autenticidade.

Observando a Falha com uma Mensagem Modificada

Vamos também ver o que acontece se a própria mensagem for adulterada. Modificaremos ligeiramente o message.txt:

echo -n "This is a tampered message." > message.txt

Agora, calcule o HMAC novamente usando a chave original e correta ($HMAC_KEY):

openssl dgst -sha256 -mac hmac -macopt hexkey:$HMAC_KEY message.txt

Novamente, você obterá um valor de HMAC completamente diferente. Isso prova que qualquer modificação na mensagem, por menor que seja, será detectada, garantindo assim a integridade.

Implementar HMAC em Python

Nesta etapa, você aprenderá a realizar operações de HMAC programaticamente usando Python. Este é um requisito comum em aplicações web, APIs e outro software que precisa garantir a segurança das mensagens. A biblioteca padrão do Python fornece os módulos hmac e hashlib para este propósito.

Escreveremos um script Python simples para calcular o HMAC-SHA256 de uma mensagem. Primeiro, abra o arquivo hmac_example.py usando o editor de texto nano:

nano hmac_example.py

Agora, copie e cole o seguinte código Python no editor nano. Este código importa as bibliotecas necessárias, define uma chave e uma mensagem, e então calcula e imprime o HMAC.

Nota: Para este exemplo, estamos codificando a chave e a mensagem (hardcoding). Em uma aplicação real, a chave seria armazenada e gerenciada de forma segura. Tanto a chave quanto a mensagem devem ser byte strings (sequências de bytes), por isso as prefixamos com b.

import hmac
import hashlib

## A chave secreta (deve ser bytes)
## Em uma aplicação real, obtenha isso de um local seguro
key = b'\x0d\xb3\x48\xc7\x84\x73\xce\x84\x60\x41\x6f\x87\x5c\xd8\x72\x39\xd0\xf5\xf6\x6f\xbe\x51\x03\xba\x4b\x5c\x84\xcf\x2c\xd7\x69\x14'

## A mensagem a ser autenticada (deve ser bytes)
message = b'This is a secret message.'

## 1. Criar um novo objeto HMAC
##    - Passar a chave
##    - Passar a mensagem
##    - Especificar o algoritmo hash (de hashlib)
h = hmac.new(key, message, hashlib.sha256)

## 2. Obter o digest em formato hexadecimal
hex_digest = h.hexdigest()

print("HMAC Digest:")
print(hex_digest)

Após colar o código, salve o arquivo e saia do nano pressionando Ctrl+O, depois Enter para confirmar o nome do arquivo, e finalmente Ctrl+X para sair.

Agora, execute seu script Python no terminal:

python3 hmac_example.py

O script será executado e imprimirá o digest HMAC calculado.

HMAC Digest:
214fbb56f716dfe1c2f4a60615a5b901b263fd74c9678b2aef4f01779b34dea8

Você implementou com sucesso a geração de HMAC em Python, uma habilidade diretamente aplicável na construção de software seguro.

Resumo

Neste laboratório, você adquiriu experiência prática com Códigos de Autenticação de Mensagem Baseados em Hash (HMAC - Hash-based Message Authentication Codes), um pilar da criptografia moderna para garantir a integridade e a autenticidade dos dados.

Você aprendeu que:

• O HMAC combina uma função de hash criptográfica com uma chave secreta para criar um código de autenticação de mensagem.
• Apenas as partes que possuem a chave secreta podem gerar ou verificar o HMAC, prevenindo modificações não autorizadas e falsificações.
• A ferramenta de linha de comando openssl é um utilitário poderoso para realizar operações criptográficas, incluindo a geração de chaves aleatórias (openssl rand) e o cálculo de HMACs (openssl dgst).
• Qualquer alteração na mensagem ou o uso de uma chave incorreta resultará em um HMAC completamente diferente, tornando a adulteração facilmente detectável.
• O Python fornece as bibliotecas hmac e hashlib para integrar facilmente a funcionalidade de HMAC em suas aplicações.

Ao dominar o HMAC, você deu um passo importante para construir sistemas mais seguros e confiáveis.