Skip to content

8. Autenticación y autorización

Para cada solicitud surgen dos preguntas distintas:

  • ¿Quién es el usuario? Esto es la autenticación: el usuario se ha identificado con un nombre de usuario y una contraseña, y cada solicitud posterior debe demostrar que proviene de él;
  • ¿Tiene permiso para acceder a esta página? Esto es la autorización: en el caso de estudio, solo un usuario con el rol ADMIN administra los médicos y los clientes.

Como el servidor no tiene estado (capítulo 6), la prueba de identidad debe incluirse en cada solicitud. Se utiliza un token JWT ([JSON Web Token]): tras el inicio de sesión, el servidor genera un token que contiene la identidad del usuario y lo firma con una clave secreta. El token se almacena en una cookie; el navegador lo devuelve con cada solicitud; el servidor verifica la firma. El usuario puede leer su token, pero no modificarlo: cualquier modificación invalida la firma.

[NestJS] se apoya en dos bibliotecas para esto: [passport] (y su estrategia [passport-jwt]), que verifica los tokens, y [@nestjs/jwt], que los genera.

8.1. Ejemplo 25: inicio de sesión, token y página protegida

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

El archivo [src/auth/constants.ts]:

1
2
3
4
5
6
// el nombre de la cookie que transporta el token
export const JWT_COOKIE = 'token';
// la clave secreta que firma los tokens (en producción: una variable de entorno)
export const JWT_SECRET = process.env.JWT_SECRET ?? 'development-secret';
// vigencia de un token, en segundos
export const JWT_DURATION = 3600;

Línea 4: la clave que firma los tokens. Cualquiera que conozca esta clave puede generar tokens válidos: en producción, proviene de una variable de entorno, nunca del código fuente.

El archivo [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; // NUNCA la contraseña misma
}

// los usuarios, en memoria (el próximo capítulo los pondrá en una base de datos).
// La contraseña de cada uno es su login; solo se conserva su hash bcrypt
@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);
  }
}
  • Línea 9: nunca se almacena una contraseña; solo se almacena su hash, una huella calculada mediante una función unidireccional. Podemos verificar que una contraseña corresponde a una huella, pero no podemos recuperar la contraseña a partir de la huella;
  • Líneas 16–19: [bcrypt.hashSync(password, 10)] calcula el hash con el algoritmo [bcrypt]. El número 10 representa el «costo»: bcrypt es intencionalmente lento (2¹⁰ iteraciones) para desalentar a quien intente probar millones de contraseñas. Dos hashes de la misma contraseña son distintos (se agrega un «salt» aleatorio): [bcrypt.compare] se encarga de verificarlos.

El archivo [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';

// lo que contiene el token: lo suficiente para identificar al usuario sin leer la base de datos
export interface TokenContent {
  sub: number; // "subject": el identificador del usuario (convención JWT)
  login: string;
  name: string;
  role: string;
}

@Injectable()
export class AuthService {
  constructor(
    private readonly users: UsersService,
    private readonly jwt: JwtService,
  ) {}

  // el usuario si el par login / contraseña es correcto, null en caso contrario
  async check(login: string, password: string): Promise<User | null> {
    const u = this.users.byLogin(login);
    // bcrypt.compare calcula el hash de la contraseña escrita y compara los hashes
    return u && (await bcrypt.compare(password, u.passwordHash)) ? u : null;
  }

  // un token FIRMADO: el navegador puede leerlo, pero no modificarlo
  createToken(u: User): string {
    const content: TokenContent = { sub: u.id, login: u.login, name: u.name, role: u.role };
    return this.jwt.sign(content);
  }
}
  • líneas 7–12: el contenido del token. [sub] ([subject]) es el nombre convencional del identificador del usuario. Incluimos lo que las páginas necesitan (nombre, rol) para no tener que consultar la base de datos en cada solicitud;
  • líneas 22–26: verificación del nombre de usuario y la contraseña;
  • líneas 29–32: [JwtService.sign] genera el token firmado. [JwtService] se configura (clave, duración) en el módulo de la aplicación.

El archivo [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';

// el usuario conectado, tal como lo ven los controladores (req.user)
export interface LoggedInUser {
  id: number;
  login: string;
  name: string;
  role: string;
}

// la estrategia "jwt" de Passport: dónde encontrar el token, cómo verificarlo
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
  constructor() {
    super({
      // el token se lee de la cookie (y no del encabezado Authorization)
      jwtFromRequest: ExtractJwt.fromExtractors([(req: Request) => req?.cookies?.[JWT_COOKIE] ?? null]),
      ignoreExpiration: false, // un token expirado se rechaza
      secretOrKey: JWT_SECRET, // para verificar la firma
    });
  }

  // se llama si el token es válido; lo que devuelve se convierte en req.user
  validate(content: TokenContent): LoggedInUser {
    return { id: content.sub, login: content.login, name: content.name, role: content.role };
  }
}
  • línea 18: una estrategia de [Passport], llamada [jwt], describe cómo autenticar una solicitud;
  • línea 22: dónde encontrar el token: en la cookie. (Un cliente [JavaScript] lo enviaría, en cambio, en el encabezado [Authorization: Bearer ...]; véase [ExtractJwt.fromAuthHeaderAsBearerToken()]);
  • líneas 23–24: se rechaza un token vencido o con una firma incorrecta;
  • líneas 29–31: se llama cuando el token es válido. El resultado es [req.user]: el usuario conectado, con acceso a las acciones.

El archivo [src/auth/jwt-auth.guard.ts]:

1
2
3
4
5
6
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

// el guard que ejecuta la estrategia 'jwt': sin token válido -> 401
@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

[AuthGuard('jwt')] crea un guardia que ejecuta la estrategia [jwt]. Sin un token válido, lanza una [UnauthorizedException] (401).

El archivo [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) {
      // mensaje deliberadamente vago: no decimos cuál de los dos es incorrecto
      res.render('login', { login: body.login, error: 'Incorrect login or password.' });
      return;
    }
    // el token se coloca en una cookie httpOnly: el JavaScript de la página
    // no puede leerla, el navegador la devuelve con cada solicitud
    res.cookie(JWT_COOKIE, this.auth.createToken(user), {
      httpOnly: true,
      sameSite: 'lax',
      maxAge: JWT_DURATION * 1000,
    });
    res.redirect('/profile');
  }

  // cerrar sesión MODIFICA el estado: es un POST, no un enlace
  @Post('logout')
  logOut(@Res() res: Response): void {
    res.clearCookie(JWT_COOKIE);
    res.redirect('/login');
  }
}
  • líneas 17–32: el inicio de sesión. Si falla, el formulario se vuelve a mostrar con un mensaje deliberadamente vago: indicar «este nombre de usuario no existe» ayudaría a un atacante a encontrar nombres de usuario válidos;
  • líneas 26–30: si tiene éxito, el token se almacena en una cookie [httpOnly]; el [JavaScript] de la página no puede leerla, lo que protege el token si se ejecutara un script malicioso en la página. [sameSite: 'lax']: la cookie no se incluye en las solicitudes POST enviadas desde otro sitio, lo que protege contra la falsificación de solicitudes ([CSRF]);
  • Líneas 35–39: cerrar sesión elimina la cookie. Se hace mediante un POST: cambia el estado del usuario (véase el ejemplo 21).

El archivo [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 {
  // página pública
  @Get()
  @Render('home')
  home(): object {
    return {};
  }

  // página protegida: el guard exige un token válido
  @Get('profile')
  @UseGuards(JwtAuthGuard)
  @Render('profile')
  profile(@Req() req: Request): object {
    return { user: req.user as LoggedInUser };
  }
}

Línea 17: la página [/profile] está protegida por el guardia. La acción lee el usuario de [req.user].

El archivo [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 (sin token, o token inválido): a la página de inicio de sesión
    if (status === HttpStatus.UNAUTHORIZED) {
      res.redirect('/login');
      return;
    }
    res.status(status).render('error', { status, message: exception.message });
  }
}

Líneas 10–13: un error 401 no muestra una página de error; el usuario es redirigido a la página de inicio de sesión.

El archivo [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, configurado de una vez por todas: clave y vigencia
    JwtModule.register({ secret: JWT_SECRET, signOptions: { expiresIn: JWT_DURATION } }),
  ],
  controllers: [AuthController, ProfileController],
  providers: [UsersService, AuthService, JwtStrategy],
})
export class AppModule {}

Línea 15: la configuración de [JwtService]: clave y duración del token (una hora).

El archivo [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. Ejecución

Sin cookie, la página protegida redirige a la página de inicio de sesión:

curl -i http://localhost:3000/profile
1
2
3
4
5
6
HTTP/1.1 302 Found
Location: /login
Content-Type: text/plain; charset=utf-8
Content-Length: 28

Found. Redirecting to /login

Image

Una contraseña incorrecta:

Image

Inicio de sesión exitoso, visto con [curl]:

curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:3000/login
1
2
3
4
5
6
7
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

El token consta de tres partes separadas por puntos: un encabezado, el contenido y la firma. Las dos primeras simplemente están codificadas en [base64url]; decodifiquemos el contenido:

1
2
3
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjIsImxvZ2luIjoibWFyaWUiLCJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwMTczMDg3LCJleHAiOjE3OTAxNzY2ODd9.LoujmLAq__cPbevACUDUMvdPHkH7r_ekv48IwHqc3Dk

{"sub": 2, "login": "marie", "name": "Marie Pélissier", "role": "USER", "iat": 1790173087, "exp": 1790176687}

Se incluye el contenido generado por [createToken], junto con dos campos agregados por [JwtService]: [iat] ([issued at], la fecha de creación) y [exp] (la fecha de vencimiento), en segundos desde el 1 de enero de 1970. El token no está cifrado: no debe contener información confidencial. En el navegador:

Image

Ahora intentemos modificar el token para asignarnos el rol ADMIN: decodificamos el contenido, reemplazamos [USER] por [ADMIN] y lo volvemos a codificar… pero no podemos recalcular la firma sin la clave secreta:

curl -i -b "token=eyJhbGciOi...(modified content)...LoujmLAq..." http://localhost:3000/profile
1
2
3
4
5
6
HTTP/1.1 302 Found
Location: /login
Content-Type: text/plain; charset=utf-8
Content-Length: 28

Found. Redirecting to /login

La firma ya no coincide con el contenido: el token es rechazado (error 401) y el manejador de excepciones redirige a la página de inicio de sesión. Cierre de sesión:

curl -i -b cookies.txt -X POST http://localhost:3000/logout
1
2
3
4
5
6
7
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. Ejemplo 26: roles

El ejemplo 26 se basa en el ejemplo 25 y agrega una página reservada para el rol ADMIN. Se han añadido tres archivos nuevos.

El archivo [src/auth/roles.decorator.ts]:

1
2
3
4
5
6
7
import { SetMetadata } from '@nestjs/common';

export const ROLES_KEY = 'roles';

// @Roles('ADMIN'): coloca un METADATO en la acción (o en el controlador);
// el decorador no verifica nada por sí mismo, será RolesGuard quien lo lea
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);

Línea 7: [SetMetadata] adjunta metadatos (cualquier información) a la clase o al método decorado. [@Roles('ADMIN')] no verifica nada: declara el rol requerido.

El archivo [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: la herramienta de NestJS para volver a leer los metadatos
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // el @Roles de la acción o, en su defecto, el del controlador
    const required = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [context.getHandler(), context.getClass()]);
    if (!required || required.length === 0) {
      return true; // sin @Roles: sin restricción de rol
    }
    // req.user fue establecido por JwtAuthGuard, que se ejecuta ANTES de este guard
    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;
  }
}
  • línea 10: [Reflector] es el servicio de [NestJS] que lee los metadatos;
  • línea 14: los roles requeridos por la acción o, en su defecto, por su controlador. Aquí entra en juego el contexto de ejecución del guardia (véase el capítulo 7);
  • líneas 15–17: sin [@Roles], no hay restricciones;
  • línea 19: [req.user] fue registrado por el guardia [JwtAuthGuard], que se ejecuta antes que este;
  • líneas 20–22: un rol insuficiente provoca un error 403 (Forbidden).

El archivo [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';

// el orden importa: primero QUIÉN es (JwtAuthGuard), luego SI TIENE PERMISO (RolesGuard)
@Controller('admin')
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('ADMIN')
export class AdminController {
  @Get()
  @Render('admin')
  admin(): object {
    return {};
  }
}

líneas 8–9: los guardias se ejecutan en el orden en que se enumeran: primero la identificación y luego la verificación del rol. Todo el controlador está reservado para el rol ADMIN. El usuario [marie] (rol USER) intenta abrir la página de administración:

Image

El mismo intento de [admin]:

Image

El caso de estudio tiene tres roles (ADMIN, DOCTOR, USER) y utiliza exactamente estos dos guardias. El filtro de excepciones convierte el 403 en una página de error traducida.

8.3. Ejemplo 27: CAPTCHA y límite de intentos

Una página de inicio de sesión atrae a los bots: programas que prueban miles de combinaciones de nombre de usuario y contraseña. Dos medidas de protección complementarias:

  • un CAPTCHA: una imagen de caracteres distorsionados que una persona puede leer con facilidad, pero que un bot simple no puede descifrar;
  • un límite de intentos: tras unos pocos intentos fallidos, la dirección IP se bloquea durante un tiempo.

El ejemplo 27 agrega estas dos medidas de protección al ejemplo 25.

El archivo [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; // colocado en un campo oculto del formulario
  svg: string; // la imagen, insertada tal cual en la página
}

@Injectable()
export class CaptchaService {
  // id -> respuesta esperada. La respuesta NUNCA sale del servidor
  private readonly answers = new Map<string, string>();

  generate(): Captcha {
    // svg-captcha: un texto aleatorio, dibujado con caracteres distorsionados
    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 };
  }

  // ¿es correcta la respuesta? En todos los casos, el captcha se
  // consume: una imagen se usa una sola vez
  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();
  }
}
  • Línea 13: las respuestas esperadas se almacenan en el servidor bajo un identificador aleatorio. La página contiene solo la imagen y el identificador: la respuesta nunca sale del servidor;
  • líneas 15–21: la biblioteca [svg-captcha] genera una cadena de texto aleatoria y la convierte en una imagen (SVG), oscurecida con líneas. Se excluyen los caracteres que se confunden fácilmente (0 y O, 1 y l, etc.);
  • líneas 25–32: el proceso de verificación consume el CAPTCHA: una imagen se usa una sola vez; un bot no puede reutilizar una respuesta que ya encontró.

El archivo [src/auth/limiter.service.ts]:

import { Injectable } from '@nestjs/common';

const MAX_FAILURES = 3; // fallos tolerados...
const BLOCK_MS = 60 * 1000; // ... antes de un bloqueo de un minuto

// limita el número de intentos de inicio de sesión por dirección IP
@Injectable()
export class LimiterService {
  private readonly counters = new Map<string, { failures: number; blockedUntil: number }>();

  // 0 si la IP puede intentarlo, de lo contrario el número de segundos de espera
  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);
  }
}
  • líneas 3–4: tres fallos bloquean la dirección IP durante un minuto;
  • líneas 12–16: el tiempo de bloqueo restante;
  • líneas 18–26 y 28–30: se cuenta un fallo; un éxito restablece el contador a cero.

El archivo [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. una IP bloqueada ni siquiera es atendida
    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. el captcha, luego 3. el login y la contraseña
    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');
  }

  // cada visualización del formulario tiene un captcha NUEVO
  private display(res: Response, model: object): void {
    res.render('login', { ...model, captcha: this.captchas.generate() });
  }
}
  • línea 29: [@Ip()] inyecta la dirección IP del cliente;
  • líneas 32–35: una IP bloqueada ni siquiera se procesa;
  • líneas 37–38: primero se verifica el CAPTCHA; la contraseña (que requiere un cálculo bcrypt costoso desde el punto de vista computacional) solo se comprueba si el CAPTCHA es correcto;
  • líneas 39–44: un CAPTCHA incorrecto cuenta como un fallo;
  • líneas 61–63: cada vez que se muestra el formulario, se genera un nuevo CAPTCHA.

El archivo [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>
    {{!-- la imagen SVG se inserta tal cual: llaves triples --}}
    <div class="mb-1">{{{captcha.svg}}}</div>
    {{!-- el identificador del captcha viaja con el formulario; no la respuesta --}}
    <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>

líneas 14–17: la imagen SVG se inserta en la página tal cual (triple llave: es HTML generado por el servidor); el identificador del CAPTCHA se pasa en un campo oculto.

Image

Un CAPTCHA transcrito incorrectamente:

Image

En el tercer intento fallido:

Image

El caso de estudio aplica estas dos medidas de seguridad a su página de inicio de sesión y al proceso de creación de cuentas, con umbrales ajustables en el archivo [.env].