跳到正文
零到全栈 · 卷 6 · 数据与状态

多用户与鉴权

本合集目录
本章目录

单册说明:本文件是卷 6 的第 7 章,可独立阅读。前置:第 6 章(状态与会话)。本章把"你是谁"和"你能碰哪些数据"分开讲,用两个账号复现一次越权读取,再把它堵死;顺带把密码哈希为什么必须是 scrypt 讲清楚。

项 内容
所属卷 卷 6 · 数据与状态(第 7 / 8 章)
前置章节 6.6 状态与会话
本章产出 注册/登录/当前用户的完整链路 · 一次越权复现与修复 · 一套统一的错误话术
对应代码 app/security.py、app/services/auth.py、app/deps.py、app/storage/notes.py
配图 无(后续统一制图)
读完的判定 能用两个账号证明"B 读不到 A 的数据",并说清这条保证写在哪一行 SQL 里

6.7.1 一句话结论:认证管"你是谁",授权管"这条是不是你的"

两件事经常被混成一件。混在一起的后果是:登录做得很严,数据却全泄。

先看现场。B 登录之后,把自己的 id 猜成别人的,直接请求详情:

curl -i -b b_cookie.txt http://127.0.0.1:8097/api/notes/2
HTTP/1.1 200 OK

{"id":2,"title":"A 的私人摘录","content":"这句话只该 A 看到",
 "source_url":null,"tags":["私密"],"created_at":"2026-11-16T18:32:22Z"}

B 拿到了 A 的私人摘录。注意三件事:登录是有效的(有合法 cookie)、接口没有报错、返回的是完整内容。整个系统在"认证"这一层完全正确,坏在"授权"。

原因只有一行:

"SELECT ... FROM notes n WHERE n.id = ?"          # 少了 AND n.user_id = ?

这就是 IDOR(Insecure Direct Object Reference,不安全的直接对象引用):用别人资源的 id 直接访问,而服务端只检查了"你登录了",没检查"这东西是你的"。 它是 Web 应用里最常见的真实漏洞之一,因为它不产生任何报错。

6.7.2 原理与方法

认证与授权的分工

认证 Authentication 授权 Authorization
回答的问题 你是谁 你能不能做这件事 / 看这条数据
凭证是什么 邮箱 + 密码 → session token 当前用户 id 与资源的归属关系
在哪实现 deps.current_user service 的判断 + storage 的 SQL 条件
失败返回 401(没登录) 404(当作不存在)或 403(存在但不给)
失败时的典型症状 一直跳登录页 什么都没有,数据安静地流出去

一个记忆法:认证只做一次(登录时),授权要做每一次(每个访问数据的请求)。 只做一次的检查最容易写成"中间件",只做一次也最容易漏。

密码为什么不能直接存,也不能用 md5

做法 攻击者拿到库之后 结论
存明文 直接登录所有账号 绝对不行
md5(password) 现代显卡每秒几十亿次,8 位密码几分钟跑完 不行
sha1(password) 同上,且早已有碰撞攻击 不行
sha256(password) 快,等于给爆破加速 不行
sha256(salt + password) 挡住了彩虹表,但单次仍只要微秒 不够
scrypt(n=2^14, r=8, p=1) 单次约 240 毫秒,且要吃 16MB 内存 可以

关键不是"哈希不可逆",而是快慢。md5 的设计目标是"越快越好",这在密码场景里正好是灾难:攻击者可以用同样的快,去试几亿个候选密码。scrypt 的设计目标相反——故意慢,而且故意吃内存。吃内存这一条专门对付显卡和专用芯片:它们的优势是并行,而每个并行单元都要 16MB 内存时,"并行几千路"就变成了硬件成本问题。

盐是什么,为什么必须有

盐是每个用户独立的随机字节,和密码一起参与哈希,明文存在哈希串里(不需要保密)。

没有盐 有盐
两个用户密码都是 123456,哈希值一模一样 两个哈希值完全不同
攻击者算一次 123456 的哈希,就能同时命中所有用它的账号 每个账号都得单独算
预先算好的大表(彩虹表)可以直接查 表作废,因为盐是随机的

本书的哈希串格式是 scrypt$16384$8$1$<salt_hex>$<hash_hex>。把参数一起存进去,是为了将来能调整强度:老用户用老参数验证(参数从串里读),新用户用新参数,不需要强制所有人改密码。

为什么用标准库的 scrypt,而不是装 passlib 或 bcrypt

方案 优点 代价
hashlib.scrypt 标准库自带,零依赖;底层是 OpenSSL 实现,性能好 参数要自己选,没有"一行搞定"的封装
bcrypt 生态成熟,参数简单 需要编译或装 wheel,Windows 上偶发装不上;多一个依赖要跟版本
argon2-cffi 目前公认最强的密码哈希 同样要装依赖,且需要调参
passlib 统一封装多种算法 项目已进入维护状态,且仍要拉底层库

这一卷的方法论是"先把标准库用透"。scrypt 是 RFC 7914 定义的算法,hashlib.scrypt 在 Python 3.6 之后一直可用,参数我们自己定、注释写清楚,比多一个依赖更可控。等到有合规要求(比如必须 argon2),再换,那时也是一次替换 security.py 的事。

注册流程与错误话术

注册要做的五步,顺序不能乱:

  1. 规范化:email.strip().lower()。不统一大小写,[email protected] 和 [email protected] 会变成两个账号;
  2. 校验:格式、密码长度(本项目 8 位起)、标签数量上限;
  3. 哈希:hash_password(),绝不在日志里打印明文;
  4. 插入:捕获 IntegrityError,把 UNIQUE constraint failed: users.email 翻译成 409;
  5. 返回:只返回 id / email / created_at,password_hash 永远不出现在响应里。

错误话术的原则是"别让人靠试错把用户名单试出来":

场景 不该说 该说 为什么
邮箱不存在 "该邮箱未注册" "邮箱或密码不正确" 否则攻击者能批量验证哪些邮箱在用
密码错误 "密码错误" 同上 同上
注册时邮箱已占用 "这个邮箱已注册" "这个邮箱暂时不能注册,可以试试直接登录" 前者等于确认"此人在本站有账号"

第三条是个真实的取舍:完全隐藏会让正常用户困惑("我到底注册过没有")。更彻底的做法是"注册一律返回成功,同时发一封确认邮件"——那需要邮件服务,超出本卷范围。本书选折中话术,并把理由写在代码注释里。

从 session 到 current_user

def current_user(
    sid: str | None = Cookie(default=None, alias=COOKIE_NAME),
    con: sqlite3.Connection = Depends(get_db),
) -> dict:
    user = auth_service.user_from_token(con, sid)
    if user is None:
        raise Unauthorized()
    return user

三件事值得注意:

细节 原因
alias=COOKIE_NAME cookie 名叫 sid,但变量名不必跟着叫 sid;用常量避免拼错
查不到就 Unauthorized 没 cookie、token 无效、已过期,对用户来说是同一件事:请重新登录
返回 dict 而不是 User 对象 上层只需要 user["id"],不需要 ORM 对象;跨层传简单结构更省事

路由里写 user: dict = Depends(current_user),拿到的就是"当前登录的人"。任何需要身份的接口都必须带这个依赖——漏了它,接口就变成匿名可访问,而 FastAPI 不会提醒你。

越权的三种修法

修法 写法 评价
查出来再判断 先 SELECT ... WHERE id = ?,再 if note["user_id"] != uid: raise 能挡住越权,但别人的数据已经进了内存;将来加日志、加缓存就泄露;而且每个接口都要记得写
查询条件带归属 WHERE id = ? AND user_id = ? 推荐。不匹配就是"查不到",上层统一当作 404;危险写法在代码里不存在
中间件统一鉴权 在中间件里检查登录 只解决"是否登录",不解决"这条是不是你的",不能替代前两条

第二种是唯一"想犯错都难"的写法。代价是每个针对单条资源的 SQL 都要多一个条件——所以第 4 章才要求 SQL 全部集中在 storage/:只有五处要检查,而不是五十处。

403 还是 404

返回 含义 泄露了什么
403 这条存在,但不是你的 确认了这个 id 真实存在,可以拿来枚举数据量、探测别人有多少条
404 当作不存在 什么都没泄露;对用户来说"这条没了"也说得通
401 你没登录 与归属无关,只在没有有效会话时返回

本书统一用 404。判断依据是:对越权者来说,"不存在"和"不是你的"应该是同一个答案。

6.7.3 动手:造两个用户,把越权堵死

第一步:注册两个账号

B=http://127.0.0.1:8097          # 换成你自己起的端口
curl -s -X POST $B/api/auth/register -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"s3cret-pass"}'
curl -s -X POST $B/api/auth/register -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"another-pass"}'

第二步:A 建一条私人摘录,B 去读

curl -s -c ck_a.txt -X POST $B/api/auth/login -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"s3cret-pass"}'
curl -s -b ck_a.txt -X POST $B/api/notes -H "Content-Type: application/json" \
  -d '{"title":"A 的私人摘录","content":"这句话只该 A 看到","tags":["私密"]}'

拿到 id: 2。B 登录后直接请求它 —— 修复前的实测结果:

B 读它:  HTTP/1.1 200 OK
{"id":2,"title":"A 的私人摘录","content":"这句话只该 A 看到", ...}

把 storage 里那一行改成 WHERE n.id = ? AND n.user_id = ?,重启,再读:

修复后 B 读:  HTTP/1.1 404 Not Found
{"error":{"code":"not_found","message":"摘录不存在"}}
修复后 A 读:  HTTP/1.1 200 OK

同一份数据、同一个 cookie,差别只在一个 SQL 条件。

第三步:在数据层确认"不是靠返回前判断"

print("带 user_id(正确):", store.get_note(con, 2, 1))
print("不带 user_id(错误):", dict(con.execute(
    "SELECT id, user_id, title FROM notes WHERE id = 1").fetchone()))
带 user_id(正确): None
不带 user_id(错误): {'id': 1, 'user_id': 1, 'title': '第一条'}

第一行 None 就是 404 的来源:它从来没被读出来过,不是在读完之后被拦下。

第四步:看一次哈希

from app.security import hash_password, verify_password
h = hash_password("s3cret-pass")
print(h[:60], "…")
print(verify_password("s3cret-pass", h), verify_password("s3cret-pas", h))
scrypt$16384$8$1$277c30d0f272dc4a5ce70261abc56581$4a22cf7e73 …
True False

连跑五次取平均,单次约 241ms(本机 CPU)。这个数字是故意大的:它让"离线爆破"从每秒百万次降到每秒 4 次。登录慢 0.24 秒,用户感知不到;攻击者要多花六个数量级的时间。

第五步:看错误话术

不存在的邮箱:  401  {"error":{"code":"unauthorized","message":"邮箱或密码不正确"}}
存在但密码错:  401  {"error":{"code":"unauthorized","message":"邮箱或密码不正确"}}
重复注册:      409  {"error":{"code":"email_unavailable","message":"这个邮箱暂时不能注册,可以试试直接登录"}}

前两条必须完全一致,连标点都一样。任何差异都是信息泄漏——哪怕只是状态码从 401 变成 404,也足以让人判断出邮箱是否存在。

6.7.4 三个坑

坑一:先查出来再判断,看起来对,其实留了后门

症状:代码里明明有 if note["user_id"] != user_id: raise NotFound(),越权测试也过了。但某天加了一行"记录访问日志",把 note 整个打进日志,A 的私人内容就出现在日志文件里,谁有服务器权限谁都能看。

成因:数据已经被读进应用内存,之后的每一处使用(日志、缓存、监控、异常堆栈)都是潜在的泄露点。判断只能拦住"返回给用户",拦不住"在应用内部流转"。

修法:把条件放进 SQL。判断"这条属于谁"这件事,应该发生在数据库里,不该发生在应用内存里。这样一来,越权请求连一行数据都拿不到。

坑二:用 sha256 加盐,觉得"加了盐就够了"

症状:数据库里看不到明文了,看起来安全。某天库文件泄露,攻击者用一台显卡服务器,三天跑完大部分 8 位密码。

成因:盐解决的是"相同密码不能产生相同哈希"和"彩虹表失效",它不解决速度问题。sha256 单次只要微秒级,攻击者可以对着每个盐暴力枚举,盐只是把"一次算全表"变成"每个账号各算一次",成本增加有限。

修法:换慢哈希。判断标准是"单次耗时是否在几十到几百毫秒"、"是否消耗可控的内存"。scrypt 的 n=2^14, r=8, p=1 吃 16MB 内存、约 240ms,正好落在"用户无感、攻击者极贵"的区间。

坑三:只保护了"读",忘了"改"和"删"

症状:详情接口修好了,越权测试只测了 GET /api/notes/2,通过。上线后有人发现 PATCH 和 DELETE 用的是同一套"先查后改"逻辑,而 PATCH 分支忘了判断。

成因:越权漏洞按接口分布,不同接口的实现是分别写的。测一个接口不代表其他接口安全。

修法:① 让所有针对单条资源的操作都走同一个 get_note(con, user_id, note_id),它不带归属条件就查不到;② 回归脚本里对 GET/PATCH/DELETE 三个动词各测一次越权,别只测一个。第 8 章的检查表会把这一条列进去。

本章验收

  • 两个账号各自登录,B 读 A 的摘录返回 404,A 自己能读
  • 能在 storage/notes.py 里指出那条 AND n.user_id = ?,并说明它保护了哪几个接口
  • users 表里看不到任何明文密码,哈希串以 scrypt$16384$8$1$ 开头
  • 邮箱不存在与密码错误的登录响应逐字相同
  • 能说出 403 与 404 各自的泄露代价,以及本项目为什么选 404

自测

Q1:为什么"先查出来再判断 user_id"不算最佳实践?它到底漏了什么?

看答案 它没有漏"返回给用户"这一环,漏的是"数据进入应用之后的所有路径"。一旦行被读进内存,日志、缓存、异常堆栈、监控上报、调试打印都可能把它带走;而且这段判断要在每个接口重复写,新增接口时漏一次就是漏洞。把条件写进 SQL 之后,越权请求在数据库层就查不到任何东西,后续无论加什么功能都不会把别人的数据带出来。

Q2:盐是明文存在哈希串里的,那它还有意义吗?

看答案 有意义,因为盐防的不是"被看到",而是"被复用"。攻击者拿到盐,仍然要为每个账号单独做一次暴力枚举;没有盐时,同一个密码的哈希值相同,算一次就能命中所有使用该密码的账号,还能直接查预先算好的彩虹表。盐的作用是"让每次计算都独一无二",它不需要保密,只需要随机。

Q3:注册接口返回"这个邮箱暂时不能注册",和返回"这个邮箱已注册",安全性差在哪?

看答案 后者确认了"这个邮箱在本站有账号"。攻击者可以拿一批邮箱批量注册,根据响应筛出"哪些人在用这个站",这本身就是隐私泄露,也是后续钓鱼的素材。前者只说明"现在不能注册",不确认原因——可能是已注册,也可能是被风控拦了。代价是正常用户体验略差,所以还要在文案里给出下一步("试试直接登录")。

下一步

数据进了库、用户分开了、越权堵住了。最后一章把这些零散的保证收成一张能逐条执行的检查表,并真的做一次"备份 → 删库 → 恢复"。

→ 卷6-08-数据不丢越权不进.md