Every time you create an account, you hand a website your password and then trust it to keep that password safe. But what actually happens to it after you hit “sign up”? The honest answer is that most people, including many who work in tech, have only a fuzzy idea.
Many also do not know what password hashing is or how the difference between two hashing algorithms you may never have heard of, SHA256 and Argon2id, can mean the difference between a password that survives a data breach and one that is cracked in seconds.
This guide explains how password hashing works, how these two algorithms compare, and what recent research tells us about which one is actually protecting you.
What is password hashing?
When you sign up for a service, it should never store your password as plain text. If it did, anyone who stole the database would instantly have every user’s password.
Instead, well-built services run your password through a hashing algorithm, a one-way mathematical function that turns your password into a long, fixed-length string of characters called a hash. The key word is one-way: you can turn a password into a hash easily, but you cannot reverse a hash back into the password.
When you log in, the service hashes what you typed and compares it to the stored hash. If they match, you’re in. The real password is never kept.
So where does the risk come from? When attackers steal a database of hashes, they try to reverse-engineer the passwords by guessing. They take billions of likely passwords, hash each one, and look for a match. This is called cracking, and how fast they can do it depends almost entirely on which algorithm was used.
SHA256: fast, trusted, but easier to crack
SHA256 is a member of the SHA-2 family and a genuinely excellent cryptographic hash. It is fast, reliable, and used everywhere from digital signatures to verifying file downloads.
But that speed its greatest strength for most jobs is exactly what makes it a poor choice for storing passwords. Because SHA256 is so quick to compute, an attacker can test an astronomical number of guesses per second.
Modern hardware can churn through hundreds of billions of SHA256 hashes a second, which means weak or even moderately strong passwords fall fast.
Argon2id: built specifically to resist cracking
Argon2 was created to solve that problem, and it won the 2015 Password Hashing Competition, an open contest to find a modern, purpose-built password-hashing algorithm. It comes in a few variants, and Argon2id is the recommended general-purpose choice for most systems.
Its defining feature is that it is memory-hard. Each hash calculation is deliberately designed to consume a large amount of memory, not just processing power.
That matters because attackers typically speed up cracking by using graphics cards (GPUs), which have thousands of small cores but limited memory per core.
A memory-hard algorithm chokes that advantage. The GPUs simply cannot run thousands of Argon2 calculations in parallel the way they can with SHA256.
The result: Argon2id is slow and expensive to attack by design, which is exactly what you want from a password hash.
SHA256 vs Argon2id: the head-to-head comparison
Recent time-to-crack research from Specops Software put both algorithms on identical hardware: a rig of eight Nvidia RTX 5090 graphics cards and measured how fast each could be cracked. The gap is enormous.
| Feature | SHA256 | Argon2id |
|---|---|---|
| Designed for | General cryptography (signatures, file integrity) | Password storage specifically |
| Speed philosophy | Fast by design | Deliberately slow and memory-hard |
| Cracking rate (8× RTX 5090) | ~221 billion hashes/sec | ~490 hashes/sec |
| Relative crack difficulty | Baseline | ~451 million times slower to crack |
| Real-world example | Password cracked in ~1 second | Same password holds for 14+ years |
| Resists GPU attacks? | No | Yes (memory-hard) |
| Best use for passwords? | Not recommended | Recommended |
To translate that bottom row: a password that would fall in one second when protected by SHA256 would take more than 14 years to crack when protected by Argon2id, on the very same equipment. That is not a small improvement; it is a different league.
The surprising footnote: CPUs can beat GPUs against Argon2
There is one twist worth knowing. Because Argon2’s memory-hard design specifically neutralizes the GPU advantage, a well-matched processor can actually do better.
In the same research, a tool called mdxfind reached 730 hashes per second on a single AMD EPYC server processor costing about $2,100, outperforming the far more expensive eight-GPU rig.
The takeaway is not that Argon2 is weak; it remains vastly stronger than SHA256, but that “stronger hashing” raises the cost of attack rather than making passwords magically uncrackable.
The limit no algorithm can fix
Here is the most important point, and it applies to SHA256, Argon2id, and every algorithm in between: none of this protects a password an attacker already has.
If your password leaked in an earlier data breach, was captured by a phishing page, or was stolen by an infostealer on your device, the hashing algorithm is irrelevant.
The attacker simply logs in with the real password. And weak, predictable passwords can still be guessed regardless of how they are stored.
That is why strong hashing is one layer of defense, not the whole wall.
What this means for you
If you’re a developer or run a system: use a memory-hard algorithm like Argon2id (or bcrypt/scrypt) for password storage, never a fast hash like SHA256 or MD5. Combine it with salting and, where possible, screening against known-breached credentials.
If you’re an everyday user: you can’t choose the algorithm a website uses, but you can remove the weakest link. Use long passwords; the research recommends a minimum of 15 characters. Never reuse them across sites, and lean on a password manager to make that practical.
If you run a business: the highest-value move is blocking passwords that are already known to be compromised. The Specops research coincides with an update to its Breached Password Protection service, which added more than 60 million newly compromised passwords from its honeypot network and threat intelligence sources. Screening Active Directory passwords against a live breach database means an exposed credential gets flagged and changed before an attacker can use it.
Conclusion
SHA256 and Argon2id are both excellent algorithms at completely different jobs. SHA256 is a fast, trusted workhorse for general cryptography, but its speed makes it a poor guardian for passwords. Argon2id is purpose-built to be slow and memory-hard, making it hundreds of millions of times harder to crack.
But the strongest hash in the world can’t defend a password that has already been stolen. The real security formula is simple: a modern hashing algorithm behind the scenes, plus long, unique passwords and breach screening out front.
