Hvordan bør passord lagres og håndteres sikkert?

Question

Accepted Answer

Passord må lagres sikkert — **aldri i klartekst**, men **hashet** med en sterk, langsom, saltet passord-hash-algoritme (bcrypt, Argon2, scrypt). Riktig passord-håndtering er kritisk fordi passord-brudd er ekstremt skadelige og vanlige.

## Aldri lagre klartekst; hash riktig

```text
❌ NEVER store passwords in plaintext (a breach exposes all passwords directly)
❌ Don't use fast/general hashes (MD5, SHA-256) alone — too fast → easily brute-forced
✅ HASH with a dedicated PASSWORD HASHING algorithm: BCRYPT, ARGON2, or scrypt:
  → SLOW by design (resistant to brute-force/GPU cracking)
  → SALTED (a unique random salt per password) → prevents rainbow-table attacks and
    identical passwords hashing the same
```

```js
// hashing with bcrypt (handles salting automatically)
const hash = await bcrypt.hash(password, 12);   // store the hash (with salt + cost)
// verifying at login
const valid = await bcrypt.compare(inputPassword, storedHash);   // compare securely
```

## Hvorfor disse algoritmene

```text
SALT → unique random value per password → identical passwords get DIFFERENT hashes;
  defeats precomputed (rainbow table) attacks
SLOW (work factor) → deliberately expensive to compute → brute-forcing millions of
  guesses becomes impractical (tunable cost factor as hardware improves)
→ bcrypt/Argon2/scrypt are designed for passwords; general hashes (SHA) are NOT.
```

## Andre passord-praksis

```text
✓ Enforce reasonable strength (length over complexity); check against breached-password lists
✓ MULTI-FACTOR authentication (MFA) → strong protection even if a password leaks
✓ HTTPS for transmission; rate-limit / lock out brute-force login attempts
✓ Secure password RESET (time-limited tokens); never email passwords; never log them
```

## Hvorfor det er viktig

Å forstå sikker passord-lagring og håndtering er essensielt fordi **passord-brudd er ekstremt vanlige og skadelige**, og feil passord-lagring er en alvorlig, hyppig sårbarhet, så det er kritisk sikkerhetskunnskap.

De grunnleggende reglene er kritiske: **lagre aldri passord i klaritekst** (et brudd ville eksponere ethvert brukers passord direkte — katastrofalt), og **ikke stol på raske generelle hash-funksjoner** (MD5, SHA-256) som er for raske og lett knekkes ved brute-force.

I stedet bør du **hashe med dedikerte passord-hash-algoritmer** (bcrypt, Argon2, scrypt) som er **langsomme ved design** (motstandsdyktige mot brute-force og GPU-angrep) og **saltete** (en unik tilfeldig salt per passord, som forhindrer rainbow-table-angrep og sikrer at identiske passord får ulike hashes).

Å forstå **hvorfor disse algoritmene** — salting (som besejrer forhåndsberegnede angrep og gjør at identiske passord hastes ulikt) og langsomhet/work-faktor (som gjør massebrute-force upraktisk, med justerbar kostnad etter hvert som maskinvaren forbedres) — forklarer den riktige tilnærmingen kontra vanlige feil (klarekst, raske hash-funksjoner, ingen salt).

Å forstå **andre praksis** — å håndheve rimelig styrke (lengde fremfor kompleksitet, sjekking mot lister over brutte passord), **MFA** (sterk beskyttelse selv om et passord lekker), HTTPS for overføring, hastighetsbegrensning av påloggingsforsøk, sikker passord-tilbakestilling (tidsavgrensede tokens), og aldri logging eller e-post med passord — reflekterer omfattende passord-sikkerhet.

Passord-håndtering er et høyrisiko-område hvor feil (klarekst-lagring, svak hashing) direkte forårsaker store brudd, mens riktig håndtering (sterk saltetet hashing, MFA) beskytter brukere betydelig.

Fordi passord-brudd er vanlige og skadelige og feil lagring er en alvorlig, hyppig sårbarhet, og fordi å forstå sikker lagring (aldri klarekst, sterk saltetet langsom hashing med bcrypt/Argon2) og god praksis (MFA, hastighetsbegrensning) er essensielt for å beskytte brukere, er forståelse av sikker passord-lagring og håndtering essensielt, kritisk sikkerhetskunnskap — et kritisk, høyrisiko-område hvor den riktige tilnærmingen (dedikert passord-hashing, salting, MFA) forhindrer de katastrofale passord-bruddene som feil håndtering forårsaker, grunnleggende kunnskap for enhver utvikler som håndterer autentisering.