Skip to content

8. 身份验证与授权

每个请求都会引出两个不同的问题:

  • 用户是谁?这是身份验证:用户已通过用户名和密码表明了身份,此后的每个请求都必须证明它来自该用户;
  • 他是否有权访问此页面?这是授权:在案例研究中,只有角色为 ADMIN 的用户才能管理医生和客户。

身份证明必须随每个请求一起提交。[Django] 提供了一个完整的身份验证应用 [django.contrib.auth]:包含一个 [User] 模型(一张数据库表)、把已登录用户存入 [request.user] 的中间件、登录和注销视图、权限、组,以及管理这些内容的管理界面。它把已登录用户存放在其会话中(参见关于作用域的章节),这是 Web 应用最简单的方案。案例研究的所有版本([ASP.NET Core MVC]、[Spring MVC]、[NestJS]、[Flask]、[Laravel]、[Symfony])则改用 JWT 令牌(JSON Web Token),我们在此也将采用:登录后,服务器生成一个包含用户身份的令牌,并用密钥对其签名(这就是示例 23 中签名 Cookie 的原理)。令牌存放在 Cookie 中;浏览器在每个请求中把它发回;服务器验证签名。用户可以读取自己的令牌,但无法修改它:任何修改都会使签名失效。该格式已标准化(RFC 7519),所有编程语言都能理解,并且令牌包含其过期时间。最重要的是,服务器无需存储任何内容:任何知道密钥的服务器都可以验证令牌。

案例研究中的用户位于其专属的表 [users]中,而不是 [django.contrib.auth] 的用户;令牌本身在 [django.contrib.auth] 中也没有位置。因此我们将使用已经熟悉的工具自己实现身份验证,这样的好处是让一切都透明:

  • 一个中间件(示例 03)根据 Cookie 中的令牌,为每个请求确定用户是谁,并把用户放入请求中([request.user],示例 12)。应用程序的其余部分只看到这个结果;
  • 装饰器(示例 08)保护视图:[@login_required], [@role_required("ADMIN")];
  • 密码使用 [Django] 的哈希函数进行验证([django.contrib.auth.hashers],它可以脱离应用 [auth] 的其余部分单独使用);
  • 拒绝访问表现为 [PermissionDenied] 异常,由 [handler403] 视图转换为错误页面(示例 24);
  • 登录尝试次数借助 [Django] 中的缓存加以限制(示例 27)。

令牌的创建和验证由 [PyJWT] 库负责,它是 [Python] 中最常用的此类库,由示例文件 [requirements.txt] 安装(导入时使用的名称是 [jwt])。(也有适用于 [Django] 的 JWT 令牌库,例如 [djangorestframework-simplejwt],它们是为 API 设计的;对于 Web 应用,只需几行代码就够了,而且更能说明其机制。)

8.1. 示例 25:登录、令牌、受保护页面

25-jwt/
├── accounts/
│   ├── __init__.py
│   └── views.py
├── config/
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── security/
│   ├── __init__.py
│   ├── auth.py
│   ├── decorators.py
│   ├── middleware.py
│   └── users.py
├── templates/
│   ├── auth/
│   │   └── login.html
│   ├── profile/
│   │   └── profile.html
│   └── layout.html
└── manage.py

8.1.1. 配置:config/settings.py

令牌使用密钥签名,而密钥在生产环境的应用代码中不能硬编码。现在是时候真正把配置与代码分开了:

# config/settings.py:示例 25 的配置

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-jr8u&rl2ff+bpg(h18&^u2dtu^qtulf9yoy!e&la+nt_z-vb*8"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    "security",
    "accounts",
]

MIDDLEWARE = [
    "django.middleware.csrf.CsrfViewMiddleware",
    # 身份验证:每个请求都根据其 Cookie 中的
    # JWT 令牌找到用户(见 security/middleware.py)
    "security.middleware.Authentication",
]

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]

# 我们自己的设置:签名 JWT 令牌的密钥(至少 32 个字符),以及
# 它们的有效期。os.environ.get:同名的环境变量(若存在,生产环境中),
# 否则使用此处写的值(开发环境中)
JWT_SECRET = os.environ.get("JWT_SECRET", "a-secret-key-of-at-least-32-characters-for-example-25")
JWT_DURATION_MINUTES = int(os.environ.get("JWT_DURATION_MINUTES", "60"))
  • 第 21–26 行:两个中间件:防 CSRF 保护(示例 18),随后是我们的身份验证中间件;
  • 第 43–44 行:两个应用程序专用的设置(示例 06):用于签名令牌的密钥,以及令牌的有效期(以分钟计)。[os.environ.get("NAME", default)] 若环境变量 [NAME] 存在,就把它的值作为设置值;否则使用默认值。开发期间,写在文件中的值就够用了;在生产环境中,真正的密钥通过环境变量提供,环境变量优先。环境变量始终是字符串:[int] 把有效期转换为整数。

对于所用的算法(HMAC-SHA256),标准要求密钥至少为 256 位,即 32 字节:对于更短的密钥,[PyJWT] 会发出警告。在 [Linux] 或 [macOS] 上,要用不同的密钥启动应用程序,可按如下方式:

JWT_SECRET="another-key-of-at-least-thirty-two-characters" python manage.py runserver

而在 [Windows] ([PowerShell])上:

$env:JWT_SECRET="another-key-of-at-least-thirty-two-characters"
python manage.py runserver

[Django] 自身的密钥 [SECRET_KEY] 也需要同样的处理;案例研究从名为 [.env] 的文件或环境中读取所有机密信息。

8.1.2. 用户:security/users.py

# security/users.py:用户,保存在内存中(示例 28 和案例
# 研究会把它们放进数据库)

from dataclasses import dataclass, field


@dataclass(frozen=True)
class User:
    login: str
    name: str
    # 角色:USER 或 ADMIN
    role: str
    # 密码的哈希(对从令牌读取的用户则为空)
    password_hash: str = ""
    # 验证该用户身份的令牌的内容;field(default_factory=dict):
    # 每个对象一个新的空字典
    claims: dict = field(default_factory=dict)


# 我们从不保存密码,只保存它的哈希,由 Django 的 make_password 函数
# 一次性计算得出(PBKDF2-SHA256 算法,1,500,000
# 次迭代,随机盐):
# python -c "from django.conf import settings; settings.configure();
#            from django.contrib.auth.hashers import make_password; print(make_password('marie'))"
USERS = {
    "marie": ("Marie Pélissier", "USER",
              "pbkdf2_sha256$1500000$pjnFn2tL1G4bu5rVFTv6sZ$Y6v+fj3dC+Y0LZYJGxeE1OOi9beaZVuMVm6R6tljEwI="),
    "admin": ("Administrator", "ADMIN",
              "pbkdf2_sha256$1500000$UTT2hXVaLIEAuGHPFxgnv9$D9+Owt9lDG14VrvArR3n0GGQXWjY9Sg8cgFwip4+yx4="),
}


def find(login: str) -> User | None:
    if login not in USERS:
        return None
    # 元组的"解包":它的三个元素分别赋给三个变量
    name, role, password_hash = USERS[login]
    return User(login, name, role, password_hash)
  • 第 7–17 行:一个用户:登录名、姓名、角色、密码哈希,以及用于验证该用户身份的令牌内容(对于从用户列表中读取的用户则为空)。最后两个属性有默认值。对于字典,不能把这个默认值写成 [claims: dict = {}]:这个字典只会创建一次,并被所有对象共享。[field(default_factory=dict)] 指示 [@dataclass] 为每个新对象调用 [dict()];
  • 第 20–24 行:服务器绝不存储密码,即使是加密形式也不行:如果数据库被盗,密码也会随之被盗(而且很多人在所有地方都使用同一个密码)。服务器存储的是哈希函数的结果,哈希函数是单向函数:可以计算密码的哈希值,但无法从哈希值还原出密码。要验证输入的密码,就计算它的哈希值,并与数据库中存储的哈希值比较;
  • 第 25–30 行:两个测试用户,硬编码在程序中(示例 28 和案例研究会用它们填充数据库):每个登录名对应姓名、角色和密码哈希。该哈希由 [make_password] 函数(来自 [Django])一次性算好(命令写在注释中),使用其默认算法 PBKDF2-SHA256。存储的哈希由四部分组成,用 [$] 分隔:算法([pbkdf2_sha256])、迭代次数、盐,以及结果。好的密码哈希算法有两个特点。其一,它被有意设计得很慢,且慢的程度可调:PBKDF2 把 SHA-256 函数应用 1,500,000 次,耗时几百毫秒——用户几乎察觉不到,但黑客尝试数十亿个密码的代价会非常高昂;[Django] 在每个版本中都会增加这个数字,以跟上计算能力的发展(其 [auth] 应用会在用户登录时更新已存储的哈希);较旧的哈希仍然可以验证,因为它们包含自己的迭代次数。其二,它加了盐:随机生成的盐在哈希之前与密码混合,并存储在哈希本身之中;因此,密码相同的两个用户,其哈希也不同。[Django] 还可以使用 [Argon2] 和 [bcrypt] (通过设置 [PASSWORD_HASHERS]);案例研究的数据库中包含 [bcrypt] 哈希,因此直接使用库 [bcrypt];
  • 第 33–38 行:某个登录名对应的用户,或 [None]。[not in] 检查某个键是否不存在;赋值 [name, role, password_hash = ...] 解包一个元组:每个变量获得对应的元素。

8.1.3. 身份验证服务:security/auth.py

# security/auth.py:密码和 JWT 令牌的检查

import time

import jwt
from django.conf import settings
from django.contrib.auth.hashers import check_password

from . import users
from .users import User

# 携带令牌的 Cookie 的名称
COOKIE = "token"


# 用户,若登录名未知或密码错误则为 None。
# check_password 用所存哈希的盐和算法对输入的密码求哈希,
# 然后比较两个结果
def validate(login: str, password: str) -> User | None:
    if not login or not password:
        return None
    user = users.find(login)
    if user is None or not check_password(password, user.password_hash):
        return None
    return user


# 用户的 JWT 令牌,用密钥签名(HMAC-SHA256)
def create_token(user: User) -> str:
    now = int(time.time())
    # 令牌的内容:"claims"(关于用户的声明)
    claims = {
        "sub": user.login,
        "name": user.name,
        "role": user.role,
        "iat": now,
        "exp": now + settings.JWT_DURATION_MINUTES * 60,
    }
    return jwt.encode(claims, settings.JWT_SECRET, algorithm="HS256")


# 由令牌描述的用户,该令牌的签名和过期时间
# 有效;否则为 None(伪造、过期或无法读取的令牌)
def verify(token: str) -> User | None:
    try:
        # decode 同时检查签名和过期时间(exp claim)
        claims = jwt.decode(token, settings.JWT_SECRET, algorithms=["HS256"])
    except jwt.InvalidTokenError:
        return None
    return User(claims["sub"], claims["name"], claims["role"], claims=claims)
  • 第 5 行:[PyJWT] 库;
  • 第 7 行:来自 [Django] 的函数 [check_password] ;
  • 第 13 行:携带令牌的 Cookie 的名称;
  • 第 19–25 行:验证用户名和密码。[check_password] 从存储的哈希中读取算法、迭代次数和盐,用它们对输入的密码做哈希,并比较两个结果(以恒定时间比较,见示例 23)。未知的用户名和错误的密码得到相同的结果,即 [None];
  • 第 29–39 行:生成令牌。其内容是一个关于用户的声明字典。其中一些有标准化的名称:[sub] (subject),用户的标识符;[iat] (issued at),创建时间;[exp] (expiration),过期时间。时间以自 1970 年 1 月 1 日起经过的秒数表示([time.time()] 返回这个数字,包含小数部分,而 [int] 会舍去小数)。其他字段是可选的:这里是姓名和角色。[jwt.encode] 生成令牌,并使用算法 [HS256] (HMAC-SHA256,一种使用共享密钥的签名)对其签名;
  • 第 44–50 行:验证令牌。[jwt.decode] 验证签名和过期时间,然后返回其中的声明。任何异常情况(伪造、过期或格式错误的令牌)都会引发 [jwt.InvalidTokenError] 类或其子类的异常,由 [except] 块捕获。参数 [algorithms] 指定接受的算法列表:声明使用其他算法(或完全不使用算法,即 [none])的令牌将被拒绝。有效的令牌会变成一个 [User],不含哈希,但带有其声明(名为 [claims] 的参数)。

8.1.4. 身份验证中间件:security/middleware.py

# security/middleware.py:身份验证:每个请求中,用户是谁?

from django.shortcuts import redirect

from . import auth


class Authentication:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 默认情况下,访问者是匿名的
        request.user = None
        token = request.COOKIES.get(auth.COOKIE)
        if token is not None:
            user = auth.verify(token)
            if user is None:
                # 无效的令牌(过期、伪造):转到 /login,并且我们
                # 删除该 Cookie
                response = redirect("login")
                response.delete_cookie(auth.COOKIE)
                return response
            request.user = user
        return self.get_response(request)

对于每个请求,在视图之前:

  • 第 14 行:默认情况下,访问者是匿名的:[request.user] 等于 [None];
  • 第 15–17 行:如果请求包含令牌 Cookie,就验证该令牌;
  • 第 18–23 行:令牌无效(已过期或被伪造):中间件自行响应,不再调用后续流程,而是重定向到登录页面,并顺便删除该 Cookie:[delete_cookie] 会在响应中加入一个为空且已过期的 Cookie;
  • 第 24 行:令牌有效:它所标识的用户被放入请求中。这里不在用户列表中查找用户:由于令牌已签名,有令牌就足够了。

中间件并不拒绝访问:它只确定用户是谁,或确定用户是匿名的。这就是身份验证。拒绝访问由访问控制负责。

8.1.5. 访问控制:security/decorators.py

# security/decorators.py:视图的访问控制

from functools import wraps

from django.shortcuts import redirect


# @login_required:只有已通过身份验证的用户才会执行该视图;匿名
# 访问者会被重定向到登录页面
def login_required(view):
    @wraps(view)
    def wrapper(request, *args, **kwargs):
        if request.user is None:
            return redirect("login")
        return view(request, *args, **kwargs)
    return wrapper

装饰器 [@login_required] 包装一个视图(示例 08):如果用户是匿名的,它不调用视图,而是直接重定向到登录页面;否则,调用该视图。[django.contrib.auth] 提供了一个同名且作用相同的装饰器 [@login_required],它基于它自己的 [request.user]。

8.1.6. 视图:accounts/views.py

# accounts/views.py:登录、注销,以及一个仅限已通过身份验证的
# 用户访问的页面

from django.conf import settings
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_http_methods, require_POST

from security import auth
from security.decorators import login_required


@require_GET
def home(request):
    return redirect("profile")


# GET:表单;POST:登录(防 CSRF 令牌已经由
# CsrfViewMiddleware 检查过)
@require_http_methods(["GET", "POST"])
def login(request):
    if request.method == "GET":
        return render(request, "auth/login.html")
    login = request.POST.get("login", "")
    user = auth.validate(login, request.POST.get("password", ""))
    if user is None:
        # 一条故意含糊的消息:我们不说明是登录名还是密码有误
        return render(request, "auth/login.html",
                      {"login": login, "error": "Incorrect login or password."})
    # 令牌放在 Cookie 中:页面的 JavaScript 无法读取它
    # (httponly);来自其他站点的 POST 请求不会携带它
    # (samesite);它在令牌过期的同时消失(max_age)
    response = redirect("profile")
    response.set_cookie(auth.COOKIE, auth.create_token(user),
                        max_age=settings.JWT_DURATION_MINUTES * 60, httponly=True, samesite="Lax")
    return response


# 注销:仅限 POST(放在另一个站点上的简单链接,不能
# 在用户不知情的情况下将其注销);我们删除该 Cookie
@require_POST
def logout(request):
    response = redirect("login")
    response.delete_cookie(auth.COOKIE)
    return response


# request.user:已通过身份验证的用户,由中间件找到
@require_GET
@login_required
def profile(request):
    return render(request, "profile/profile.html", {"user": request.user})
  • 第 19–22 行:在模板中手工编写的登录表单,与所有 POST 表单一样(示例 18),由 [CsrfViewMiddleware] 中间件防范伪造请求;
  • 第 23–28 行:登录过程。如果登录失败,会重新显示表单,保留输入的用户名,并给出一条刻意含糊的消息:如果明确提示“用户名未知”,就会向黑客泄露哪些用户名存在;
  • 第 32–35 行:如果成功,令牌被存入 Cookie,用户被重定向到受保护页面(PRG 模式)。该 Cookie 是 [httponly] 的:页面的 [JavaScript] 无法读取它,这可以保护令牌免受脚本注入(XSS);它是 [SameSite=Lax] 的:浏览器不会在来自其他站点的 POST 请求中发送它,这可以保护应用程序免受 CSRF 攻击;它的有效期([max_age],以秒计)与令牌的有效期相同。在生产环境中,对于 HTTPS,我们会加上 [secure=True]:这样 Cookie 就永远不会通过未加密的连接发送;
  • 第 40–44 行:注销会删除 Cookie([delete_cookie])。这是一个 POST 视图,受防 CSRF 令牌保护:放在其他网站或图片中的指向 [/logout] 的简单链接,无法在用户不知情的情况下使其注销。请注意令牌的一个局限:令牌本身在过期之前一直有效。复制了它的人仍然可以使用它。这就是要限制令牌有效期的原因;
  • 第 48–51 行:受保护页面。装饰器 [@login_required] 确保 [request.user] 不是 [None]。

8.1.7. 模板

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Login</h1>
  <form method="post" action="{% url 'login' %}">
    {% csrf_token %}
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ login }}" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  {% if error %}
    <div class="alert alert-danger mt-3">{{ error }}</div>
  {% endif %}
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
{% endblock %}
  • 第 6 行:表单的防 CSRF 令牌;
  • 第 9 行:登录失败后,再次显示输入的登录名(缺失的变量显示为空字符串)。
{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Hello {{ user.name }}</h1>
  <p>Your role: <b>{% if user.role == "ADMIN" %}administrator{% else %}user{% endif %}</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    {% for key, value in user.claims.items %}
      <tr><td><code>{{ key }}</code></td><td>{{ value }}</td></tr>
    {% endfor %}
  </table>
  {# 退出登录:一个只有按钮的 POST 表单 #}
  <form method="post" action="{% url 'logout' %}">
    {% csrf_token %}
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
{% endblock %}
  • 第 8–10 行:令牌的内容,仅作说明之用显示。[items] 遍历字典中的(键,值)对(示例 18);
  • 第 13–16 行:注销,通过只有一个按钮的表单实现。

8.1.8. 执行

我们在未登录的情况下请求受保护页面 [/profile] :

curl -i http://localhost:8000/profile
1
2
3
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /login

密码错误:

Image

登录成功。使用 [curl] 时,必须先请求表单以获取防 CSRF 令牌及其 Cookie(示例 18),然后在保留所收到的 Cookie 的情况下提交表单:

curl -c token.txt -b token.txt http://localhost:8000/login
curl -i -c token.txt -b token.txt -d "csrfmiddlewaretoken=...&login=marie&password=marie" http://localhost:8000/login
1
2
3
4
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /profile
Set-Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJtYXJpZSIsIm5hbWUiOiJNYXJpZSBQXHUwMGU5bGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwNTMwOTM5LCJleHAiOjE3OTA1MzQ1Mzl9.eJQdDTFEYVlAzHENW7esgY82dUbjsj5dN6jW-Dy6Lfo; expires=Sun, 27 Sep 2026 18:42:19 GMT; HttpOnly; Max-Age=3600; Path=/; SameSite=Lax

令牌由三部分组成,以句点分隔,每部分都经过 Base64 编码:头部、内容和签名。前两部分无需任何密钥即可解码:

{"alg":"HS256","typ":"JWT"}
{"sub":"marie","name":"Marie Pélissier","role":"USER","iat":1790530939,"exp":1790534539}

([é] 以其转义形式 JSON 写成,即 [\u00e9]。)过期时间为创建后一小时(3,600 秒)。在浏览器中,个人资料页面显示的正是这同一内容:

Image

一个恶意用户修改了自己的令牌:他把内容中的角色 ***[USER]*** 替换为 ***[ADMIN]***,把这一部分重新做 Base64 编码,并保留原来的签名。服务器重新计算修改后内容的签名,结果与原签名不再匹配:

curl -i -b "token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.<modified content>.eJQdDTFEYVlAzHENW7esgY82dUbjsj5dN6jW-Dy6Lfo" http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /login
Set-Cookie: token=""; expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/

伪造的令牌被拒绝并被删除(空值和已过期的日期会指示浏览器删除该 Cookie)。要生成有效的签名,就必须知道密钥——因此保守密钥秘密并选择足够长的随机密钥非常重要。

8.2. 示例 26:角色

示例 26 增加了一个仅限角色 ADMIN 访问的管理页面。这里只显示新增或修改过的文件。

8.2.1. 角色:security/users.py

# security/users.py:用户,保存在内存中(示例 28 和案例
# 研究会把它们放进数据库)

from dataclasses import dataclass, field


@dataclass(frozen=True)
class User:
    login: str
    name: str
    # 角色:USER 或 ADMIN
    role: str
    # 密码的哈希(对从令牌读取的用户则为空)
    password_hash: str = ""
    # 验证该用户身份的令牌的内容;field(default_factory=dict):
    # 每个对象一个新的空字典
    claims: dict = field(default_factory=dict)

    # 角色的层级:管理员同时拥有用户的权限
    def has_role(self, role: str) -> bool:
        return role in HIERARCHY.get(self.role, set())

    # 供模板使用,因为模板无法调用带参数的方法
    @property
    def is_admin(self) -> bool:
        return self.has_role("ADMIN")


# 每个角色,及其拥有的角色集合({...}:一个集合)
HIERARCHY = {
    "ADMIN": {"ADMIN", "USER"},
    "USER": {"USER"},
}


# 我们从不保存密码,只保存它的哈希,由 Django 的 make_password 函数
# 一次性计算得出(PBKDF2-SHA256 算法,1,500,000
# 次迭代,随机盐):
# python -c "from django.conf import settings; settings.configure();
#            from django.contrib.auth.hashers import make_password; print(make_password('marie'))"
USERS = {
    "marie": ("Marie Pélissier", "USER",
              "pbkdf2_sha256$1500000$pjnFn2tL1G4bu5rVFTv6sZ$Y6v+fj3dC+Y0LZYJGxeE1OOi9beaZVuMVm6R6tljEwI="),
    "admin": ("Administrator", "ADMIN",
              "pbkdf2_sha256$1500000$UTT2hXVaLIEAuGHPFxgnv9$D9+Owt9lDG14VrvArR3n0GGQXWjY9Sg8cgFwip4+yx4="),
}


def find(login: str) -> User | None:
    if login not in USERS:
        return None
    # 元组的"解包":它的三个元素分别赋给三个变量
    name, role, password_hash = USERS[login]
    return User(login, name, role, password_hash)
  • 第 20–21 行:[has_role] 方法根据角色层次结构判断用户是否拥有某个角色;
  • 第 24–26 行:一个属性(示例 14),供模板使用:DTL 无法调用带参数的方法([has_role("ADMIN")]),但可以读取属性([user.is_admin]);
  • 第 30–33 行:角色层次结构:对每个角色,给出它所拥有的角色集合([set],用花括号括起来)。角色 [ADMIN] 包含角色 [USER]:因此管理员拥有用户的全部权限,无需同时分配两个角色。方法 [has_role] 可以使用 [HIERARCHY],尽管它定义在文件的更下方:名称只在调用时才查找,而此时整个模块已经加载完毕。

8.2.2. 访问控制:security/decorators.py

# security/decorators.py:视图的访问控制

from functools import wraps

from django.core.exceptions import PermissionDenied
from django.shortcuts import redirect


# @login_required:只有已通过身份验证的用户才会执行该视图;匿名
# 访问者会被重定向到登录页面
def login_required(view):
    @wraps(view)
    def wrapper(request, *args, **kwargs):
        if request.user is None:
            return redirect("login")
        return view(request, *args, **kwargs)
    return wrapper


# @role_required("ADMIN"):一个带参数的装饰器(见示例 08)。只有当已通过身份验证的用户
# 拥有所要求的角色时才执行该视图;否则,
# PermissionDenied 异常会产生 403 响应(见 security/errors.py)
def role_required(role):
    def decorator(view):
        @wraps(view)
        @login_required
        def wrapper(request, *args, **kwargs):
            if not request.user.has_role(role):
                raise PermissionDenied(f"role {role} required")
            return view(request, *args, **kwargs)
        return wrapper
    return decorator
  • 第 23–32 行:一个带参数的装饰器(示例 08),[@role_required("ADMIN")]。其包装函数本身又被 [@login_required] 包装:匿名访问者首先被送到登录页面;不具备所需角色的已认证用户会触发 [PermissionDenied] 异常(示例 24),最终得到 403(Forbidden)错误。

这两种拒绝情形的区别很重要:匿名访问者请求受保护页面时,会被重定向到登录页面;不具备所需角色的已认证用户则收到 403 错误——登录毫无意义,因为他们已经通过了身份验证。

8.2.3. 访问被拒绝:security/errors.py 和 config/urls.py

1
2
3
4
5
6
7
8
# security/errors.py:对请求被禁止访问的页面的、已通过身份验证的
# 用户所给出的响应(见 config/urls.py 中的 handler403)

from django.shortcuts import render


def access_denied(request, exception):
    return render(request, "errors/403.html", status=403)
# config/urls.py:主路由表

from django.urls import path

from accounts import views
from security.errors import access_denied

urlpatterns = [
    path("", views.home),
    path("login", views.login, name="login"),
    path("logout", views.logout, name="logout"),
    path("profile", views.profile, name="profile"),
    path("admin", views.admin, name="admin"),
]

# 403 错误(PermissionDenied 异常)的视图
handler403 = access_denied

视图 [access_denied] 是应用程序的 403 错误视图(变量 [handler403],示例 24):[Django] 在调试模式和生产模式下,对任何 [PermissionDenied] 异常都会调用它。[templates/errors/403.html] 页面是一个标准错误页面,带有返回个人资料页的链接。如果没有这个视图,用户会看到 [Django] 自带的普通 403 页面(“403 Forbidden”)。

8.2.4. 视图:accounts/views.py

# accounts/views.py:登录、注销,以及仅限已通过身份验证的
# 用户访问的页面

from django.conf import settings
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_http_methods, require_POST

from security import auth
from security.decorators import login_required, role_required


@require_GET
def home(request):
    return redirect("profile")


# GET:表单;POST:登录(防 CSRF 令牌已经由
# CsrfViewMiddleware 检查过)
@require_http_methods(["GET", "POST"])
def login(request):
    if request.method == "GET":
        return render(request, "auth/login.html")
    login = request.POST.get("login", "")
    user = auth.validate(login, request.POST.get("password", ""))
    if user is None:
        # 一条故意含糊的消息:我们不说明是登录名还是密码有误
        return render(request, "auth/login.html",
                      {"login": login, "error": "Incorrect login or password."})
    # 令牌放在 Cookie 中:页面的 JavaScript 无法读取它
    # (httponly);来自其他站点的 POST 请求不会携带它
    # (samesite);它在令牌过期的同时消失(max_age)
    response = redirect("profile")
    response.set_cookie(auth.COOKIE, auth.create_token(user),
                        max_age=settings.JWT_DURATION_MINUTES * 60, httponly=True, samesite="Lax")
    return response


# 注销:仅限 POST(放在另一个站点上的简单链接,不能
# 在用户不知情的情况下将其注销);我们删除该 Cookie
@require_POST
def logout(request):
    response = redirect("login")
    response.delete_cookie(auth.COOKIE)
    return response


# request.user:已通过身份验证的用户,由中间件找到
@require_GET
@login_required
def profile(request):
    return render(request, "profile/profile.html", {"user": request.user})


# 一个仅限 ADMIN 角色访问的页面
@require_GET
@role_required("ADMIN")
def admin(request):
    return render(request, "admin/admin.html", {"name": request.user.name})
  • 第 55–58 行:管理页面,由装饰器 [@role_required("ADMIN")] 保护。视图本身不执行任何检查。

对于比角色更细粒度的规则(“用户只能编辑自己的预约”),视图自己执行验证,并在需要时引发 [PermissionDenied] 。案例研究中提供了这方面的示例。

8.2.5. 个人资料视图

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Hello {{ user.name }}</h1>
  <p>Your role: <b>{% if user.role == "ADMIN" %}administrator{% else %}user{% endif %}</b>.</p>
  {# is_admin:用户是否具有 ADMIN 角色? #}
  {% if user.is_admin %}
    <p><a href="{% url 'admin' %}">The administration area</a></p>
  {% else %}
    <p><a href="{% url 'admin' %}">The administration area</a> (which is forbidden to you)</p>
  {% endif %}
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    {% for key, value in user.claims.items %}
      <tr><td><code>{{ key }}</code></td><td>{{ value }}</td></tr>
    {% endfor %}
  </table>
  {# 退出登录:一个只有按钮的 POST 表单 #}
  <form method="post" action="{% url 'logout' %}">
    {% csrf_token %}
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
{% endblock %}
  • 第 7–11 行:[is_admin] 属性使页面能够根据角色进行调整。这样可以避免显示在真实应用中会导致错误的链接(这里为了实验,仍然给 Marie 保留了该链接);不过这只是一种便利:真正的保护由视图提供。

8.2.6. 执行

角色为 USER 的 Marie 点击指向管理页面的链接:

Image

相反,管理员可以访问它:

Image

使用 [curl]:先是角色为 USER 的用户(按示例 25 的方式登录,Cookie 保存在文件 [token.txt] 中),然后是匿名访问者:

curl -i -b token.txt http://localhost:8000/admin
curl -i http://localhost:8000/admin
HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8
...
  <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
...
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /login

逐个保护视图有一个缺陷:只要漏掉一个,该页面就会对所有人开放。案例研究将反转这一逻辑:所有 URL 页面默认都由访问控制中间件保护,只有少数 URL 页面(登录页面、注册页面)例外。

8.3. 示例 27:验证码与尝试次数限制

登录表单是攻击目标:程序每分钟可以尝试数千个密码(暴力破解攻击)。两种保护措施相辅相成:

  • 验证码(CAPTCHA,Completely Automated Public Turing test to tell Computers and Humans Apart,即全自动区分计算机和人类的图灵测试):一张包含扭曲字符的图像,人类很容易辨认,程序却很难识别;
  • 尝试次数限制:连续三次失败后,客户端的 IP 地址将被封锁一分钟。

示例 27 以示例 25 为基础,增加了这两项安全措施:

27-captcha/
├── accounts/
│   └── views.py
├── config/
│   └── settings.py
├── security/
│   ├── auth.py
│   ├── captcha_drawing.py
│   ├── captchas.py
│   ├── decorators.py
│   ├── limiter.py
│   ├── middleware.py
│   └── users.py
├── templates/
│   └── auth/
│       └── login.html
└── ...

8.3.1. 验证码图像:security/captcha_drawing.py

# security/captcha_drawing.py:验证码(CAPTCHA)的绘制,一幅 SVG 图像(XML 文本),
# 手工构建

import math
import secrets

WIDTH = 150
HEIGHT = 50

# "字体":每个字符是一组笔画,每个笔画是在 4 x 6 的网格中
# 由点 x, y 构成的序列(y 轴向下)。
# 过于容易互相混淆的字符:已排除(0 O,1 I L)。
FONT = {
    "A": [[0, 6, 2, 0, 4, 6], [0.8, 3.8, 3.2, 3.8]],
    "B": [[0, 0, 0, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3], [0, 0, 3, 0, 4, 1, 4, 2, 3, 3]],
    "C": [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5]],
    "D": [[0, 0, 0, 6, 2.5, 6, 4, 4.5, 4, 1.5, 2.5, 0, 0, 0]],
    "E": [[4, 0, 0, 0, 0, 6, 4, 6], [0, 3, 3, 3]],
    "F": [[4, 0, 0, 0, 0, 6], [0, 3, 3, 3]],
    "G": [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 3.5, 2.5, 3.5]],
    "H": [[0, 0, 0, 6], [4, 0, 4, 6], [0, 3, 4, 3]],
    "J": [[4, 0, 4, 5, 3, 6, 1, 6, 0, 5]],
    "K": [[0, 0, 0, 6], [4, 0, 0, 3.5], [1.3, 2.6, 4, 6]],
    "M": [[0, 6, 0, 0, 2, 3.5, 4, 0, 4, 6]],
    "N": [[0, 6, 0, 0, 4, 6, 4, 0]],
    "P": [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3]],
    "Q": [[1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5, 0, 1, 1, 0], [2.5, 4.5, 4, 6.3]],
    "R": [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3], [2, 3, 4, 6]],
    "S": [[4, 1, 3, 0, 1, 0, 0, 1, 0, 2, 1, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
    "T": [[0, 0, 4, 0], [2, 0, 2, 6]],
    "U": [[0, 0, 0, 5, 1, 6, 3, 6, 4, 5, 4, 0]],
    "V": [[0, 0, 2, 6, 4, 0]],
    "W": [[0, 0, 1, 6, 2, 2.5, 3, 6, 4, 0]],
    "X": [[0, 0, 4, 6], [4, 0, 0, 6]],
    "Y": [[0, 0, 2, 3, 4, 0], [2, 3, 2, 6]],
    "Z": [[0, 0, 4, 0, 0, 6, 4, 6]],
    "2": [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 0, 6, 4, 6]],
    "3": [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1.5, 3], [3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
    "4": [[3, 6, 3, 0, 0, 4, 4, 4]],
    "5": [[4, 0, 0, 0, 0, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
    "6": [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3]],
    "7": [[0, 0, 4, 0, 1.5, 6]],
    "8": [[1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1, 3, 0, 4, 0, 5, 1, 6, 3, 6, 4, 5,
           4, 4, 3, 3]],
    "9": [[4, 3, 1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5]],
}

# 几种深色,在浅色背景上易于阅读
COLORS = ["#1f4e79", "#7b2d26", "#2e6b30", "#5b2c83", "#8a5a00", "#23395d", "#9c2a5b"]

# 一个"密码学"生成器,不可预测(不同于 random 模块,
# 其序列可能被猜出)
_random = secrets.SystemRandom()


def random_text(length: int) -> str:
    alphabet = list(FONT)
    return "".join(secrets.choice(alphabet) for _ in range(length))


# 一个随机的浮点数,介于最小值和最大值之间
def random(minimum: float, maximum: float) -> float:
    return _random.uniform(minimum, maximum)


def color() -> str:
    return secrets.choice(COLORS)


def svg(text: str) -> str:
    w, h = WIDTH, HEIGHT
    parts = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">',
             '<rect width="100%" height="100%" fill="#f5f7fa"/>']
    # 字符:每个都经过放大、倾斜、平移,且每个点都被随机
    # 轻微移动
    step = (w - 20) / len(text)
    for i, character in enumerate(text):
        scale = random(4.6, 5.6)    # 网格单元的大小,单位为像素
        angle = random(-0.35, 0.35)   # 旋转,单位为弧度(约 ±20°)
        cx = 10 + step * (i + 0.5) + random(-3, 3)    # 字符的中心
        cy = h / 2 + random(-4, 4)
        for stroke in FONT[character]:
            d = []
            # range(0, n, 2):0, 2, 4……一个点 = 两个数
            for k in range(0, len(stroke), 2):
                # 网格中的点,以 (2, 3) 为中心,经过扭曲、旋转、放置
                x = (stroke[k] - 2 + random(-0.2, 0.2)) * scale
                y = (stroke[k + 1] - 3 + random(-0.2, 0.2)) * scale
                px = cx + x * math.cos(angle) - y * math.sin(angle)
                py = cy + x * math.sin(angle) + y * math.cos(angle)
                d.append(f"{'M' if k == 0 else 'L'}{px:.1f} {py:.1f}")
            parts.append(f'<path d="{" ".join(d)}" fill="none" stroke="{color()}" '
                         f'stroke-width="{random(2.2, 3):.1f}" stroke-linecap="round" '
                         f'stroke-linejoin="round"/>')
    # 3 条干扰笔画:穿过图像的曲线
    for _ in range(3):
        parts.append(f'<path d="M{random(0, 20):.1f} {random(5, 45):.1f} '
                     f'C{random(30, 60):.1f} {random(0, 50):.1f} {random(90, 120):.1f} '
                     f'{random(0, 50):.1f} {random(130, 150):.1f} {random(5, 45):.1f}" '
                     f'fill="none" stroke="{color()}" stroke-width="1.3"/>')
    parts.append("</svg>")
    return "".join(parts)

该图像为 SVG 格式(Scalable Vector Graphics,可缩放矢量图形):一种用 XML(即文本)描述的矢量图形,由服务器在不使用图形库的情况下生成,浏览器可直接在页面上显示。这个模块是纯 [Python] 代码,不含任何 [Django] 特有的内容:它是本课程 [Python] 版本对 [Laravel] 和 [Symfony] 版本中那些类的实现。

  • 第 13–46 行:一个极简的“字体”:每个字符是一组笔画的列表,每个笔画是 4 × 6 网格中的一组 x、y 坐标。容易混淆的字符([0] 和 [O]、[1]、[I]和 [L])被排除在外;
  • 第 53–58 行:随机文本,从字体中的字符里抽取([list(FONT)]:字典键的列表)。[random] 模块在 [Python] 中产生的数字序列是可预测的(只要知道几个值,就能猜出后面的值):它适用于模拟,不适用于安全场景。[secrets] 模块是不可预测的密码学生成器:[secrets.choice] 从列表中抽取一个元素,[secrets.SystemRandom] 则使用这个生成器提供 [random] 的各个函数([uniform]:两个边界之间的浮点数)。[for _ in range(length)] 重复 [length] 次;名称 [_] 表示不会被使用的变量;
  • 第 70–102 行:绘制。每个字符被随机放大、旋转和移动,其每个点还会略微偏移;每个笔画成为 SVG 的一个 [<path>] 元素([M]:移动,[L]:直线)。三条曲线([C]:贝塞尔曲线)横穿图像,以干扰识别程序。在 f-string 中,[{px:.1f}] 写出保留一位小数的数字;还可以包含条件表达式([{'M' if k == 0 else 'L'}])。[math] 模块提供 [cos] 和 [sin]。SVG 的各个部分由 [join] 拼装。

8.3.2. 验证码服务:security/captchas.py

# security/captchas.py:待验证的验证码(CAPTCHA),由服务器保存在缓存中

import secrets
from dataclasses import dataclass

from django.core.cache import cache

from . import captcha_drawing

# 验证码的有效期,以秒为单位
LIFETIME = 600


# 一个验证码:它的标识符,及其图像(SVG)
@dataclass(frozen=True)
class Captcha:
    id: str
    svg: str


def generate() -> Captcha:
    text = captcha_drawing.random_text(5)
    # 一个无法猜测的随机标识符:由密码学生成器抽取的 12 个字节,
    # 以十六进制书写
    id = secrets.token_hex(12)
    # 缓存中的预期答案,保存 10 分钟:之后缓存会自行
    # 将其遗忘
    cache.set(f"captcha.{id}", text, LIFETIME)
    return Captcha(id, captcha_drawing.svg(text))


# 验证码在任何情况下都会被消耗:一幅图像只使用一次
def verify(id: str, entered: str) -> bool:
    if not id or not entered:
        return False
    # get 返回值,或 None;delete 从缓存中删除答案,无论
    # 答案是否正确
    expected = cache.get(f"captcha.{id}")
    cache.delete(f"captcha.{id}")
    if expected is None:
        return False    # 未知标识符,或验证码已过期
    # casefold:转换为小写的字符串,用于忽略大小写的比较
    return expected.casefold() == entered.strip().casefold()
  • 第 6 行:[Django] 的缓存:一个由所有模块共享的键→值存储。这些值存放在哪里,取决于设置 [CACHES] (见下文);
  • 第 21–29 行:生成一个新的验证码:一个随机文本字符串,一个无法猜测的随机标识符([secrets.token_hex(12)]:12 个随机字节,以十六进制写出,即 24 个字符),以及图像。对于每个标识符,服务器把预期的答案在缓存中保存十分钟:[cache.set] 的第三个参数是有效期,单位为秒。时间一到,缓存会自动丢弃它。页面只收到标识符和图像:答案永远不会离开服务器;
  • 第 33–43 行:验证。先读取预期的答案(对于不存在的键,[cache.get] 返回 [None] ),然后将其从缓存中删除([cache.delete]):无论成功与否,验证码在任何情况下都会被消耗。否则,程序就可以针对同一张图像尝试所有可能的答案。比较时忽略大小写([casefold] 把字符串转换为小写,并能正确处理所有字母表)以及输入两侧的空格([strip])。

8.3.3. 尝试次数限制:security/limiter.py

# security/limiter.py:按 IP 地址限制登录尝试次数

import time

from django.conf import settings
from django.core.cache import cache


# 客户端的失败次数在一个固定的时间窗口内计数:每个
# LOGIN_WINDOW_SECONDS 秒的窗口内最多 LOGIN_MAX_FAILURES 次失败
class Limiter:
    def __init__(self, ip: str):
        self.key = f"login.{ip}"

    # 若客户端被封锁,则为需要等待的秒数,否则为 0
    def wait(self) -> int:
        state = cache.get(self.key)
        if state is None or state["failures"] < settings.LOGIN_MAX_FAILURES:
            return 0
        return max(1, int(state["end"] - time.time()))

    # 再失败一次
    def failure(self) -> None:
        state = cache.get(self.key)
        if state is None:
            # 开始一个新窗口
            state = {"failures": 0, "end": time.time() + settings.LOGIN_WINDOW_SECONDS}
        state["failures"] += 1
        # 该键在窗口结束时从缓存中消失(timeout,以秒为单位)
        cache.set(self.key, state, timeout=max(1, int(state["end"] - time.time())))

    # 登录成功会清除失败次数
    def clear(self) -> None:
        cache.delete(self.key)

限制器在固定的时间窗口内统计客户端的失败尝试次数:每个 60 秒窗口内最多允许三次失败尝试,窗口从第一次失败尝试开始计算。每个客户端由其 IP 地址标识。

  • 第 13 行:缓存键,针对具体客户端:[login.127.0.0.1];
  • 第 16–20 行:客户端被封锁(失败次数已达上限)时需要等待的秒数,否则为 0。缓存中保存的状态是一个字典:失败次数和窗口的结束时间;
  • 第 23–30 行:再记一次失败。如果缓存中没有状态,就开始一个新的窗口。状态被重新写入,其有效期在窗口结束时到期:之后缓存会自动忘记它,客户端从零重新开始;
  • 第 33–34 行:一次成功的连接会清除失败记录。

这个为说明目的而编写的限制器有一个弱点:两次同时发生的失败可能读取到相同的状态,因而只被计为一次。[Django] 的缓存提供了原子操作([cache.add],仅当键不存在时才写入;以及 [cache.incr],对数字加一),案例研究版本中就使用了它们。也有现成的库可用([django-ratelimit]、[django-axes])。

8.3.4. 配置:config/settings.py

# config/settings.py:示例 27 的配置

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-y=#3-i_9nrm%&a&_%_v^ajq460=!u*ry3uit-nj9_thr&v3ev)"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    "security",
    "accounts",
]

MIDDLEWARE = [
    "django.middleware.csrf.CsrfViewMiddleware",
    # 身份验证:每个请求都根据其 Cookie 中的
    # JWT 令牌找到用户(见 security/middleware.py)
    "security.middleware.Authentication",
]

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]

# 我们自己的设置:签名 JWT 令牌的密钥(至少 32 个字符),以及
# 它们的有效期。os.environ.get:同名的环境变量(若存在,生产环境中),
# 否则使用此处写的值(开发环境中)
JWT_SECRET = os.environ.get("JWT_SECRET", "a-secret-key-of-at-least-32-characters-for-example-27")
JWT_DURATION_MINUTES = int(os.environ.get("JWT_DURATION_MINUTES", "60"))

# 应用的缓存:这里是服务器进程的内存(这是
# Django 的默认缓存)。待验证的验证码和失败计数器
# 都存储在其中
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
    },
}

# 限制登录尝试次数:每个 60 秒的窗口内 3 次失败
LOGIN_MAX_FAILURES = 3
LOGIN_WINDOW_SECONDS = 60
  • 第 49–53 行:应用程序缓存。[LocMemCache] 把值存放在进程的内存中:这是 [Django] 的默认缓存,我们把它显式写出来以便可见。它仅限于应用程序作用域(参见关于作用域的章节):它是进程专属的,服务器关闭时就会丢失。案例研究使用存储在文件中的缓存([FileBasedCache]),它在重启后依然保留;在生产环境中,我们会更倾向于使用 [Redis] ([django.core.cache.backends.redis.RedisCache]),由所有进程共享;
  • 第 56–57 行:限制器的参数。

8.3.5. 视图:accounts/views.py

# accounts/views.py:登录(带验证码并限制尝试次数)、
# 注销,以及一个仅限已通过身份验证的用户访问的页面

from django.conf import settings
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_http_methods, require_POST

from security import auth, captchas
from security.decorators import login_required
from security.limiter import Limiter


@require_GET
def home(request):
    return redirect("profile")


# GET:表单;POST:登录,带验证码并限制尝试次数
@require_http_methods(["GET", "POST"])
def login(request):
    if request.method == "GET":
        return login_page(request)
    login = request.POST.get("login", "")
    # 此客户端的限制器:其失败次数按其 IP 地址计数
    limiter = Limiter(request.META["REMOTE_ADDR"])
    # 1. 被封锁的地址根本不予理会
    seconds = limiter.wait()
    if seconds > 0:
        return login_page(request, login, f"Too many attempts: try again in {seconds} s.")
    # 2. 先检查验证码(开销小),再检查密码(PBKDF2,开销大)
    if not captchas.verify(request.POST.get("captcha_id", ""), request.POST.get("captcha", "")):
        limiter.failure()
        return login_page(request, login, "The code of the image is incorrect.")
    user = auth.validate(login, request.POST.get("password", ""))
    if user is None:
        limiter.failure()
        return login_page(request, login, "Incorrect login or password.")
    limiter.clear()
    response = redirect("profile")
    response.set_cookie(auth.COOKIE, auth.create_token(user),
                        max_age=settings.JWT_DURATION_MINUTES * 60, httponly=True, samesite="Lax")
    return response


# 每次显示表单都会生成一个新的验证码
def login_page(request, login="", error=None):
    return render(request, "auth/login.html",
                  {"login": login, "error": error, "captcha": captchas.generate()})


# 注销:仅限 POST(放在另一个站点上的简单链接,不能
# 在用户不知情的情况下将其注销);我们删除该 Cookie
@require_POST
def logout(request):
    response = redirect("login")
    response.delete_cookie(auth.COOKIE)
    return response


# request.user:已通过身份验证的用户,由中间件找到
@require_GET
@login_required
def profile(request):
    return render(request, "profile/profile.html", {"user": request.user})
  • 第 25 行:该客户端的限制器,基于其 IP 地址([REMOTE_ADDR],示例 05);
  • 第 27–29 行:被封锁的地址连听都不听;
  • 第 31–37 行:先验证验证码,再验证密码;验证验证码几乎没有成本,而 PBKDF2 哈希是有意设计得很慢的。因此,验证码答错的程序不会给服务器带来任何负载。每次失败——无论是验证码错误还是密码错误——都会被计数。第三次失败时,该地址会被封锁,直到 60 秒窗口结束,窗口从第一次失败开始计算;
  • 第 38 行:登录成功会清除失败计数;
  • 第 46–48 行:每次显示表单时都会生成一个新的验证码,即使是在失败之后也是如此。

8.3.6. 模板:templates/auth/login.html

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Login</h1>
  <form method="post" action="{% url 'login' %}">
    {% csrf_token %}
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ login }}" required>
    </div>
    <div class="mb-2">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="captcha">Copy the code of the image</label>
      {# SVG 图像,由服务器构建:不经转义直接插入(safe 过滤器) #}
      <div class="mb-1">{{ captcha.svg|safe }}</div>
      {# 验证码标识符通过隐藏字段传递;答案本身保留在服务器上 #}
      <input type="hidden" name="captcha_id" value="{{ captcha.id }}">
      <input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  {% if error %}
    <div class="alert alert-danger mt-3">{{ error }}</div>
  {% endif %}
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
{% endblock %}
  • 第 18 行:SVG 图像原样插入页面,不做转义(过滤器 [safe],示例 14)。这是合理的:这段 HTML 由服务器生成,不包含任何用户输入;
  • 第 20 行:验证码 ID,放在隐藏字段中;
  • 第 21 行:浏览器不会为该字段建议任何以前的输入([autocomplete="off"])。

8.3.7. 执行

Image

抄错的验证码:

Image

三次失败的尝试之后,该地址被封锁:

Image

使用 [curl],用一个虚构的验证码 ID 尝试四次(像示例 25 那样,先获取 Cookie 和防 CSRF 令牌):

curl -b cookies.txt -d "csrfmiddlewaretoken=...&login=marie&password=marie&captcha_id=abc&captcha=ABCDE" http://localhost:8000/login
1
2
3
4
    <div class="alert alert-danger mt-3">The code of the image is incorrect.</div>
    <div class="alert alert-danger mt-3">The code of the image is incorrect.</div>
    <div class="alert alert-danger mt-3">The code of the image is incorrect.</div>
    <div class="alert alert-danger mt-3">Too many attempts: try again in 59 s.</div>

即使密码正确,第四次尝试也会被直接拒绝,不予处理。