Wie versenden Sie Passwörter und verwenden das crypto-Modul?

Question

Accepted Answer

Nodes eingebautes **`crypto`**-Modul bietet kryptografische Funktionen: Hashing, Verschlüsselung, Zufallswerte und HMAC. Die wichtigste praktische Anwendung — **Passwort-Hashing** — hat eine kritische Regel: Verwenden Sie niemals schnelle, allgemeine Hashes (MD5/SHA-256) für Passwörter.

## Passwort-Hashing: Verwenden Sie einen LANGSAMEN, gesalzenen Algorithmus

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

Schlüsselpunkte: **`scrypt`** (oder bcrypt/argon2) ist *absichtlich langsam*, um Brute-Force-Angriffen zu widerstehen; ein **eindeutiges Salt pro Passwort** schlägt Rainbow-Tabellen fehl; und **`timingSafeEqual`** vergleicht Hashes in konstanter Zeit, um Timing-Angriffe zu verhindern.

## Warum NICHT MD5/SHA-256 für Passwörter

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

Schnelle Hashes eignen sich gut für Datei-Checksummen, sind aber katastrophal für Passwörter — ihre Geschwindigkeit ist genau das, was sie anfällig für Brute-Force macht. (In der Praxis werden Bibliotheken wie **bcrypt** oder **argon2** häufig gegenüber reinem scrypt bevorzugt, um die Ergonomie zu verbessern.)

## Andere crypto-Verwendungen

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

## Warum es wichtig ist

Die ordnungsgemäße Speicherung von Passwörtern ist eine kritische Sicherheitsverantwortung, und es ist ein häufiger, gefährlicher Fehler, schnelle Hashes zu verwenden oder das Salzen zu überspringen.

Das `crypto`-Modul (oder höherwertiges bcrypt/argon2) bietet die richtigen Primitive: langsames, gesalzenes Hashing für Passwörter, konstante Zeitvergleiche, sichere Zufallsgenerierung für Token und HMAC zur Integritätsprüfung (wie Webhook-Signaturen).

Zu verstehen, *warum* Passwörter langsame, gesalzene, zeitkonstante Behandlung benötigen — und dass schnelle Hashes nur für nicht-geheime Checksummen vorgesehen sind — ist für die Erstellung einer Authentifizierung, die Benutzer nicht dem Diebstahl von Anmeldedaten aussetzt, von Wesentlicher Bedeutung.