Implementación de HMAC en Python

Tabla de contenidos

HMAC (RFC 2104) se ha implementado en Python. Se utilizó la biblioteca SHA-256 para la función hash.

Resumen de HMAC

HMAC es una técnica criptográfica utilizada para generar un Código de Autenticación de Mensaje (MAC) para la autenticación del remitente y la detección de manipulación del mensaje. HMAC combina una función hash con una clave secreta para producir el MAC.

HMAC tiene las siguientes características:

Genera el MAC dependiendo tanto de la clave secreta como del mensaje, por lo que alguien que no conozca la clave secreta no puede calcular el mismo MAC. Esto permite la autenticación del remitente.
Al aplicar la función hash dos veces, reduce significativamente la probabilidad de que el MAC coincida incluso si se cambia una parte del mensaje. Esto mejora la capacidad de detectar la manipulación del mensaje.
HMAC puede utilizar cualquier función hash. Por ejemplo, se pueden aplicar funciones hash como SHA-256 o MD5 a HMAC.
HMAC es una técnica criptográfica irreversible.

Explicación del Procedimiento

Los procedimientos se describen detalladamente en RFC 2104.

Lo necesario para HMAC es la función hash H y la clave secreta K.

Vamos a denotar la longitud del bloque de la función hash H como B bytes y la longitud de salida como L bytes. Para la función hash H = SHA-256, B = 64, L = 32.

Aunque se menciona que K es una clave secreta, no es necesario que sea la clave privada en la criptografía de clave pública. Solo necesita ser una cadena secreta desconocida para otros. RFC 2104 especifica que la longitud de K debe ser al menos la longitud de salida de la función hash. Dado que K realiza operaciones bit a bit con el valor hash, si es más corto que el valor hash, debe rellenarse con el valor especificado para evitar que sea adivinado fácilmente.

El flujo del cálculo de HMAC es el siguiente:

Si la clave secreta K es más larga que la longitud del bloque B de la función hash, convierta K en un valor hash de L bytes utilizando la función hash. Utilice el valor hash generado como la clave secreta K para HMAC.
Si la clave secreta K es más corta que la longitud del bloque B de la función hash, agregue ceros (0x00) al final de K para que tenga en total B bytes.
Calcule el XOR del resultado anterior y el valor repetido B veces (ipad = b'\x36' * B). Esto es una operación bit a bit.
Agregue el mensaje encriptado (arreglo de bits) al resultado anterior.
Convierta el resultado anterior en un valor hash utilizando la función hash H.
Calcule el XOR de la clave secreta y el valor repetido B veces (opad = b'\x5c' * B). Esto es una operación bit a bit.
Agregue el valor hash calculado al XOR obtenido anteriormente.
Convierta el resultado anterior en un valor hash utilizando la función hash H.

Programa

Y aquí está el HMAC (SHA-256) implementado en Python:

Entorno

Python 3.10.13

Código

# HMAC with SHA-256
def sha256(message):
# Implementación de SHA-256
import hashlib
return hashlib.sha256(message).digest()
def xor(a, b):
# XOR de dos cadenas de bytes
return bytes([x ^ y for x, y in zip(a, b)])
def hmac_sha256(key, message):
"""
Implementación de HMAC-SHA256
>>> text = b"Hi There"
>>> key = b'\x0b' * 20
>>> a = hmac_sha256(key, text).hex()
>>> import hmac
>>> b = hmac.new(key, text.encode('ascii'), hashlib.sha256).digest().hex()
>>> a == b
True
>>> text = b"Hello" * 100
>>> key = b'1234567890' * 100
>>> a = hmac_sha256(key, text).hex()
>>> import hmac
>>> b = hmac.new(key, text.encode('ascii'), hashlib.sha256).digest().hex()
>>> a == b
True
:param key:
:param message:
:return:
"""
if len(key) > 64:
key = sha256(key)
if len(key) < 64:
key = key + b'\x00' * (64 - len(key))
o_key_pad = xor(b'\x5c' * 64, key)
i_key_pad = xor(b'\x36' * 64, key)
return sha256(o_key_pad + sha256(i_key_pad + message))
if __name__ == '__main__':
import hmac
import hashlib

# HMAC with SHA-256

def sha256(message):

# Implementación de SHA-256

import hashlib

return hashlib.sha256(message).digest()

def xor(a, b):

# XOR de dos cadenas de bytes

return bytes([x ^ y for x, y in zip(a, b)])

def hmac_sha256(key, message):

"""

Implementación de HMAC-SHA256

>>> text = b"Hi There"

>>> key = b'\x0b' * 20

>>> a = hmac_sha256(key, text).hex()

>>> import hmac

>>> b = hmac.new(key, text.encode('ascii'), hashlib.sha256).digest().hex()

>>> a == b

True

>>> text = b"Hello" * 100

>>> key = b'1234567890' * 100

>>> a = hmac_sha256(key, text).hex()

>>> import hmac

>>> b = hmac.new(key, text.encode('ascii'), hashlib.sha256).digest().hex()

>>> a == b

True

:param key:

:param message:

:return:

"""

if len(key) > 64:

key = sha256(key)

if len(key) < 64:

key = key + b'\x00' * (64 - len(key))

o_key_pad = xor(b'\x5c' * 64, key)

i_key_pad = xor(b'\x36' * 64, key)

return sha256(o_key_pad + sha256(i_key_pad + message))

if __name__ == '__main__':

import hmac

import hashlib

Métodos Alternativos para la Generación de MAC Además de HMAC

Además de HMAC, hay otros métodos para generar un MAC utilizando la función hash Keccak llamada KMAC y utilizando cualquier cifrado de bloques llamado CMAC.

The Life