HMAC

Em criptografia, HMAC (Hash-based Message Authentication Code) é uma construção específica para calcular o código de autenticação de mensagem (MAC) envolvendo uma função hash criptográfica em combinação com uma chave secreta. Da mesma forma que em qualquer MAC, este pode ser usado para simultaneamente verificar tanto a integridade como a autenticidade de uma mensagem. Qualquer função hash criptográfica, tal como MD5 ou SHA-1, pode ser usada no cálculo do HMAC; o algoritmo MAC resultante é denominado HMAC-MD5 ou HMAC-SHA1 em conformidade. A força criptográfica do HMAC depende da força da criptográfica da função hash subjacente, do tamanho do hash produzido como saída em bits, e do tamanho e da qualidade da chave criptográfica.

Uma função hash iterativa quebra uma mensagem em blocos de tamanho fixo e realiza uma iteração sobre eles com uma função de compressão. Por exemplo, MD5 e SHA-1 operam em blocos de 512 bits. O tamanho da saída do HMAC é o mesmo que o da função hash subjacente (128 ou 160 bits no caso do MD5 ou SHA-1, respectivamente), embora este possa ser truncado se desejado.

A definição e análise da construção HMAC foi publicada inicialmente em 1996 por Mihir Bellare, Ran Canetti, e Hugo Krawczyk, que também escreveu a RFC 2104. Este paper também definiu uma variante chamada NMAC que é raramente usada. FIPS PUB 198 generaliza e normatiza o uso de HMACs. HMAC-SHA1 e HMAC-MD5 são usados dentro dos protocolos IPSec e TLS.

Definição(RFC 2104)

Dado que:

• H(·) é uma função hash criptográfica
• K é uma chave secreta preenchida com zeros extras à direita para entrada no bloco do tamanho da função hash , ou o hash da chave original se esta é maior que o tamanho do bloco
• m é a mensagem a ser autenticada
• ∥ denota concatenação
• ⊕ denota ou exclusivo (XOR)
• opad é o preenchimento externo (0x5c5c5c…5c5c, um bloco de comprimento constante hexadecimal)
• ipad é o preenchimento interno (0x363636…3636, um bloco de comprimento constante hexadecimal)

Então HMAC(K,m) é definido matematicamente por

HMAC(K,m) = H((K ⊕ opad) ∥ H((K ⊕ ipad) ∥ m)).

Implementação

O seguinte pseudocódigo demonstra como o HMAC pode ser implementado. O tamanho do bloco é 64 (bytes) quando uma das seguintes funções hash é usada: SHA-1, MD5, RIPEMD-128/160..

function hmac (key, message)
    if (length(key) > blocksize) then
        key = hash(key) // keys longer than blocksize are shortened
    end if
    if (length(key) < blocksize) then
        key = key ∥ [0x00 * (blocksize - length(key))] // keys shorter than blocksize are zero-padded ('∥' is concatenation) 
    end if
   
    o_key_pad = [0x5c * blocksize] ⊕ key // Where blocksize is that of the underlying hash function
    i_key_pad = [0x36 * blocksize] ⊕ key // Where ⊕ is exclusive or (XOR)
   
    return hash(o_key_pad ∥ hash(i_key_pad ∥ message)) // Where '∥' is concatenation
end function

Abaixo uma implementação Python do HMAC-MD5:

#!/usr/bin/env python
from hashlib import md5 
trans_5C = "".join(chr(x ^ 0x5c) for x in xrange(256))
trans_36 = "".join(chr(x ^ 0x36) for x in xrange(256))
blocksize = md5().block_size

def hmac_md5(key, msg):
    if len(key) > blocksize:
        key = md5(key).digest()
    key += chr(0) * (blocksize - len(key))
    o_key_pad = key.translate(trans_5C)
    i_key_pad = key.translate(trans_36)
    return md5(o_key_pad + md5(i_key_pad + msg).digest())

if __name__ == "__main__":
    h = hmac_md5("key", "The quick brown fox jumps over the lazy dog")
    print h.hexdigest()  # 80070713463e7749b90c2dc24911e275

Exemplo de uso

Uma empresa que sofre com atacantes que inserem pedidos fraudulentos pela Internet podem solicitar que todos os seus clientes forneçam uma chave secreta com eles. Junto com um pedido, um cliente deve fornecer o resumo do HMAC do pedido, computado por meio da chave simétrica do cliente. A empresa, que conhece a chave simétrica do cliente, pode então verificar que o pedido se originou a partir do cliente indicado e não foi adulterado.

Princípios de projeto

O projeto da especificação do HMAC foi motivado pela existência de ataques a mecanismos mais triviais por combinar uma chave com uma função hash. Por exemplo, pode-se supor que a mesma segurança que o HMAC provê poderia ser alcançada com MAC = H(chave ∥ mensagem). Contudo, este método apresenta uma falha grave: como a maioria das funções hash, é fácil acrescentar dados a mensagem sem conhecer a chave e obter outro MAC válido (“ataque extensão de comprimento”). A alternativa, anexando a chave usando MAC = H(mensagem ∥ chave), , sofre com o problema de que um atacante qu90e pode encontrar uma colisão em uma função hash (sem chave) tem uma colisão no MAC (como duas mensagens m1 e m2 produzem o mesmo hash será fornecido a mesma condição de inicio para a função hash antes que a chave adiciona seja hashed, portanto, o hash final será o mesmo). Usando MAC = H(chave ∥ mensagem ∥ chave) é melhor, contudo vários paper sobre segurança apresentam vulnerabilidades com esta abordagem, mesmo quando duas chaves diferentes são usadas.

Nenhuma extensão de ataque tem sido encontrada contra a especificação atual do HMAC o qual é definido como H(chave1 ∥ H(chave2 ∥ mensagem)) porque a aplicação da função hash externa mascara o resultado intermediário do hash interno. Os valores do ipad e do opad não são críticos para a segurança do algoritmo, mas foram definidos de tal modo a ter uma grande distância de Hamming entre si e assim as chaves interna e externa terão menos bits em comum.

Segurança

A força criptográfica do HMAC depende do tamanho da chave secreta que é usada. O ataque mais comum contra HMACs é a força bruta para descobrir a chave secreta. HMACs são substancialmente menos afetados por colisões do que os seus algoritmos de hash subjacentes sendo utilizados sozinhos. Portanto, HMAC-MD5 não sofre as mesmas fraquezas que foram encontradas no MD5.

Em 2006, Jongsung Kim, Alex Biryuukov, Bart Preneel e Seokhie Hong mostraram como distinguir HMAC com versões reduzidas de MD5 e SHA-1 ou versões completas do HAVAL, MD4, e SHA-0 de uma função aleatória ou HMAC com uma função aleatória. Distinguidores diferenciais permitem que um atacante planeje um ataque de falsificação no HMAC. Além disso, distinguidores diferenciais e distinguidores retangulares podem levar a um ataque de segunda pré-imagem. HMAC com versões completas do MD4 podem ser falsificados com este conhecimento. Estes ataques não contradizem a prova de segurança do HMAC, mas fornecem informações sobre o HMAC baseadas em funções hash criptográficas existentes.

Pelo menos teoricamente, um ataque de temporização pode ser realizado para descobri um HMAC dígito por dígito..

Exemplo de HMAC (MD5, SHA1, SHA256)

Aqui estão alguns valores vazios HMAC -

HMAC_MD5("", "") = 0x74e6f7298a9c2d168935f58c001bad88
HMAC_SHA1("", "") = 0xfbdb1d1b18aa6c08324b7d64b71fb76370690e1d
HMAC_SHA256("", "") = 0xb613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad

Aqui estão alguns valores não vazios HMAC -

HMAC_MD5("key", "The quick brown fox jumps over the lazy dog") = 0x80070713463e7749b90c2dc24911e275
HMAC_SHA1("key", "The quick brown fox jumps over the lazy dog") = 0xde7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9
HMAC_SHA256("key", "The quick brown fox jumps over the lazy dog") = 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8

Nota: Os dados de entrada e a chave são do tipo ANSI de byte único, e não de dois bytes UCS-2 encoded Unicode Characters.

Ligações externas

• FIPS PUB 198, The Keyed-Hash Message Authentication Code
• PHP HMAC implementation
• Python HMAC implementation
• Perl HMAC implementation
• Ruby HMAC implementation
• C HMAC implementation
• Java implementation
• JavaScript MD5 and SHA HMAC implementation
• JavaScript SHA-only HMAC implementation
• .NET's System.Security.Cryptography.HMAC

Referências

Notes