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,[1] 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..[2]
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.[1][3][4]
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. [5] [6] [7] 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. [8]
Pelo menos teoricamente, um ataque de temporização pode ser realizado para descobri um HMAC dígito por dígito..[9]
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
- ↑ a b Bellare, Mihir; Canetti, Ran; Krawczyk, Hugo (1996). «Keying Hash Functions for Message Authentication».
- ↑ RFC 2104, section 2, "Definition of HMAC", page 3.
- ↑ Preneel, Bart; van Oorschot, Paul C. (1995). «MDx-MAC and Building Fast MACs from Hash Functions». Consultado em 28 de agosto de 2009.
- ↑ Preneel, Bart; van Oorschot, Paul C. (1995). «On the Security of Two MAC Algorithms». Consultado em 28 de agosto de 2009.
- ↑ Bruce Schneier (August 2005). «SHA-1 Broken». Consultado em 9 de janeiro de 2009.
although it doesn't affect applications such as HMAC where collisions aren't important
Verifique data em:|data=
(ajuda) - ↑ IETF (February 1997). «RFC 2104». Consultado em 3 de dezembro de 2009.
The strongest attack known against HMAC is based on the frequency of collisions for the hash function H ("birthday attack") [PV,BCK2], and is totally impractical for minimally reasonable hash functions.
Verifique data em:|data=
(ajuda) - ↑ Bellare, Mihir (June 2006). «New Proofs for NMAC and HMAC: Security without Collision-Resistance». In: Dwork, Cynthia. Advances in Cryptology – Crypto 2006 Proceedings. Lecture Notes in Computer Science 4117. Springer-Verlag. Consultado em 25 de maio de 2010.
This paper proves that HMAC is a PRF under the sole assumption that the compression function is a PRF. This recovers a proof based guarantee since no known attacks compromise the pseudorandomness of the compression function, and it also helps explain the resistance-to-attack that HMAC has shown even when implemented with hash functions whose (weak) collision resistance is compromised.
Verifique data em:|data=
(ajuda) - ↑ Jongsung, Kim; Biryukov, Alex; Preneel, Bart; Hong, Seokhie (2006). «On the Security of HMAC and NMAC Based on HAVAL, MD4, MD5, SHA-0 and SHA-1» (PDF).
- ↑ Briefly mentioned at the end of this session Sebastian Schinzel:Time is on my Side - Exploiting Timing Side Channel Vulnerabilities on the Web 28th Chaos Communication Congress, 2011.
- Notes
- 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).