Skip to content

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

1
2
3
4
5
6
// 携带令牌的 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]:

1
2
3
4
5
6
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
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

密码错误:

Image

登录成功,用 [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

令牌由三部分组成,以句点分隔:头、内容和签名。前两部分只是用 [base64url] 编码;我们来解码内容:

1
2
3
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 日起的秒数表示。令牌 没有加密:它不包含任何机密信息。在浏览器中:

Image

现在我们尝试修改令牌,让自己获得 ADMIN 角色:我们解码内容,把 [USER] 替换为 [ADMIN],然后重新编码……但没有密钥,我们就无法重新计算签名:

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

签名与内容不再匹配:令牌被拒绝(401 错误),异常处理程序重定向到登录页面。注销:

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. 示例 26:角色

示例 26 在示例 25 的基础上增加了一个仅限 ADMIN 角色访问的页面。新增了三个文件。

文件 [src/auth/roles.decorator.ts]:

1
2
3
4
5
6
7
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)尝试打开管理页面:

Image

[admin] 进行同样的尝试:

Image

案例研究有三个角色(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);验证码标识符通过隐藏字段传递。

Image

验证码抄写错误:

Image

第三次失败尝试时:

Image

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