安全加固与漏洞防护

安全加固与漏洞防护

Express框架作为Node.js生态中最流行的Web应用框架之一，其灵活性和易用性广受开发者青睐。但随着应用规模扩大，安全问题不容忽视，从请求验证到依赖管理都可能成为攻击入口。

基础安全防护配置

Helmet中间件集成

Helmet是一组安全相关的HTTP头设置中间件，能有效防护常见Web漏洞。安装后只需几行代码即可启用11项安全策略：

const express = require('express');
const helmet = require('helmet');

const app = express();
app.use(helmet());

关键防护包括：

• X-XSS-Protection：启用浏览器XSS过滤
• X-Frame-Options：防止点击劫持攻击
• Strict-Transport-Security：强制HTTPS连接
• Content-Security-Policy：控制资源加载来源

请求体大小限制

未限制的请求体可能导致内存耗尽攻击。使用express内置的limit配置：

app.use(express.json({ limit: '100kb' }));
app.use(express.urlencoded({ 
  limit: '100kb',
  extended: true 
}));

对于文件上传场景，建议使用multer中间件并设置明确限制：

const multer = require('multer');
const upload = multer({
  limits: {
    fileSize: 1024 * 1024 * 5 // 5MB
  }
});

输入验证与净化

请求参数验证

使用express-validator处理输入验证：

const { body, validationResult } = require('express-validator');

app.post('/user', 
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }),
  body('age').isInt({ min: 18 }),
  (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    // 处理逻辑
  }
);

XSS防护措施

手动转义输出内容：

const escapeHtml = (unsafe) => {
  return unsafe
    .replace(/&/g, "&")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#039;");
};

app.get('/search', (req, res) => {
  const query = escapeHtml(req.query.q);
  res.send(`搜索结果: ${query}`);
});

模板引擎自动转义（以EJS为例）：

<h1><%= userControlledInput %></h1>

认证与会话安全

JWT最佳实践

实现安全的JWT认证流程：

const jwt = require('jsonwebtoken');
const crypto = require('crypto');

// 生成随机密钥
const secret = crypto.randomBytes(64).toString('hex');

app.post('/login', (req, res) => {
  // 验证凭证...
  const token = jwt.sign(
    { userId: user.id },
    secret,
    { 
      expiresIn: '1h',
      algorithm: 'HS256' 
    }
  );
  res.cookie('token', token, {
    httpOnly: true,
    secure: true,
    sameSite: 'strict'
  });
});

会话管理防护

使用express-session的安全配置：

const session = require('express-session');
const RedisStore = require('connect-redis')(session);

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: crypto.randomBytes(32).toString('hex'),
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true,
    httpOnly: true,
    maxAge: 24 * 60 * 60 * 1000,
    sameSite: 'lax'
  }
}));

依赖安全维护

定期漏洞扫描

使用npm audit检查依赖：

npm audit
npm audit fix --force

集成到CI/CD流程：

# .github/workflows/audit.yml
name: Security Audit
on: [push, pull_request]
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: npm install
      - run: npm audit --audit-level=high

依赖版本锁定

使用package-lock.json确保一致性：

{
  "dependencies": {
    "express": "^4.18.2",
    "helmet": "^7.0.0"
  }
}

建议使用精确版本号而非语义化版本范围：

"dependencies": {
  "express": "4.18.2"
}

高级防护策略

速率限制实现

使用express-rate-limit防御暴力破解：

const rateLimit = require('express-rate-limit');

const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  message: '请求过于频繁，请15分钟后再试',
  headers: true
});

app.use('/api/', apiLimiter);

针对登录接口的特殊限制：

const loginLimiter = rateLimit({
  windowMs: 60 * 60 * 1000,
  max: 5,
  handler: (req, res) => {
    res.status(429).json({
      error: '登录尝试过多，账户已锁定1小时'
    });
  }
});

app.post('/login', loginLimiter, authController.login);

CSRF防护机制

使用csurf中间件（需配合会话）：

const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
  res.render('send', { csrfToken: req.csrfToken() });
});

app.post('/process', csrfProtection, (req, res) => {
  // 验证通过
});

前端表单集成：

<form action="/process" method="POST">
  <input type="hidden" name="_csrf" value="<%= csrfToken %>">
  <!-- 其他表单字段 -->
</form>

日志与监控

安全事件日志记录

结构化日志记录示例：

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ 
      filename: 'security.log',
      level: 'warn'
    })
  ]
});

app.post('/login', (req, res, next) => {
  if (failedLogin) {
    logger.warn({
      message: '登录失败',
      ip: req.ip,
      userAgent: req.headers['user-agent'],
      timestamp: new Date()
    });
  }
});

异常请求检测

识别可疑User-Agent：

app.use((req, res, next) => {
  const ua = req.headers['user-agent'];
  const badBots = ['sqlmap', 'nikto', 'wget'];
  
  if (badBots.some(bot => ua.includes(bot))) {
    logger.warn(`可疑UA访问: ${ua}`);
    return res.status(403).send('访问被拒绝');
  }
  next();
});

生产环境强化

HTTP头安全配置

自定义安全头示例：

app.use((req, res, next) => {
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('Referrer-Policy', 'same-origin');
  res.setHeader('Feature-Policy', "geolocation 'none'");
  next();
});

错误处理规范化

安全的自定义错误处理：

app.use((err, req, res, next) => {
  if (err instanceof SyntaxError && 'body' in err) {
    return res.status(400).json({ error: '无效的JSON格式' });
  }
  
  // 不泄露堆栈信息
  res.status(500).json({ 
    error: '服务器内部错误',
    requestId: req.id 
  });
  
  logger.error({
    error: err.message,
    stack: err.stack,
    path: req.path
  });
});