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

Uma senha incorreta:

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

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

Mesma tentativa feita por [admin]:

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.

Um CAPTCHA transcrito incorretamente:

Na terceira tentativa malsucedida:

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