8. Authentifizierung und Autorisierung
Bei jeder Anfrage stellen sich zwei getrennte Fragen:
- Wer ist der Benutzer? Das ist die Authentifizierung: Der Benutzer hat sich mit einem Benutzernamen und einem Passwort identifiziert, und jede weitere Anfrage muss belegen, dass sie von ihm stammt;
- Hat er die Berechtigung, auf diese Seite zuzugreifen? Das ist die Autorisierung: In der Fallstudie verwaltet nur ein Benutzer mit der Rolle ADMIN die Ärzte und Clients.
Da der Server zustandslos ist (Kapitel 6), muss der Identitätsnachweis jeder Anfrage beigefügt werden. Dazu dient ein JWT-Token ([JSON Web Token]): Nach der Anmeldung erzeugt der Server ein Token, das die Identität des Benutzers enthält, und signiert es mit einem geheimen Schlüssel. Das Token wird in einem Cookie gespeichert; der Browser sendet es bei jeder Anfrage zurück; der Server überprüft die Signatur. Der Benutzer kann sein Token lesen, aber nicht verändern: Jede Änderung macht die Signatur ungültig.
[NestJS] stützt sich dafür auf zwei Bibliotheken: [passport] (und seine Strategie [passport-jwt]), das Token überprüft, und [@nestjs/jwt], das sie erzeugt.
8.1. Beispiel 25: Anmeldung, Token, geschützte Seite
| 25-auth-jwt/
├── src/
│ ├── auth/
│ │ ├── auth.controller.ts
│ │ ├── auth.service.ts
│ │ ├── constants.ts
│ │ ├── jwt-auth.guard.ts
│ │ ├── jwt.strategy.ts
│ │ └── users.service.ts
│ ├── app.module.ts
│ ├── errors.filter.ts
│ ├── main.ts
│ └── profile.controller.ts
├── views/
│ ├── error.hbs
│ ├── home.hbs
│ ├── layout.hbs
│ ├── login.hbs
│ └── profile.hbs
├── nest-cli.json
└── tsconfig.json
|
Die Datei [src/auth/constants.ts]:
| // der Name des Cookies, das das Token trägt
export const JWT_COOKIE = 'token';
// der geheime Schlüssel, der die Token signiert (in Produktion: eine Umgebungsvariable)
export const JWT_SECRET = process.env.JWT_SECRET ?? 'development-secret';
// Lebensdauer eines Tokens in Sekunden
export const JWT_DURATION = 3600;
|
Zeile 4: der Schlüssel, der die Token signiert. Wer diesen Schlüssel kennt, kann gültige Token erzeugen: In der Produktion stammt er aus einer Umgebungsvariablen, niemals aus dem Quellcode.
Die Datei [src/auth/users.service.ts]:
| import { Injectable } from '@nestjs/common';
import * as bcrypt from 'bcryptjs';
export interface User {
id: number;
login: string;
name: string;
role: 'ADMIN' | 'USER';
passwordHash: string; // NIEMALS das Passwort selbst
}
// die Benutzer, im Speicher (das nächste Kapitel legt sie in einer Datenbank ab).
// Das Passwort jedes Benutzers ist sein Login; nur sein bcrypt-Hash wird gespeichert
@Injectable()
export class UsersService {
private readonly users: User[] = [
{ id: 1, login: 'admin', name: 'Administrator', role: 'ADMIN', passwordHash: bcrypt.hashSync('admin', 10) },
{ id: 2, login: 'marie', name: 'Marie Pélissier', role: 'USER', passwordHash: bcrypt.hashSync('marie', 10) },
];
byLogin(login: string): User | undefined {
return this.users.find((u) => u.login === login);
}
}
|
- Zeile 9: Ein Passwort wird niemals gespeichert; gespeichert wird nur sein Hash – ein Fingerabdruck, der durch eine Einwegfunktion berechnet wird. Man kann überprüfen, ob ein Passwort zu einem Fingerabdruck passt, aber aus dem Fingerabdruck lässt sich das Passwort nicht wiederherstellen;
- Zeilen 16–19: [bcrypt.hashSync(password, 10)] berechnet den Hash mit dem Algorithmus [bcrypt]. Die Zahl 10 steht für die „Kosten“: bcrypt ist absichtlich langsam (2¹⁰ Iterationen), um jeden davon abzuhalten, Millionen von Passwörtern auszuprobieren. Zwei Hashes desselben Passworts sind verschieden (es wird ein zufälliger „Salt“ hinzugefügt): [bcrypt.compare] übernimmt die Überprüfung.
Die Datei [src/auth/auth.service.ts]:
| import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import * as bcrypt from 'bcryptjs';
import { User, UsersService } from './users.service';
// was das Token enthält: genug, um den Benutzer zu identifizieren, ohne die Datenbank zu lesen
export interface TokenContent {
sub: number; // "subject": die Kennung des Benutzers (JWT-Konvention)
login: string;
name: string;
role: string;
}
@Injectable()
export class AuthService {
constructor(
private readonly users: UsersService,
private readonly jwt: JwtService,
) {}
// der Benutzer, wenn das Paar aus Login und Passwort korrekt ist, andernfalls null
async check(login: string, password: string): Promise<User | null> {
const u = this.users.byLogin(login);
// bcrypt.compare hasht das eingegebene Passwort und vergleicht die Hashes
return u && (await bcrypt.compare(password, u.passwordHash)) ? u : null;
}
// ein SIGNIERTES Token: der Browser kann es lesen, aber nicht ändern
createToken(u: User): string {
const content: TokenContent = { sub: u.id, login: u.login, name: u.name, role: u.role };
return this.jwt.sign(content);
}
}
|
- Zeilen 7–12: der Inhalt des Tokens. [sub] ([subject]) ist die übliche Bezeichnung für die Benutzer-ID. Wir nehmen alles auf, was die Seiten benötigen (Name, Rolle), damit wir nicht bei jeder Anfrage die Datenbank abfragen müssen;
- Zeilen 22–26: Überprüfung von Benutzername und Passwort;
- Zeilen 29–32: [JwtService.sign] erzeugt das signierte Token. [JwtService] wird (Schlüssel, Gültigkeitsdauer) im Anwendungsmodul konfiguriert.
Die Datei [src/auth/jwt.strategy.ts]:
| import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Request } from 'express';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { TokenContent } from './auth.service';
import { JWT_COOKIE, JWT_SECRET } from './constants';
// der angemeldete Benutzer, wie ihn die Controller sehen (req.user)
export interface LoggedInUser {
id: number;
login: string;
name: string;
role: string;
}
// die Passport-Strategie "jwt": wo das Token zu finden ist und wie es geprüft wird
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
constructor() {
super({
// das Token wird aus dem Cookie gelesen (und nicht aus dem Header Authorization)
jwtFromRequest: ExtractJwt.fromExtractors([(req: Request) => req?.cookies?.[JWT_COOKIE] ?? null]),
ignoreExpiration: false, // ein abgelaufenes Token wird abgelehnt
secretOrKey: JWT_SECRET, // um die Signatur zu prüfen
});
}
// wird aufgerufen, wenn das Token gültig ist; was zurückgegeben wird, wird zu req.user
validate(content: TokenContent): LoggedInUser {
return { id: content.sub, login: content.login, name: content.name, role: content.role };
}
}
|
- Zeile 18: eine [Passport]-Strategie namens [jwt], die beschreibt, wie eine Anfrage authentifiziert wird;
- Zeile 22: wo das Token zu finden ist: im Cookie. (Ein [JavaScript]-Client würde es stattdessen im Header [Authorization: Bearer ...] senden; siehe [ExtractJwt.fromAuthHeaderAsBearerToken()]);
- Zeilen 23–24: Ein abgelaufenes oder falsch signiertes Token wird abgelehnt;
- Zeilen 29–31: wird aufgerufen, wenn das Token gültig ist. Das Ergebnis ist [req.user]: der angemeldete Benutzer, der Zugriff auf die Actions hat.
Die Datei [src/auth/jwt-auth.guard.ts]:
| import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
// der Guard, der die Strategie 'jwt' ausführt: kein gültiges Token -> 401
@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}
|
[AuthGuard('jwt')] erzeugt einen Guard, der die Strategie [jwt] ausführt. Ohne gültiges Token löst er eine [UnauthorizedException] (401) aus.
Die Datei [src/auth/auth.controller.ts]:
| import { Body, Controller, Get, Post, Render, Res } from '@nestjs/common';
import { Response } from 'express';
import { AuthService } from './auth.service';
import { JWT_COOKIE, JWT_DURATION } from './constants';
@Controller()
export class AuthController {
constructor(private readonly auth: AuthService) {}
@Get('login')
@Render('login')
form(): object {
return {};
}
@Post('login')
async logIn(@Body() body: { login?: string; password?: string }, @Res() res: Response): Promise<void> {
const user = await this.auth.check(body.login ?? '', body.password ?? '');
if (!user) {
// bewusst vage Meldung: wir sagen nicht, welches der beiden Angaben falsch ist
res.render('login', { login: body.login, error: 'Incorrect login or password.' });
return;
}
// das Token wird in einem httpOnly-Cookie abgelegt: das JavaScript der Seite
// kann es nicht lesen, der Browser sendet es bei jeder Anfrage zurück
res.cookie(JWT_COOKIE, this.auth.createToken(user), {
httpOnly: true,
sameSite: 'lax',
maxAge: JWT_DURATION * 1000,
});
res.redirect('/profile');
}
// das Abmelden ÄNDERT den Zustand: es ist ein POST, kein Link
@Post('logout')
logOut(@Res() res: Response): void {
res.clearCookie(JWT_COOKIE);
res.redirect('/login');
}
}
|
- Zeilen 17–32: die Anmeldung. Schlägt sie fehl, wird das Formular mit einer bewusst vagen Meldung erneut angezeigt: Die Angabe „dieser Benutzername existiert nicht“ würde einem Angreifer helfen, gültige Benutzernamen zu finden;
- Zeilen 26–30: Bei Erfolg wird das Token in einem [httpOnly]-Cookie gespeichert; das [JavaScript] der Seite kann es nicht lesen, was das Token schützt, falls ein bösartiges Skript auf der Seite ausgeführt werden sollte. [sameSite: 'lax']: Das Cookie wird nicht in POST-Anfragen aufgenommen, die von einer anderen Website gesendet werden, was vor Cross-Site-Request-Forgery schützt ([CSRF]);
- Zeilen 35–39: Die Abmeldung löscht das Cookie. Das ist ein POST: Sie ändert den Status des Benutzers (siehe Beispiel 21).
Die Datei [src/profile.controller.ts]:
| import { Controller, Get, Render, Req, UseGuards } from '@nestjs/common';
import { Request } from 'express';
import { JwtAuthGuard } from './auth/jwt-auth.guard';
import { LoggedInUser } from './auth/jwt.strategy';
@Controller()
export class ProfileController {
// öffentliche Seite
@Get()
@Render('home')
home(): object {
return {};
}
// geschützte Seite: der Guard verlangt ein gültiges Token
@Get('profile')
@UseGuards(JwtAuthGuard)
@Render('profile')
profile(@Req() req: Request): object {
return { user: req.user as LoggedInUser };
}
}
|
Zeile 17: Die Seite [/profile] ist durch den Guard geschützt. Die Action liest den Benutzer aus [req.user].
Die Datei [src/errors.filter.ts]:
| import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from '@nestjs/common';
import { Response } from 'express';
@Catch(HttpException)
export class ErrorsFilter implements ExceptionFilter {
catch(exception: HttpException, host: ArgumentsHost): void {
const res = host.switchToHttp().getResponse<Response>();
const status = exception.getStatus();
// 401 (kein Token oder ungültiges Token): ab zur Login-Seite
if (status === HttpStatus.UNAUTHORIZED) {
res.redirect('/login');
return;
}
res.status(status).render('error', { status, message: exception.message });
}
}
|
Zeilen 10–13: Ein 401-Fehler zeigt keine Fehlerseite an; der Benutzer wird auf die Anmeldeseite umgeleitet.
Die Datei [src/app.module.ts]:
| import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { AuthController } from './auth/auth.controller';
import { AuthService } from './auth/auth.service';
import { JWT_DURATION, JWT_SECRET } from './auth/constants';
import { JwtStrategy } from './auth/jwt.strategy';
import { UsersService } from './auth/users.service';
import { ProfileController } from './profile.controller';
@Module({
imports: [
PassportModule,
// JwtService, ein für alle Mal konfiguriert: Schlüssel und Lebensdauer
JwtModule.register({ secret: JWT_SECRET, signOptions: { expiresIn: JWT_DURATION } }),
],
controllers: [AuthController, ProfileController],
providers: [UsersService, AuthService, JwtStrategy],
})
export class AppModule {}
|
Zeile 15: die Konfiguration von [JwtService]: Token-Schlüssel und Gültigkeitsdauer (eine Stunde).
Die Datei [views/login.hbs]:
| <h1 class="h3">Login</h1>
<form method="post" action="/login">
<div class="mb-2">
<label class="form-label" for="login">Login</label>
<input class="form-control" id="login" name="login" value="{{login}}" autocomplete="username">
</div>
<div class="mb-3">
<label class="form-label" for="password">Password</label>
<input class="form-control" id="password" name="password" type="password" autocomplete="current-password">
</div>
<button class="btn btn-primary" type="submit">Log in</button>
</form>
{{#if error}}<div class="alert alert-danger mt-3">{{error}}</div>{{/if}}
<p class="text-muted mt-3">Accounts: admin / admin, marie / marie</p>
|
8.1.1. Ausführung
Ohne Cookie leitet die geschützte Seite auf die Anmeldeseite um:
| curl -i http://localhost:3000/profile
|
| HTTP/1.1 302 Found
Location: /login
Content-Type: text/plain; charset=utf-8
Content-Length: 28
Found. Redirecting to /login
|

Ein falsches Passwort:

Erfolgreiche Anmeldung, gesehen mit [curl]:
| curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:3000/login
|
| HTTP/1.1 302 Found
Set-Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjIsImxvZ2luIjoibWFyaWUiLCJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwMTczMDg3LCJleHAiOjE3OTAxNzY2ODd9.LoujmLAq__cPbevACUDUMvdPHkH7r_ekv48IwHqc3Dk; Max-Age=3600; Path=/; Expires=Wed, 23 Sep 2026 15:18:07 GMT; HttpOnly; SameSite=Lax
Location: /profile
Content-Type: text/plain; charset=utf-8
Content-Length: 30
Found. Redirecting to /profile
|
Das Token besteht aus drei durch Punkte getrennten Teilen: einem Header, dem Inhalt und der Signatur. Die ersten beiden sind lediglich als [base64url] kodiert; dekodieren wir den Inhalt:
| eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjIsImxvZ2luIjoibWFyaWUiLCJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwMTczMDg3LCJleHAiOjE3OTAxNzY2ODd9.LoujmLAq__cPbevACUDUMvdPHkH7r_ekv48IwHqc3Dk
{"sub": 2, "login": "marie", "name": "Marie Pélissier", "role": "USER", "iat": 1790173087, "exp": 1790176687}
|
Der von [createToken] erzeugte Inhalt ist enthalten, dazu zwei von [JwtService] hinzugefügte Felder: [iat] ([issued at], das Erstellungsdatum) und [exp] (das Ablaufdatum), in Sekunden seit dem 1. Januar 1970. Das Token ist nicht verschlüsselt: Es darf keine vertraulichen Informationen enthalten. Im Browser:

Versuchen wir nun, das Token so zu verändern, dass wir uns die Rolle ADMIN zuweisen: Wir dekodieren den Inhalt, ersetzen [USER] durch [ADMIN] und kodieren ihn neu … aber ohne den geheimen Schlüssel können wir die Signatur nicht neu berechnen:
| curl -i -b "token=eyJhbGciOi...(modified content)...LoujmLAq..." http://localhost:3000/profile
|
| HTTP/1.1 302 Found
Location: /login
Content-Type: text/plain; charset=utf-8
Content-Length: 28
Found. Redirecting to /login
|
Die Signatur stimmt nicht mehr mit dem Inhalt überein: Das Token wird abgelehnt (Fehler 401), und der Exception-Handler leitet auf die Anmeldeseite um. Abmeldung:
| curl -i -b cookies.txt -X POST http://localhost:3000/logout
|
| HTTP/1.1 302 Found
Set-Cookie: token=; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT
Location: /login
Content-Type: text/plain; charset=utf-8
Content-Length: 28
Found. Redirecting to /login
|
8.2. Beispiel 26: Rollen
Beispiel 26 baut auf Beispiel 25 auf und fügt eine Seite hinzu, die der Rolle ADMIN vorbehalten ist. Es kommen drei neue Dateien hinzu.
Die Datei [src/auth/roles.decorator.ts]:
| import { SetMetadata } from '@nestjs/common';
export const ROLES_KEY = 'roles';
// @Roles('ADMIN'): setzt eine METADATA auf die Action (oder den Controller);
// der Dekorator prüft selbst nichts, RolesGuard ist derjenige, der sie lesen wird
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);
|
Zeile 7: [SetMetadata] hängt Metadaten (beliebige Informationen) an die dekorierte Klasse oder Methode an. [@Roles('ADMIN')] prüft nichts: Es deklariert die erforderliche Rolle.
Die Datei [src/auth/roles.guard.ts]:
| import { CanActivate, ExecutionContext, ForbiddenException, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Request } from 'express';
import { LoggedInUser } from './jwt.strategy';
import { ROLES_KEY } from './roles.decorator';
@Injectable()
export class RolesGuard implements CanActivate {
// Reflector: das NestJS-Werkzeug, um die Metadaten zurückzulesen
constructor(private readonly reflector: Reflector) {}
canActivate(context: ExecutionContext): boolean {
// @Roles der Action, ersatzweise das des Controllers
const required = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [context.getHandler(), context.getClass()]);
if (!required || required.length === 0) {
return true; // kein @Roles: keine Rollenbeschränkung
}
// req.user wurde von JwtAuthGuard gesetzt, der VOR diesem Guard läuft
const user = context.switchToHttp().getRequest<Request>().user as LoggedInUser;
if (!required.includes(user.role)) {
throw new ForbiddenException(`the ${user.role} role does not give access to this page`);
}
return true;
}
}
|
- Zeile 10: [Reflector] ist der Service von [NestJS] , der die Metadaten liest;
- Zeile 14: die von der Action oder, falls dort keine angegeben sind, von ihrem Controller verlangten Rollen. Hier kommt der Ausführungskontext des Guards ins Spiel (siehe Kapitel 7);
- Zeilen 15–17: Ohne [@Roles] gibt es keine Einschränkungen;
- Zeile 19: [req.user] wurde vom Guard [JwtAuthGuard] eingetragen, der vor ihm ausgeführt wird;
- Zeilen 20–22: Eine unzureichende Rolle führt zu einem 403-Fehler (Forbidden).
Die Datei [src/admin.controller.ts]:
| import { Controller, Get, Render, UseGuards } from '@nestjs/common';
import { JwtAuthGuard } from './auth/jwt-auth.guard';
import { Roles } from './auth/roles.decorator';
import { RolesGuard } from './auth/roles.guard';
// die Reihenfolge ist wichtig: zuerst WER ist es (JwtAuthGuard), dann IST ES ERLAUBT (RolesGuard)
@Controller('admin')
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('ADMIN')
export class AdminController {
@Get()
@Render('admin')
admin(): object {
return {};
}
}
|
Zeilen 8–9: Die Guards werden in der Reihenfolge ausgeführt, in der sie aufgeführt sind: zuerst die Identifizierung, dann die Rollenprüfung. Der gesamte Controller ist der Rolle ADMIN vorbehalten. Der Benutzer [marie] (Rolle USER) versucht, die Administrationsseite zu öffnen:

Derselbe Versuch durch [admin]:

Die Fallstudie hat drei Rollen (ADMIN, DOCTOR, USER) und verwendet genau diese beiden Guards. Der Exception-Filter wandelt den 403-Fehler in eine übersetzte Fehlerseite um.
8.3. Beispiel 27: CAPTCHA und Begrenzung der Versuche
Eine Anmeldeseite zieht Bots an: Programme, die Tausende von Kombinationen aus Benutzername und Passwort ausprobieren. Zwei einander ergänzende Schutzmaßnahmen:
- ein CAPTCHA: ein Bild mit verzerrten Zeichen, das ein Mensch leicht lesen kann, ein einfacher Bot aber nicht entziffern kann;
- eine Begrenzung der Versuche: Nach einigen fehlgeschlagenen Versuchen wird die IP-Adresse für eine Weile gesperrt.
Beispiel 27 ergänzt Beispiel 25 um diese beiden Schutzmaßnahmen.
Die Datei [src/auth/captcha.service.ts]:
| import { Injectable } from '@nestjs/common';
import { randomUUID } from 'crypto';
import * as svgCaptcha from 'svg-captcha';
export interface Captcha {
id: string; // in einem versteckten Feld des Formulars abgelegt
svg: string; // das Bild, unverändert in die Seite eingefügt
}
@Injectable()
export class CaptchaService {
// id -> erwartete Antwort. Die Antwort verlässt den Server NIEMALS
private readonly answers = new Map<string, string>();
generate(): Captcha {
// svg-captcha: ein zufälliger Text, gezeichnet mit verzerrten Zeichen
const { text, data } = svgCaptcha.create({ size: 5, noise: 3, color: true, ignoreChars: '0oO1iIlL' });
const id = randomUUID();
this.answers.set(id, text.toLowerCase());
return { id, svg: data };
}
// ist die Antwort die richtige? In jedem Fall wird das Captcha
// verbraucht: ein Bild wird nur einmal verwendet
check(id: unknown, input: unknown): boolean {
if (typeof id !== 'string' || typeof input !== 'string') {
return false;
}
const expected = this.answers.get(id);
this.answers.delete(id);
return expected !== undefined && expected === input.trim().toLowerCase();
}
}
|
- Zeile 13: Die erwarteten Antworten werden vom Server unter einer zufälligen Kennung gespeichert. Die Seite enthält nur das Bild und die Kennung: Die Antwort verlässt den Server nie;
- Zeilen 15–21: Die Bibliothek [svg-captcha] erzeugt eine zufällige Zeichenfolge und stellt sie als Bild (SVG) dar, das durch Linien verdeckt wird. Leicht verwechselbare Zeichen (0 und O, 1 und l usw.) sind ausgeschlossen;
- Zeilen 25–32: Die Überprüfung verbraucht das CAPTCHA: Ein Bild wird nur einmal verwendet; ein Bot kann keine bereits gefundene Antwort wiederverwenden.
Die Datei [src/auth/limiter.service.ts]:
| import { Injectable } from '@nestjs/common';
const MAX_FAILURES = 3; // tolerierte Fehlversuche ...
const BLOCK_MS = 60 * 1000; // ... vor einer Sperre von einer Minute
// begrenzt die Anzahl der Anmeldeversuche pro IP-Adresse
@Injectable()
export class LimiterService {
private readonly counters = new Map<string, { failures: number; blockedUntil: number }>();
// 0, wenn die IP es versuchen darf, andernfalls die Anzahl der Sekunden, die zu warten sind
blockedSeconds(ip: string): number {
const c = this.counters.get(ip);
const remaining = c ? c.blockedUntil - Date.now() : 0;
return remaining > 0 ? Math.ceil(remaining / 1000) : 0;
}
failure(ip: string): void {
const c = this.counters.get(ip) ?? { failures: 0, blockedUntil: 0 };
c.failures++;
if (c.failures >= MAX_FAILURES) {
c.blockedUntil = Date.now() + BLOCK_MS;
c.failures = 0;
}
this.counters.set(ip, c);
}
success(ip: string): void {
this.counters.delete(ip);
}
}
|
- Zeilen 3–4: Drei Fehlversuche sperren die IP-Adresse für eine Minute;
- Zeilen 12–16: die verbleibende Sperrzeit;
- Zeilen 18–26 und 28–30: Ein Fehlversuch wird gezählt; ein Erfolg setzt den Zähler auf null zurück.
Die Datei [src/auth/auth.controller.ts]:
| import { Body, Controller, Get, Ip, Post, Res } from '@nestjs/common';
import { Response } from 'express';
import { AuthService } from './auth.service';
import { CaptchaService } from './captcha.service';
import { JWT_COOKIE, JWT_DURATION } from './constants';
import { LimiterService } from './limiter.service';
interface LoginBody {
login?: string;
password?: string;
captchaId?: string;
captcha?: string;
}
@Controller()
export class AuthController {
constructor(
private readonly auth: AuthService,
private readonly captchas: CaptchaService,
private readonly limiter: LimiterService,
) {}
@Get('login')
form(@Res() res: Response): void {
this.display(res, {});
}
@Post('login')
async logIn(@Body() body: LoginBody, @Ip() ip: string, @Res() res: Response): Promise<void> {
// 1. eine gesperrte IP wird gar nicht erst angehört
const seconds = this.limiter.blockedSeconds(ip);
if (seconds > 0) {
this.display(res, { login: body.login, error: `Too many attempts: try again in ${seconds} s.` });
return;
}
// 2. das Captcha, dann 3. das Login und das Passwort
const captchaOk = this.captchas.check(body.captchaId, body.captcha);
const user = captchaOk ? await this.auth.check(body.login ?? '', body.password ?? '') : null;
if (!user) {
this.limiter.failure(ip);
const error = captchaOk ? 'Incorrect login or password.' : 'The copied characters are incorrect.';
this.display(res, { login: body.login, error });
return;
}
this.limiter.success(ip);
res.cookie(JWT_COOKIE, this.auth.createToken(user), {
httpOnly: true,
sameSite: 'lax',
maxAge: JWT_DURATION * 1000,
});
res.redirect('/profile');
}
@Post('logout')
logOut(@Res() res: Response): void {
res.clearCookie(JWT_COOKIE);
res.redirect('/login');
}
// jede Anzeige des Formulars erhält ein NEUES Captcha
private display(res: Response, model: object): void {
res.render('login', { ...model, captcha: this.captchas.generate() });
}
}
|
- Zeile 29: [@Ip()] injiziert die IP-Adresse des Clients;
- Zeilen 32–35: Eine gesperrte IP-Adresse wird gar nicht erst verarbeitet;
- Zeilen 37–38: Zuerst wird das CAPTCHA überprüft; das Passwort (dessen Prüfung eine rechenintensive bcrypt-Berechnung erfordert) wird nur geprüft, wenn das CAPTCHA korrekt ist;
- Zeilen 39–44: Ein falsches CAPTCHA zählt als Fehlversuch;
- Zeilen 61–63: Jedes Mal, wenn das Formular angezeigt wird, wird ein neues CAPTCHA erzeugt.
Die Datei [views/login.hbs]:
| <h1 class="h3">Login</h1>
<form method="post" action="/login">
<div class="mb-2">
<label class="form-label" for="login">Login</label>
<input class="form-control" id="login" name="login" value="{{login}}" autocomplete="username">
</div>
<div class="mb-3">
<label class="form-label" for="password">Password</label>
<input class="form-control" id="password" name="password" type="password" autocomplete="current-password">
</div>
<div class="mb-3">
<label class="form-label" for="captcha">Copy the characters of the image</label>
{{!-- das SVG-Bild wird unverändert eingefügt: dreifache geschweifte Klammern --}}
<div class="mb-1">{{{captcha.svg}}}</div>
{{!-- die Captcha-ID wird mit dem Formular übermittelt; nicht die Antwort --}}
<input type="hidden" name="captchaId" value="{{captcha.id}}">
<input class="form-control" id="captcha" name="captcha" autocomplete="off">
</div>
<button class="btn btn-primary" type="submit">Log in</button>
</form>
{{#if error}}<div class="alert alert-danger mt-3">{{error}}</div>{{/if}}
<p class="text-muted mt-3">Accounts: admin / admin, marie / marie</p>
|
Zeilen 14–17: Das SVG-Bild wird unverändert in die Seite eingefügt (dreifache geschweifte Klammern: Es handelt sich um vom Server erzeugtes HTML); die CAPTCHA-ID wird in einem versteckten Feld übergeben.

Ein falsch abgeschriebenes CAPTCHA:

Beim dritten fehlgeschlagenen Versuch:

Die Fallstudie wendet diese beiden Sicherheitsmaßnahmen auf ihre Anmeldeseite und auf die Kontoerstellung an, mit einstellbaren Schwellenwerten in der Datei [.env].