Programma Les 78 van 156 · Privacy bij ontwerp
Privacy bij ontwerp

Behoud wat je veilig bewaart

Waarom dit ertoe doetZelfs een zorgvuldige site houdt wat data vast: een e-mail om in te loggen, een wachtwoord, misschien een adres voor leveringen. Databases worden gekopieerd, back-ups gaan verloren, laptops worden gestolen. Als het goed gedaan is, vertelt een gestolen kopie van je database de dief bijna niets. Deze les behandelt de twee belangrijkste tools: password hashing en het versleutelen van velden in rust.

Wachtwoorden: sla ze nooit op, sla een trage vingerafdruk op

Denk aan een blender. Doe een aardbei erin en je krijgt een smoothie; je kunt de aardbei niet terugkrijgen. Om een wachtwoord te controleren, blend je de poging op dezelfde manier en kijk je of de smoothie overeenkomt. Je hebt het origineel nooit nodig.

Password hash: een eenrichtingsvingerafdruk van een wachtwoord, gemaakt met een functie die bewust traag is en een salt gebruikt, zodat gestolen hashes erg duur zijn om te raden.

Salt: willekeurige bytes die naast elke hash worden opgeslagen en ervoor worden gemengd, zodat twee mensen met hetzelfde wachtwoord verschillende hashes krijgen en vooraf berekende lijst met gokken nutteloos zijn.

Waarom traag? Een snelle hash zoals plain SHA-256 kan miljarden keren per seconde worden geprobeerd, dus korte wachtwoorden vallen snel. Wachtwoordhashes zijn afgesteld om elk een merkbaar fractie van een seconde te kosten. Dat is niets voor één login en een enorme kosten voor iemand die een miljard gokken probeert. De veelgebruikte keuzes zijn Argon2id (de eerste aanbeveling in de wachtwoordopslagrichtlijn van OWASP), scrypt, bcrypt en PBKDF2 (gecontroleerd oktober 2026).

# Teaching code. In a real app, use your framework's password functions.
import hashlib, hmac, os

ROUNDS = 600_000    # PBKDF2-HMAC-SHA256 setting suggested by OWASP (checked October 2026)

def hash_password(password):
    salt = os.urandom(16)
    key = hashlib.pbkdf2_hmac("sha256", password.encode(), salt, ROUNDS)
    return salt.hex() + "$" + key.hex()

def check_password(password, stored):
    salt_hex, key_hex = stored.split("$")
    key = hashlib.pbkdf2_hmac("sha256", password.encode(), bytes.fromhex(salt_hex), ROUNDS)
    return hmac.compare_digest(key.hex(), key_hex)   # compare without leaking timing

In Django schrijf je dit niet zelf: user.set_password() en check_password() gebruiken standaard al PBKDF2, en Django kan overschakelen naar Argon2 of scrypt in settings (gecontroleerd oktober 2026).

Een veelvoorkomende misvatting: "we versleutelen onze wachtwoorden". Versleuteling kan worden ongedaan gemaakt door iedereen die de sleutel heeft, dus één gestolen sleutel onthult elk wachtwoord. Wachtwoorden moeten worden gehasht, nooit versleuteld.

Andere velden: versleutel in rust, bewaar de sleutel ergens anders

Een e-mailadres moet weer leesbaar zijn (om een ontvangstbewijs te sturen), dus een one-way hash is niet voldoende. Hier encrypt: vergrendel de waarde met een sleutel en ontgrendel deze alleen wanneer de app het nodig heeft.

Encryption at rest: het opslaan van data in de database of op de schijf in vergrenderde vorm, zodat een kopie van de bestanden onleesbaar is zonder de sleutel.

  • Houd de sleutel buiten de database, bijvoorbeeld in een omgevingsvariabele of een key service. Een sleutel die in dezelfde back-up als de data staat beschermt niets.
  • Gebruik een getoetste library, nooit zelfgemaakte cryptografie. In Python is de Fernet van het cryptography pakket een eenvoudige, veilige keuze.
  • Dingen opzoeken. Goede versleuteling geeft elke keer een ander resultaat, zelfs voor dezelfde e-mail, dus je kunt er niet naar zoeken. Sla een keyed hash ernaast op, een HMAC (een hash gemengd met een geheime sleutel), en zoek daarop. Zonder de sleutel kan de HMAC niet worden brute-forced zoals een gewone hash dat kan.
# Concept sketch (needs: pip install cryptography)
from cryptography.fernet import Fernet
import hmac, hashlib
box = Fernet(ENCRYPTION_KEY)                      # key from the environment
email_enc = box.encrypt(email.encode())           # stored, readable only with the key
email_lookup = hmac.new(LOOKUP_KEY, email.strip().lower().encode(), hashlib.sha256).hexdigest()

Zo werkt de eigen wachtlijst van floati.life: de e-mail wordt versleuteld opgeslagen, duplicaten worden gevonden met een keyed HMAC van het adres, en alleen een hash van het IP-adres wordt bewaard voor rate limiting. De Learn "save across devices" functie gaat verder en slaat de e-mail helemaal niet op, alleen een keyed fingerprint, met versleutelde voortgang (gecontroleerd in oktober 2026).

Wat het beschermt, en wat het niet beschermt

Encryption at rest beschermt tegen een gestolen backup, een gekopieerde database of een verloren schijf. Het doet notbeschermen tegen een aanvaller die code uitvoert binnen je app, omdat je app de sleutel vasthoudt. Daarom is het verzamelen van minder (les 76) en op tijd verwijderen (volgende les) nog steeds het belangrijkst.

In andere talen
// JavaScript (Node): password hashing with built-in scrypt
const salt = crypto.randomBytes(16);
const key = crypto.scryptSync(password, salt, 64);
// Go
hash, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
// PHP (Argon2id where available)
$hash = password_hash($password, PASSWORD_ARGON2ID);
$ok = password_verify($attempt, $hash);
// C# (ASP.NET Core Identity)
var hash = new PasswordHasher<User>().HashPassword(user, password);

Samenvatting

  • Hash wachtwoorden met een trage, gesalzde functie (Argon2id, scrypt, bcrypt of PBKDF2); versleutel ze nooit.
  • Versleutel velden die je terug moet lezen, houd de sleutel buiten de database en zoek ze op met een keyed HMAC.
  • Encryption at rest stopt gestolen kopieën, niet een aanvaller binnen je draaiende app.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.