HMAC

Geração de um HMAC-SHA1

Em criptografia, o código de autenticação de mensagem com chave hash (do inglês: keyed-hash message authentication code, abreviado HMAC) ou código de autenticação de mensagem com base em hash (do inglês: hash-based message authentication code) é um tipo específico de código de autenticação de mensagem (MAC) que usa uma função hash criptográfica e uma chave criptográfica secreta; que pode ser usado para verificar simultaneamente a integridade dos dados e a autenticidade de uma mensagem. Qualquer função hash criptográfica, como SHA-256 ou SHA-3, pode ser usada no cálculo de um HMAC; o algoritmo MAC resultante é denominado HMAC-X, em que X é a função de hash usada (por exemplo, HMAC-SHA256 ou HMAC-SHA3). A força criptográfica do HMAC depende da força criptográfica da função de hash subjacente, do tamanho de sua saída de hash e do tamanho e qualidade da chave.

O HMAC usa duas passagens de computação de hash. A chave secreta é usada primeiro para derivar duas chaves - interna e externa. A primeira passagem do algoritmo produz um hash interno derivado da mensagem e da chave interna. A segunda passagem produz o código HMAC final derivado do resultado do hash interno e da chave externa. Assim, o algoritmo fornece melhor imunidade contra ataques de extensão de comprimento.

Uma função de hash iterativa divide uma mensagem em blocos de tamanho fixo e itera sobre eles com uma função de compactação. Por exemplo, o SHA-256 opera em blocos de 512 bits. O tamanho da saída do HMAC é o mesmo da função de hash subjacente (por exemplo, 256 e 1600 bits no caso de SHA-256 e SHA-3, respectivamente), embora possa ser truncado, se desejado.

O HMAC não criptografa a mensagem. Em vez disso, a mensagem (criptografada ou não) deve ser enviada juntamente com o hash HMAC. Os participantes com a chave secreta irão fazer o hash da mensagem novamente e, se for autêntico, os hashes recebidos e computados serão correspondentes.

A definição e análise da construção do HMAC foram publicadas pela primeira vez em 1996, em um artigo de Mihir Bellare, Ran Canetti e Hugo Krawczyk, que também escreveram a RFC 2104 em 1997. O artigo de 1996 também definiu uma variante aninhada chamada NMAC. O FIPS PUB 198 generaliza e padroniza o uso de HMACs. O HMAC é usado nos protocolos IPsec e TLS; e para JSON Web Tokens.

Definição

Esta definição é proveniente da RFC 2104:

${\begin{aligned}\operatorname {HMAC} (K,m)&=\operatorname {H} {\Bigl (}{\bigl (}K'\oplus opad{\bigr )}\parallel \operatorname {H} {\bigl (}\left(K'\oplus ipad\right)\parallel m{\bigr )}{\Bigr )}\\K'&={\begin{cases}\operatorname {H} \left(K\right)&K{\text{ é maior que o tamanho do bloco}}\\K&{\text{caso contrário}}\end{cases}}\end{aligned}}$

Em 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)

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-160/128.

function hmac (key, message)
    if (length(key) > blocksize) then
        key = hash(key) // encurta chaves maiores que o bloco (64 bytes)
    end if
    if (length(key) < blocksize) then
        key = key ∥ [0x00 * (blocksize - length(key))] // alonga chaves menores que o bloco ('∥' = concatenação) 
    end if
    o_key_pad = [0x5c * blocksize] ⊕ key // blocksize é o tamanho do bloco da função hash
    i_key_pad = [0x36 * blocksize] ⊕ key // '⊕' = operação “ou exclusivo” (XOR)
    return hash(o_key_pad ∥ hash(i_key_pad ∥ message)) // '∥' = concatenação
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 que 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 início 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 diversos papers sobre segurança apresentam vulnerabilidades com esta abordagem, mesmo quando duas chaves distintas são utilizadas.

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 descobrir 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.

Bibliografia

• Mihir Bellare, Ran Canetti and Hugo Krawczyk, Keying Hash Functions for Message Authentication, CRYPTO 1996, pp1–15 (PS or PDF).
• Mihir Bellare, Ran Canetti and Hugo Krawczyk, Message authentication using hash functions: The HMAC construction, CryptoBytes 2(1), Spring 1996 (PS or PDF).

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