Hur bör lösenord lagras och hanteras säkert?

Question

Accepted Answer

Lösenord måste lagras säkert — **aldrig i klartext**, utan **hashade** med en stark, långsam, saltad lösenordshashningsalgoritm (bcrypt, Argon2, scrypt). Korrekt lösenordshantering är kritisk eftersom lösenordskränkningar är extremt skadliga och vanliga.

## Lagra aldrig klartext; hasha korrekt

```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
```

## Varför dessa algoritmer

```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.
```

## Andra lösenordspraxis

```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
```

## Varför det är viktigt

Att förstå säker lagring och hantering av lösenord är väsentligt eftersom **lösenordskränkningar är extremt vanliga och skadliga**, och felaktig lösenordslagring är en allvarlig, vanlig sårbarhet, så det är måste-kunskap inom säkerhet.

De grundläggande reglerna är kritiska: **lagra aldrig lösenord i klartext** (en kränkning skulle exponera varje användares lösenord direkt — katastrofalt), och **förlita dig inte på snabba generella hash-funktioner** (MD5, SHA-256) som är för snabba och lätt bryts.

Istället **hasha med dedikerade lösenordshashningsalgoritmer** (bcrypt, Argon2, scrypt) som är **långsamma från design** (motstånd mot brute-force och GPU-cracking) och **saltade** (en unik slumpmässig salt per lösenord, förhindrar regnbågstabellattacker och säkerställer att identiska lösenord får olika hasher).

Att förstå **varför dessa algoritmer** — saltning (besegra förkalkylerade attacker, göra så identiska lösenord hasherar olika) och långsamhet/arbetsfaktor (göra massiv brute-forcing opraktisk, med en justerbar kostnad när hårdvaran förbättras) — förklarar rätt tillvägagångssätt kontra vanliga misstag (klartext, snabba hasher, ingen salt).

Att förstå **andra praxis** — genomdriva rimlig styrka (längd framför komplexitet, kontrollera kränkta lösenordslistor), **MFA** (starkt skydd även om ett lösenord läcker), HTTPS för överföring, hastighetsbegränsning av inloggningsförsök, säker lösenordsåterställning (tidsbegränsade tokens), och aldrig logga eller skicka lösenord via e-post — återspeglar omfattande lösenordssäkerhet.

Lösenordshantering är ett högt insatsområde där misstag (klartext-lagring, svag hashning) direkt orsakar stora kränkningar, medan korrekt hantering (stark saltad hashning, MFA) skyddar användare betydligt.

Eftersom lösenordskränkningar är vanliga och skadliga och felaktig lagring är en allvarlig, vanlig sårbarhet, och eftersom förståelse för säker lagring (aldrig klartext, stark saltad långsam hashning med bcrypt/Argon2) och god praxis (MFA, hastighetsbegränsning) är väsentlig för att skydda användare, är förståelse för säker lösenordslagring och hantering väsentlig, måste-kunskap inom säkerhet — ett kritiskt, högt insatsområde där rätt tillvägagångssätt (dedikerad lösenordshashning, saltning, MFA) förhindrar de katastrofala lösenordskränkningar som felaktig hantering orsakar, grundläggande kunskap för alla utvecklare som hanterar autentisering.