Python HMAC

HMAC é um método de hash de mensagem popular. Ele faz isso usando uma chave criptográfica secreta e uma função de hash criptográfica. Pode ser usado para garantir a validade e a autenticidade dos dados. Em vez de confiar em uma infraestrutura pública -chave com certificados, ele nos permite calcular a autenticidade e a integridade de mensagens utilizando uma chave compartilhada entre duas partes.

O módulo HMAC em Python nos oferece uma implementação para este método. Ele usa a forma de um algoritmo de hash como entrada, que é um dos algoritmos mencionados no módulo hashlib de Python. Este artigo mostrará como criar código de autenticação de mensagens com o módulo HMAC do Python usando exemplos simples.

Exemplo 1:

Este é o primeiro exemplo do artigo. A mensagem e a chave (marcadas como "msgg" e key_val em nosso código) são inicializadas no código deste exemplo. Em seguida, ele usa a chave e o algoritmo SHA1 para criar um código de autenticação de mensagem para a mensagem fornecida de três maneiras distintas.

Primeiro, construímos uma instância de HMAC usando o método novo (), passando bytes para a chave e mensagem e "sha1" para o algoritmo de hashing.

O método novo () gera uma instância de HMAC com uma mensagem inicial baseada em bytes. Então pode ser usado para produzir código para autenticação de mensagem. Sem a mensagem inicial, só podemos construir uma instância de HMAC. Mas precisaremos de uma chave e "DigestMod" para esse fim.

Uma chamada para o método update () pode ser usada para adicionar mensagens. A chave deve seguir um formato de byte. O parâmetro DigestMod aceita nomes de algoritmos seguros de hash do módulo Hashlib.

O código de autenticação da mensagem é então impresso. A instância do HMAC é criada sem qualquer mensagem inicial na segunda metade do código. Depois disso, a mensagem será adicionada usando o método update (). O método update () adiciona mensagens transmitidas como entrada para uma mensagem que já existe. Podemos chamar esse método várias vezes e continuará acumulando mensagens.

Finalmente, ele calcula e imprime o resumo. O código na terceira seção gera uma instância de HMAC sem mensagem inicial. O método update () é então usado para adicionar mensagens em duas seções. Finalmente, ele calcula e imprime o resumo. Finalmente, o código publica os tamanhos de digestão e bloco para cada instância do HMAC.

O método Digest () retorna o código de autenticação da mensagem dos dados. O código está em formato de bytes. O tamanho da saída é determinado pelo algoritmo de hash seguro de entrada. Se o algoritmo de hash usado na entrada for SHA1, a saída será de 20 bytes. Para sua compreensão do conceito, anexamos uma imagem de todo o código abaixo.

importar hmac
msgg = "python é fácil."
key_val = "abcxyz"
hmac_one = hmac.novo (key = key_val.code (), msg = msgg.code (), DigestMod = "SHA1")
message_digest_one = hmac_one.digerir()
print (" - Mensagem Digest One: ".formato (hmac_one.nome, message_digest_one))
hmac_two = hmac.novo (key = key_val.code (), DigestMod = "SHA1")
hmac_two.Update (bytes (msgg, coding = "utf-8")))
message_digest_two = hmac_two.digerir()
print (" - Mensagem Digest dois: ".formato (hmac_two.nome, message_digest_two))
hmac_three = hmac.novo (key = key_val.code (), DigestMod = "SHA1")
hmac_three.Update (bytes ("Programação is", coding = "utf-8")))
hmac_three.Update (Bytes ("Easy and Fun", Encoding = "UTF-8")))
message_digest_three = hmac_three.digerir()
print (" - Mensagem Digest Three: ".formato (hmac_three.nome, message_digest_three))
print ("\ nmessage Digest Tamanho para 1: , 2: e 3: ".formato (hmac_one.Digest_size, hmac_two.Digest_size, hmac_three.Digest_size,))
print ("Tamanho do bloco de mensagens para 1: , 2: e 3: ".formato (hmac_one.block_size, hmac_two.block_size, hmac_three.tamanho do bloco,))

Aqui, a mensagem de autenticação e o tamanho do byte são exibidos ao executar o código anexado.

Exemplo 2:

Em nosso segundo exemplo, mostraremos como construir códigos de autenticação de mensagens usando a técnica HMAC mais uma vez, mas desta vez com o algoritmo SHA256 Secure Hashing. Nosso código para esta seção é quase idêntico ao de nosso exemplo anterior, com algumas pequenas diferenças. Faz uso da referência da Biblioteca Hashlib ao algoritmo SHA256.

importar hmac
importar hashlib
msg_one = "Python é fácil de aprender."
key_one = "AABBCCXXYYZZ"
hmac_one = hmac.novo (key = key_one.code (), msg = msg_one.code (), digestmod = hashlib.sha256)
message_digest_one = hmac_one.digerir()
print (" - Mensagem Digest One: ".formato (hmac_one.nome, message_digest_one))
hmac_two = hmac.novo (key = key_one.code (), digestmod = hashlib.sha256)
hmac_two.Update (bytes (msg_one, coding = "utf-8")))
message_digest_two = hmac_two.digerir()
print (" - Mensagem Digest dois: ".formato (hmac_two.nome, message_digest_two))
hmac_three = hmac.novo (key = key_one.code (), digestmod = hashlib.sha256)
hmac_three.Update (Bytes ("Learn", Encoding = "UTF-8")))
hmac_three.Update (bytes ("python", coding = "utf-8")))
message_digest_three = hmac_three.digerir()
print (" - Mensagem Digest Three: ".formato (hmac_three.nome, message_digest_three))
print ("\ nmessage Digest Tamanho para 1: , 2: e 3: ".formato (hmac_one.Digest_size, hmac_two.Digest_size, hmac_three.Digest_size,))
print ("Tamanho do bloco de mensagens para 1: , 2: e 3: ".formato (hmac_one.block_size, hmac_two.block_size, hmac_three.tamanho do bloco,))

Aqui está o resultado em que você pode ver que calculamos o código de autenticação da mensagem usando o algoritmo HMAC e SHA256.

Exemplo 3:

Em nosso terceiro exemplo, mostraremos como construir um código de autenticação de mensagem hexadecimal com a técnica HMAC e SHA256 como o back -end. O código deste exemplo é idêntico ao anterior, com a exceção de que estamos usando a técnica HexDigest () para calcular o código de autenticação hexadecimal.

O método HexDigest retorna dados como dígitos hexadecimais como um código de autenticação de mensagem. Porque um byte pode fazer dois dígitos hexadecimais, este é o caso.

O tamanho da saída é determinado pelo algoritmo de hash seguro de entrada. Se o algoritmo de hash de entrada SHA1 for usado, por exemplo, o valor resultante será de 40 dígitos hexadecimais.

importar hmac
importar hashlib
msg_one = "tudo sobre python."
key_one = "AABBCCXYZ"
hmac_one = hmac.novo (key = key_one.code (), msg = msg_one.code (), digestmod = hashlib.sha512)
message_digest_one = hmac_one.hexdigest ()
print (" - mensagem hexágica Digest One: ".formato (hmac_one.nome, message_digest_one))
hmac_two = hmac.novo (key = key_one.code (), digestmod = hashlib.sha512)
hmac_two.Update (bytes (msg_one, coding = "utf-8")))
message_digest_two = hmac_two.hexdigest ()
print (" - Mensagem hexadecimal Digest Two: ".formato (hmac_two.nome, message_digest_two))
hmac_three = hmac.novo (key = key_one.code (), digestmod = hashlib.sha512)
hmac_three.Update (Bytes ("All About", Encoding = "UTF-8"))
hmac_three.atualização (bytes ("idioma python.", coding =" utf-8 "))))
message_digest_three = hmac_three.hexdigest ()
print (" - Mensagem hexadecimal Digest Twest: ".formato (hmac_three.nome, message_digest_three))
print ("\ nmessage Digest Tamanho para 1: , 2: e 3: ".formato (hmac_one.Digest_size, hmac_two.Digest_size, hmac_three.Digest_size,))
print ("Tamanho do bloco de mensagens para 1: , 2: e 3: ".formato (hmac_one.block_size, hmac_two.block_size, hmac_three.tamanho do bloco,))

Abaixo está a captura de tela de saída, onde você pode ver que as mensagens de autenticação e o tamanho do resumo e o tamanho do bloco são exibidos.

Exemplo 4:

Demonstramos como produzir código de autenticação de mensagem sem estabelecer uma instância do HMAC utilizando o método Digest () do módulo HMAC. Digest (key, msg, Digest) - É preciso como entrada uma chave, uma mensagem para codificar e o algoritmo Digest gera um código de autenticação para a mensagem fornecida.

Este código demonstra como usar o método Digest () para construir um código de autenticação de mensagem para uma mensagem específica diretamente da chave de entrada, em vez de criar uma instância de HMAC como no exemplo anterior. Por empregar uma implementação C otimizada para a construção do resumo, esse método é mais rápido do que usar o HMAC para criar códigos de autenticação para pequenas comunicações.

importar hmac
importar hashlib
msgg = "Programação Python"
key_one = "abcabcabc"
message_digest_one = hmac.Digest (key = key_one.code (), msg = msgg.code (), Digest = "SHA3_256")
print ("Mensagem Digest One: ".formato (message_digest_one))
message_digest_two = hmac.Digest (key = key_one.code (), msg = bytes (msgg, coding = "utf-8"), digest = hashlib.sha3_256)
print ("Mensagem Digest Two: ".formato (message_digest_two))

Aqui está o resultado em que você pode ver que o código de autenticação da mensagem é criado usando o digerir() método.

Conclusão:

HMAC é uma técnica de autenticação de mensagem baseada em função criptográfica de hash hash. A técnica HMAC amplamente usada é discutida em detalhes neste post. A principal idéia dessa abordagem é usar uma chave secreta compartilhada para combinar um hash criptográfico dos dados reais. Isto é com o único objetivo de criar uma chave secreta compartilhada. Passamos por essa ideia em profundidade e fornecemos exemplos para ajudá-lo a entender.