mitmario.dev

Anmelden

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

Auf eine Anmeldung gibt es zwei Absagen, unbekannte Adresse und falsches Passwort. Sind sie unterscheidbar, verrät die Anmeldung jedem, welche Adressen ein Konto haben. Der Rest einer Anmeldung ist dagegen schnell geschrieben.

Der Ablauf einer Anmeldung

Die Sitzung bekommt jetzt einen Inhalt, die Kennung des angemeldeten Nutzers. Mehr braucht sie nicht. Alles Weitere steht in der Datenbank.

Suchen, prüfen, Sitzung, Cookie
import express from "express";
import { DatabaseSync } from "node:sqlite";
import { randomBytes } from "node:crypto";
import { hashePasswort, pruefePasswort } from "./passwoerter.js";

const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL UNIQUE, passwort TEXT NOT NULL)");
db.prepare("INSERT INTO nutzer (email, passwort) VALUES (?, ?)").run("anna@example.com", await hashePasswort("einlangesgeheimnis"));

const sitzungen = new Map();
const app = express();
app.use(express.urlencoded({ extended: true }));

app.get("/", (req, res) =>
  res.type("html").send(
    '<form method="post" action="/login">' +
      '<p><input name="email" value="anna@example.com"></p>' +
      '<p><input name="passwort" value="einlangesgeheimnis"></p>' +
      "<p><button>Anmelden</button></p>" +
      "</form>" +
      '<p><a href="/konto">/konto</a></p>'
  )
);

app.post("/login", async (req, res) => {
  const nutzer = db.prepare("SELECT id, passwort FROM nutzer WHERE email = ?").get(req.body?.email ?? "");
  if (!nutzer || !(await pruefePasswort(req.body?.passwort ?? "", nutzer.passwort))) {
    return res.status(401).send("Anmeldung fehlgeschlagen.");
  }

  const sid = randomBytes(16).toString("hex");
  sitzungen.set(sid, { nutzerId: nutzer.id });
  res.cookie("sid", sid, { httpOnly: true, sameSite: "lax" });
  res.redirect(303, "/konto");
});

app.get("/konto", (req, res) => {
  const sid = (req.headers.cookie ?? "").split("=")[1];
  const sitzung = sitzungen.get(sid);
  if (!sitzung) return res.send("Nicht angemeldet");
  res.send(`Angemeldet als ${db.prepare("SELECT email FROM nutzer WHERE id = ?").get(sitzung.nutzerId).email}`);
});

app.listen(3000);

Das Formular ist mit Annas Daten schon ausgefüllt. Nach dem Anmelden landet der Browser auf /konto und trägt die Sitzungskennung von da an mit. Tippst du ein falsches Passwort ein, bleibt es bei der Absage.

Auf den erfolgreichen POST kommt ein 303 auf eine Seite, die per GET erreichbar ist, wie beim Muster Post, Redirect, Get. Wer sich anmeldet und dann F5 drückt, soll seine Zugangsdaten nicht ein zweites Mal abschicken.

Die Anfrage selbst findest du im Reiter Netzwerk. Klappst du dort den POST /login auf, steht im Anfrage-Rumpf dein Passwort im Klartext, so wie dein Browser es abgeschickt hat. In den Kopfzeilen steht davon nichts. Unterwegs war es trotzdem verschlüsselt, denn der Reiter Browser spricht HTTPS mit dem Server dieses Kurses. Ohne diese Verschlüsselung könnte jeder auf dem Weg mitlesen. Wegprogrammieren lässt sich das nicht, ein Formular schickt eben, was jemand eingetippt hat. Das ist derselbe Punkt wie bei Secure, diesmal von der anderen Seite.

Eine Meldung für beide Fälle

Getrennte Absagen entstehen aus einem sympathischen Grund. Man will hilfreich sein. „Diese Adresse kennen wir nicht“ ist ein nützlicher Hinweis, wenn man sich vertippt hat. Leider ist er genauso nützlich für jemanden, der wissen will, wer bei dir Kunde ist.

Zwei Absagen, die sich verplappern
import { DatabaseSync } from "node:sqlite";
import { hashePasswort, pruefePasswort } from "./passwoerter.js";

const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL UNIQUE, passwort TEXT NOT NULL)");
db.prepare("INSERT INTO nutzer (email, passwort) VALUES (?, ?)").run("anna@example.com", await hashePasswort("einlangesgeheimnis"));

const BLINDWERT = await hashePasswort("nur-damit-hier-immer-gerechnet-wird");
let rechnungen = 0;
function pruefe(passwort, gespeichert) {
  rechnungen += 1;
  return pruefePasswort(passwort, gespeichert);
}
const finde = (email) => db.prepare("SELECT id, passwort FROM nutzer WHERE email = ?").get(email);

// So nicht: jede Absage sagt genau, woran es lag.
async function gespraechig(email, passwort) {
  const nutzer = finde(email);
  if (!nutzer) return "404  Diese Adresse kennen wir nicht.";
  if (!(await pruefe(passwort, nutzer.passwort))) return "401  Falsches Passwort.";
  return "303  angemeldet";
}

// So: eine Antwort fuer beide Faelle, und gerechnet wird auch dann,
// wenn es die Adresse gar nicht gibt.
async function verschwiegen(email, passwort) {
  const nutzer = finde(email);
  const stimmt = await pruefe(passwort, nutzer?.passwort ?? BLINDWERT);
  if (!nutzer || !stimmt) return "401  Anmeldung fehlgeschlagen.";
  return "303  angemeldet";
}

console.log("mit getrennten Meldungen");
rechnungen = 0;
console.log(`  unbekannte Adresse   ${await gespraechig("gibtsnicht@example.com", "egal")}`);
console.log(`  falsches Passwort    ${await gespraechig("anna@example.com", "falsch")}`);
console.log(`  Hash-Rechnungen:     ${rechnungen} von 2 Versuchen`);

console.log("");
console.log("mit einer Meldung");
rechnungen = 0;
console.log(`  unbekannte Adresse   ${await verschwiegen("gibtsnicht@example.com", "egal")}`);
console.log(`  falsches Passwort    ${await verschwiegen("anna@example.com", "falsch")}`);
console.log(`  Hash-Rechnungen:     ${rechnungen} von 2 Versuchen`);

Mit getrennten Meldungen wird deine Anmeldemaske zum Auskunftsschalter (englisch user enumeration, das Abzählen der Konten). Adresse eintippen, irgendein Passwort dazu, und an der Antwort siehst du, ob es das Konto gibt. Das lässt sich in wenigen Zeilen automatisieren, und wer eine geleakte Adressliste hat, weiß danach, welche davon bei dir ein Konto haben.

Verraten kann auch die Zeit, und das ist feiner. Gibt es die Adresse nicht, gibt es nichts nachzurechnen, und scrypt ist absichtlich langsam. Die Absage kommt also messbar schneller, hier um rund 25 Millisekunden. Den Grund siehst du im Beispiel in der Zeile mit den Hash-Rechnungen, 1 von 2 Versuchen.

Dagegen hilft es, auch dann zu rechnen, und zwar gegen einen festen Blindwert (englisch dummy hash), dessen Ergebnis man wegwirft. Das kostet dich einen Sekundenbruchteil bei einem Versuch, der ohnehin scheitert.

Nach der Anmeldung gibt es eine neue Sitzungskennung

Der Angriff dazu heißt Session Fixation. Die Regel, dass man eine mitgebrachte Sitzungskennung niemals übernimmt, kennst du schon aus der Aufgabe zu den Sitzungen. Beim Anmelden bekommt sie ihre Bedeutung.

Die untergeschobene Sitzungskennung
import { randomBytes } from "node:crypto";

// Der Angreifer hat sich vorher eine Sitzungskennung besorgt und dem
// Opfer einen Link mit genau dieser Kennung untergeschoben.
const UNTERGESCHOBEN = "kennung-vom-angreifer";

function wasDerAngreiferSieht(sitzungen) {
  const sitzung = sitzungen.get(UNTERGESCHOBEN);
  return sitzung?.nutzer ? `Angemeldet als ${sitzung.nutzer}` : "Nicht angemeldet";
}

// So nicht: die mitgebrachte Sitzung wird einfach weiterverwendet.
const schlecht = new Map([[UNTERGESCHOBEN, { nutzer: null }]]);
schlecht.get(UNTERGESCHOBEN).nutzer = "opfer@example.com";
console.log("Sitzung übernommen");
console.log(`  Kennung nach der Anmeldung:  ${UNTERGESCHOBEN}`);
console.log(`  Der Angreifer sieht:         ${wasDerAngreiferSieht(schlecht)}`);

// So: die alte Kennung verfaellt, die Anmeldung bekommt eine neue.
const gut = new Map([[UNTERGESCHOBEN, { nutzer: null }]]);
gut.delete(UNTERGESCHOBEN);
const neueKennung = randomBytes(16).toString("hex");
gut.set(neueKennung, { nutzer: "opfer@example.com" });
console.log("");
console.log("neue Sitzung");
console.log(`  Kennung nach der Anmeldung:  eine neue mit ${neueKennung.length} Zeichen`);
console.log(`  Der Angreifer sieht:         ${wasDerAngreiferSieht(gut)}`);

Der Angreifer holt sich auf deiner Seite ganz normal eine Sitzung, merkt sich ihre Kennung und bringt das Opfer dann dazu, mit genau dieser Kennung loszulegen, etwa über einen präparierten Link. Solange niemand angemeldet ist, ist das harmlos. Meldet sich das Opfer dann aber an und dein Server hängt die Anmeldung an die bestehende Sitzung, ist der Angreifer mit angemeldet. Die Kennung hat er ja.

Abwehren lässt sich das beim Anmelden selbst. Die alte Sitzung wird verworfen und eine neue vergeben, und die Kennung des Angreifers gehört danach zu nichts mehr. Dasselbe gilt bei jeder Änderung der Rechte, etwa wenn jemand Admin wird.

Was hier bewusst offen bleibt

Eine Anmelderoute ohne Grenze für die Zahl der Versuche lässt sich durchprobieren, so oft man will. Wie man diese Grenze zieht, ist ein eigenes Thema und kommt in Lektion 15.5. Und was passiert, wenn jemand sein Passwort vergisst, hängt an einem E-Mail-Versand, den dieser Kurs nicht hat. In einer echten Anwendung gehört davon noch einiges dazu, und was genau, steht in der Synthese dieses Abschnitts.

Mit zwei Konten in der Datenbank, dem Übungskonto und Annas, baust du in der Aufgabe eine Anmeldung, deren Absagen nichts verraten.

Zum Mitnehmen

Unbekannte Adresse und falsches Passwort bekommen dieselbe Antwort nach derselben Zeit, sonst wird die Anmeldemaske zum Verzeichnis deiner Kunden. Wer sich anmeldet, bekommt eine neue Sitzungskennung, und die mitgebrachte verfällt.

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.