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]:
| // 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]:
| 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
|
| HTTP/1.1 302 Found
Location: /login
Content-Type: text/plain; charset=utf-8
Content-Length: 28
Found. Redirecting to /login
|

Una contraseña incorrecta:

Inicio de sesión exitoso, visto con [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
|
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:
| 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:

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
|
| 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
|
| 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]:
| 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:

El mismo intento de [admin]:

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.

Un CAPTCHA transcrito incorrectamente:

En el tercer intento fallido:

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].