Kaip jūs šifruojate slaptažodžius ir naudojate crypto modulį?

Question

Accepted Answer

Node įtaisytasis **`crypto`** modulis teikia kriptografines funkcijas: šifravimą, šifrą, atsitiktines reikšmes ir HMAC. Svarbiausias praktinis panaudojimas — **slaptažodžio šifravimas** — turi kritinę taisyklę: niekada nenaudokite greitų, bendrojo tikslo šifrų (MD5/SHA-256) slaptažodžiams.

## Slaptažodžio šifravimas: naudokite LĖTĄ, druską turintį algoritmą

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

Svarbiausiai punktai: **`scrypt`** (arba bcrypt/argon2) yra *sąmoningai lėtas* brute-force atakoms atsparus; **unikalus druskos per slaptažodį** atmeta rainbow lenteles; ir **`timingSafeEqual`** lygina šifrus pastoviu laiku, kad būtų išvengta laiko atakų.

## Kodėl ne MD5/SHA-256 slaptažodžiams

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

Greiti šifrai yra gerai failų kontrolinėms sumoms, tačiau katastrofiški slaptažodžiams — jų greitis yra tiesiog tai, kas juos brute-force jautriais daro. (Praktiškai bibliotekos kaip **bcrypt** arba **argon2** dažnai pirmenybė gauna grynojo scrypt prieš ergonomiją.)

## Kitas crypto naudojimas

```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");
```

## Kodėl tai svarbu

Slaptažodžio saugojimo teisingumas yra kritinė saugumo atsakomybė, ir tai yra dažna, pavojinga klaida naudoti greitus šifrus arba praleisti druską.

`crypto` modulis (arba aukštesnio lygio bcrypt/argon2) teikia teisingus primityvus: lėtus druską turintį šifrą slaptažodžiams, pastovaus laiko palyginimą, saugų atsitiktinių reikšmių generavimą žetonams, ir HMAC integralo patvirtinimui (kaip webhook parašams).

Supratimas *kodėl* slaptažodžiams reikalingas lėtas, druskos turintis, pastovaus laiko tvarkymas — ir tai, kad greitieji šifrai skirti tik ne paslapties kontrolinėms sumoms — yra būtinas norint sukurti autentifikaciją, kuri neatskleistų vartotojus kredencialo vagystės grėsmei.