Skip to content

8. Autenticação e autorização

Duas questões distintas se colocam a cada requisição:

  • Quem é o usuário? Isso é a autenticação: o usuário se identificou com um nome de usuário e uma senha, e toda requisição seguinte deve provar que vem dele;
  • Ele tem permissão para acessar esta página? Isso é a autorização: no estudo de caso, apenas um usuário com o papel ADMIN gerencia médicos e clientes.

Como o servidor é stateless (Capítulo 6), a prova de identidade deve acompanhar cada requisição. Usa-se um token JWT ([JSON Web Token]): após o login, o servidor gera um token contendo a identidade do usuário e o assina com uma chave secreta. O token é guardado em um cookie; o navegador o reenvia a cada requisição; o servidor verifica a assinatura. O usuário pode ler seu token, mas não pode modificá-lo: qualquer modificação invalida a assinatura.

O [NestJS] se apoia em duas bibliotecas para isso: [passport] (e sua estratégia [passport-jwt]), que verifica os tokens, e [@nestjs/jwt], que os gera.

8.1. Exemplo 25: login, token, 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

O arquivo [src/auth/constants.ts]:

1
2
3
4
5
6
// o nome do cookie que carrega o token
export const JWT_COOKIE = 'token';
// a chave secreta que assina os tokens (em produção: uma variável de ambiente)
export const JWT_SECRET = process.env.JWT_SECRET ?? 'development-secret';
// tempo de vida de um token, em segundos
export const JWT_DURATION = 3600;

Linha 4: a chave que assina os tokens. Quem conhece essa chave pode gerar tokens válidos: em produção, ela vem de uma variável de ambiente, nunca do código-fonte.

O arquivo [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 a senha em si
}

// os usuários, em memória (o próximo capítulo os colocará em um banco de dados).
// A senha de cada um é o seu login; apenas o hash bcrypt dela é mantido
@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);
  }
}
  • Linha 9: nunca guardamos uma senha; guardamos apenas seu hash, uma impressão digital calculada por uma função unidirecional. Podemos verificar que uma senha corresponde a uma impressão digital, mas não podemos recuperar a senha a partir da impressão digital;
  • Linhas 16–19: [bcrypt.hashSync(password, 10)] calcula o hash com o algoritmo [bcrypt]. O número 10 representa o “custo”: o bcrypt é intencionalmente lento (2¹⁰ iterações) para desencorajar quem tentar milhões de senhas. Dois hashes da mesma senha são diferentes (é acrescentado um “salt” aleatório): [bcrypt.compare] é o responsável por verificá-los.

O arquivo [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';

// o que o token contém: o suficiente para identificar o usuário sem ler o banco de dados
export interface TokenContent {
  sub: number; // "subject": o identificador do usuário (convenção JWT)
  login: string;
  name: string;
  role: string;
}

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

  // o usuário se o par login / senha estiver correto, null caso contrário
  async check(login: string, password: string): Promise<User | null> {
    const u = this.users.byLogin(login);
    // bcrypt.compare calcula o hash da senha digitada e compara os hashes
    return u && (await bcrypt.compare(password, u.passwordHash)) ? u : null;
  }

  // um token ASSINADO: o navegador pode lê-lo, mas não modificá-lo
  createToken(u: User): string {
    const content: TokenContent = { sub: u.id, login: u.login, name: u.name, role: u.role };
    return this.jwt.sign(content);
  }
}
  • linhas 7–12: o conteúdo do token. [sub] ([subject]) é o nome convencional do identificador do usuário. Incluímos tudo de que as páginas precisam (nome, papel) para não consultar o banco de dados a cada requisição;
  • linhas 22–26: verificação do nome de usuário e da senha;
  • linhas 29–32: [JwtService.sign] gera o token assinado. [JwtService] é configurado (chave, duração) no módulo da aplicação.

O arquivo [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';

// o usuário logado, como os controllers o veem (req.user)
export interface LoggedInUser {
  id: number;
  login: string;
  name: string;
  role: string;
}

// a estratégia "jwt" do Passport: onde encontrar o token, como verificá-lo
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
  constructor() {
    super({
      // o token é lido do cookie (e não do cabeçalho Authorization)
      jwtFromRequest: ExtractJwt.fromExtractors([(req: Request) => req?.cookies?.[JWT_COOKIE] ?? null]),
      ignoreExpiration: false, // um token expirado é rejeitado
      secretOrKey: JWT_SECRET, // para verificar a assinatura
    });
  }

  // chamado se o token for válido; o que ele retorna se torna req.user
  validate(content: TokenContent): LoggedInUser {
    return { id: content.sub, login: content.login, name: content.name, role: content.role };
  }
}
  • linha 18: uma estratégia do [Passport], chamada [jwt], descreve como autenticar uma requisição;
  • linha 22: onde encontrar o token: no cookie. (Um cliente [JavaScript] o enviaria, em vez disso, no cabeçalho [Authorization: Bearer ...]; veja [ExtractJwt.fromAuthHeaderAsBearerToken()]);
  • linhas 23–24: um token expirado ou com assinatura incorreta é rejeitado;
  • linhas 29–31: chamado quando o token é válido. O resultado é [req.user]: o usuário logado, com acesso às actions.

O arquivo [src/auth/jwt-auth.guard.ts]:

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

// o guard que executa a estratégia 'jwt': nenhum token válido -> 401
@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

[AuthGuard('jwt')] cria um guard que executa a estratégia [jwt]. Sem um token válido, ele lança uma [UnauthorizedException] (401).

O arquivo [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) {
      // mensagem deliberadamente vaga: não dizemos qual dos dois está errado
      res.render('login', { login: body.login, error: 'Incorrect login or password.' });
      return;
    }
    // o token é colocado em um cookie httpOnly: o JavaScript da página
    // não pode lê-lo, o navegador o reenvia a cada requisição
    res.cookie(JWT_COOKIE, this.auth.createToken(user), {
      httpOnly: true,
      sameSite: 'lax',
      maxAge: JWT_DURATION * 1000,
    });
    res.redirect('/profile');
  }

  // sair MODIFICA o estado: é um POST, não um link
  @Post('logout')
  logOut(@Res() res: Response): void {
    res.clearCookie(JWT_COOKIE);
    res.redirect('/login');
  }
}
  • linhas 17–32: o login. Se o login falhar, o formulário é exibido novamente com uma mensagem deliberadamente vaga: dizer “este login não existe” ajudaria um atacante a encontrar logins válidos;
  • linhas 26–30: em caso de sucesso, o token é guardado em um cookie [httpOnly]; o [JavaScript] da página não consegue lê-lo, o que protege o token caso um script malicioso seja executado na página. [sameSite: 'lax']: o cookie não é incluído em requisições POST enviadas de outro site, o que protege contra a falsificação de requisições ([CSRF]);
  • Linhas 35–39: o logout exclui o cookie. É um POST: ele altera o estado do usuário (veja o Exemplo 21).

O arquivo [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: o guard exige um token válido
  @Get('profile')
  @UseGuards(JwtAuthGuard)
  @Render('profile')
  profile(@Req() req: Request): object {
    return { user: req.user as LoggedInUser };
  }
}

Linha 17: a página [/profile] é protegida pelo guard. A action lê o usuário em [req.user].

O arquivo [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 (sem token, ou token inválido): direto para a página de login
    if (status === HttpStatus.UNAUTHORIZED) {
      res.redirect('/login');
      return;
    }
    res.status(status).render('error', { status, message: exception.message });
  }
}

Linhas 10–13: um erro 401 não exibe uma página de erro; o usuário é redirecionado para a página de login.

O arquivo [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 uma vez por todas: chave e tempo de vida
    JwtModule.register({ secret: JWT_SECRET, signOptions: { expiresIn: JWT_DURATION } }),
  ],
  controllers: [AuthController, ProfileController],
  providers: [UsersService, AuthService, JwtStrategy],
})
export class AppModule {}

Linha 15: a configuração do [JwtService]: chave do token e duração (uma hora).

O arquivo [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. Execução

Sem cookie, a página protegida redireciona para a página de login:

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

Uma senha incorreta:

Image

Login bem-sucedido, visto pelo [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

O token é composto por três partes separadas por pontos: um cabeçalho, o conteúdo e a assinatura. As duas primeiras são simplesmente codificadas em [base64url]; vamos decodificar o conteúdo:

1
2
3
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjIsImxvZ2luIjoibWFyaWUiLCJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwMTczMDg3LCJleHAiOjE3OTAxNzY2ODd9.LoujmLAq__cPbevACUDUMvdPHkH7r_ekv48IwHqc3Dk

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

O conteúdo gerado por [createToken] está presente, junto com dois campos acrescentados pelo [JwtService]: [iat] ([issued at], a data de criação) e [exp] (a data de expiração), em segundos desde 1º de janeiro de 1970. O token não é criptografado: ele não deve conter nenhuma informação confidencial. No navegador:

Image

Agora vamos tentar modificar o token para atribuir a nós mesmos o papel ADMIN: decodificamos o conteúdo, substituímos [USER] por [ADMIN] e o codificamos de novo… mas não conseguimos recalcular a assinatura sem a chave 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

A assinatura não corresponde mais ao conteúdo: o token é rejeitado (erro 401) e o tratador de exceções redireciona para a página de login. Logout:

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. Exemplo 26: papéis

O Exemplo 26 se baseia no Exemplo 25 e acrescenta uma página reservada ao papel ADMIN. Três novos arquivos foram adicionados.

O arquivo [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 um METADADO na action (ou no controller);
// o decorador não verifica nada por si só, é o RolesGuard quem o lerá
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);

Linha 7: [SetMetadata] associa metadados (qualquer informação) à classe ou ao método decorado. [@Roles('ADMIN')] não verifica nada: ele declara o papel exigido.

O arquivo [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: a ferramenta do NestJS para reler os metadados
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // @Roles da action, na falta dele o do controller
    const required = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [context.getHandler(), context.getClass()]);
    if (!required || required.length === 0) {
      return true; // sem @Roles: nenhuma restrição de papel
    }
    // req.user foi definido por JwtAuthGuard, que executa ANTES deste 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;
  }
}
  • linha 10: [Reflector] é o serviço do [NestJS] que lê os metadados;
  • linha 14: os papéis exigidos pela action ou, na falta deles, por seu controller. É aqui que entra em jogo o contexto de execução do guard (veja o Capítulo 7);
  • linhas 15–17: sem [@Roles], não há restrições;
  • linha 19: [req.user] foi registrado pelo guard [JwtAuthGuard], que é executado antes dele;
  • linhas 20–22: um papel insuficiente provoca um erro 403 (Forbidden).

O arquivo [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';

// a ordem importa: primeiro QUEM é (JwtAuthGuard), depois SE É PERMITIDO (RolesGuard)
@Controller('admin')
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('ADMIN')
export class AdminController {
  @Get()
  @Render('admin')
  admin(): object {
    return {};
  }
}

linhas 8–9: os guards são executados na ordem em que são listados: primeiro a identificação, depois a verificação do papel. O controller inteiro é reservado ao papel ADMIN. O usuário [marie] (papel USER) tenta abrir a página de administração:

Image

Mesma tentativa feita por [admin]:

Image

O estudo de caso tem três papéis (ADMIN, DOCTOR, USER) e usa exatamente esses dois guards. O filtro de exceção converte o 403 em uma página de erro traduzida.

8.3. Exemplo 27: CAPTCHA e limite de tentativas

Uma página de login atrai bots: programas que testam milhares de combinações de login e senha. Duas salvaguardas complementares:

  • um CAPTCHA: uma imagem de caracteres distorcidos que um humano lê com facilidade, mas que um bot simples não consegue decifrar;
  • um limite de tentativas: após algumas tentativas malsucedidas, o endereço IP é bloqueado por um tempo.

O Exemplo 27 acrescenta essas duas salvaguardas ao Exemplo 25.

O arquivo [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 em um campo oculto do formulário
  svg: string; // a imagem, inserida como está na página
}

@Injectable()
export class CaptchaService {
  // id -> resposta esperada. A resposta NUNCA sai do servidor
  private readonly answers = new Map<string, string>();

  generate(): Captcha {
    // svg-captcha: um texto aleatório, desenhado com caracteres distorcidos
    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 };
  }

  // a resposta é a correta? Em todos os casos, o captcha é
  // consumido: uma imagem é usada uma única 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();
  }
}
  • Linha 13: as respostas esperadas são guardadas pelo servidor sob um identificador aleatório. A página contém apenas a imagem e o identificador: a resposta nunca sai do servidor;
  • linhas 15–21: a biblioteca [svg-captcha] gera uma cadeia de texto aleatória e a renderiza como imagem (SVG), obscurecida por linhas. Caracteres facilmente confundidos (0 e O, 1 e l etc.) são excluídos;
  • linhas 25–32: a verificação consome o CAPTCHA: uma imagem é usada uma única vez; um bot não pode reutilizar uma resposta que já encontrou.

O arquivo [src/auth/limiter.service.ts]:

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

const MAX_FAILURES = 3; // falhas toleradas...
const BLOCK_MS = 60 * 1000; // ... antes de um bloqueio de um minuto

// limita o número de tentativas de login por endereço IP
@Injectable()
export class LimiterService {
  private readonly counters = new Map<string, { failures: number; blockedUntil: number }>();

  // 0 se o IP pode tentar a sorte, caso contrário o 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);
  }
}
  • linhas 3–4: três falhas bloqueiam o endereço IP por um minuto;
  • linhas 12–16: o tempo de bloqueio restante;
  • linhas 18–26 e 28–30: uma falha é contabilizada; um sucesso zera o contador.

O arquivo [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. um IP bloqueado nem sequer é ouvido
    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. o captcha, depois 3. o login e a senha
    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 exibição do formulário tem um captcha NOVO
  private display(res: Response, model: object): void {
    res.render('login', { ...model, captcha: this.captchas.generate() });
  }
}
  • linha 29: [@Ip()] injeta o endereço IP do cliente;
  • linhas 32–35: um IP bloqueado nem sequer é processado;
  • linhas 37–38: o CAPTCHA é verificado primeiro; a senha (cuja verificação exige um cálculo bcrypt computacionalmente caro) só é conferida se o CAPTCHA estiver correto;
  • linhas 39–44: um CAPTCHA incorreto conta como uma falha;
  • linhas 61–63: cada vez que o formulário é exibido, um novo CAPTCHA é gerado.

O arquivo [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>
    {{!-- a imagem SVG é inserida como está: chaves triplas --}}
    <div class="mb-1">{{{captcha.svg}}}</div>
    {{!-- o identificador do captcha viaja com o formulário; a resposta não --}}
    <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>

linhas 14–17: a imagem SVG é inserida na página como está (chaves triplas: trata-se de HTML gerado pelo servidor); o identificador do captcha é passado em um campo oculto.

Image

Um CAPTCHA transcrito incorretamente:

Image

Na terceira tentativa malsucedida:

Image

O estudo de caso aplica essas duas medidas de segurança à sua página de login e ao processo de criação de conta, com limites ajustáveis no arquivo [.env].