如何修复 Node.js 中常见的 Web 应用程序安全漏洞

对于那些刚开始接触安全领域的开发者来说，有这样一个现象往往会让他们感到惊讶：大多数Web漏洞其实并非由复杂的攻击行为所导致。这些漏洞往往源于一些看似完全合理的代码模式——比如信任URL中传递的参数值、将请求体直接用于数据库更新操作，或者明明只需要执行一次查询却实际执行了两次。

本指南涵盖了其中六种常见的代码模式。对于每种模式，我们都会提供一个具体的代码示例来说明这种模式是如何导致漏洞产生的，同时解释其危险性，并提供修改后的代码版本，同时详细说明哪些地方发生了变化以及为什么需要做出这些修改。

阅读本指南并不要求读者具备任何安全方面的专业知识，不过熟悉Node.js和SQL会有一定的帮助。

先决条件

这些示例假设您已经掌握了以下内容：

• Node.js和Express.js的基础知识

• SQL查询语句的编写方法

• HTTP请求与响应的工作原理

• 基本的身份验证机制（会话、令牌等）

关于代码示例的说明：在本教程中，db.query()是一个虚构的数据库操作函数。对于SELECT查询，它会返回一个包含查询结果的单行对象；如果未找到匹配记录，则会返回null；而对于INSERT/UPDATE查询，它则会返回一个包含所有修改结果的对象。在讨论“竞态条件”这一主题时使用的connection.query()函数直接调用了mysql2库中的Promise API，此时query()会返回一个包含rows和fields的数组。请根据您实际使用的数据库驱动程序调整相关语法。

目录

• 1. 访问控制漏洞与IDOR攻击

• 2. 批量赋值漏洞

• 3>原型污染问题

• 4>竞态条件漏洞

• 5>业务逻辑缺陷

• 6>JWT配置错误

• 总结

1. 访问控制漏洞与IDOR攻击

自2021年以来，“访问控制漏洞”一直位列OWASP十大安全威胁之首，其原因显而易见。其中最常见的漏洞类型就是不安全的直接对象引用(IDOR)攻击：应用程序会在URL中暴露数据库记录的ID，如果用户擅自修改了这个ID，就会非法访问其他用户的资料。

事后看来，这种漏洞的解决方法似乎非常简单。但实际上，在许多生产环境中，这类问题仍然屡见不鲜，因为身份验证和权限控制这两个环节经常被混淆。确认用户已经登录与确认他们是否有权访问特定资源是两回事。

如何在自己的代码中识别这种漏洞

以下是一个典型的用户资料端点示例：

// Express.js – 存在安全漏洞
app.get('/api/users/:id/profile', authenticate, async (req, res) => {
  const userId = req.params.id;

  const user = await db.query(
    'SELECT id, name, email, address FROM users WHERE id = ?,'
    [userId]
  );

  if (!user) {
    return res.status(404).json({ error: '用户未找到' });
  }

  res.json(user);
});

authenticate中间件会验证请求中是否包含有效的令牌，但并不会检查经过身份验证的用户是否被允许访问所请求的资源。

任何经过身份验证的用户都可以请求/api/users/1/profile、/api/users/2/profile等路径，从而获取其他用户的资料。

为什么这很重要

身份验证用于确认“你是谁”，而授权则用于确定“你被允许做什么”。上述代码只完成了身份验证的部分，完全忽略了授权环节。

如果使用顺序编号作为用户标识符，好奇的用户无需任何特殊工具，只需将URL中的1改为2即可获取其他用户的资料。但如果使用UUID或简写地址格式，且没有进行所有权验证，同样的问题依然存在。

如何修复这一安全漏洞

在服务器端，必须确认经过身份验证的用户确实拥有或被明确授权访问所请求的资源：

// Express.js – 加强安全性
app.get('/api/users/:id/profile', authenticate, async (req, res) => {
  // 如果参数不是数字字符串，就会抛出错误
  if (!/^\d+$/.test(req.params.id)) {
    return res.status(400).json({ error: '用户ID无效' });
  }

  const requestedId = Number(req.params.id);

  // 如果用户ID小于1，说明输入有误
  if (requestedId < 1) {
    return res.status(400).json({ error: '用户ID无效' });
  }

  // 经过身份验证的用户的ID由authenticate中间件设置
  const authenticatedId = req.user.id;

  // 确保用户只能访问自己的资料
  if (requestedId !== authenticatedId) {
    return res.status(403).json({ error: '禁止访问' });
  }

  const user = await db.query(
    'SELECT id, name, email, address FROM users WHERE id = ?,'
    [requestedId]
  );

  if (!user) {
    return res.status(404).json({ error: '用户未找到' });
  }

  res.json(user);
});

对于那些确实需要访问任何用户信息的管理员端点，必须明确实施基于角色的授权机制：

// 包含明确角色验证的管理员端点
app.get('/api/admin/users/:id', authenticate, requireRole('admin'), async (req, res) => {
  if (!/^\d+$/.test(req.params.id)) {
    return res.status(400).json({ error: '用户ID无效' });
  }

  const userId = Number(req.params.id);

  const user = await db.query(
    'SELECT id, name, email, role FROM users WHERE id = ?,'
    [userId]
  );

  if (!user) {
    return res.status(404).json({ error: '用户未找到' });
  }

  res.json(user);
});

以下是发生变化的内容及其原因：

• /^\d+$/.test(req.params.id)会拒绝任何非纯数字字符串。例如，parseInt("12abc", 10)会默默地将“12abc”转换为数字12，并让其通过后续检查。而正则表达式能够有效防止这种情况发生。

• Number(req.params.id)会安全地将已经经过验证的字符串转换为数字。

• 比较语句requestedId !== authenticatedId用于确保操作权限的正确性。

• 管理员功能是通过独立的接口提供的，该接口也有自己的授权检查机制。

切勿仅根据URL参数来判断用户的授权级别，而应通过已认证的会话信息来确定。

2. 批量赋值功能

批量赋值是一种在编写代码时几乎难以被察觉的安全漏洞。你只是想提高效率而已，对吧？既然可以直接传递整个对象，为什么还要手动遍历每个字段呢？

问题在于，你的数据库表中包含了用户本不应能够修改的字段。

如何在代码中识别这种漏洞

以下是一个用于更新用户信息的接口示例：

// Express.js 示例——存在安全漏洞
app.put('/api/users/me', authenticate, async (req, res) => {
  const userId = req.user.id;

  // req.body中包含了客户端发送的所有数据
  const updates = req.body;

  await db.query(
    'UPDATE users SET ? WHERE id = ?',
    [updates, userId]
  );

  res.json({ success: true });
});

users表包含以下字段：

CREATE TABLE users (
  id           INT PRIMARY KEY,
  name         VARCHAR(100),
  email        VARCHAR(100),
  bio          TEXT,
  role         ENUM('user', 'moderator', 'admin') DEFAULT 'user',
  credits      INT DEFAULT 0,
  is_banned    BOOLEAN DEFAULT false
);

开发者的本意是让用户能够修改name、email和bio字段，但role、credits和is_banned也在表中——因此查询会更新客户端发送的任何字段。

为什么这很重要

客户端发送的数据会直接被用于SQL查询。由于users表中也包含了这些字段，因此查询机制并不知道开发者“真正想要修改哪些字段”。

如果有人发送如下数据：

{
  "name": "Alice",
  "role": "admin",
  "credits": 100000,
  "is_banned": false
}

那么这个人就会自动成为管理员，解除自己的封禁状态，并获得十万的积分。

如何修复这种漏洞

应该使用明确的允许列表，逐个字段地构建需要更新的对象，从而避免这种安全问题。

// Express.js – 安全版本
app.put('/api/users/me', authenticate, async (req, res) => {
  const userId = req.user.id;

  // 只有这些字段才能被用户修改
  const ALLOWED_fields = ['name', 'email', 'bio'];
  const updates = {};

  for (const field of ALLOWED_fields) {
    if (req.body[field] !== undefined) {
      updates[field] = req.body[field];
    }
  }

  if (Object.keys(updates).length === 0) {
    return res.status(400).json({ error: '没有提供有效的字段' });
  }

  // 对各个字段进行验证
  // isValidEmail是一个简单的辅助函数，用于检查电子邮件格式是否合法：^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
  if (updates.email && !isValidEmail(updates.email)) {
    return res.status(400).json({ error: '电子邮件格式无效' });
  }

  if (updates.name && (typeof updates.name !== 'string' || updates.name.length > 100)) {
    return res.status(400).json({ error: '名称必须是长度不超过100个字符的字符串' });
  }

  await db.query(
    'UPDATE users SET ? WHERE id = ?,'
    [updates, userId]
  );

  res.json({ success: true });
});

对于那些确实需要更新敏感字段的管理操作，应使用专门的接口端点，并为该端点设置独立的授权机制：

// 仅管理员可使用的用于修改用户角色的接口
app.put('/api/admin/users/:id/role', authenticate, requireRole('admin'), async (req, res) => {
  if (!/^\d+$/.test(req.params.id)) {
    return res.status(400).json({ error: '无效的用户ID' });
  }

  const userId = Number(req.params.id);
  const { role } = req.body;

  const VALID_ROLES = ['user', 'moderator', 'admin'];

  if (!VALID_ROLES.includes(role)) {
    return res.status(400).json({ error: '无效的角色' });
  }

  await db.query(
    'UPDATE users SET role = ? WHERE id = ?,'
    [role, userId]
  );

  res.json({ success: true });
});

切勿 将 req.body 直接用于数据库查询中，而应该逐个字段地构建更新对象。

3. 原型污染

当不可信的数据被递归地合并到某个对象中时，就会发生原型污染。这种机制会让攻击者有机会向 Object.prototype（所有普通 JavaScript 对象都继承自的这个基对象）中注入额外的属性。

OWASP Top 10 将这一安全漏洞归类为“软件与数据完整性故障（A08:2021）”。

如何识别代码中的这一漏洞

下面是一个用于处理用户输入设置的配置合并函数：

// 存在安全风险的递归合并函数
function mergeConfig(target, source) {
  for (const key of Object.keys(source)) {
    if (typeof source[key] === 'object' && source[key] !== null) {
      if (!target[key]) target[key] = {};
      mergeConfig(target[key], source[key]); // 递归调用
    } else {
      target[key] = source[key]; // 通过方括号语法触发 __proto__ 的设置操作
    }
  }
}

app.post('/api/settings', authenticate, (req, res) => {
  const userSettings = {};
  mergeConfig(userSettings, req.body); // 合并不可信的输入数据
  applySettings(userSettings);
  res.json({ success: true });
});

为什么这很重要

攻击者会发送如下请求体：

{
  "__proto__": {
    "isAdmin": true
  }
}

递归调用的 mergeConfig 函数会到达 __proto__ 这个键，并执行 target '__proto__']['isAdmin'] = true 这一行代码。由于 __proto__ 是 JavaScript 的原型访问机制，因此这条指令会直接修改 Object.prototype。合并操作完成后：

const anyObject = {};
console.log(anyObject.isAdmin); // 输出 true — 这个值是从 Object.prototype 继承而来的

此时，运行中的应用程序中所有普通对象都会继承 isAdmin: true 这一属性。如果某个授权检查机制使用了这样的逻辑……

if (user.isAdmin) { /* 授予管理员权限 */ }

现在，这一检查对于所有用户来说都是有效的，无论他们的实际角色是什么。

如何修复这一漏洞

应在服务器端存储用户状态，并对每个字段进行单独验证。切勿递归地合并不可信的输入：

// Express.js - 安全版本
app.post('/api/settings', authenticate, async (req, res) => {
  // 从数据库中获取当前设置——绝不要从客户端获取
  const current = await db.query(
    'SELECT theme, language, notifications FROM user_settings WHERE user_id = ?,'
    [req.user.id]
  );

  // 根据允许的列表验证每个字段
  const safeSettings = {
    theme: validateEnum(req.body.theme, ['light', 'dark'], currenttheme),
    language: validateEnum(req.body.language, ['en', 'es', 'fr', 'de'], currentlanguage),
    notifications: typeof req.body.notifications === 'boolean'
      ? req.bodynotifications
      : currentNotifications
  };

  await db.query(
    'UPDATE user_settings SET ? WHERE user_id = ?,'
    [safeSettings, req.user.id]
  );

  res.json({ success: true });
});

function validateEnum(value, allowed, defaultValue) {
  return allowed.includes(value) ? value : defaultValue;
}

如果需要使用合并工具，可以使用Object.create(null)作为基础对象——该对象没有原型，因此__proto__属性不会被污染——并且要明确指定允许的键值对：

// 安全的合并方法：使用没有原型的对象
function safeMerge(allowedKeys, source) {
  const result = Object.create(null); // 没有原型，因此不会发生污染

  for (const key of allowedKeys) {
    if (key in source && typeof source[key] !== 'object') {
      result[key] = source[key];
    }
  }

  return result;
}

规则：

// Express.js – 存在安全漏洞
app.post('/api/redeem-coupon', authenticate, async (req, res) => {
  const { couponCode } = req.body;
  const userId = req.user.id;

  // 第一步：检查优惠券是否仍然有效
  const coupon = await db.query(
    'SELECT id, discount_amount, used FROM coupons WHERE code = ? AND used = false',
    [couponCode]
  );

  if (!coupon) {
    return res.status(400).json({ error: '无效或已被使用的优惠券' });
  }

  // 在执行第三步之前，可能会有其他请求先通过第一步的验证。

  // 第二步：应用折扣优惠
  await applyDiscountToOrder(userId, coupon.discount_amount);

  // 第三步：将优惠券标记为已使用状态
  await db.query(
    'UPDATE coupons SET used = true, used_by = ? WHERE code = ?,',
    [userId, couponCode]
  );

  res.json({ success: true });
});

// Express.js — 存在安全漏洞
app.post('/api/checkout', authenticate, async (req, res) => {
  const { items } = req.body;

  let total = 0;
  const processedItems = [];

  for (const item of items) {
    const product = await db.query(
      'SELECT id, price FROM products WHERE id = ?,'
      [itemproductId]
    );

    if (!product) {
      return res.status(400).json({ error: `产品未找到：${item productId}` });
    }

    // 相信客户端提供的数量值
    const itemTotal = product.price * item.quantity;
    total += itemTotal;

    processedItems.push({productId: product.id, quantity: item_quantity, price: product.price });
  }

  if (total > 100) {
    total = total * 0.9; // 打九折
  }

  await createOrder(req.user.id, processedItems, total);
  res.json({ success: true, total });
});

// Express.js — 加强安全性
app.post('/api/checkout', authenticate, async (req, res) => {
  const { items } = req.body;

  if (!Array.isArray(items) || items.length === 0) {
    return res.status(400).json({ error: '购物车中至少需要包含一件商品' });
  }

  if (items.length > 50) {
    return res.status(400).json({ error: '购物车中不能超过50件商品' });
  }

  let totalCents = 0; // 使用整数运算可避免浮点数误差
  const processedItems = [];

  for (const item of items) {
    if (!/^\d+$/.test(String(itemproductId))) {
      return res.status(400).json({ error: `无效的产品ID：${item productId}` });
    }

    const productId = Number(item.productId);

    // 验证数量：必须是由数字组成的字符串，且数值在1到10之间
    if (!/^\d+$/.test(String(item.quantity))) {
      return res.status(400).json({
        error: `产品${productId}的数量无效`
      });
    }

    const quantity = Number(itemquantity);

    if (quantity < 1 || quantity > 10) {
      return res.status(400).json({
        error: `产品${productId}的数量必须在1到10之间`
      });
    }

    const product = await db.query(
      'SELECT id, name, price_cents, stock FROM products WHERE id = ? AND active = true',
      [productId]
    );

    if (!product) {
      return res.status(400).json({ error: `产品未找到：${productId}` });
    }

    if (product.stock < quantity) {
      return res.status(400).json({
        error: `商品${product.name}的库存不足`
      });
    }

    // 使用服务器提供的价格——切勿相信客户端的价格信息
    totalCents += product.price_cents * quantity;

    processedItems.push({
      productId: product.id,
      name: product.name,
      quantity,
      unitPriceCents: product.price_cents
    });

    // 计算折扣时使用整数运算
    const discountMultiplier = totalCents > 10000 ? 90 : 100; // 10000分等于100美元
    const finalTotalCents = Math.round(totalCents * discountMultiplier / 100);

    await createOrder(req.user.id, processedItems, finalTotalCents);

    res.json({
      success: true,
      total: (finalTotalCents / 100).toFixed(2),
      currency: 'USD'
    });
});

// 存在安全隐患
const decoded = jwt.verify(token, process.env.JWT_SECRET);

 存在安全隐患
const token = jwt.sign({ userId: user.id }, 'secret');

 存在安全隐患
const token = jwt.sign({
  userId: user.id,
  passwordHash: user.passwordHash, // 绝对不要这样做
  role: user.role
}, secret);

 安全的JWT实现方式
const jwt = require('jsonwebtoken');
const crypto = require('crypto');

// 一次性生成一个强密钥，并将其存储为环境变量：
// node -e "console.log(crypto.randomBytes(64).toString('hex'))"
const JWT_SECRET = process.env.JWT_SECRET;

if (!JWT_SECRET || Buffer.from(JWT_SECRET, 'hex').length < 32) {
  throw new Error('JWT_SECRET必须至少由32个随机字节组成');
}

function signToken(userId) {
  return jwt.sign(
    { sub: userId },         // ‘sub’是用于表示用户身份的标准字段
    JWT_SECRET,
    {
      algorithm: 'HS256',    // 必须明确指定算法
      expires: '15m',      // 使用有效期较短的令牌可以减少被窃取后造成的风险
      issuer: 'your-app-name',
      audience: 'your-app-name'
    }
  );
}

function verifyToken(token) {
  return jwt.verify(token, JWT_SECRET, {
    algorithms: ['HS256'],   // 只允许使用预期的算法
    issuer: 'your-app-name',
    audience: 'your-app-name'
  });
}

function authenticate(req, res, next) {
  const authHeader = req.headersauthorization;

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: '未提供令牌' });
  }

  const token = authHeader.split(' ')[1];

  try {
    const decoded = verifyToken(token);
    req.user = { id: decoded.sub };
    next();
  } catch (err) {
    return res.status(401).json({ error: '令牌无效或已过期' });
  }
}