Hashing is not anonymising

A one-way blender

Think of a hash as a blender: put in a strawberry and you get the same pink smoothie every time, but you cannot turn the smoothie back into a strawberry. That sounds safe. The catch: if you suspect it was a strawberry, you blend one yourself and compare.

Why it is not anonymous

Emails are hashed precisely so two companies can match them: both hash sam.smith@mail.example and get the same 64 characters. Hashed-email IDs in advertising work this way. The hash is a stable ID for the person, not a disguise.

And there are not that many emails. Our practice mail system only hands out first.last@domain or firstNN@domain, from 30 first names, 30 last names and 3 domains: 11,610 possible addresses in total. Hashing all of them takes a blink. Real address spaces are much bigger, but data brokers already hold huge lists of real addresses, so they only hash what they have and compare.

The plan

1. normalise(email): strip spaces and lower-case. Everyone does this before hashing, so Sam.Smith@Mail.Example and sam.smith@mail.example match.
2. sha256_hex(text): hashlib.sha256(text.encode("utf-8")).hexdigest(). .encode turns text into bytes, which is what hash functions eat.
3. all_candidates(): loop over domains, first names and last names to list every possible address.
4. crack(hashes): build a dict from each candidate's hash to the candidate, once, then look each leaked hash up. Building it once matters: hashing 11,610 addresses for every one of 200 leaked hashes would be 200 times slower.

A common misconception

"SHA-256 is unbreakable, so hashed data is safe." SHA-256 is fine at what it does: nobody runs it backwards. The weakness is the input: when the possible inputs can be listed, you never need to run it backwards. Phone numbers are a well-known case: all the numbers in one country fit into a few billion possibilities, few enough for a fast computer to try every one.

Reminder: this only ever runs on synthetic addresses. Doing it to real people's data is exactly the harm this module teaches you to prevent, and the next lesson is the defence.

const { createHash } = require("crypto");
const sha256 = t => createHash("sha256").update(t, "utf8").digest("hex");

const lookup = new Map(allCandidates().map(e => [sha256(e), e]));
const found = leaked.filter(h => lookup.has(h)).map(h => [h, lookup.get(h)]);

$lookup = [];
foreach (all_candidates() as $e) { $lookup[hash('sha256', $e)] = $e; }
$found = array_intersect_key($lookup, array_flip($leaked));