Python HMAC

HMAC es un método popular de hashing de mensajes. Logra esto mediante el uso de una clave criptográfica secreta y una función de hash criptográfico. Se puede utilizar para garantizar la validez y la autenticidad de los datos. En lugar de confiar en una infraestructura de clave pública con certificados, nos permite calcular la autenticidad de los mensajes y la integridad utilizando una clave compartida entre dos partes.

El módulo HMAC en Python nos ofrece una implementación para este método. Utiliza la forma de un algoritmo de hash como una entrada, que es uno de los algoritmos mencionados en el módulo Hashlib de Python. Este artículo le mostrará cómo crear el código de autenticación de mensajes con el módulo HMAC de Python utilizando ejemplos simples.

Ejemplo 1:

Este es el primer ejemplo del artículo. El mensaje y la clave (marcado como "msgg" y key_val en nuestro código) se inicializan primero en el código de este ejemplo. Luego usa la clave y el algoritmo SHA1 para crear un código de autenticación de mensaje para el mensaje dado de tres maneras distintas.

Primero construimos una instancia de HMAC usando el método nuevo (), pasándolo por la clave y el mensaje y "SHA1" para el algoritmo de hashing.

El método nuevo () genera una instancia de HMAC con un mensaje inicial basado en bytes. Luego se puede usar para producir código para la autenticación de mensajes. Sin el mensaje inicial, solo podemos construir una instancia de HMAC. Pero requeriremos una llave y "DigestMod" para este propósito.

Se puede usar una llamada al método update () para agregar mensajes. La clave debe seguir un formato de byte. El parámetro DigestMod acepta nombres de algoritmos de hashing seguros del módulo Hashlib.

Luego se imprime el código de autenticación del mensaje. La instancia de HMAC se crea sin ningún mensaje inicial en la segunda mitad del código. Después de eso, el mensaje se agregará usando el método update (). El método update () agrega mensajes pasados ​​como entrada a un mensaje que ya existe. Podemos llamar a este método varias veces, y continuará acumulando mensajes.

Finalmente, calcula e imprime el resumen. El código en la tercera sección genera una instancia de HMAC sin mensaje inicial. El método Update () se usa para agregar mensajes en dos secciones. Finalmente, calcula e imprime el resumen. Finalmente, el código publica los tamaños de resumen y bloque para cada instancia de HMAC.

El método Digest () devuelve el código de autenticación del mensaje de los datos. El código está en formato bytes. El tamaño de salida está determinado por el algoritmo de hashing seguro de entrada. Si el algoritmo de hash utilizado en la entrada es SHA1, la salida será de 20 bytes. Para su comprensión del concepto, hemos adjuntado una imagen de todo el código a continuación.

Importar HMAC
msgg = "python es fácil."
key_val = "abcxyz"
hmac_one = hmac.nuevo (Key = Key_Val.encode (), msg = msgg.encode (), digestMod = "sha1")
Message_digest_one = hmac_one.digerir()
print (" - Mensaje Digest One: ".formato (HMAC_One.nombre, mensaje_digest_one))
HMAC_TWO = HMAC.nuevo (Key = Key_Val.encode (), digestMod = "sha1")
hmac_two.Actualización (bytes (msgg, encoding = "utf-8"))
Message_digest_two = hmac_two.digerir()
print (" - Mensaje Digest Two: ".Formato (HMAC_TWO.nombre, mensaje_digest_two))
hmac_three = hmac.nuevo (Key = Key_Val.encode (), digestMod = "sha1")
hmac_three.Update (bytes ("Programming Is", Encoding = "UTF-8"))
hmac_three.Update (bytes ("fácil y divertido", encoding = "utf-8"))
Message_digest_three = hmac_three.digerir()
print (" - Mensaje Digest Three: ".formato (HMAC_THREE.nombre, mensaje_digest_three))
print ("\ nmessage digest tamaño para 1: , 2: y 3: ".formato (HMAC_One.digest_size, hmac_two.digest_size, hmac_three.digest_size,))
imprimir ("Tamaño del bloque de mensajes para 1: , 2: y 3: ".formato (HMAC_One.block_size, hmac_two.block_size, hmac_three.tamaño de bloque,))

Aquí, el mensaje de autenticación y el tamaño del byte se muestran al ejecutar el código adjunto.

Ejemplo 2:

En nuestro segundo ejemplo, le mostraremos cómo construir códigos de autenticación de mensajes utilizando la técnica HMAC una vez más, pero esta vez con el algoritmo de hashing seguro SHA256. Nuestro código para esta sección es casi idéntico al de nuestro ejemplo anterior, con algunas pequeñas diferencias. Hace uso de la referencia de la Biblioteca Hashlib al algoritmo SHA256.

Importar HMAC
importar hashlib
msg_one = "Python es fácil de aprender."
key_one = "aabbccxxyyzz"
hmac_one = hmac.Nuevo (Key = Key_one.encode (), msg = msg_one.encode (), digestMod = hashlib.SHA256)
Message_digest_one = hmac_one.digerir()
print (" - Mensaje Digest One: ".formato (HMAC_One.nombre, mensaje_digest_one))
HMAC_TWO = HMAC.Nuevo (Key = Key_one.encode (), digestMod = hashlib.SHA256)
hmac_two.Update (bytes (msg_one, encoding = "utf-8"))
Message_digest_two = hmac_two.digerir()
print (" - Mensaje Digest Two: ".Formato (HMAC_TWO.nombre, mensaje_digest_two))
hmac_three = hmac.Nuevo (Key = Key_one.encode (), digestMod = hashlib.SHA256)
hmac_three.Actualización (bytes ("Learn", coding = "UTF-8"))
hmac_three.Update (bytes ("python", encoding = "utf-8"))
Message_digest_three = hmac_three.digerir()
print (" - Mensaje Digest Three: ".formato (HMAC_THREE.nombre, mensaje_digest_three))
print ("\ nmessage digest tamaño para 1: , 2: y 3: ".formato (HMAC_One.digest_size, hmac_two.digest_size, hmac_three.digest_size,))
imprimir ("Tamaño del bloque de mensajes para 1: , 2: y 3: ".formato (HMAC_One.block_size, hmac_two.block_size, hmac_three.tamaño de bloque,))

Aquí está el resultado en el que puede ver que hemos calculado el código de autenticación del mensaje utilizando el algoritmo HMAC y SHA256.

Ejemplo 3:

En nuestro tercer ejemplo, mostraremos cómo construir un código de autenticación de mensajes hexadecimales con la técnica HMAC y SHA256 como el backend. El código de este ejemplo es idéntico al anterior, con la excepción de que estamos utilizando la técnica hexdigest () para calcular el código de autenticación hexadecimal.

El método Hexdigest devuelve los datos como dígitos hexadecimales como código de autenticación de mensajes. Porque un byte puede hacer dos dígitos hexadecimales, este es el caso.

El tamaño de salida está determinado por el algoritmo de hashing seguro de entrada. Si se usa el algoritmo de hash de entrada SHA1, por ejemplo, el valor resultante será 40 dígitos hexadecimales.

Importar HMAC
importar hashlib
msg_one = "Todo sobre Python."
key_one = "aabbccxyz"
hmac_one = hmac.Nuevo (Key = Key_one.encode (), msg = msg_one.encode (), digestMod = hashlib.SHA512)
Message_digest_one = hmac_one.hexdigest ()
print (" - Hex Message Digest One: ".formato (HMAC_One.nombre, mensaje_digest_one))
HMAC_TWO = HMAC.Nuevo (Key = Key_one.encode (), digestMod = hashlib.SHA512)
hmac_two.Update (bytes (msg_one, encoding = "utf-8"))
Message_digest_two = hmac_two.hexdigest ()
print (" - Hex Message Digest Two: ".Formato (HMAC_TWO.nombre, mensaje_digest_two))
hmac_three = hmac.Nuevo (Key = Key_one.encode (), digestMod = hashlib.SHA512)
hmac_three.Actualización (bytes ("All About", Encoding = "UTF-8"))
hmac_three.Actualización (bytes ("Python Language.", encoding =" utf-8 "))
Message_digest_three = hmac_three.hexdigest ()
print (" - Hex Message Digest Three: ".formato (HMAC_THREE.nombre, mensaje_digest_three))
print ("\ nmessage digest tamaño para 1: , 2: y 3: ".formato (HMAC_One.digest_size, hmac_two.digest_size, hmac_three.digest_size,))
imprimir ("Tamaño del bloque de mensajes para 1: , 2: y 3: ".formato (HMAC_One.block_size, hmac_two.block_size, hmac_three.tamaño de bloque,))

A continuación se muestra la captura de pantalla de salida donde puede ver que se muestran los mensajes de autenticación y el tamaño de la digestión y el tamaño del bloque.

Ejemplo 4:

Demostramos cómo producir código de autenticación de mensajes sin establecer una instancia del HMAC utilizando el método Digest () del módulo HMAC. Digest (clave, msg, digest): toma como entrada una clave, un mensaje para codificar, y el algoritmo Digest genera un código de autenticación para el mensaje proporcionado.

Este código demuestra cómo usar el método Digest () para construir un código de autenticación de mensaje para un mensaje específico directamente desde la clave de entrada, en lugar de crear una instancia de HMAC como en el ejemplo anterior. Debido a que emplea una implementación de C optimizada para construir el resumen, este método es más rápido que usar HMAC para crear códigos de autenticación para pequeñas comunicaciones.

Importar HMAC
importar hashlib
msgg = "programación de python"
key_one = "ABCABCABC"
Message_digest_one = HMAC.Digest (Key = Key_one.encode (), msg = msgg.encode (), digest = "sha3_256")
imprimir ("Mensaje Digest One: ".Formato (Message_Digest_One))
Message_digest_two = HMAC.Digest (Key = Key_one.encode (), msg = bytes (msgg, encoding = "utf-8"), digest = hashlib.SHA3_256)
imprimir ("Mensaje Digest Two: ".Formato (Message_Digest_Two))

Aquí está el resultado en el que puede ver que el código de autenticación del mensaje se crea utilizando el digerir() método.

Conclusión:

HMAC es una técnica de autenticación de mensajes criptográfica basada en funciones. La técnica HMAC ampliamente utilizada se discute en detalle en esta publicación. La idea principal de este enfoque es utilizar una clave secreta compartida para combinar un hash criptográfico de los datos reales. Esto es para el único propósito de crear una clave secreta compartida. Hemos pasado por esta idea en profundidad y proporcionamos ejemplos para ayudarlo a comprenderla.