Why password hashes break

You read it all the time: "database of website X stolen, millions of passwords leaked". But a good site doesn't store your password — only its hash. And you can't calculate a password back from a hash, you know that since the last chapter. So… is there even a problem? Yes. And in this chapter you play the hacker to see why.

How an "uncrackable" hash gets cracked anyway

The hacker doesn't calculate backwards. He calculates forwards. He takes a list of the billion most-used passwords — 123456, qwerty, welcome, the names of every football club — and calculates the hash of each one. That takes a while, but he only has to do it once. After that, he compares the stolen hashes against his list. Every hash that matches is a cracked password. No math, just patience and a big hard drive.

Salt: everyone gets their own problem

A hash is just a function, and you can write it down like any other. Call your password x and the hash y:

y = SHA256(x)

And that's exactly where the problem sits. The same x always gives the same y — that's the first rule from chapter 2. So everyone in the world who picks welcome ends up in the database with the exact same 64 characters:

Three times the same row. The hacker looks up 280d44ab1e9f… once in his table and has all three at the same time. With ten million accounts it works exactly as well.

What salt changes about that

Salt fixes this by gluing one thing in front of the password:

y = SHA256(salt + x)

Exactly how you'd write it yourself. Watch the + though: here it doesn't mean adding up, but sticking together. Salt and password become one long text, and that is what the hash is taken of. A salt of a3f9c2e1… with password welcome therefore hashes the text a3f9c2e1…welcome.

And here's the point: every user gets a different salt, which the website draws at random the moment you register. Same table, same password:

Three times the same password, three hashes that have nothing to do with each other. That's the avalanche effect from chapter 2 at work: the input differs, so the output differs completely. From the database you can no longer see who has the same password.

But the salt is sitting right there

Look at that table again. The salt is in its own column, readable, in the same database that got stolen. So the hacker has it too. And it still works — that's the clever part.

His ready-made table holds the hashes of SHA256(x). What he needs are the hashes of SHA256(a3f9c2e1… + x). Those are completely different numbers. His table is worthless in one stroke: he has to compute it all over again — a billion passwords × one hash — and then he only has Sam. For Noor he starts from scratch, because her salt is different. And for Jules once more.

That's what salt does. It doesn't make your password one bit stronger. It turns one big job — cracking ten million accounts — into ten million separate jobs. Click Same password, with salt in the demo above and you'll see it happen twice with real numbers.

Slowness: the one weapon that really counts

SHA-256 is blazing fast — a decent graphics card manages billions of hashes per second. That's handy for files and disastrous for passwords. That's why good sites use a function that's deliberately slow. Click PBKDF2 in the demo and watch the time. A few hundred milliseconds is barely noticeable to you when logging in. But for the hacker, every attempt gets multiplied by that number — and he has billions of attempts to make.

What this means for you

• Length beats weirdness. blue-bike-rain-tuesday is much stronger than P@ss1!, because it's on no list at all.
• Never reuse a password across two sites. If the weakest site leaks, hackers immediately try that password on your email and your games.
• A password manager remembers it for you. Then every password can be thirty random characters — you only have to remember one.

For when you build a website yourself one day: never write this yourself. Every programming language has a built-in function that handles salt and slowness properly (in PHP it's called password_hash()). Rolling your own thing with a hash and a salt is the classic beginner mistake — and behind half the leaks in the news.