Hello and welcome to this fundamentals of cryptography course, so far in this section we've been talking
about hash functions started out with an introduction to hash functions, talking about what they are,
how they work, et cetera, in the next second video.
We discussed some of the security assumptions of hash functions, essentially what needs to be true
about a hash algorithm for to do what it has to.
In this video, we're going to talk about some common hash functions, both from a historical and a
modern day perspective.
And there certainly are a lot of hash algorithms out there.
We're including this video because it's interesting to see how some of the most well-known hash algorithms
in existence aren't news sitting more.
And so in this video, we have two main topics.
We're going to start out with a history of hash algorithms looking at some of the most famous hash algorithms
in existence and how they're currently considered secure or insecure.
We'll then move on to a brief discussion of the SHA Hash family.
So there are a lot of different hash algorithms out there.
Many of them are single algorithm sets.
Shor's a bit different in that it's a collection of related hash functions.
And in fact, some of the SHA hash algorithms in that family are currently considered deprecated or
insecure, while others are still in common use today and some are intended for use in the future.
But first, let's talk about a brief history of harsh algorithms.
So when we talk hash, algorithms, security, it works a lot like the security of encryption algorithms.
Essentially, you're using them until they break.
So when and why do you hash algorithms break?
And the previous video, we discussed some of the security assumptions of hash algorithms.
They need to be collision resistant.
And in order to have that collision resistance, you need a one way function.
You need a large state space and you need to non locality.
And with those together and discussing the pigeonhole principle, we've got a hard upper bound on the
number of inputs that an attacker has to try until they find a collision.
However, we also briefly mentioned the birthday paradox, which puts a much lower bound on how many
will have to be tried before you've got a reasonable Pro Bowl probability of success.
And so when we talk about a hash function being broken, typically it's considered insecure after the
first collision has been found because there's the assumption that if it can be done once, someone
motivated enough can do it again.
And depending on how what data is being protected by that algorithm, people might be motivated enough
to do so.
And so some of the most well-known hash algorithms are MDT five, Shaa one and Schaar 256.
So Empty five was designed to create 128 bit hash.
So theoretically, there are two to 128 bit output options.
And so that's how many you should have to try before you're guaranteed to find a collision.
However, MDT five was broken after trying about two to the twenty one hashes.
So it's a much, much, much smaller value and really demonstrates that difference between that theoretical
upper bound and the practical.
How many have to be searched before you find a collision?
That upper bound is the guaranteed stopping point.
Not read actually have to stop in reality.
Same thing with Sha one sha one's a well-known algorithm.
It produced one hundred and sixty bit harsh and it was broken after two to the sixty one hashes.
So again, much, much smaller.
SHA 256 is a 256 bit harsh.
And it's currently considered secure.
Nobody successfully created a collision for the SHA 256 hash algorithm.
And so sha one and SHA 256 are examples of the sha hash family.
So SHA actually stands for secure hash algorithms.
And it was published by Nyst as a federal information processing standard, or FIPS.
And what this just means is that it received Nest's blessing for use in government systems for its intended
purpose.
So hash algorithms designed to protect the integrity of data.
And so you're allowed to use Shaw in the U.S. government for data integrity protection.
However, you need to use the secure or trusted algorithms.
So Schaar is generally a fan lamp hash algorithms.
You have Shor's zero, Shaa one, SHA two and SHA three.
And in streetside SHA two and shot three, you actually have subfamilies.
So there's Shalal 224 256 384 512, each of which produce outputs of the length in their name to twenty
four to fifty six, three, eighty four and 512.
You also have Schaff 512 224 and Schaff 512 256 which produce a longer output, but then truncate it
down to a shorter length.
In short, three, you again have a collection of hash functions.
I have shot three in each of the three lengths that we see above two.
Twenty four, two fifty six, three eighty four and five twelve.
And then you also have Shake 128 and shake two.
Fifty six.
And so currently, of these four groups of hash algorithms, you have two sets that are trusted.
Shabaz zero and Shaa one are no longer trusted.
They're considered weak and deprecated because somebody has found a coalition for them that shall,
too, and shall.
Three algorithms are currently considered secure and are trusted for common use.
And in fact, say SHA 256 is one of the best known hash algorithms out there, and that's under the
SHA to subclass.
And so just as a brief recap in this video, talking about what makes hash algorithms trusted untrusted
in some of the more common algorithms.
So looking at the history of hash algorithms, we saw the MDT five and Schar one, which have some of
the best name recognition hash hash algorithms are actually no longer considered secure or fit for purpose.
256, on the other hand, perfectly usable.
And that same sort of trend between trusted, non trusted continues in the Shaw family.
You have a huge collection of hash functions, some of which are trusted and some of which are not,
because somebody is found a coalition for them.
And so it's important to know when using a hash algorithm whether or not it's actually trusted and fit
for purpose based off of if someone's found a collision for it.
Thank you.