Abschnitt 14 · Lektion 2
Registrierung
Auf den ersten Blick ist eine Registrierung kurz. Trotzdem hat sie vier Stellen, an denen man danebengreifen kann. An zweien steht dieselbe Adresse danach zweimal in der Tabelle. An der dritten kommt jemand nie wieder in sein eigenes Konto, und an der vierten erfährt ein Fremder, wer bei dir ein Konto hat.
Vier Schritte in einer Route
Adresse und Passwort prüfen, nachsehen ob es die Adresse schon gibt, das Passwort hashen, Zeile
anlegen. In dieser Reihenfolge, denn eine Prüfung, die nach dem INSERT kommt, ist keine.
import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
import { promisify } from "node:util";
// Gegeben, die beiden Funktionen aus 14.1, mit dem scrypt, das nicht blockiert:
// Während ein Hash rechnet, nimmt der Server weiter Anfragen an (6.5).
const scryptAsync = promisify(scrypt);
export async function hashePasswort(passwort) {
const salt = randomBytes(16);
const hash = await scryptAsync(passwort, salt, 64, { N: 16384 });
return ["scrypt", 16384, salt.toString("hex"), hash.toString("hex")].join("$");
}
export async function pruefePasswort(passwort, gespeichert) {
const [verfahren, kosten, saltHex, hashHex] = gespeichert.split("$");
if (verfahren !== "scrypt") return false;
const erwartet = Buffer.from(hashHex, "hex");
const berechnet = await scryptAsync(passwort, Buffer.from(saltHex, "hex"), erwartet.length, { N: Number(kosten) });
return timingSafeEqual(berechnet, erwartet);
} import express from "express";
import { hashePasswort } from "./passwoerter.js";
// Die Konten liegen hier nur in einer Liste im Speicher, damit der
// Ablauf fuer sich zu sehen ist.
const konten = [];
const app = express();
app.use(express.urlencoded({ extended: true }));
app.post("/registrieren", async (req, res) => {
const email = (req.body?.email ?? "").trim().toLowerCase();
const passwort = req.body?.passwort ?? "";
if (konten.some((konto) => konto.email === email)) {
return res.status(409).type("text/plain").send("Diese Adresse ist schon vergeben.");
}
konten.push({ email, passwort: await hashePasswort(passwort) });
res.status(201).type("text/plain").send(`Konto angelegt, jetzt sind es ${konten.length}.`);
});
// Was in der Liste steht, zeigt der Reiter Browser.
app.get("/", (req, res) => {
const zeilen = konten.map((konto) => `${konto.email} ${konto.passwort.slice(0, 28)} ...`);
res.type("text/plain").send(zeilen.join("\n") || "Noch kein Konto.");
});
app.listen(3000); Die beiden Befehle in der Befehlsleiste schicken dieselbe Adresse, einmal mit großem A. Der erste bekommt 201, der zweite 409. Nach Seite neu laden steht im Reiter Browser ein Konto mit dem Anfang seines scrypt-Werts. Die Prüfung der Felder fehlt hier noch, sie gehört ganz nach vorn.
Neu ist das await vor hashePasswort. Ab dieser Lektion rechnet passwoerter.js mit dem
scrypt, das den Server nicht anhält, und macht es dafür mit promisify zu einer Funktion, die ein
Promise liefert, wie in Lektion 6.3. Sonst ließe eine Route, die rund 25 Millisekunden lang nur
rechnet, jede andere Anfrage so lange warten. Das wäre der blockierende Code aus Lektion 6.5.
In den ersten beiden Zeilen der Route stecken zwei Kleinigkeiten. Das ?. steht dort, weil
req.body in Express 5 undefined ist, wenn der Inhaltstyp nicht passt oder gar kein Rumpf kommt.
Ohne das ?. endet so eine Anfrage mit
TypeError: Cannot read properties of undefined (reading 'email') und einem 500, und die Prüfung
der Felder käme gar nicht erst dran. In der Bücher-API aus Abschnitt 11 stand dafür der Standardwert
{}, hier steht das ?. vor jedem Feld. Und die Adresse geht durch trim() und toLowerCase(),
das Passwort nicht.
Zwei Anfragen gleichzeitig
Das Nachsehen sieht wasserdicht aus. Wer die Adresse nicht findet, legt an, sonst nicht. Zwischen
deinem SELECT und deinem INSERT liegt aber ein Moment, mit dem await vor hashePasswort rund
25 Millisekunden lang. In diesem Moment kann eine zweite Anfrage denselben SELECT machen.
import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL UNIQUE)");
const frei = (email) => db.prepare("SELECT id FROM nutzer WHERE email = ?").get(email) === undefined;
// Zwei Anfragen, die kurz hintereinander hereinkommen. Beide sehen
// nach, beide finden nichts, und erst danach legt die erste an.
console.log(`Anfrage A hält die Adresse für frei: ${frei("doppelt@example.com")}`);
console.log(`Anfrage B hält die Adresse für frei: ${frei("doppelt@example.com")}`);
const anlegen = db.prepare("INSERT INTO nutzer (email) VALUES (?)");
anlegen.run("doppelt@example.com");
console.log("Anfrage A hat angelegt.");
try {
anlegen.run("doppelt@example.com");
console.log("Anfrage B hat auch angelegt.");
} catch (fehler) {
console.log(`Anfrage B wird abgewiesen: ${fehler.message}`);
}
console.log(`Zeilen in der Tabelle: ${db.prepare("SELECT count(*) AS n FROM nutzer").get().n}`); Beide halten die Adresse für frei, beide legen an, und am Ende steht die Adresse zweimal in der
Tabelle. Es sei denn, die Tabelle selbst lässt das nicht zu. Dafür steht UNIQUE in der
Spaltendefinition, und im Beispiel scheitert das zweite INSERT mit der Meldung
UNIQUE constraint failed: nutzer.email.
Deine Prüfung bleibt trotzdem. Die Regel gilt aber wirklich erst in der Tabelle, denn an der kommt keine Anfrage vorbei. Derselbe Gedanke stand schon am Anfang des SQLite-Abschnitts, als zwei Schreiber sich gegenseitig die Datei überschrieben haben. Hier hat er nur Folgen, die man nicht mehr zurückdrehen kann.
In eine fertige Registrierung gehören deshalb beide. Die Vorab-Prüfung gibt dem Normalfall eine
freundliche Antwort. Ein try um das INSERT fängt den seltenen Fall ab, der sonst als 500 beim
Besucher landet. Beide antworten dasselbe.
Warum die Adresse kleingeschrieben wird und das Passwort nicht
UNIQUE vergleicht Zeichen für Zeichen, und für eine Datenbank sind Anna@Example.com und
anna@example.com zwei verschiedene Dinge.
import { DatabaseSync } from "node:sqlite";
const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL UNIQUE)");
const anlegen = db.prepare("INSERT INTO nutzer (email) VALUES (?)");
// UNIQUE vergleicht Zeichen fuer Zeichen. Fuer die Datenbank sind das
// zwei verschiedene Adressen, fuer den Menschen dahinter ist es eine.
anlegen.run("Anna@Example.com");
anlegen.run("anna@example.com");
console.log(`Zeilen nach zweimal derselben Adresse: ${db.prepare("SELECT count(*) AS n FROM nutzer").get().n}`);
for (const zeile of db.prepare("SELECT id, email FROM nutzer ORDER BY id").all()) {
console.log(` ${zeile.id} ${zeile.email}`);
}
// Und die Gegenrichtung: beim Passwort darf nichts weggeschnitten werden.
const eingetippt = " nachtzug-nach-wien ";
console.log("");
console.log(`eingetippt: "${eingetippt}" mit ${eingetippt.length} Zeichen`);
console.log(`mit trim(): "${eingetippt.trim()}" mit ${eingetippt.trim().length} Zeichen`);
console.log("Wer beim Anlegen trimmt und beim Anmelden nicht, sperrt den Besitzer aus."); Für den Menschen dahinter ist es eine Adresse. Wie er sie damals getippt hat, weiß er beim nächsten
Mal nicht mehr. Deshalb wird sie kleingeschrieben gespeichert und kleingeschrieben gesucht, und dann
kann UNIQUE auch das leisten, wofür es da ist.
Beim Passwort ist es umgekehrt. Da wird nichts weggeschnitten und nichts umgeformt. Ein Leerzeichen
am Ende gehört dazu, wenn der Besitzer es so gewählt hat. Wer beim Anlegen trim() aufruft und beim
Anmelden nicht, sperrt die Leute aus, die eins gesetzt haben, und niemand versteht, warum. Aus
demselben Grund gibt es keine Höchstlänge und kein Abschneiden nach 20 Zeichen. Gehasht wird alles
zur selben Länge, ein langes Passwort kostet also nichts.
Bei den Mindestanforderungen zählt die Länge, alles andere kaum. Erzwungene Sonderzeichen führen zu
Passwort1! und zu Haftnotizen am Monitor. Sie bringen also weniger als die Länge, die du ohnehin
verlangst. Der Kurs verlangt 15 Zeichen, weil das Authentication Cheat Sheet von OWASP ein kürzeres
Passwort als schwach einstuft, solange kein zweiter Faktor dazukommt. Sinnvoll ist außerdem, sehr
lange Passwörter zuzulassen und die bekanntesten abzulehnen.
Die Antwort für eine Adresse, die es schon gibt
Die ehrliche Antwort lautet „diese Adresse ist schon vergeben“. Damit erfährt aber auch ein Fremder, dass es zu dieser Adresse ein Konto bei dir gibt. Bei einem Onlineshop ist das lästig, bei einer Partnerbörse oder einem Ärzteportal ist es ein Problem. Der Ausweg ist, immer dasselbe zu antworten und die eigentliche Nachricht per E-Mail an die Adresse selbst zu schicken. Dieser Kurs bleibt beim offenen 409, weil er keinen E-Mail-Versand hat. Beim Anmelden kommt dieselbe Überlegung wieder, und dort lässt sie sich ohne Versand lösen.
Die Registrierungsroute der Aufgabe glaubt noch alles, was das Formular schickt.
Zum Mitnehmen
Eine Registrierung prüft die Felder, schreibt die Adresse klein, hasht das Passwort unverändert und legt an. Dass es jede Adresse nur einmal gibt, sichert erst UNIQUE in der Tabelle, denn zwischen Nachsehen und Anlegen passt eine zweite Anfrage.
Jetzt du
Basis Konto, kostenlosZu 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.