Python hmac

HMAC est une méthode de hachage de message populaire. Il accomplit cela en utilisant une clé cryptographique secrète et une fonction de hachage cryptographique. Il peut être utilisé pour assurer la validité et l'authenticité des données. Au lieu de compter sur une infrastructure de clé publique avec des certificats, il nous permet de calculer l'authenticité et l'intégrité des messages en utilisant une clé partagée entre deux parties.

Le module HMAC dans Python nous offre une implémentation pour cette méthode. Il utilise la forme d'un algorithme de hachage comme entrée, qui est l'un des algorithmes mentionnés dans le module Hashlib de Python. Cet article vous montrera comment créer un code d'authentification des messages avec le module HMAC de Python en utilisant des exemples simples.

Exemple 1:

Ceci est le premier exemple de l'article. Le message et la clé (marqués comme «msgg» et key_val dans notre code) sont d'abord initialisés dans le code de cet exemple. Il utilise ensuite la clé et l'algorithme SHA1 pour créer un code d'authentification de message pour le message donné de trois manières distinctes.

Nous construisons d'abord une instance de HMAC en utilisant la méthode nouvelle (), en le faisant passer pour la clé et le message et «Sha1» pour l'algorithme de hachage.

La méthode nouvelle () génère une instance de HMAC avec un message initial basé sur les octets. Il peut ensuite être utilisé pour produire du code pour l'authentification des messages. Sans le message de départ, nous ne pouvons créer qu'une instance de HMAC. Mais nous aurons besoin d'une clé et «digestmod» à cet effet.

Un appel à la méthode Update () peut être utilisé pour ajouter des messages. La clé doit suivre un format d'octet. Le paramètre Digestmod accepte les noms des algorithmes de hachage sécurisés du module Hashlib.

Le code d'authentification du message est ensuite imprimé. L'instance HMAC est créée sans aucun message de départ dans la seconde moitié du code. Après cela, le message sera ajouté en utilisant la méthode Update (). La méthode Update () ajoute des messages transmis en entrée à un message qui existe déjà. Nous pouvons appeler cette méthode plusieurs fois, et il continuera à accumuler des messages.

Enfin, il calcule et imprime le digest. Le code de la troisième section génère une instance de HMAC sans message initial. La méthode Update () est ensuite utilisée pour ajouter des messages en deux sections. Enfin, il calcule et imprime le digest. Enfin, le code publie les tailles de digest et de blocs pour chaque instance HMAC.

La méthode digest () renvoie le code d'authentification du message des données. Le code est au format octets. La taille de sortie est déterminée par l'algorithme de hachage sécurisé d'entrée. Si l'algorithme de hachage utilisé dans l'entrée est SHA1, la sortie sera de 20 octets. Pour votre compréhension du concept, nous avons joint une image de l'ensemble du code ci-dessous.

Importer HMAC
msgg = "python est facile."
key_val = "abcxyz"
hmac_one = hmac.new (key = key_val.Encode (), msg = msgg.encode (), digestmod = "sha1")
message_digest_one = hmac_one.digérer()
print (" - Message Digest One: ".format (hmac_one.nom, message_digest_one))
hmac_two = hmac.new (key = key_val.encode (), digestmod = "sha1")
hmac_two.Mise à jour (bytes (msgg, coding = "utf-8"))
message_digest_two = hmac_two.digérer()
print (" - Message Digest Two: ".format (hmac_two.nom, message_digest_two))
HMAC_THREE = HMAC.new (key = key_val.encode (), digestmod = "sha1")
hmac_ trois.Mise à jour (Bytes ("Programmation IS", Encoding = "UTF-8"))
hmac_ trois.Mise à jour (octets ("Easy and Fun", Encoding = "UTF-8"))
Message_digest_ trois = hmac_ trois.digérer()
print (" - Message Digest Three: ".format (hmac_ trois.nom, message_digest_ trois)))
print ("\ nMessage Digest Taille pour 1: , 2: et 3: ".format (hmac_one.digest_size, hmac_two.digest_size, hmac_ trois.digest_size,))
print ("Taille du bloc de message pour 1: , 2: et 3: ".format (hmac_one.block_size, hmac_two.block_size, hmac_three.taille de bloc,))

Ici, le message d'authentification et la taille de l'octet sont affichés lors de l'exécution du code joint.

Exemple 2:

Dans notre deuxième exemple, nous vous montrerons comment construire des codes d'authentification des messages à l'aide de la technique HMAC une fois de plus, mais cette fois avec l'algorithme de hachage SCHA256. Notre code pour cette section est presque identique à celui de notre exemple précédent, avec quelques petites différences. Il utilise la référence de la bibliothèque Hashlib à l'algorithme SHA256.

Importer HMAC
Importer un hashlib
msg_one = "python est facile à apprendre."
key_one = "aabbccxxyyzz"
hmac_one = hmac.new (key = key_one.encode (), msg = msg_one.encode (), digestmod = hashlib.sha256)
message_digest_one = hmac_one.digérer()
print (" - Message Digest One: ".format (hmac_one.nom, message_digest_one))
hmac_two = hmac.new (key = key_one.encode (), digestmod = hashlib.sha256)
hmac_two.Mise à jour (bytes (msg_one, coding = "utf-8"))
message_digest_two = hmac_two.digérer()
print (" - Message Digest Two: ".format (hmac_two.nom, message_digest_two))
HMAC_THREE = HMAC.new (key = key_one.encode (), digestmod = hashlib.sha256)
hmac_ trois.Mise à jour (Bytes ("Learn", Encoding = "UTF-8"))
hmac_ trois.Mise à jour (Bytes ("Python", Encoding = "UTF-8"))
Message_digest_ trois = hmac_ trois.digérer()
print (" - Message Digest Three: ".format (hmac_ trois.nom, message_digest_ trois)))
print ("\ nMessage Digest Taille pour 1: , 2: et 3: ".format (hmac_one.digest_size, hmac_two.digest_size, hmac_ trois.digest_size,))
print ("Taille du bloc de message pour 1: , 2: et 3: ".format (hmac_one.block_size, hmac_two.block_size, hmac_three.taille de bloc,))

Voici le résultat où vous pouvez voir que nous avons calculé le code d'authentification du message en utilisant l'algorithme HMAC et SHA256.

Exemple 3:

Dans notre troisième exemple, nous montrerons comment construire un code d'authentification de message hexadécimal avec la technique HMAC et le SHA256 comme backend. Le code de cet exemple est identique à la précédente, à l'exception que nous utilisons la technique hexdigest () pour calculer le code d'authentification hexadécimal.

La méthode hexdigest renvoie les données sous forme de chiffres hexadécimaux comme code d'authentification de message. Parce qu'un octet peut faire deux chiffres hexadécimaux, c'est le cas.

La taille de sortie est déterminée par l'algorithme de hachage sécurisé d'entrée. Si l'algorithme de hachage d'entrée SHA1 est utilisé, par exemple, la valeur résultante sera de 40 chiffres hexadécimaux.

Importer HMAC
Importer un hashlib
msg_one = "tout sur Python."
key_one = "aabbccxyz"
hmac_one = hmac.new (key = key_one.encode (), msg = msg_one.encode (), digestmod = hashlib.sha512)
message_digest_one = hmac_one.hexdigest ()
print (" - Hex Message Digest One: ".format (hmac_one.nom, message_digest_one))
hmac_two = hmac.new (key = key_one.encode (), digestmod = hashlib.sha512)
hmac_two.Mise à jour (bytes (msg_one, coding = "utf-8"))
message_digest_two = hmac_two.hexdigest ()
print (" - Message hex mobilière digest deux: ".format (hmac_two.nom, message_digest_two))
HMAC_THREE = HMAC.new (key = key_one.encode (), digestmod = hashlib.sha512)
hmac_ trois.Mise à jour (Bytes ("All About", Encoding = "UTF-8"))
hmac_ trois.Mise à jour (Bytes ("Langue Python.", encoding =" utf-8 "))
Message_digest_ trois = hmac_ trois.hexdigest ()
print (" - Hex Message Digest Three: ".format (hmac_ trois.nom, message_digest_ trois)))
print ("\ nMessage Digest Taille pour 1: , 2: et 3: ".format (hmac_one.digest_size, hmac_two.digest_size, hmac_ trois.digest_size,))
print ("Taille du bloc de message pour 1: , 2: et 3: ".format (hmac_one.block_size, hmac_two.block_size, hmac_three.taille de bloc,))

Vous trouverez ci-dessous la capture d'écran de sortie où vous pouvez voir que les messages d'authentification et la taille de la digestion et la taille du bloc sont affichés.

Exemple 4:

Nous démontrons comment produire du code d'authentification des messages sans établir une instance du HMAC en utilisant la méthode digest () du module HMAC. Digest (clé, msg, digest) - il faut comme entrée une clé, un message à encoder et l'algorithme de digest génére un code d'authentification pour le message fourni.

Ce code montre comment utiliser la méthode digest () pour construire un code d'authentification de message pour un message spécifique directement à partir de la touche d'entrée, plutôt que de créer une instance de HMAC comme dans l'exemple précédent. Parce qu'il utilise une implémentation C optimisée pour construire le digest, cette méthode est plus rapide que d'utiliser HMAC pour créer des codes d'authentification pour les communications minuscules.

Importer HMAC
Importer un hashlib
MSGG = "Programmation Python"
key_one = "abcabcabc"
message_digest_one = hmac.digest (key = key_one.Encode (), msg = msgg.encode (), digest = "sha3_256")
print ("Message Digest One: ".format (message_digest_one))
message_digest_two = hmac.digest (key = key_one.Encode (), msg = bytes (msgg, coding = "utf-8"), digest = hashlib.sha3_256)
print ("Message Digest Two: ".format (message_digest_two))

Voici le résultat dans lequel vous pouvez voir que le code d'authentification du message est créé en utilisant le digérer() méthode.

Conclusion:

HMAC est une technique d'authentification de message basée sur la fonction du hachage cryptographique. La technique HMAC largement utilisée est discutée en détail dans ce post. L'idée principale de cette approche est d'utiliser une clé secrète partagée pour combiner un hachage cryptographique des données réelles. C'est dans le seul but de créer une clé secrète partagée. Nous avons vécu cette idée en profondeur et avons fourni des exemples pour vous aider à le comprendre.