mitmario.dev

Passwörter speichern

Node.js Sandbox 4 Min Lesezeit 3 BeispieleLektion 1 von 7

Eine Sitzung weiß, dass jemand wiederkommt, aber nicht, wer. Dafür braucht es Konten, und ein Konto braucht ein Passwort, das irgendwo gespeichert wird. Wer erst das Formular baut und sich dann Gedanken über das Speichern macht, hat die Passwörter längst im Klartext in der Tabelle.

Ein Passwort speichert man gar nicht

In der Datenbank steht nur etwas, das sich aus dem Passwort berechnen lässt und aus dem man nicht zurückrechnen kann. Das gilt auch für die eine Zeile, die du „nur zum Testen“ einbaust, denn die bleibt drin. Und es gilt selbst dann, wenn niemand außer dir an die Datenbank kommt. Es geht hier ja gerade um den Tag, an dem doch jemand drankommt.

Ein Hash wie SHA-256 klingt nach der Antwort darauf. Er ist eine Einbahnstraße, aus dem Ergebnis lässt sich die Eingabe nicht zurückrechnen. Für Passwörter ist er trotzdem der falsche, und im Beispiel stecken beide Gründe.

Derselbe Hash für dasselbe Passwort
import { createHash, scryptSync } from "node:crypto";

function sha256(text) {
  return createHash("sha256").update(text).digest("hex");
}

// Drei Konten, zwei davon mit demselben Passwort.
console.log(`Anna:  ${sha256("geheim123")}`);
console.log(`Bernd: ${sha256("geheim123")}`);
console.log(`Clara: ${sha256("geheim124")}`);

// Wie schnell „schnell" ist. Die nackte Millisekundenzahl schwankt von
// Lauf zu Lauf, die Antwort auf die Frage nicht.
const vorher = process.hrtime.bigint();
for (let i = 0; i < 1000; i++) sha256(`versuch${i}`);
const dazwischen = process.hrtime.bigint();
scryptSync("geheim123", "irgendeinsalt", 64);
const nachher = process.hrtime.bigint();

console.log(`1000 mal sha256 geht schneller als 1 mal scrypt: ${dazwischen - vorher < nachher - dazwischen}`);

Der erste Grund sind Anna und Bernd. Sie haben dasselbe Passwort, und deshalb sind ihre beiden Hashes Zeichen für Zeichen gleich. Wer die Tabelle in die Hand bekommt, sortiert nach dieser Spalte und weiß sofort, welche Konten zusammengehören. Ein einziges geknacktes Passwort öffnet dann gleich mehrere Türen.

Den zweiten Grund siehst du in der letzten Zeile der Ausgabe. SHA-256 ist für Geschwindigkeit gebaut, und hier ist Geschwindigkeit das Falsche. Ein Angreifer mit deiner Tabelle probiert Milliarden Passwörter pro Sekunde, und zwar der Reihe nach die, die Menschen wirklich nehmen. Für Hashes ohne Salt muss er die Liste nicht einmal selbst rechnen. Die gibt es fertig.

Salt macht jede fertige Liste wertlos

Gegen beides hilft ein zufälliger Wert, der zu jedem Passwort dazukommt und mitgespeichert wird, der Salt. Geheim ist er nicht. Er muss nur je Konto verschieden sein.

Salt gegen die fertige Liste
import { randomBytes, scryptSync } from "node:crypto";

// Verfahren, Kostenfaktor, Salt und Hash in einem Text. Wer
// spaeter das Verfahren wechselt, erkennt an den ersten beiden Feldern,
// was mit einem alten Eintrag zu tun ist.
function speichern(passwort, salt) {
  const hash = scryptSync(passwort, salt, 64);
  return ["scrypt", 16384, salt.toString("hex"), hash.toString("hex")].join("$");
}

const anna = speichern("geheim123", randomBytes(16));
const bernd = speichern("geheim123", randomBytes(16));
console.log(`Anna und Bernd, jeder mit eigenem Salt, gleich? ${anna === bernd ? "ja" : "nein"}`);

// Nur fuer dieses Beispiel ein fester Wert, damit unten immer dasselbe
// steht. In deinem Code kommt der Salt aus randomBytes, sonst faellt
// der ganze Nutzen wieder weg.
const festerSalt = Buffer.from("immer-derselbe-salt");
const einmal = speichern("geheim123", festerSalt);
const nochmal = speichern("geheim123", festerSalt);
console.log(`Zweimal mit demselben Salt, gleich? ${einmal === nochmal ? "ja" : "nein"}`);

// Und so steht ein Eintrag dann in der Tabelle, hier der Anfang davon.
console.log("");
console.log(`${einmal.slice(0, 84)} ...`);
console.log(`insgesamt ${einmal.length} Zeichen`);

Damit sehen zwei gleiche Passwörter verschieden aus. Eine fertige Liste hilft auch nicht mehr, denn sie müsste für jeden Salt neu gerechnet werden. Das Verfahren heißt hier scrypt und kommt aus node:crypto, du brauchst also kein Paket dafür.

Das Verfahren ist absichtlich langsam und absichtlich speicherhungrig, und der Kostenfaktor sagt, wie sehr. 16384 ist die Vorgabe von Node und kostet hier rund 25 Millisekunden. Bei deiner eigenen Anmeldung merkst du davon nichts, aber für jemanden, der Milliarden Versuche fahren will, ist das das Ende der Rechnung.

OWASP, ein offenes Projekt für Websicherheit, nennt heute das Achtfache als Untergrenze, 2 hoch 17. Dafür braucht scrypt mehr Speicher, als Node ihm von sich aus erlaubt, und maxmem muss mit in die Optionen. Ich bleibe im Kurs bei 16384, weil eine Anmeldung mit 2 hoch 17 hier rund eine Viertelsekunde rechnet und Prüfen in diesem Abschnitt mehrere davon hintereinander schickt.

Im gespeicherten Text stehen das Verfahren, der Kostenfaktor, der Salt und erst dann der Hash beisammen. Alle vier brauchst du beim Prüfen ohnehin wieder, und die ersten beiden sind deine Versicherung für später. Erhöhst du den Kostenfaktor irgendwann, erkennst du an jedem Eintrag, mit welchem er entstanden ist, und kannst ihn beim nächsten Anmelden still auf den neuen Stand heben. Ohne diese Angaben bliebe dir nur, alle Konten zurückzusetzen.

Prüfen heißt nachrechnen

Beim Anmelden nimmst du das eingetippte Passwort, holst Salt und Kostenfaktor aus dem gespeicherten Eintrag, rechnest damit neu und vergleichst die beiden Ergebnisse.

Vergleichen, ohne dabei zu verraten
import { scryptSync, timingSafeEqual } from "node:crypto";

const salt = Buffer.from("immer-derselbe-salt");
const gespeichert = scryptSync("geheim123", salt, 64);

// === vergleicht Zeichen fuer Zeichen und hoert beim ersten Unterschied
// auf. Die Dauer verraet also, wie weit vorn der Unterschied liegt. Bei
// zwei gesalzenen Hashes nuetzt das einem Angreifer kaum.
const eingetippt = scryptSync("geheim123", salt, 64);
console.log(`mit ===           ${eingetippt.toString("hex") === gespeichert.toString("hex")}`);

// So: timingSafeEqual sieht sich immer alle Bytes an, egal wo der
// Unterschied liegt.
console.log(`timingSafeEqual   ${timingSafeEqual(eingetippt, gespeichert)}`);
console.log(`bei falschem Wort ${timingSafeEqual(scryptSync("geheim124", salt, 64), gespeichert)}`);

// Zwei ungleich lange Buffer ergeben kein false, timingSafeEqual wirft.
// Hinein gehoert deshalb der Hash des eingetippten Passworts, nie
// das Passwort selbst.
try {
  timingSafeEqual(Buffer.from("geheim123"), gespeichert);
} catch (fehler) {
  console.error(`${fehler.constructor.name}: ${fehler.message}`);
}

Ein === hört beim ersten unterschiedlichen Byte auf. Je früher der Unterschied liegt, desto schneller kommt die Antwort, wenn auch nur ein winziges bisschen. Bei einem Wert, den man direkt vergleicht, etwa einem Schlüssel aus einem Link, kann sich ein Angreifer so herantasten. Bei zwei gesalzenen Hashes bringt es ihm kaum etwas, weil er ohne den Salt nicht steuern kann, welche Bytes sein Versuch ergibt. timingSafeEqual sieht sich immer alles an und braucht deshalb immer gleich lang.

Ich nehme es trotzdem überall, wo zwei Geheimnisse verglichen werden. Es kostet eine Funktion statt eines Operators, und ich muss nicht jedes Mal überlegen, ob es darauf ankommt.

Am Ende des Beispiels steht die rote Zeile im Terminal. Bei zwei ungleich langen Buffern gibt timingSafeEqual gar nichts zurück, es wirft. Hier fängt ein catch den Fehler ab und schreibt RangeError: Input buffers must have the same byte length auf den Fehlerkanal. In deinem Anmeldeweg gäbe es das catch nicht, und der Wurf wäre ein Serverfehler. Hinein gehört deshalb der Hash des eingetippten Passworts, und der ist ohnehin genauso lang wie der gespeicherte.

Zwei Funktionen für alles Weitere

Für jedes Konto reichen zwei Funktionen. Eine macht aus einem Passwort einen speicherbaren Wert, die andere prüft einen Versuch dagegen. Eine dritte, die aus dem gespeicherten Wert das Passwort zurückholt, gibt es nicht.

Nur in dieser Aufgabe schreibst du beide selbst, ab der Registrierung liegen sie als fertige Datei passwoerter.js dabei.

Zum Mitnehmen

Gespeichert wird ein Hash mit eigenem Salt, gerechnet mit einem absichtlich langsamen Verfahren wie scrypt. Verglichen wird mit timingSafeEqual, Hash gegen Hash.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.