Incryptography, anHMAC (sometimes expanded as eitherkeyed-hash message authentication code orhash-based message authentication code) is a specific type ofmessage authentication code (MAC) involving acryptographic hash function and a secret cryptographic key. As with any MAC, it may be used to simultaneously verify both thedata integrity and authenticity of a message. An HMAC is a type of keyed hash function that can also be used in a key derivation scheme or a key stretching scheme.

HMAC can provide authentication using ashared secret instead of usingdigital signatures withasymmetric cryptography. It trades off the need for a complexpublic key infrastructure by delegating the key exchange to the communicating parties, who are responsible for establishing and using a trusted channel to agree on the key prior to communication.

Any cryptographic hash function, such asSHA-2 orSHA-3, may be used in the calculation of an HMAC; the resulting MAC algorithm is termed HMAC-x, wherex is the hash function used (e.g. HMAC-SHA256 or HMAC-SHA3-512). Thecryptographic strength of the HMAC depends upon the cryptographic strength of the underlying hash function, the size of its hash output, and the size and quality of the key.^[1]

HMAC uses two passes of hash computation. Before either pass, the secret key is used to derive two keys – inner and outer. Next, the first pass of the hash algorithm produces an internal hash derived from the message and the inner key. The second pass produces the final HMAC code derived from the inner hash result and the outer key. Thus the algorithm provides better immunity againstlength extension attacks.

An iterative hash function (one that uses theMerkle–Damgård construction) breaks up a message into blocks of a fixed size and iterates over them with acompression function. For example, SHA-256 operates on 512-bit blocks. The size of the output of HMAC is the same as that of the underlying hash function (e.g., 256 and 512 bits in the case of SHA-256 and SHA3-512, respectively), although it can be truncated if desired.

HMAC does not encrypt the message. Instead, the message (encrypted or not) must be sent alongside the HMAC hash. Parties with the secret key will hash the message again themselves, and if it is authentic, the received and computed hashes will match.

The definition and analysis of the HMAC construction was first published in 1996 in a paper byMihir Bellare,Ran Canetti, andHugo Krawczyk,^[1][2] and they also wrote RFC 2104 in 1997.^[3]: §2 The 1996 paper also defined a nested variant called NMAC (Nested MAC).FIPS PUB 198 generalizes and standardizes the use of HMACs.^[4] HMAC is used within theIPsec,^[2]SSH andTLS protocols and forJSON Web Tokens.

This definition is taken from RFC 2104:

where

${\displaystyle \mathrm{H}}$ is a cryptographic hash function.

${\displaystyle m}$ is the message to be authenticated.

${\displaystyle K}$ is the secret key.

${\displaystyle K^{\prime }}$ is a block-sized key derived from the secret key,K; either by padding to the right with 0s up to the block size, or by hashing down to less than or equal to the block size first and then padding to the right with zeros.

${\displaystyle \parallel }$ denotesconcatenation.

${\displaystyle \oplus }$ denotes bitwiseexclusive or (XOR).

${\displaystyle opad}$ is the block-sized outer padding, consisting of repeated bytes valued 0x5c.

${\displaystyle ipad}$ is the block-sized inner padding, consisting of repeated bytes valued 0x36.^[3]: §2

The followingpseudocode demonstrates how HMAC may be implemented. The block size is 512 bits (64 bytes) when using one of the following hash functions: SHA-1, MD5, RIPEMD-128.^[3]: §2

function hmacisinput:        key:        Bytes// Array of bytes        message:    Bytes// Array of bytes to be hashed        hash:       Function// The hash function to use (e.g. SHA-1)        blockSize:  Integer// The block size of the hash function (e.g. 64 bytes for SHA-1)// Compute the block sized key    block_sized_key = computeBlockSizedKey(key, hash, blockSize)    o_key_pad ← block_sized_key xor [0x5c blockSize]// Outer padded key    i_key_pad ← block_sized_key xor [0x36 blockSize]// Inner padded keyreturn  hash(o_key_pad ∥ hash(i_key_pad ∥ message))function computeBlockSizedKeyisinput:        key:        Bytes// Array of bytes        hash:       Function// The hash function to use (e.g. SHA-1)        blockSize:  Integer// The block size of the hash function (e.g. 64 bytes for SHA-1)// Keys longer thanblockSize are shortened by hashing themif (length(key) > blockSize)then        key = hash(key)// Keys shorter thanblockSize are padded toblockSize by padding with zeros on the rightif (length(key) < blockSize)thenreturn  Pad(key, blockSize)// Pad key with zeros to make itblockSize bytes longreturn  key

The design of the HMAC specification was motivated by the existence of attacks on more trivial mechanisms for combining a key with a hash function. For example, one might assume the same security that HMAC provides could be achieved with MAC =H(key ∥message). However, this method suffers from a serious flaw: with most hash functions, it is easy to append data to the message without knowing the key and obtain another valid MAC ("length-extension attack"). The alternative, appending the key using MAC =H(message ∥key), suffers from the problem that an attacker who can find a collision in the (unkeyed) hash function has a collision in the MAC (as two messages m1 and m2 yielding the same hash will provide the same start condition to the hash function before the appended key is hashed, hence the final hash will be the same). Using MAC =H(key ∥message ∥key) is better, but various security papers have suggested vulnerabilities with this approach, even when two different keys are used.^[1][7][8]

No known extension attacks have been found against the current HMAC specification which is defined asH(key ∥H(key ∥message)) because the outer application of the hash function masks the intermediate result of the internal hash. The values ofipad andopad are not critical to the security of the algorithm, but were defined in such a way to have a largeHamming distance from each other and so the inner and outer keys will have fewer bits in common. The security reduction of HMAC does require them to be different in at least one bit.^{[citation needed]}

TheKeccak hash function, that was selected byNIST as theSHA-3 competition winner, doesn't need this nested approach and can be used to generate a MAC by simply prepending the key to the message, as it is not susceptible to length-extension attacks.^[9]

The cryptographic strength of the HMAC depends upon the size of the secret key that is used and the security of the underlying hash function used. It has been proven that the security of an HMAC construction is directly related to security properties of the hash function used. The most common attack against HMACs is brute force to uncover the secret key. HMACs are substantially less affected by collisions than their underlying hashing algorithms alone.^[2][10][11]In particular, Mihir Bellare proved that HMAC is apseudo-random function (PRF) under the sole assumption that the compression function is a PRF.^[12] Therefore, HMAC-MD5 does not suffer from the same weaknesses that have been found in MD5.^[13]

RFC 2104 requires that "keys longer thanB bytes are first hashed usingH" which leads to a confusing pseudo-collision: if the key is longer than the hash block size (e.g. 64 bytes for SHA-1), thenHMAC(k, m) is computed asHMAC(H(k), m). This property is sometimes raised as a possible weakness of HMAC in password-hashing scenarios: it has been demonstrated that it's possible to find a long ASCII string and a random value whose hash will be also an ASCII string, and both values will produce the same HMAC output.^[14][15][16]

In 2006,Jongsung Kim,Alex Biryukov,Bart Preneel, andSeokhie Hong showed how to distinguish HMAC with reduced versions of MD5 and SHA-1 or full versions ofHAVAL,MD4, andSHA-0 from arandom function or HMAC with a random function. Differential distinguishers allow an attacker to devise a forgery attack on HMAC. Furthermore, differential and rectangle distinguishers can lead tosecond-preimage attacks. HMAC with the full version of MD4 can beforged with this knowledge. These attacks do not contradict the security proof of HMAC, but provide insight into HMAC based on existing cryptographic hash functions.^[17]

In 2009,Xiaoyun Wanget al. presented a distinguishing attack on HMAC-MD5 without using related keys. It can distinguish an instantiation of HMAC with MD5 from an instantiation with a random function with 2⁹⁷ queries with probability 0.87.^[18]

In 2011 an informational RFC 6151 was published to summarize security considerations inMD5 and HMAC-MD5. For HMAC-MD5 the RFC summarizes that – although the security of theMD5 hash function itself is severely compromised – the currently known"attacks on HMAC-MD5 do not seem to indicate a practical vulnerability when used as a message authentication code", but it also adds that"for a new protocol design, a ciphersuite with HMAC-MD5 should not be included".^[13]

In May 2011, RFC 6234 was published detailing the abstract theory and source code for SHA-based HMACs.^[19]

Here are some HMAC values, assuming 8-bit ASCII for the input and hexadecimal encoding for the output:

HMAC_MD5("key", "The quick brown fox jumps over the lazy dog")    = 80070713463e7749b90c2dc24911e275HMAC_SHA1("key", "The quick brown fox jumps over the lazy dog")   = de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9HMAC_SHA256("key", "The quick brown fox jumps over the lazy dog") = f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8HMAC_SHA512("key", "The quick brown fox jumps over the lazy dog") = b42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3a

• HMAC-based one-time password

• Online HMAC Generator / Tester Tool
• FIPS PUB 198-1,The Keyed-Hash Message Authentication Code (HMAC)Archived 17 February 2013 at theWayback Machine
• C HMAC implementation
• Python HMAC implementation
• Java implementation
• Rust HMAC implementation

• Message authentication codes
• Hashing

• All articles with dead external links
• Articles with dead external links from July 2025
• Articles with permanently dead external links
• Articles with short description
• Short description is different from Wikidata
• Wikipedia indefinitely semi-protected pages
• Use dmy dates from June 2024
• All articles with unsourced statements
• Articles with unsourced statements from June 2015
• Webarchive template wayback links