8. 身份验证与授权
每个请求都会涉及两个不同的问题:
- 用户 是谁?这就是 身份验证:用户已经用用户名和密码表明了自己的身份,之后的每个请求都必须证明它来自该用户;
- 他们是否有权限 访问这个页面?这就是 授权:在案例研究中,只有角色为 ADMIN 的用户才能管理医生和客户。
由于服务器是无状态的(第 6 章),身份证明必须随每个请求一起提交。这里使用 JWT 令牌 ([JSON Web Token]):登录后,服务器生成一个包含用户身份的令牌,并用密钥对其 签名。令牌存储在 Cookie 中;浏览器在每个请求中把它发回;服务器验证签名。用户可以读取自己的令牌,但无法修改它:任何修改都会使签名失效。
[NestJS] 为此依赖两个库:[passport] (及其策略 [passport-jwt]),用于验证令牌;以及 [@nestjs/jwt],用于生成令牌。
8.1. 示例 25:登录、令牌、受保护的页面
| 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
|
文件 [src/auth/constants.ts]:
| // 携带令牌的 Cookie 的名称
export const JWT_COOKIE = 'token';
// 用于签名令牌的密钥(生产环境中:使用环境变量)
export const JWT_SECRET = process.env.JWT_SECRET ?? 'development-secret';
// 令牌的有效期,单位为秒
export const JWT_DURATION = 3600;
|
第 4 行:用于签署令牌的密钥。任何知道这个密钥的人都可以生成有效的令牌:在生产环境中,它来自环境变量,绝不能来自源代码。
文件 [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; // 绝不存放密码本身
}
// 用户保存在内存中(下一章会将它们放入数据库)。
// 每个用户的密码就是其登录名;只保留其 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);
}
}
|
- 第 9 行:我们 绝不存储密码;我们只存储它的 哈希——由单向函数计算出的指纹。我们可以验证某个密码是否与某个指纹匹配,但无法从指纹恢复出密码;
- 第 16–19 行:[bcrypt.hashSync(password, 10)] 使用 [bcrypt] 算法计算哈希。数字 10 表示“成本”:bcrypt 故意设计得很慢(2¹⁰ 次迭代),以阻止有人尝试数百万个密码。同一个密码的两个哈希是不同的(因为添加了随机的“盐”):由 [bcrypt.compare] 负责验证它们。
文件 [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';
// 令牌包含的内容:足以识别用户,而无需读取数据库
export interface TokenContent {
sub: number; // "subject":用户的标识符(JWT 约定)
login: string;
name: string;
role: string;
}
@Injectable()
export class AuthService {
constructor(
private readonly users: UsersService,
private readonly jwt: JwtService,
) {}
// 如果登录名 / 密码对正确则返回用户,否则返回 null
async check(login: string, password: string): Promise<User | null> {
const u = this.users.byLogin(login);
// bcrypt.compare 对输入的密码进行哈希,并比较哈希值
return u && (await bcrypt.compare(password, u.passwordHash)) ? u : null;
}
// 已签名的令牌:浏览器可以读取,但不能修改
createToken(u: User): string {
const content: TokenContent = { sub: u.id, login: u.login, name: u.name, role: u.role };
return this.jwt.sign(content);
}
}
|
- 第 7–12 行:令牌的内容。[sub] ([subject])是用户 ID 的惯用名称。我们放入页面所需的一切(姓名、角色),这样就不必在每个请求时都查询数据库;
- 第 22–26 行:验证用户名和密码;
- 第 29–32 行:[JwtService.sign] 生成签名的令牌。[JwtService] 在应用模块中配置(密钥、有效期)。
[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';
// 已登录的用户,即控制器所见的样子(req.user)
export interface LoggedInUser {
id: number;
login: string;
name: string;
role: string;
}
// Passport 的 "jwt" 策略:在哪里找到令牌,如何检查
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
constructor() {
super({
// 令牌从 Cookie 中读取(而不是从 Authorization 标头)
jwtFromRequest: ExtractJwt.fromExtractors([(req: Request) => req?.cookies?.[JWT_COOKIE] ?? null]),
ignoreExpiration: false, // 已过期的令牌会被拒绝
secretOrKey: JWT_SECRET, // 用于检查签名
});
}
// 令牌有效时调用;其返回值成为 req.user
validate(content: TokenContent): LoggedInUser {
return { id: content.sub, login: content.login, name: content.name, role: content.role };
}
}
|
- 第 18 行:一个名为 [jwt] 的 [Passport] 策略,描述如何对请求进行身份验证;
- 第 22 行:到哪里查找令牌:在 Cookie 中。([JavaScript] 客户端则会改为把它放在 [Authorization: Bearer ...] 头中发送;参见 [ExtractJwt.fromAuthHeaderAsBearerToken()]);
- 第 23–24 行:已过期或签名不正确的令牌会被拒绝;
- 第 29–31 行:在令牌有效时调用。结果是 [req.user]:已登录的用户,可在操作中访问。
文件 [src/auth/jwt-auth.guard.ts]:
| import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
// 运行 'jwt' 策略的守卫:没有有效令牌 -> 401
@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}
|
[AuthGuard('jwt')] 创建一个执行 [jwt] 策略的守卫。没有有效令牌时,它会抛出 [UnauthorizedException] (401)。
文件 [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) {
// 故意模糊的消息:我们不说明两者中哪一个有误
res.render('login', { login: body.login, error: 'Incorrect login or password.' });
return;
}
// 令牌放在 httpOnly Cookie 中:页面的 JavaScript
// 无法读取,浏览器会在每次请求时将其发回
res.cookie(JWT_COOKIE, this.auth.createToken(user), {
httpOnly: true,
sameSite: 'lax',
maxAge: JWT_DURATION * 1000,
});
res.redirect('/profile');
}
// 退出登录会修改状态:因此使用 POST,而不是链接
@Post('logout')
logOut(@Res() res: Response): void {
res.clearCookie(JWT_COOKIE);
res.redirect('/login');
}
}
|
- 第 17–32 行:登录。如果登录失败,表单会重新显示,并带有一条有意含糊的消息:如果说“该登录名不存在”,就会帮助攻击者找到有效的登录名;
- 第 26–30 行:如果成功,令牌会存入一个 [httpOnly] Cookie;页面的 [JavaScript] 无法读取它,这样即使页面上执行了恶意脚本,令牌也能得到保护。[sameSite: 'lax']:来自其他站点的 POST 请求不会携带该 Cookie,这可以防范请求伪造([CSRF]);
- 第 35–39 行:注销会删除 Cookie。这是一个 POST:它改变用户的状态(参见示例 21)。
[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 {
// 公开页面
@Get()
@Render('home')
home(): object {
return {};
}
// 受保护页面:守卫要求有效令牌
@Get('profile')
@UseGuards(JwtAuthGuard)
@Render('profile')
profile(@Req() req: Request): object {
return { user: req.user as LoggedInUser };
}
}
|
第 17 行:页面 [/profile] 受守卫保护。操作从 [req.user] 读取用户。
文件 [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(没有令牌,或令牌无效):转到登录页面
if (status === HttpStatus.UNAUTHORIZED) {
res.redirect('/login');
return;
}
res.status(status).render('error', { status, message: exception.message });
}
}
|
第 10–13 行:401 错误不显示错误页面;用户会被重定向到登录页面。
文件 [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,一次性配置完成:密钥和有效期
JwtModule.register({ secret: JWT_SECRET, signOptions: { expiresIn: JWT_DURATION } }),
],
controllers: [AuthController, ProfileController],
providers: [UsersService, AuthService, JwtStrategy],
})
export class AppModule {}
|
第 15 行:[JwtService] 的配置:令牌密钥和有效期(一小时)。
文件 [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. 执行
没有 Cookie 时,受保护的页面会重定向到登录页面:
| 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
|

密码错误:

登录成功,用 [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
|
令牌由三部分组成,以句点分隔:头、内容和签名。前两部分只是用 [base64url] 编码;我们来解码内容:
| eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjIsImxvZ2luIjoibWFyaWUiLCJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwMTczMDg3LCJleHAiOjE3OTAxNzY2ODd9.LoujmLAq__cPbevACUDUMvdPHkH7r_ekv48IwHqc3Dk
{"sub": 2, "login": "marie", "name": "Marie Pélissier", "role": "USER", "iat": 1790173087, "exp": 1790176687}
|
由 [createToken] 生成的内容都在其中,另外还有 [JwtService] 添加的两个字段:[iat] ([issued at],创建日期)和 [exp] (过期日期),以自 1970 年 1 月 1 日起的秒数表示。令牌 没有加密:它不包含任何机密信息。在浏览器中:

现在我们尝试修改令牌,让自己获得 ADMIN 角色:我们解码内容,把 [USER] 替换为 [ADMIN],然后重新编码……但没有密钥,我们就无法重新计算签名:
| 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
|
签名与内容不再匹配:令牌被拒绝(401 错误),异常处理程序重定向到登录页面。注销:
| 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. 示例 26:角色
示例 26 在示例 25 的基础上增加了一个仅限 ADMIN 角色访问的页面。新增了三个文件。
文件 [src/auth/roles.decorator.ts]:
| import { SetMetadata } from '@nestjs/common';
export const ROLES_KEY = 'roles';
// @Roles('ADMIN'):在动作(或控制器)上设置一个元数据;
// 装饰器本身不检查任何内容,由 RolesGuard 来读取它
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);
|
第 7 行:[SetMetadata] 为被装饰的类或方法附加 元数据 (任意信息)。[@Roles('ADMIN')] 本身不检查任何内容:它只是 声明所需的角色。
文件 [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:NestJS 中用于读回元数据的工具
constructor(private readonly reflector: Reflector) {}
canActivate(context: ExecutionContext): boolean {
// 动作上的 @Roles,没有则取控制器上的
const required = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [context.getHandler(), context.getClass()]);
if (!required || required.length === 0) {
return true; // 没有 @Roles:没有角色限制
}
// req.user 由 JwtAuthGuard 设置,它在此守卫之前运行
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;
}
}
|
- 第 10 行:[Reflector] 是 [NestJS] 中读取元数据的服务;
- 第 14 行:操作所需的角色,如果没有,则取其控制器所需的角色。这就是守卫的执行上下文发挥作用的地方(参见第 7 章);
- 第 15–17 行:没有 [@Roles] 时,没有任何限制;
- 第 19 行:[req.user] 是由守卫 [JwtAuthGuard] 注册的,该守卫在它 之前执行;
- 第 20–22 行:角色不足会导致 403(Forbidden)错误。
文件 [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';
// 顺序很重要:先判断是谁(JwtAuthGuard),再判断是否被允许(RolesGuard)
@Controller('admin')
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('ADMIN')
export class AdminController {
@Get()
@Render('admin')
admin(): object {
return {};
}
}
|
第 8–9 行:守卫按列出的顺序执行:先是身份识别,然后是角色检查。整个控制器都仅限 ADMIN 角色访问。用户 [marie] (角色 USER)尝试打开管理页面:

[admin] 进行同样的尝试:

案例研究有三个角色(ADMIN、DOCTOR、USER),并且恰好使用这两个守卫。异常过滤器把 403 转换为经过翻译的错误页面。
8.3. 示例 27:验证码与尝试次数限制
登录页面会吸引 机器人:这类程序会尝试成千上万种登录名/密码组合。有两种互补的防护措施:
- 验证码(CAPTCHA):一张字符扭曲的图像,人类可以轻松读出,而简单的机器人无法识别;
- 尝试次数限制:失败几次之后,该 IP 地址会被封锁一段时间。
示例 27 把这两种防护措施添加到示例 25 中。
文件 [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; // 放在表单的隐藏字段中
svg: string; // 图片,原样插入页面
}
@Injectable()
export class CaptchaService {
// id -> 预期答案。答案绝不离开服务器
private readonly answers = new Map<string, string>();
generate(): Captcha {
// svg-captcha:随机文本,用扭曲的字符绘制
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 };
}
// 答案是否正确?无论如何,验证码都会被
// 消耗:一张图片只使用一次
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();
}
}
|
- 第 13 行:预期的答案由 服务器 以随机标识符为键保存。页面只包含图像和标识符:答案永远不会离开服务器;
- 第 15–21 行:[svg-captcha] 库生成一个随机文本字符串,并把它渲染成图像(SVG),再用线条加以干扰。容易混淆的字符(0 和 O、1 和 l 等)被排除在外;
- 第 25–32 行:验证过程会 消耗该验证码:一张图像只能使用一次;机器人无法重复使用它已经找到的答案。
文件 [src/auth/limiter.service.ts]:
| import { Injectable } from '@nestjs/common';
const MAX_FAILURES = 3; // 容忍的失败次数……
const BLOCK_MS = 60 * 1000; // ……超过后封锁一分钟
// 限制每个 IP 地址的登录尝试次数
@Injectable()
export class LimiterService {
private readonly counters = new Map<string, { failures: number; blockedUntil: number }>();
// 如果该 IP 可以尝试则为 0,否则为需要等待的秒数
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);
}
}
|
- 第 3–4 行:失败三次会封锁该 IP 地址一分钟;
- 第 12–16 行:剩余的封锁时间;
- 第 18–26 行和第 28–30 行:记录一次失败;成功则把计数器清零。
文件 [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. 被封锁的 IP 根本不予理会
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. 先验证码,然后 3. 登录名和密码
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');
}
// 每次显示表单都使用新的验证码
private display(res: Response, model: object): void {
res.render('login', { ...model, captcha: this.captchas.generate() });
}
}
|
- 第 29 行:[@Ip()] 注入客户端的 IP 地址;
- 第 32–35 行:被封锁的 IP 甚至不会被处理;
- 第 37–38 行:先验证验证码;只有验证码正确时,才会检查密码(这需要进行计算开销很大的 bcrypt 计算);
- 第 39–44 行:验证码错误也算一次失败;
- 第 61–63 行:每次显示表单时,都会生成一个 新的 验证码。
文件 [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>
{{!-- SVG 图像原样插入:使用三重花括号 --}}
<div class="mb-1">{{{captcha.svg}}}</div>
{{!-- 验证码标识符随表单一起传递;答案则不传递 --}}
<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>
|
第 14–17 行:SVG 图像被原样插入页面(三重花括号:这是由服务器生成的 HTML);验证码标识符通过隐藏字段传递。

验证码抄写错误:

第三次失败尝试时:

案例研究把这两项安全措施应用于其登录页面和账户创建流程,阈值可在文件 [.env] 中调整。