Kuinka tiivisit salasanoja ja käytät crypto-moduulia?

Question

Accepted Answer

Noden sisäänrakennettu **`crypto`**-moduuli tarjoaa kryptografisia funktioita: tiivistäminen, salaus, satunnaiset arvot ja HMAC. Tärkein käytännön käyttö — **salasanan tiivistäminen** — on kriittinen sääntö: älä koskaan käytä nopeita, yleiskäyttöisiä tiivisteitä (MD5/SHA-256) salasanoille.

## Salasanan tiivistäminen: käytä HIDASTA, suolattua algoritmia

```js
import { scrypt, randomBytes, timingSafeEqual } from "crypto";
import { promisify } from "util";
const scryptAsync = promisify(scrypt);

// HASH a password (on signup)
async function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");          // unique random salt per user
  const derived = await scryptAsync(password, salt, 64); // slow, salted derivation
  return `${salt}:${derived.toString("hex")}`;            // store salt + hash together
}

// VERIFY a password (on login)
async function verify(password, stored) {
  const [salt, hash] = stored.split(":");
  const derived = await scryptAsync(password, salt, 64);
  const hashBuf = Buffer.from(hash, "hex");
  return timingSafeEqual(hashBuf, derived); // constant-time compare (avoid timing attacks)
}
```

Keskeiset kohdat: **`scrypt`** (tai bcrypt/argon2) on *tarkoituksella hidas* brute-force-hyökkäysten vastustamiseen; **ainutlaatuinen suola jokaista salasanaa kohti** estää sateenkaaren taulukot; ja **`timingSafeEqual`** vertaa tiivisteitä vakioajassa ajoitushyökkäysten estämiseksi.

## Miksi EI MD5/SHA-256 salasanoille

```js
// ❌ NEVER do this — SHA/MD5 are FAST, so attackers can guess billions/sec
crypto.createHash("sha256").update(password).digest("hex");
```

Nopeat tiivisteet sopivat tiedoston tarkistussummille mutta ovat katastrofaaliset salasanoille — niiden nopeus on juuri se, joka tekee niistä alttiita brute-force-hyökkäyksille. (Käytännössä kirjastot, kuten **bcrypt** tai **argon2**, ovat usein parempia kuin raaka scrypt käytettävyyden vuoksi.)

## Muut crypto-käytöt

```js
import crypto from "crypto";

crypto.randomBytes(32).toString("hex");        // secure random tokens (session ids, CSRF)
crypto.randomUUID();                            // a secure UUID v4

// HMAC — verify integrity/authenticity (e.g. webhook signatures)
crypto.createHmac("sha256", secret).update(payload).digest("hex");

// hashing for NON-secret integrity (file checksums) — SHA is fine here
crypto.createHash("sha256").update(fileBuffer).digest("hex");
```

## Miksi se on tärkeää

Salasanan varastoinnin oikea tekeminen on kriittinen turvallisuusvastuulla, ja on yleinen, vaarallinen virhe käyttää nopeita tiivisteitä tai ohittaa suolaus.

`crypto`-moduuli (tai korkeamman tason bcrypt/argon2) tarjoaa oikeat primitiivit: hitaan suolatun tiivistämisen salasanoille, vakioaikaisen vertailun, turvallisen satunnaisen sukupolven tokeneille ja HMAC:n eheyden tarkistamiseen (kuten webhook-allekirjoitukset).

Ymmärtäminen *miksi* salasanat tarvitsevat hidasta, suolattua, vakioaikaista käsittelyä — ja että nopeat tiivisteet ovat vain ei-salaisille tarkistussummille — on välttämätöntä todennuksen luomiselle, joka ei altista käyttäjiä tunnistetietojen varkaudelle.