Mostrar código-fonte de HMAC

[[File:SHAhmac.svg|thumb|300x300px|Geração de um HMAC-[[SHA-1|SHA1]]]]
Em [[criptografia]], o '''código de autenticação de mensagem com chave ''hash''''' ([[Língua inglesa|do inglês]]: '''''keyed-hash message authentication code''''', [[Abreviatura|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 [[Autenticador de mensagem|código de autenticação de mensagem]] (MAC) que usa uma [[Função hash criptográfica|função ''hash'' criptográfica]] e uma [[Chave (criptografia)|chave criptográfica]] secreta; que pode ser usado para verificar simultaneamente a [[Integridade de dados|integridade dos dados]] e a [[Autenticação|autenticidade]] de uma [[Texto simples|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 ''[[Bit|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 científico|artigo]] de Mihir Bellare, Ran Canetti e Hugo Krawczyk,<ref name="BCK96" /> que também escreveram a RFC 2104 em [[1997]]. O artigo de 1996 também definiu uma variante aninhada chamada NMAC. O [[Federal Information Processing Standard|FIPS]] PUB 198 generaliza e padroniza o uso de HMACs. O HMAC é usado nos protocolos [[IPsec]] e [[TLS]]; e para [[JSON Web Token]]s.

== Definição ==
Esta definição é proveniente da RFC 2104:

:<math>\begin{align}
  \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{align}</math>

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]])
* {{Sic|ipad|hide=yes}} é 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 (''[[Byte|bytes]]'') quando uma das seguintes [[Função hash|funções ''hash'']] é usada: [[SHA-1]], [[MD5]], [[RIPEMD-160]]/128.<ref>{{Citar periódico |url=https://tools.ietf.org/html/rfc2104 |título=HMAC: Keyed-Hashing for Message Authentication |data=1997-02 |acessodata=2022-11-25 |periódico=Network Working Group |publicado=RFC Editor |ultimo=Krawczyk |primeiro=Hugo |ultimo2=Bellare |primeiro2=Mihir |pagina=3 |lingua=en |doi=10.17487/RFC2104 |issn=2070-1721 |rfc=2104 |ultimo3=Canetti |primeiro3=Ran}}</ref>

 '''function''' hmac (key, message)
     '''if''' (length(key) > blocksize) '''then'''
         key = hash(key) <span style="color: green;">''// encurta chaves maiores que o bloco (64 bytes)''</span>
     '''end if'''
     '''if''' (length(key) < blocksize) '''then'''
         key = key ∥ [0x00 * (blocksize - length(key))] <span style="color:green;">// alonga chaves menores que o bloco ('∥' = concatenação) </span>
     '''end if'''
     o_key_pad = [0x5c * blocksize] ⊕ key <span style="color: green;">''// blocksize é o tamanho do bloco da função hash''</span>
     i_key_pad = [0x36 * blocksize] ⊕ key <span style="color: green;">''// '⊕' = operação “ou exclusivo” (XOR)''</span>
     '''return''' hash(o_key_pad ∥ hash(i_key_pad ∥ message)) <span style="color: green;">''// '∥' = concatenação''</span>
 '''end function'''

Abaixo, uma implementação [[Python]] do HMAC-MD5:
<syntaxhighlight lang="python">
# !/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
</syntaxhighlight>

== Exemplo de uso ==
Uma [[empresa]] que sofre com atacantes que inserem pedidos fraudulentos pela [[internet]] podem solicitar que todos os seus [[Clientelismo|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 [[Algoritmo de chave simétrica|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.<ref name="BCK96">{{Citar web|ultimo=Bellare|primeiro=Mihir|ultimo2=Canetti|primeiro2=Ran|url=http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.134.8430|título=Keying Hash Functions for Message Authentication|data=1996|acessodata=2022-11-25|website=CiteSeerx|lingua=en|urlmorta=yes|ultimo3=Krawczyk|primeiro3=Hugo}}</ref><ref>{{Citar web|ultimo=Preneel|primeiro=Bart|ultimo2=C. Van Oorschot|primeiro2=Paul|url=http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.3855|título=MDx-MAC and Building Fast MACs from Hash Functions|data=1995|acessodata=2022-11-25|website=CiteSeerx|lingua=en|arquivourl=https://web.archive.org/web/20100604234324/http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.3855|arquivodata=2010-06-04|urlmorta=yes}}</ref><ref>{{Citar web|ultimo=Preneel|primeiro=Bart|ultimo2=C. Van Oorschot|primeiro2=Paul|url=http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.8908|título=On the Security of Two MAC Algorithms|data=1995|acessodata=2022-11-25|website=CiteSeerx|lingua=en|arquivourl=https://web.archive.org/web/20090223134840/http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.8908|arquivodata=2009-02-23|urlmorta=yes}}</ref>

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.<ref>{{Citar web|ultimo=Schneier|primeiro=Bruce|url=http://www.schneier.com/blog/archives/2005/02/sha1_broken.html|título=SHA-1 Broken|data=2005-08|acessodata=2022-11-25|website=Schneier|lingua=en|citação=''although it doesn't affect applications such as HMAC where collisions aren't important''}}</ref><ref>{{Citar web|ultimo=Bellare|primeiro=Mihir|ultimo2=Canetti|primeiro2=Ran|url=http://www.ietf.org/rfc/rfc2104.txt|título=HMAC: Keyed-Hashing for Message|data=1997-02|acessodata=2022-11-25|website=IETF|publicado=Network Working Group|lingua=en|rfc=2104|citação=''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.''}}</ref><ref>{{citar conferência |último=Bellare |primeiro=Mihir |url=http://cseweb.ucsd.edu/~mihir/papers/hmac-new.html |título=New Proofs for NMAC and HMAC: Security without Collision-Resistance |data=2006 |acessodata=2022-11-25 |publicado=Springer-Verlag |editor-sobrenome=Dwork |editor-nome=Cynthia |series=Lecture Notes in Computer Science 4117 |lingua=en |conferencia= |urlmorta=yes |citação=''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.'' |títulolivro=Advances in Cryptology – Crypto 2006 Proceedings}}</ref> 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.<ref>{{citar periódico |url=http://eprint.iacr.org/2006/187.pdf |título=On the Security of HMAC and NMAC Based on HAVAL, MD4, MD5, SHA-0 and SHA-1 |acessodata=2022-11-25 |último=Jongsung |primeiro=Kim |ano=2006 |lingua=en |coautor=Biryukov, Alex; Preneel, Bart; Hong, Seokhie}}</ref>

Pelo menos teoricamente, um [[ataque de temporização]] pode ser realizado para descobrir um HMAC dígito por dígito.<ref>{{Citar web|url=https://fahrplan.events.ccc.de/congress/2011/Fahrplan/events/4640.en.html|titulo=28C3: Time is on my Side|data=2012-01-07|acessodata=2022-11-25|website=FahrPlan|lingua=en}}</ref>

== Exemplo de HMAC (MD5, SHA1, SHA256<!-- and SHA512-->) ==
Aqui estão alguns valores vazios HMAC -
 HMAC_MD5("", "") = 0x74e6f7298a9c2d168935f58c001bad88
 HMAC_SHA1("", "") = 0xfbdb1d1b18aa6c08324b7d64b71fb76370690e1d
 HMAC_SHA256("", "") = 0xb613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad
<!--HMAC_SHA512("", "") = 0xb936cee86c9f87aa5d3c6f2e84cb5a4239a5fe50480a6ec66b70ab5b1f4ac6730c6c515421b327ec1d69402e53dfb49ad7381eb067b338fd7b0cb22247225d47 -->

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
<!-- HMAC_SHA512("key", "The quick brown fox jumps over the lazy dog") = 0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3a -->

'''Nota:''' Os dados de entrada e a chave são do tipo [[American National Standards Institute|ANSI]] de ''byte'' único, e não de dois ''bytes'' ''UCS-2 encoded Unicode Characters''.

{{Referências}}

== Bibliografia ==
* Mihir Bellare, Ran Canetti and Hugo Krawczyk, Keying Hash Functions for Message Authentication, CRYPTO 1996, pp1–15 [http://www-cse.ucsd.edu/users/mihir/papers/hmac.html#kmd5-paper (PS or PDF)].
* Mihir Bellare, Ran Canetti and Hugo Krawczyk, Message authentication using hash functions: The HMAC construction, ''CryptoBytes'' 2(1), Spring 1996 [http://www-cse.ucsd.edu/users/mihir/papers/hmac.html#hmac-cryptobytes (PS or PDF)].

== Ligações externas ==
* [http://csrc.nist.gov/publications/fips/fips198/fips-198a.pdf FIPS PUB 198, ''The Keyed-Hash Message Authentication Code'']
* [http://us2.php.net/manual/en/function.hash-hmac.php PHP HMAC implementation]
* [http://docs.python.org/lib/module-hmac.html Python HMAC implementation]
* [https://web.archive.org/web/20120713215720/http://cpan.uwinnipeg.ca/htdocs/Digest-HMAC/Digest/HMAC.pm.html Perl HMAC implementation]
* [https://web.archive.org/web/20120220125500/http://ruby-hmac.rubyforge.org/ Ruby HMAC implementation]
* [http://www.ouah.org/ogay/hmac/ C HMAC implementation]
* [https://web.archive.org/web/20111110153119/http://download.oracle.com/javase/1.4.2/docs/guide/security/jce/JCERefGuide.html#HmacEx Java implementation]
* [http://pajhome.org.uk/crypt/md5/instructions.html JavaScript MD5 and SHA HMAC implementation]
* [http://jssha.sourceforge.net/ JavaScript SHA-only HMAC implementation]
* [http://msdn.microsoft.com/en-us/library/system.security.cryptography.hmac.aspx .NET's System.Security.Cryptography.HMAC]

{{Portal3|Tecnologias de informação}}{{Hashes Criptográficos}}
[[Categoria:Criptografia]]
[[Categoria:Hashing]]