Cryptographic hash function
A cryptographic hash function (CHF) is a hash function that is suitable for use in cryptography. It is a mathematical algorithm that maps data of arbitrary size (often called the "message") to a bit string of a fixed size (the "hash value", "hash", or "message digest") and is a oneway function, that is, a function which is practically infeasible to invert.[1] Ideally, the only way to find a message that produces a given hash is to attempt a bruteforce search of possible inputs to see if they produce a match, or use a rainbow table of matched hashes. Cryptographic hash functions are a basic tool of modern cryptography.[2]
Secure Hash Algorithms  

Concepts  
hash functions · SHA · DSA  
Main standards  
SHA0 · SHA1 · SHA2 · SHA3  
The ideal cryptographic hash function has the following main properties:
 it is deterministic, meaning that the same message always results in the same hash
 it is quick to compute the hash value for any given message
 it is infeasible to generate a message that yields a given hash value
 it is infeasible to find two different messages with the same hash value
 a small change to a message should change the hash value so extensively that the new hash value appears uncorrelated with the old hash value (avalanche effect) [3]
Cryptographic hash functions have many informationsecurity applications, notably in digital signatures, message authentication codes (MACs), and other forms of authentication. They can also be used as ordinary hash functions, to index data in hash tables, for fingerprinting, to detect duplicate data or uniquely identify files, and as checksums to detect accidental data corruption. Indeed, in informationsecurity contexts, cryptographic hash values are sometimes called (digital) fingerprints, checksums, or just hash values, even though all these terms stand for more general functions with rather different properties and purposes.
Properties
Most cryptographic hash functions are designed to take a string of any length as input and produce a fixedlength hash value.
A cryptographic hash function must be able to withstand all known types of cryptanalytic attack. In theoretical cryptography, the security level of a cryptographic hash function has been defined using the following properties:
 Preimage resistance
 Given a hash value h it should be difficult to find any message m such that h = hash(m). This concept is related to that of a oneway function. Functions that lack this property are vulnerable to preimage attacks.
 Second preimage resistance
 Given an input m_{1}, it should be difficult to find a different input m_{2} such that hash(m_{1}) = hash(m_{2}). This property is sometimes referred to as weak collision resistance. Functions that lack this property are vulnerable to secondpreimage attacks.
 Collision resistance
 It should be difficult to find two different messages m_{1} and m_{2} such that hash(m_{1}) = hash(m_{2}). Such a pair is called a cryptographic hash collision. This property is sometimes referred to as strong collision resistance. It requires a hash value at least twice as long as that required for preimage resistance; otherwise collisions may be found by a birthday attack.[4]
Collision resistance implies second preimage resistance, but does not imply preimage resistance.[5] The weaker assumption is always preferred in theoretical cryptography, but in practice, a hashfunction which is only second preimage resistant is considered insecure and is therefore not recommended for real applications.
Informally, these properties mean that a malicious adversary cannot replace or modify the input data without changing its digest. Thus, if two strings have the same digest, one can be very confident that they are identical. Second preimage resistance prevents an attacker from crafting a document with the same hash as a document the attacker cannot control. Collision resistance prevents an attacker from creating two distinct documents with the same hash.
A function meeting these criteria may still have undesirable properties. Currently popular cryptographic hash functions are vulnerable to lengthextension attacks: given hash(m) and len(m) but not m, by choosing a suitable m′ an attacker can calculate hash(m ∥ m′), where ∥ denotes concatenation.[6] This property can be used to break naive authentication schemes based on hash functions. The HMAC construction works around these problems.
In practice, collision resistance is insufficient for many practical uses. In addition to collision resistance, it should be impossible for an adversary to find two messages with substantially similar digests; or to infer any useful information about the data, given only its digest. In particular, a hash function should behave as much as possible like a random function (often called a random oracle in proofs of security) while still being deterministic and efficiently computable. This rules out functions like the SWIFFT function, which can be rigorously proven to be collision resistant assuming that certain problems on ideal lattices are computationally difficult, but as a linear function, does not satisfy these additional properties.[7]
Checksum algorithms, such as CRC32 and other cyclic redundancy checks, are designed to meet much weaker requirements, and are generally unsuitable as cryptographic hash functions. For example, a CRC was used for message integrity in the WEP encryption standard, but an attack was readily discovered which exploited the linearity of the checksum.
Degree of difficulty
In cryptographic practice, "difficult" generally means "almost certainly beyond the reach of any adversary who must be prevented from breaking the system for as long as the security of the system is deemed important". The meaning of the term is therefore somewhat dependent on the application since the effort that a malicious agent may put into the task is usually proportional to his expected gain. However, since the needed effort usually multiplies with the digest length, even a thousandfold advantage in processing power can be neutralized by adding a few dozen bits to the latter.
For messages selected from a limited set of messages, for example passwords or other short messages, it can be feasible to invert a hash by trying all possible messages in the set. Because cryptographic hash functions are typically designed to be computed quickly, special key derivation functions that require greater computing resources have been developed that make such brute force attacks more difficult.
In some theoretical analyses "difficult" has a specific mathematical meaning, such as "not solvable in asymptotic polynomial time". Such interpretations of difficulty are important in the study of provably secure cryptographic hash functions but do not usually have a strong connection to practical security. For example, an exponential time algorithm can sometimes still be fast enough to make a feasible attack. Conversely, a polynomial time algorithm (e.g., one that requires n^{20} steps for ndigit keys) may be too slow for any practical use.
Illustration
An illustration of the potential use of a cryptographic hash is as follows: Alice poses a tough math problem to Bob and claims that she has solved it. Bob would like to try it himself, but would yet like to be sure that Alice is not bluffing. Therefore, Alice writes down her solution, computes its hash and tells Bob the hash value (whilst keeping the solution secret). Then, when Bob comes up with the solution himself a few days later, Alice can prove that she had the solution earlier by revealing it and having Bob hash it and check that it matches the hash value given to him before. (This is an example of a simple commitment scheme; in actual practice, Alice and Bob will often be computer programs, and the secret would be something less easily spoofed than a claimed puzzle solution.)
Applications
Verifying the integrity of messages and files
An important application of secure hashes is verification of message integrity. Comparing message digests (hash digests over the message) calculated before, and after, transmission can determine whether any changes have been made to the message or file.
MD5, SHA1, or SHA2 hash digests are sometimes published on websites or forums to allow verification of integrity for downloaded files,[8] including files retrieved using file sharing such as mirroring. This practice establishes a chain of trust so long as the hashes are posted on a site authenticated by HTTPS. Using a cryptographic hash and a chain of trust detects malicious changes to the file. Other error detecting codes such as cyclic redundancy checks only prevent against nonmalicious alterations of the file.
Signature generation and verification
Almost all digital signature schemes require a cryptographic hash to be calculated over the message. This allows the signature calculation to be performed on the relatively small, statically sized hash digest. The message is considered authentic if the signature verification succeeds given the signature and recalculated hash digest over the message. So the message integrity property of the cryptographic hash is used to create secure and efficient digital signature schemes.
Password verification
Password verification commonly relies on cryptographic hashes. Storing all user passwords as cleartext can result in a massive security breach if the password file is compromised. One way to reduce this danger is to only store the hash digest of each password. To authenticate a user, the password presented by the user is hashed and compared with the stored hash. A password reset method is required when password hashing is performed; original passwords cannot be recalculated from the stored hash value.
Standard cryptographic hash functions are designed to be computed quickly, and, as a result, it is possible to try guessed passwords at high rates. Common graphics processing units can try billions of possible passwords each second. Password hash functions that perform Key stretching – such as PBKDF2, scrypt or Argon2 – commonly use repeated invocations of a cryptographic hash to increase the time (and in some cases computer memory) required to perform brute force attacks on stored password hash digests. A password hash requires the use of a large random, nonsecret salt value which can be stored with the password hash. The salt randomizes the output of the password hash, making it impossible for an adversary to store tables of passwords and precomputed hash values to which the password hash digest can be compared.
The output of a password hash function can also be used as a cryptographic key. Password hashes are therefore also known as Password Based Key Derivation Functions (PBKDFs).
Proofofwork
A proofofwork system (or protocol, or function) is an economic measure to deter denialofservice attacks and other service abuses such as spam on a network by requiring some work from the service requester, usually meaning processing time by a computer. A key feature of these schemes is their asymmetry: the work must be moderately hard (but feasible) on the requester side but easy to check for the service provider. One popular system – used in Bitcoin mining and Hashcash – uses partial hash inversions to prove that work was done, to unlock a mining reward in Bitcoin and as a goodwill token to send an email in Hashcash. The sender is required to find a message whose hash value begins with a number of zero bits. The average work that sender needs to perform in order to find a valid message is exponential in the number of zero bits required in the hash value, while the recipient can verify the validity of the message by executing a single hash function. For instance, in Hashcash, a sender is asked to generate a header whose 160 bit SHA1 hash value has the first 20 bits as zeros. The sender will on average have to try 2^{19} times to find a valid header.
File or data identifier
A message digest can also serve as a means of reliably identifying a file; several source code management systems, including Git, Mercurial and Monotone, use the sha1sum of various types of content (file content, directory trees, ancestry information, etc.) to uniquely identify them. Hashes are used to identify files on peertopeer filesharing networks. For example, in an ed2k link, an MD4variant hash is combined with the file size, providing sufficient information for locating file sources, downloading the file and verifying its contents. Magnet links are another example. Such file hashes are often the top hash of a hash list or a hash tree which allows for additional benefits.
One of the main applications of a hash function is to allow the fast lookup of a data in a hash table. Being hash functions of a particular kind, cryptographic hash functions lend themselves well to this application too.
However, compared with standard hash functions, cryptographic hash functions tend to be much more expensive computationally. For this reason, they tend to be used in contexts where it is necessary for users to protect themselves against the possibility of forgery (the creation of data with the same digest as the expected data) by potentially malicious participants.
Hash functions based on block ciphers
There are several methods to use a block cipher to build a cryptographic hash function, specifically a oneway compression function.
The methods resemble the block cipher modes of operation usually used for encryption. Many wellknown hash functions, including MD4, MD5, SHA1 and SHA2 are built from blockcipherlike components designed for the purpose, with feedback to ensure that the resulting function is not invertible. SHA3 finalists included functions with blockcipherlike components (e.g., Skein, BLAKE) though the function finally selected, Keccak, was built on a cryptographic sponge instead.
A standard block cipher such as AES can be used in place of these custom block ciphers; that might be useful when an embedded system needs to implement both encryption and hashing with minimal code size or hardware area. However, that approach can have costs in efficiency and security. The ciphers in hash functions are built for hashing: they use large keys and blocks, can efficiently change keys every block, and have been designed and vetted for resistance to relatedkey attacks. Generalpurpose ciphers tend to have different design goals. In particular, AES has key and block sizes that make it nontrivial to use to generate long hash values; AES encryption becomes less efficient when the key changes each block; and relatedkey attacks make it potentially less secure for use in a hash function than for encryption.
Hash function design
Merkle–Damgård construction
A hash function must be able to process an arbitrarylength message into a fixedlength output. This can be achieved by breaking the input up into a series of equalsized blocks, and operating on them in sequence using a oneway compression function. The compression function can either be specially designed for hashing or be built from a block cipher. A hash function built with the Merkle–Damgård construction is as resistant to collisions as is its compression function; any collision for the full hash function can be traced back to a collision in the compression function.
The last block processed should also be unambiguously length padded; this is crucial to the security of this construction. This construction is called the Merkle–Damgård construction. Most common classical hash functions, including SHA1 and MD5, take this form.
Wide pipe vs narrow pipe
A straightforward application of the Merkle–Damgård construction, where the size of hash output is equal to the internal state size (between each compression step), results in a narrowpipe hash design. This design causes many inherent flaws, including lengthextension, multicollisions,[9] long message attacks,[10] generateandpaste attacks, and also cannot be parallelized. As a result, modern hash functions are built on widepipe constructions that have a larger internal state size – which range from tweaks of the Merkle–Damgård construction[9] to new constructions such as the sponge construction and HAIFA construction.[11] None of the entrants in the NIST hash function competition use a classical Merkle–Damgård construction.[12]
Meanwhile, truncating the output of a longer hash, such as used in SHA512/256, also defeats many of these attacks.[13]
Use in building other cryptographic primitives
Hash functions can be used to build other cryptographic primitives. For these other primitives to be cryptographically secure, care must be taken to build them correctly.
Message authentication codes (MACs) (also called keyed hash functions) are often built from hash functions. HMAC is such a MAC.
Just as block ciphers can be used to build hash functions, hash functions can be used to build block ciphers. LubyRackoff constructions using hash functions can be provably secure if the underlying hash function is secure. Also, many hash functions (including SHA1 and SHA2) are built by using a specialpurpose block cipher in a Davies–Meyer or other construction. That cipher can also be used in a conventional mode of operation, without the same security guarantees. See SHACAL, BEAR and LION.
Pseudorandom number generators (PRNGs) can be built using hash functions. This is done by combining a (secret) random seed with a counter and hashing it.
Some hash functions, such as Skein, Keccak, and RadioGatún output an arbitrarily long stream and can be used as a stream cipher, and stream ciphers can also be built from fixedlength digest hash functions. Often this is done by first building a cryptographically secure pseudorandom number generator and then using its stream of random bytes as keystream. SEAL is a stream cipher that uses SHA1 to generate internal tables, which are then used in a keystream generator more or less unrelated to the hash algorithm. SEAL is not guaranteed to be as strong (or weak) as SHA1. Similarly, the key expansion of the HC128 and HC256 stream ciphers makes heavy use of the SHA256 hash function.
Concatenation
Concatenating outputs from multiple hash functions provides collision resistance as good as the strongest of the algorithms included in the concatenated result. For example, older versions of Transport Layer Security (TLS) and Secure Sockets Layer (SSL) use concatenated MD5 and SHA1 sums.[14][15] This ensures that a method to find collisions in one of the hash functions does not defeat data protected by both hash functions.
For Merkle–Damgård construction hash functions, the concatenated function is as collisionresistant as its strongest component, but not more collisionresistant. Antoine Joux observed that 2collisions lead to ncollisions: if it is feasible for an attacker to find two messages with the same MD5 hash, the attacker can find as many messages as the attacker desires with identical MD5 hashes with no greater difficulty.[16] Among the n messages with the same MD5 hash, there is likely to be a collision in SHA1. The additional work needed to find the SHA1 collision (beyond the exponential birthday search) requires only polynomial time.[17][18]
Cryptographic hash algorithms
There are many cryptographic hash algorithms; this section lists a few algorithms that are referenced relatively often. A more extensive list can be found on the page containing a comparison of cryptographic hash functions.
MD5
MD5 was designed by Ronald Rivest in 1991 to replace an earlier hash function MD4, and was specified in 1992 as RFC 1321. Collisions against MD5 can be calculated within seconds which makes the algorithm unsuitable for most use cases where a cryptographic hash is required. MD5 produces a digest of 128 bits (16 bytes).
SHA1
SHA1 was developed as part of the U.S. Government's Capstone project. The original specification – now commonly called SHA0 – of the algorithm was published in 1993 under the title Secure Hash Standard, FIPS PUB 180, by U.S. government standards agency NIST (National Institute of Standards and Technology). It was withdrawn by the NSA shortly after publication and was superseded by the revised version, published in 1995 in FIPS PUB 1801 and commonly designated SHA1. Collisions against the full SHA1 algorithm can be produced using the shattered attack and the hash function should be considered broken. SHA1 produces a hash digest of 160 bits (20 bytes).
Documents may refer to SHA1 as just "SHA", even though this may conflict with the other Standard Hash Algorithms such as SHA0, SHA2 and SHA3.
RIPEMD160
RIPEMD (RACE Integrity Primitives Evaluation Message Digest) is a family of cryptographic hash functions developed in Leuven, Belgium, by Hans Dobbertin, Antoon Bosselaers and Bart Preneel at the COSIC research group at the Katholieke Universiteit Leuven, and first published in 1996. RIPEMD was based upon the design principles used in MD4, and is similar in performance to the more popular SHA1. RIPEMD160 has however not been broken. As the name implies, RIPEMD160 produces a hash digest of 160 bits (20 bytes).
bcrypt
bcrypt is a password hashing function designed by Niels Provos and David Mazières, based on the Blowfish cipher, and presented at USENIX in 1999. Besides incorporating a salt to protect against rainbow table attacks, bcrypt is an adaptive function: over time, the iteration count can be increased to make it slower, so it remains resistant to bruteforce search attacks even with increasing computation power.
Whirlpool
Whirlpool is a cryptographic hash function designed by Vincent Rijmen and Paulo S. L. M. Barreto, who first described it in 2000. Whirlpool is based on a substantially modified version of the Advanced Encryption Standard (AES). Whirlpool produces a hash digest of 512 bits (64 bytes).
SHA2
SHA2 (Secure Hash Algorithm 2) is a set of cryptographic hash functions designed by the United States National Security Agency (NSA), first published in 2001. They are built using the Merkle–Damgård structure, from a oneway compression function itself built using the Davies–Meyer structure from a (classified) specialized block cipher.
SHA2 basically consists of two hash algorithms: SHA256 and SHA512. SHA224 is a variant of SHA256 with different starting values and truncated output. SHA384 and the lesser known SHA512/224 and SHA512/256 are all variants of SHA512. SHA512 is more secure than SHA256 and is commonly faster than SHA256 on 64 bit machines such as AMD64.
The output size in bits is given by the extension to the "SHA" name, so SHA224 has an output size of 224 bits (28 bytes), SHA256 produces 32 bytes, SHA384 produces 48 bytes and finally SHA512 produces 64 bytes.
SHA3
SHA3 (Secure Hash Algorithm 3) was released by NIST on August 5, 2015. SHA3 is a subset of the broader cryptographic primitive family Keccak. The Keccak algorithm is the work of Guido Bertoni, Joan Daemen, Michael Peeters, and Gilles Van Assche. Keccak is based on a sponge construction which can also be used to build other cryptographic primitives such as a stream cipher. SHA3 provides the same output sizes as SHA2: 224, 256, 384 and 512 bits.
Configurable output sizes can also be obtained using the SHAKE128 and SHAKE256 functions. Here the 128 and 256 extensions to the name imply the security strength of the function rather than the output size in bits.
BLAKE2
An improved version of BLAKE called BLAKE2 was announced in December 21, 2012. It was created by JeanPhilippe Aumasson, Samuel Neves, Zooko WilcoxO'Hearn, and Christian Winnerlein with the goal to replace widely used, but broken MD5 and SHA1 algorithms. When run on 64bit x64 and ARM architectures, BLAKE2b is faster than SHA3, SHA2, SHA1, and MD5. Although BLAKE nor BLAKE2 have not been standardized as SHA3 it has been used in many protocols including the Argon2 password hash for the high efficiency that it offers on modern CPUs. As BLAKE was a candidate for SHA3, BLAKE and BLAKE2 both offer the same output sizes as SHA3 – including a configurable output size.
Attacks on cryptographic hash algorithms
There is a long list of cryptographic hash functions but many have been found to be vulnerable and should not be used. For instance, NIST selected 51 hash functions[19] as candidates for round 1 of the SHA3 hash competition, of which 10 were considered broken and 16 showed significant weaknesses and therefore didn't make it to the next round; more information can be found on the main article about the NIST hash function competitions.
Even if a hash function has never been broken, a successful attack against a weakened variant may undermine the experts' confidence. For instance, in August 2004 collisions were found in several thenpopular hash functions, including MD5.[20] These weaknesses called into question the security of stronger algorithms derived from the weak hash functions—in particular, SHA1 (a strengthened version of SHA0), RIPEMD128, and RIPEMD160 (both strengthened versions of RIPEMD).
On 12 August 2004, Joux, Carribault, Lemuet, and Jalby announced a collision for the full SHA0 algorithm. Joux et al. accomplished this using a generalization of the Chabaud and Joux attack. They found that the collision had complexity 2^{51} and took about 80,000 CPU hours on a supercomputer with 256 Itanium 2 processors—equivalent to 13 days of fulltime use of the supercomputer.
In February 2005, an attack on SHA1 was reported that would find collision in about 2^{69} hashing operations, rather than the 2^{80} expected for a 160bit hash function. In August 2005, another attack on SHA1 was reported that would find collisions in 2^{63} operations. Other theoretical weaknesses of SHA1 have been known:[21][22] and in February 2017 Google announced a collision in SHA1.[23] Security researchers recommend that new applications can avoid these problems by using later members of the SHA family, such as SHA2, or using techniques such as randomized hashing[24][1] that do not require collision resistance.
A successful, practical attack broke MD5 used within certificates for Transport Layer Security in 2008.[25]
Many cryptographic hashes are based on the Merkle–Damgård construction. All cryptographic hashes that directly use the full output of a Merkle–Damgård construction are vulnerable against length extension attacks. This makes the MD5, SHA1, RIPEMD160, Whirlpool and the SHA256 / SHA512 hash algorithms all vulnerable against this specific attack. SHA3, BLAKE2 and the truncated SHA2 variants are not vulnerable against this type of attack.
See also
References
 Shai Halevi and Hugo Krawczyk, Randomized Hashing and Digital Signatures

Schneier, Bruce. "Cryptanalysis of MD5 and SHA: Time for a New Standard". Computerworld. Retrieved 20160420.
Much more than encryption algorithms, oneway hash functions are the workhorses of modern cryptography.
 AlKuwari, Saif; Davenport, James H.; Bradford, Russell J. (2011). "Cryptographic Hash Functions: Recent Design Trends and Security Notions". Cite journal requires
journal=
(help)  Jonathan Katz; Yehuda Lindell (6 November 2014). Introduction to Modern Cryptography, Second Edition. CRC Press. ISBN 9781466570269.
 Rogaway & Shrimpton 2004, in Sec. 5. Implications.
 Duong, Thai; Rizzo, Juliano. "Flickr's API Signature Forgery Vulnerability".
 Lyubashevsky, Vadim and Micciancio, Daniele and Peikert, Chris and Rosen, Alon (2008). "SWIFFT: A Modest Proposal for FFT Hashing". Fast Software Encryption. Lecture Notes in Computer Science. 5086. Springer. pp. 54–72. doi:10.1007/9783540710394_4. ISBN 9783540710387.CS1 maint: multiple names: authors list (link)
 Perrin, Chad (December 5, 2007). "Use MD5 hashes to verify software downloads". TechRepublic. Retrieved March 2, 2013.
 Lucks, Stefan (2004). "Design Principles for Iterated Hash Functions" – via Cryptology ePrint Archive, Report 2004/253. Cite journal requires
journal=
(help)  Kelsey, John; Schneier, Bruce (2004). "Second Preimages on nbit Hash Functions for Much Less than 2^n Work" – via Cryptology ePrint Archive: Report 2004/304. Cite journal requires
journal=
(help)  Biham, Eli; Dunkelman, Orr (24 August 2006). A Framework for Iterative Hash Functions – HAIFA. Second NIST Cryptographic Hash Workshop – via Cryptology ePrint Archive: Report 2007/278.
 Nandi, Mridul; Paul, Souradyuti (2010). "Speeding Up The Widepipe: Secure and Fast Hashing" – via Cryptology ePrint Archive: Report 2010/193. Cite journal requires
journal=
(help)  Dobraunig, Christoph; Eichlseder, Maria; Mendel, Florian (February 2015). "Security Evaluation of SHA224, SHA512/224, and SHA512/256" (PDF). Cite journal requires
journal=
(help)  Florian Mendel; Christian Rechberger; Martin Schläffer. "MD5 is Weaker than Weak: Attacks on Concatenated Combiners". "Advances in Cryptology – ASIACRYPT 2009". p. 145. quote: 'Concatenating ... is often used by implementors to "hedge bets" on hash functions. A combiner of the form MD5SHA1 as used in SSL3.0/TLS1.0 ... is an example of such a strategy.'
 Danny Harnik; Joe Kilian; Moni Naor; Omer Reingold; Alon Rosen. "On Robust Combiners for Oblivious Transfer and Other Primitives". "Advances in Cryptology – EUROCRYPT 2005". quote: "the concatenation of hash functions as suggested in the TLS... is guaranteed to be as secure as the candidate that remains secure." p. 99.
 Antoine Joux. Multicollisions in Iterated Hash Functions. Application to Cascaded Constructions. LNCS 3152/2004, pages 306–316 Full text.
 Finney, Hal (August 20, 2004). "More Problems with Hash Functions". The Cryptography Mailing List. Archived from the original on April 9, 2016. Retrieved May 25, 2016.
 Hoch, Jonathan J.; Shamir, Adi (2008). "On the Strength of the Concatenated Hash Combiner when All the Hash Functions Are Weak" (PDF). Retrieved May 25, 2016. Cite journal requires
journal=
(help)  Andrew Regenscheid, Ray Perlner, Shujen Chang, John Kelsey, Mridul Nandi, Souradyuti Paul, Status Report on the First Round of the SHA3 Cryptographic Hash Algorithm Competition
 XiaoyunWang, Dengguo Feng, Xuejia Lai, Hongbo Yu, Collisions for Hash Functions MD4, MD5, HAVAL128 and RIPEMD
 Xiaoyun Wang, Yiqun Lisa Yin, and Hongbo Yu, Finding Collisions in the Full SHA1
 Bruce Schneier, Cryptanalysis of SHA1 (summarizes Wang et al. results and their implications)
 FoxBrewster, Thomas. "Google Just 'Shattered' An Old Crypto Algorithm – Here's Why That's Big For Web Security". Forbes. Retrieved 20170224.
 Shai Halevi, Hugo Krawczyk, Update on Randomized Hashing
 Alexander Sotirov, Marc Stevens, Jacob Appelbaum, Arjen Lenstra, David Molnar, Dag Arne Osvik, Benne de Weger, MD5 considered harmful today: Creating a rogue CA certificate, accessed March 29, 2009.
External links
 Paar, Christof; Pelzl, Jan (2009). "11: Hash Functions". Understanding Cryptography, A Textbook for Students and Practitioners. Springer. Archived from the original on 20121208. (companion web site contains online cryptography course that covers hash functions)
 "The ECRYPT Hash Function Website".
 Buldas, A. (2011). "Series of minilectures about cryptographic hash functions". Archived from the original on 20121206. Cite journal requires
journal=
(help)  Rogaway, P.; Shrimpton, T. (2004). "Cryptographic HashFunction Basics: Definitions, Implications, and Separations for Preimage Resistance, SecondPreimage Resistance, and Collision Resistance". CiteSeerX 10.1.1.3.6200. Cite journal requires
journal=
(help)