高安全架构

高安全架构 ≠ 独立存在
高安全架构 = 配合其他架构共同设计

安全架构应该：
├── 贯穿系统全生命周期
├── 覆盖各个技术层面
├── 与业务架构深度融合
└── 持续演进出新

高安全架构五大策略：

┌─────────────────────────────────┐
│  1. 物理安全                     │
│     机房、设备、门禁、权限         │
├─────────────────────────────────┤
│  2. 数据安全                     │
│     访问权限、加密、保护           │
├─────────────────────────────────┤
│  3. 通信安全                     │
│     网络攻击防护、加密传输         │
├─────────────────────────────────┤
│  4. 身份安全                     │
│     认证、授权、审计               │
├─────────────────────────────────┤
│  5. 软件安全                     │
│     操作系统、数据库、Web应用      │
└─────────────────────────────────┘

物理安全要素：

机房安全
├── 选址（避开地质灾害区）
├── 建筑结构（抗震、防火）
├── 温湿度控制
├── 消防系统
└── 防水防潮

设备安全
├── 服务器物理防护
├── 网络设备保护
├── 存储设备安全
└── 电源保障（UPS、发电机）

访问控制
├── 门禁系统
├── 监控系统
├── 人员登记
└── 多人陪同机制

// 机房安全措施清单
const datacenterSecurityMeasures = {
  // 物理环境
  environment: {
    temperature: '18-28°C',
    humidity: '35-75%',
    fireProtection: '气体灭火系统',
    waterproof: '防水堤、漏水检测'
  },
  
  // 电力保障
  power: {
    dualPower: '双路市电接入',
    ups: 'UPS 不间断电源',
    generator: '柴油发电机',
    duration: '满载运行 ≥ 2小时'
  },
  
  // 访问控制
  accessControl: {
    biometric: '指纹/人脸识别',
    cardReader: '门禁卡',
    visitorPolicy: '访客登记+陪同',
    cctv: '24小时监控录像'
  },
  
  // 网络安全
  network: {
    fiberPath: '不同路由光缆',
    redundant: '双上联网络设备',
    physicalIsolation: '核心区域物理隔离'
  }
}

// 机房访问控制系统
class DatacenterAccessControl {
  constructor() {
    this.accessLevels = {
      level1: ['公共区域', '接待大厅'],
      level2: ['办公区域', '会议室'],
      level3: ['机房外围', '监控室'],
      level4: ['核心机房', '设备间']
    }
    
    this.auditLog = []
  }
  
  // 申请访问权限
  async requestAccess(userId, targetZone, reason) {
    const request = {
      id: this.generateId(),
      userId,
      targetZone,
      reason,
      timestamp: Date.now(),
      status: 'pending'
    }
    
    // 审批流程
    const approval = await this.getApproval(request)
    
    if (approval.approved) {
      // 检查是否需要陪同
      if (this.requiresEscort(targetZone)) {
        request.escort = approval.escort
      }
      
      // 记录访问日志
      this.logAccess(request)
      
      return {
        success: true,
        accessCode: this.generateAccessCode(request),
        validUntil: Date.now() + 3600000,  // 1小时有效
        escort: request.escort
      }
    }
    
    return {
      success: false,
      reason: approval.reason
    }
  }
  
  // 进入机房
  async enterZone(userId, zone, accessCode) {
    // 1. 验证访问码
    const valid = await this.validateAccessCode(accessCode)
    
    if (!valid) {
      throw new Error('访问码无效或已过期')
    }
    
    // 2. 生物识别验证
    const biometric = await this.verifyBiometric(userId)
    
    if (!biometric) {
      throw new Error('生物识别验证失败')
    }
    
    // 3. 检查陪同要求
    const requiresEscort = this.requiresEscort(zone)
    
    // 4. 记录进入时间
    const entry = {
      userId,
      zone,
      entryTime: Date.now(),
      escort: requiresEscort
    }
    
    this.auditLog.push(entry)
    
    // 5. 开启门禁
    await this.openDoor(zone)
    
    return entry
  }
  
  // 离开机房
  async exitZone(userId, zone) {
    const lastEntry = this.findLastEntry(userId, zone)
    
    if (!lastEntry) {
      throw new Error('未找到进入记录')
    }
    
    const exitRecord = {
      ...lastEntry,
      exitTime: Date.now(),
      duration: Date.now() - lastEntry.entryTime
    }
    
    this.auditLog.push(exitRecord)
    
    // 检查是否有遗留物品
    await this.checkBelongings(userId, zone)
    
    return exitRecord
  }
  
  // 是否需要陪同
  requiresEscort(zone) {
    const highSecurityZones = ['核心机房', '设备间']
    return highSecurityZones.includes(zone)
  }
  
  // 记录访问日志
  logAccess(request) {
    this.auditLog.push({
      type: 'access_request',
      ...request
    })
  }
  
  // 生成访问码
  generateAccessCode(request) {
    return `AC-${Date.now()}-${request.id}`
  }
  
  // 其他辅助方法
  generateId() {
    return Math.random().toString(36).slice(2, 11)
  }
  
  async getApproval(request) {
    // 模拟审批流程
    return { approved: true }
  }
  
  async validateAccessCode(code) {
    return true
  }
  
  async verifyBiometric(userId) {
    return true
  }
  
  async openDoor(zone) {
    console.log(`开启 ${zone} 门禁`)
  }
  
  findLastEntry(userId, zone) {
    return this.auditLog
      .filter(log => log.userId === userId && log.zone === zone && !log.exitTime)
      .pop()
  }
  
  async checkBelongings(userId, zone) {
    console.log('检查是否遗留物品')
  }
}

数据安全三要素：

1. 访问权限控制
   ├── 责任分层
   ├── 用户权限设置
   └── 最小权限原则

2. 数据加密
   ├── 对称加密
   ├── 非对称加密
   └── 数字签名

3. 数据保护
   ├── 逻辑保护
   ├── 高可用保障
   └── 备份恢复

数据访问分层：

┌─────────────────────────────────┐
│  数据所有者                      │
│  - 决定数据分类                 │
│  - 审批访问权限                 │
└─────────────┬───────────────────┘
              ↓
┌─────────────────────────────────┐
│  数据管理员                      │
│  - 执行访问控制                 │
│  - 维护数据安全                 │
└─────────────┬───────────────────┘
              ↓
┌─────────────────────────────────┐
│  数据使用者                      │
│  - 按权限访问数据               │
│  - 遵守安全规范                 │
└─────────────────────────────────┘

// 数据访问权限控制
class DataAccessControl {
  constructor() {
    this.permissions = new Map()
    this.roles = new Map()
  }
  
  // 定义角色权限
  defineRole(roleName, permissions) {
    this.roles.set(roleName, permissions)
  }
  
  // 授予用户权限
  grantPermission(userId, resource, action, conditions = {}) {
    const key = `${userId}:${resource}`
    
    const permission = {
      userId,
      resource,
      action,  // read, write, delete, admin
      conditions,
      grantedAt: Date.now(),
      grantedBy: 'system'
    }
    
    if (!this.permissions.has(key)) {
      this.permissions.set(key, [])
    }
    
    this.permissions.get(key).push(permission)
  }
  
  // 检查权限
  checkPermission(userId, resource, action, context = {}) {
    const key = `${userId}:${resource}`
    const permissions = this.permissions.get(key) || []
    
    for (const perm of permissions) {
      if (perm.action === action || perm.action === 'admin') {
        // 检查条件
        if (this.checkConditions(perm.conditions, context)) {
          return {
            allowed: true,
            permission: perm
          }
        }
      }
    }
    
    return {
      allowed: false,
      reason: '权限不足'
    }
  }
  
  // 检查条件
  checkConditions(conditions, context) {
    for (const [key, value] of Object.entries(conditions)) {
      if (context[key] !== value) {
        return false
      }
    }
    return true
  }
  
  // 最小权限原则：只授予必要的权限
  applyLeastPrivilege(userId, resources) {
    const minimalPermissions = []
    
    for (const resource of resources) {
      // 分析用户实际需要的权限
      const requiredActions = this.analyzeRequiredActions(userId, resource)
      
      // 只授予必要的权限
      for (const action of requiredActions) {
        minimalPermissions.push({
          userId,
          resource,
          action
        })
      }
    }
    
    return minimalPermissions
  }
  
  // 分析所需权限
  analyzeRequiredActions(userId, resource) {
    // 根据业务逻辑分析用户需要的权限
    return ['read']  // 默认只读权限
  }
  
  // 审计日志
  auditAccess(userId, resource, action, result) {
    const auditEntry = {
      timestamp: Date.now(),
      userId,
      resource,
      action,
      result: result.allowed ? 'granted' : 'denied',
      reason: result.reason || '',
      ipAddress: this.getClientIP(),
      userAgent: this.getUserAgent()
    }
    
    this.saveAuditLog(auditEntry)
    
    return auditEntry
  }
  
  // 辅助方法
  getClientIP() {
    return '192.168.1.100'
  }
  
  getUserAgent() {
    return 'Mozilla/5.0...'
  }
  
  saveAuditLog(entry) {
    console.log('审计日志:', entry)
  }
}

// 使用示例
const accessControl = new DataAccessControl()

// 定义角色
accessControl.defineRole('admin', ['read', 'write', 'delete', 'admin'])
accessControl.defineRole('user', ['read'])
accessControl.defineRole('editor', ['read', 'write'])

// 授予权限
accessControl.grantPermission('user123', '/api/users', 'read')
accessControl.grantPermission('user123', '/api/users/profile', 'write', { owner: 'user123' })

// 检查权限
const result = accessControl.checkPermission('user123', '/api/users', 'read')
console.log('权限检查结果:', result)  // { allowed: true }

// 审计
accessControl.auditAccess('user123', '/api/users', 'read', result)

// AES 对称加密
const crypto = require('crypto')

class SymmetricEncryption {
  constructor(algorithm = 'aes-256-cbc') {  // 生产环境建议使用 aes-256-gcm 等认证加密模式
    this.algorithm = algorithm
    this.key = crypto.randomBytes(32)  // 256位密钥
    this.iv = crypto.randomBytes(16)   // 初始化向量
  }
  
  // 加密
  encrypt(plainText) {
    const cipher = crypto.createCipheriv(
      this.algorithm,
      this.key,
      this.iv
    )
    
    let encrypted = cipher.update(plainText, 'utf8', 'hex')
    encrypted += cipher.final('hex')
    
    return {
      encrypted,
      iv: this.iv.toString('hex'),
      key: this.key.toString('hex')
    }
  }
  
  // 解密
  decrypt(encryptedData, key, iv) {
    const decipher = crypto.createDecipheriv(
      this.algorithm,
      Buffer.from(key, 'hex'),
      Buffer.from(iv, 'hex')
    )
    
    let decrypted = decipher.update(encryptedData, 'hex', 'utf8')
    decrypted += decipher.final('utf8')
    
    return decrypted
  }
}

// 使用示例
const aes = new SymmetricEncryption()

const sensitiveData = '用户的敏感信息：身份证号、银行卡号等'
const encrypted = aes.encrypt(sensitiveData)

console.log('加密后:', encrypted.encrypted)

const decrypted = aes.decrypt(
  encrypted.encrypted,
  encrypted.key,
  encrypted.iv
)

console.log('解密后:', decrypted)

// RSA 非对称加密
const crypto = require('crypto')

class AsymmetricEncryption {
  constructor() {
    // 生成密钥对
    const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
      modulusLength: 2048,
      publicKeyEncoding: {
        type: 'spki',
        format: 'pem'
      },
      privateKeyEncoding: {
        type: 'pkcs8',
        format: 'pem'
      }
    })
    
    this.publicKey = publicKey
    this.privateKey = privateKey
  }
  
  // 公钥加密
  encryptWithPublicKey(plainText) {
    const buffer = Buffer.from(plainText, 'utf8')
    
    const encrypted = crypto.publicEncrypt(
      {
        key: this.publicKey,
        padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash: 'sha256'
      },
      buffer
    )
    
    return encrypted.toString('base64')
  }
  
  // 私钥解密
  decryptWithPrivateKey(encryptedData) {
    const buffer = Buffer.from(encryptedData, 'base64')
    
    const decrypted = crypto.privateDecrypt(
      {
        key: this.privateKey,
        padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash: 'sha256'
      },
      buffer
    )
    
    return decrypted.toString('utf8')
  }
  
  // 数字签名
  sign(data) {
    const sign = crypto.createSign('SHA256')
    sign.update(data)
    sign.end()
    
    const signature = sign.sign(this.privateKey, 'base64')
    
    return signature
  }
  
  // 验证签名
  verify(data, signature) {
    const verify = crypto.createVerify('SHA256')
    verify.update(data)
    verify.end()
    
    return verify.verify(this.publicKey, signature, 'base64')
  }
}

// 使用示例
const rsa = new AsymmetricEncryption()

// 加密解密
const plainText = '敏感数据'
const encrypted = rsa.encryptWithPublicKey(plainText)
const decrypted = rsa.decryptWithPrivateKey(encrypted)

console.log('加密后:', encrypted)
console.log('解密后:', decrypted)

// 数字签名
const data = '需要签名的数据'
const signature = rsa.sign(data)
const isValid = rsa.verify(data, signature)

console.log('签名:', signature)
console.log('验证结果:', isValid)  // true

HTTPS 加密流程（以经典 RSA 密钥交换为例；TLS 1.3 已改用 (EC)DHE 临时密钥交换，不再支持 RSA 密钥传输）：

客户端                                    服务器
  │                                         │
  │  1. 请求建立 HTTPS 连接                 │
  │ ──────────────────────────────────────→ │
  │                                         │
  │  2. 返回 SSL 证书（包含公钥）            │
  │ ←────────────────────────────────────── │
  │                                         │
  │  3. 验证证书有效性                       │
  │  4. 生成随机会话密钥                     │
  │  5. 用公钥加密会话密钥                   │
  │ ──────────────────────────────────────→ │
  │                                         │
  │  6. 用私钥解密会话密钥                   │
  │                                         │
  │  7. 使用会话密钥加密通信                 │
  │ ←─────────────────────────────────────→ │
  │                                         │

// HTTPS 服务器配置
const https = require('https')
const fs = require('fs')

const options = {
  key: fs.readFileSync('private-key.pem'),
  cert: fs.readFileSync('certificate.pem'),
  ca: fs.readFileSync('ca-bundle.pem')
}

const server = https.createServer(options, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/html' })
  res.end('<h1>HTTPS 安全连接</h1>')
})

server.listen(443, () => {
  console.log('HTTPS 服务器运行在 https://localhost:443')
})

// 强制 HTTPS 跳转
const http = require('http')

const httpServer = http.createServer((req, res) => {
  res.writeHead(301, {
    Location: `https://${req.headers.host}${req.url}`
  })
  res.end()
})

httpServer.listen(80, () => {
  console.log('HTTP 服务器运行在 http://localhost:80（自动跳转 HTTPS）')
})

// 数据保护策略
class DataProtection {
  constructor() {
    this.backupSchedule = '0 2 * * *'  // 每天凌晨2点备份
  }
  
  // 数据脱敏
  maskSensitiveData(data, fields) {
    const masked = { ...data }
    
    for (const field of fields) {
      if (masked[field]) {
        masked[field] = this.maskValue(masked[field])
      }
    }
    
    return masked
  }
  
  // 脱敏规则
  maskValue(value) {
    const str = String(value)
    
    // 手机号：138****1234
    if (/^\d{11}$/.test(str)) {
      return str.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
    }
    
    // 身份证：110************1234
    if (/^\d{17}[\dXx]$/.test(str)) {
      return str.replace(/^(.{3})(.{12})(.{3})$/, '$1************$3')
    }
    
    // 邮箱：a***@example.com
    if (/@/.test(str)) {
      const [local, domain] = str.split('@')
      const maskedLocal = local[0] + '***'
      return `${maskedLocal}@${domain}`
    }
    
    // 银行卡：6222 **** **** 1234
    if (/^\d{16,19}$/.test(str)) {
      return str.replace(/(\d{4})\d+(\d{4})/, '$1 **** **** $2')
    }
    
    // 默认：保留前2位和后2位
    if (str.length > 4) {
      return str[0] + str[1] + '***' + str[str.length - 2] + str[str.length - 1]
    }
    
    return '***'
  }
  
  // 数据备份
  async backup(data, location) {
    const backup = {
      id: this.generateBackupId(),
      timestamp: Date.now(),
      data: this.encryptData(data),
      checksum: this.calculateChecksum(data),
      location
    }
    
    await this.saveBackup(backup)
    
    return backup
  }
  
  // 数据恢复
  async restore(backupId) {
    const backup = await this.loadBackup(backupId)
    
    // 验证校验和
    const decrypted = this.decryptData(backup.data)
    const checksum = this.calculateChecksum(decrypted)
    
    if (checksum !== backup.checksum) {
      throw new Error('备份数据校验失败，可能已被篡改')
    }
    
    return decrypted
  }
  
  // 辅助方法
  generateBackupId() {
    return `backup-${Date.now()}`
  }
  
  encryptData(data) {
    // 使用加密算法加密数据
    return JSON.stringify(data)
  }
  
  decryptData(encrypted) {
    return JSON.parse(encrypted)
  }
  
  calculateChecksum(data) {
    const crypto = require('crypto')
    return crypto.createHash('sha256').update(JSON.stringify(data)).digest('hex')
  }
  
  async saveBackup(backup) {
    console.log('保存备份:', backup.id)
  }
  
  async loadBackup(backupId) {
    console.log('加载备份:', backupId)
    return {}
  }
}

// 使用示例
const protection = new DataProtection()

// 数据脱敏
const userData = {
  name: '张三',
  phone: '13812345678',
  idCard: '110101199001011234',
  email: 'zhangsan@example.com',
  bankCard: '6222021234567890123'
}

const maskedData = protection.maskSensitiveData(userData, ['phone', 'idCard', 'email', 'bankCard'])

console.log('原始数据:', userData)
console.log('脱敏数据:', maskedData)
/*
脱敏数据:
{
  name: '张三',
  phone: '138****5678',
  idCard: '110************234',
  email: 'z***@example.com',
  bankCard: '6222 **** **** 0123'
}
*/

常见网络攻击：

┌─────────────────────────────────┐
│  DDoS 攻击                       │
│  分布式拒绝服务攻击               │
│  - 大量请求耗尽服务器资源         │
│  - 目标：使服务不可用             │
└─────────────────────────────────┘

┌─────────────────────────────────┐
│  DNS 劫持                        │
│  篡改 DNS 解析结果                │
│  - 将域名解析到错误 IP           │
│  - 目标：钓鱼、窃取信息           │
└─────────────────────────────────┘

┌─────────────────────────────────┐
│  重放攻击                        │
│  重复发送合法请求                 │
│  - 截获并重复发送请求             │
│  - 目标：重复执行操作             │
└─────────────────────────────────┘

┌─────────────────────────────────┐
│  ARP 欺骗                        │
│  伪造 ARP 响应                    │
│  - 篡改 MAC 地址映射             │
│  - 目标：中间人攻击               │
└─────────────────────────────────┘

┌─────────────────────────────────┐
│  中间人攻击 (MITM)               │
│  拦截通信双方消息                 │
│  - 窃听、篡改通信内容             │
│  - 目标：窃取敏感信息             │
└─────────────────────────────────┘

// DDoS 防护系统
class DDoSProtection {
  constructor() {
    this.requestCounts = new Map()
    this.blockedIPs = new Set()
    
    // 阈值配置
    this.thresholds = {
      requestsPerSecond: 100,
      requestsPerMinute: 1000,
      burstSize: 50
    }
  }
  
  // 请求限流中间件
  rateLimiter() {
    return (req, res, next) => {
      const ip = this.getClientIP(req)
      
      // 检查是否被封锁
      if (this.blockedIPs.has(ip)) {
        return res.status(429).json({
          error: 'Too Many Requests',
          message: '您的访问频率过高，已被暂时封锁'
        })
      }
      
      // 检查请求频率
      const checkResult = this.checkRateLimit(ip)
      
      if (!checkResult.allowed) {
        // 封锁 IP
        this.blockIP(ip, checkResult.reason)
        
        return res.status(429).json({
          error: 'Too Many Requests',
          message: '请求频率超过限制',
          retryAfter: checkResult.retryAfter
        })
      }
      
      next()
    }
  }
  
  // 检查请求频率
  checkRateLimit(ip) {
    const now = Date.now()
    const key = this.getRequestKey(ip)
    
    if (!this.requestCounts.has(key)) {
      this.requestCounts.set(key, {
        count: 1,
        firstRequest: now,
        lastRequest: now
      })
      
      return { allowed: true }
    }
    
    const record = this.requestCounts.get(key)
    const elapsed = now - record.firstRequest
    
    // 更新计数
    record.count++
    record.lastRequest = now
    
    // 每秒请求检查
    if (elapsed < 1000 && record.count > this.thresholds.requestsPerSecond) {
      return {
        allowed: false,
        reason: '每秒请求超过限制',
        retryAfter: 1000 - elapsed
      }
    }
    
    // 每分钟请求检查
    if (elapsed < 60000 && record.count > this.thresholds.requestsPerMinute) {
      return {
        allowed: false,
        reason: '每分钟请求超过限制',
        retryAfter: 60000 - elapsed
      }
    }
    
    // 重置计数器
    if (elapsed > 60000) {
      this.requestCounts.set(key, {
        count: 1,
        firstRequest: now,
        lastRequest: now
      })
    }
    
    return { allowed: true }
  }
  
  // 封锁 IP
  blockIP(ip, reason) {
    this.blockedIPs.add(ip)
    
    console.log(`封锁 IP: ${ip}, 原因: ${reason}`)
    
    // 自动解封（10分钟后）
    setTimeout(() => {
      this.blockedIPs.delete(ip)
      console.log(`解封 IP: ${ip}`)
    }, 600000)
  }
  
  // 验证码验证
  captchaVerification() {
    return async (req, res, next) => {
      const ip = this.getClientIP(req)
      
      // 检查是否需要验证码
      if (this.needsCaptcha(ip)) {
        const captcha = req.body.captcha
        
        if (!captcha || !(await this.verifyCaptcha(captcha))) {
          return res.status(400).json({
            error: 'Captcha Required',
            message: '需要验证码验证'
          })
        }
      }
      
      next()
    }
  }
  
  // 判断是否需要验证码
  needsCaptcha(ip) {
    const record = this.requestCounts.get(this.getRequestKey(ip))
    
    if (!record) return false
    
    // 超过阈值则需要验证码
    return record.count > this.thresholds.requestsPerMinute * 0.8
  }
  
  // 验证验证码
  async verifyCaptcha(captcha) {
    // 实际实现：调用验证码服务
    return true
  }
  
  // 辅助方法
  getClientIP(req) {
    return req.ip || req.socket.remoteAddress
  }
  
  getRequestKey(ip) {
    return `rate:${ip}`
  }
}

// 使用示例
const express = require('express')
const app = express()
const ddosProtection = new DDoSProtection()

// 应用限流中间件
app.use(ddosProtection.rateLimiter())

// 验证码验证
app.post('/api/sensitive', ddosProtection.captchaVerification(), (req, res) => {
  res.json({ message: '操作成功' })
})

app.listen(3000)

// DNS 安全检查
class DNSSecurity {
  constructor() {
    this.authorizedIPs = new Map()
  }
  
  // DNS 解析验证
  async verifyDNSResolution(domain) {
    // 从多个 DNS 服务器获取解析结果
    const dnsServers = [
      '8.8.8.8',      // Google DNS
      '1.1.1.1',      // Cloudflare DNS
      '114.114.114.114'  // 114 DNS
    ]
    
    const results = await Promise.all(
      dnsServers.map(dns => this.resolveDNS(domain, dns))
    )
    
    // 检查解析结果是否一致
    const uniqueIPs = new Set(results)
    
    if (uniqueIPs.size > 1) {
      console.warn('DNS 解析结果不一致，可能遭受 DNS 劫持')
      console.log('解析结果:', results)
      
      return {
        safe: false,
        reason: 'DNS 解析结果不一致',
        results
      }
    }
    
    // 验证 IP 是否在授权列表中
    const ip = results[0]
    const authorized = this.authorizedIPs.get(domain)
    
    if (authorized && !authorized.includes(ip)) {
      return {
        safe: false,
        reason: '解析 IP 不在授权列表中',
        ip,
        authorized
      }
    }
    
    return {
      safe: true,
      ip
    }
  }
  
  // DNS 解析
  async resolveDNS(domain, dnsServer) {
    // 实际实现：使用 DNS 解析库
    const dns = require('dns').promises
    const result = await dns.resolve4(domain)
    return result[0]
  }
  
  // DNSSEC 验证
  async verifyDNSSEC(domain) {
    // DNSSEC 签名验证
    console.log(`验证 ${domain} 的 DNSSEC 签名`)
    
    return {
      verified: true,
      chainOfTrust: 'valid'
    }
  }
  
  // HTTPS 证书验证
  async verifyCertificate(domain) {
    const tls = require('tls')
    
    return new Promise((resolve, reject) => {
      const socket = tls.connect(443, domain, {
        servername: domain
      }, () => {
        const cert = socket.getPeerCertificate()
        
        // 检查证书是否有效
        const valid = socket.authorized
        
        // 检查证书域名
        const domainMatch = this.checkCertificateDomain(cert, domain)
        
        socket.end()
        
        resolve({
          valid,
          domainMatch,
          issuer: cert.issuer,
          validFrom: cert.valid_from,
          validTo: cert.valid_to
        })
      })
      
      socket.on('error', reject)
    })
  }
  
  // 检查证书域名
  checkCertificateDomain(cert, domain) {
    // 检查 CN 和 SAN
    const cn = cert.subject.CN
    const san = cert.subjectaltname
    
    if (cn === domain) return true
    
    if (san && san.includes(domain)) return true
    
    // 通配符证书
    if (cn.startsWith('*.')) {
      const baseDomain = cn.substring(2)
      if (domain.endsWith(baseDomain)) return true
    }
    
    return false
  }
}

// 使用示例
const dnsSecurity = new DNSSecurity()

// 验证 DNS 解析
dnsSecurity.verifyDNSResolution('example.com')
  .then(result => console.log('DNS 安全检查:', result))

// 重放攻击防护
class ReplayProtection {
  constructor() {
    this.nonceStore = new Map()
    this.timestampWindow = 60000  // 60秒时间窗口
  }
  
  // 生成请求签名
  generateSignature(request) {
    const crypto = require('crypto')
    
    // 构造签名字符串
    const signString = [
      request.method,
      request.path,
      request.timestamp,
      request.nonce,
      JSON.stringify(request.body || {})
    ].join('\n')
    
    // 使用密钥签名
    const signature = crypto
      .createHmac('sha256', this.getSecretKey())
      .update(signString)
      .digest('hex')
    
    return signature
  }
  
  // 验证请求
  verifyRequest(request) {
    // 1. 检查时间戳
    const timestampValid = this.checkTimestamp(request.timestamp)
    
    if (!timestampValid.valid) {
      return {
        valid: false,
        reason: timestampValid.reason
      }
    }
    
    // 2. 检查 nonce（防重放）
    const nonceValid = this.checkNonce(request.nonce, request.timestamp)
    
    if (!nonceValid.valid) {
      return {
        valid: false,
        reason: nonceValid.reason
      }
    }
    
    // 3. 验证签名
    const expectedSignature = this.generateSignature(request)
    
    if (request.signature !== expectedSignature) {
      return {
        valid: false,
        reason: '签名验证失败'
      }
    }
    
    return { valid: true }
  }
  
  // 检查时间戳
  checkTimestamp(timestamp) {
    const now = Date.now()
    const diff = Math.abs(now - timestamp)
    
    if (diff > this.timestampWindow) {
      return {
        valid: false,
        reason: `请求时间戳超出有效范围（${diff}ms > ${this.timestampWindow}ms）`
      }
    }
    
    return { valid: true }
  }
  
  // 检查 nonce
  checkNonce(nonce, timestamp) {
    // 检查 nonce 是否已使用
    if (this.nonceStore.has(nonce)) {
      return {
        valid: false,
        reason: 'Nonce 已使用，可能是重放攻击'
      }
    }
    
    // 存储 nonce
    this.nonceStore.set(nonce, timestamp)
    
    // 清理过期的 nonce
    this.cleanExpiredNonces()
    
    return { valid: true }
  }
  
  // 清理过期 nonce
  cleanExpiredNonces() {
    const now = Date.now()
    const expireTime = this.timestampWindow * 2
    
    for (const [nonce, timestamp] of this.nonceStore) {
      if (now - timestamp > expireTime) {
        this.nonceStore.delete(nonce)
      }
    }
  }
  
  // 获取密钥
  getSecretKey() {
    return 'your-secret-key'
  }
  
  // 生成 nonce
  generateNonce() {
    const crypto = require('crypto')
    return crypto.randomBytes(16).toString('hex')
  }
}

// 使用示例
const replayProtection = new ReplayProtection()

// 客户端发送请求
const request = {
  method: 'POST',
  path: '/api/payment',
  timestamp: Date.now(),
  nonce: replayProtection.generateNonce(),
  body: {
    amount: 100,
    userId: 'user123'
  }
}

// 生成签名
request.signature = replayProtection.generateSignature(request)

console.log('请求:', request)

// 服务器验证请求
const result = replayProtection.verifyRequest(request)

console.log('验证结果:', result)  // { valid: true }

// 综合安全防护
const securityMeasures = {
  // WAF (Web 应用防火墙)
  waf: {
    features: [
      'SQL 注入防护',
      'XSS 攻击防护',
      'CSRF 防护',
      '恶意爬虫识别',
      '敏感信息泄露防护'
    ],
    implementation: 'ModSecurity / 云 WAF'
  },
  
  // IDS/IPS (入侵检测/防御系统)
  ids_ips: {
    ids: {
      name: '入侵检测系统',
      function: '检测并告警可疑行为',
      mode: '被动'
    },
    ips: {
      name: '入侵防御系统',
      function: '主动阻止攻击行为',
      mode: '主动'
    },
    tools: ['Snort', 'Suricata', 'OSSIM']
  },
  
  // VPN (虚拟专用网络)
  vpn: {
    protocols: ['IPSec', 'OpenVPN', 'WireGuard'],
    useCase: '远程安全访问',
    encryption: '端到端加密'
  },
  
  // 加密传输
  encryption: {
    https: 'SSL/TLS 加密',
    ssh: 'SSH 隧道加密',
    vpn: 'VPN 隧道加密'
  }
}

身份安全三要素：

1. 认证 (Authentication)
   ├── 验证用户身份
   ├── JWT、OAuth 2.0
   └── 多因素认证 (MFA)

2. 授权 (Authorization)
   ├── 权限控制
   ├── RBAC、ABAC
   └── 细粒度权限管理

3. 审计 (Audit)
   ├── 操作日志记录
   ├── 异常行为检测
   └── 合规性审计

// JWT 认证系统
const jwt = require('jsonwebtoken')

class JWTAuthentication {
  constructor() {
    this.secret = 'your-secret-key'
    this.expiresIn = '7d'
    this.refreshExpiresIn = '30d'
  }
  
  // 生成访问令牌
  generateAccessToken(user) {
    const payload = {
      userId: user.id,
      username: user.username,
      role: user.role,
      type: 'access'
    }
    
    return jwt.sign(payload, this.secret, {
      expiresIn: this.expiresIn
    })
  }
  
  // 生成刷新令牌
  generateRefreshToken(user) {
    const payload = {
      userId: user.id,
      type: 'refresh'
    }
    
    return jwt.sign(payload, this.secret, {
      expiresIn: this.refreshExpiresIn
    })
  }
  
  // 验证令牌
  verifyToken(token) {
    try {
      const decoded = jwt.verify(token, this.secret)
      
      return {
        valid: true,
        decoded
      }
    } catch (error) {
      return {
        valid: false,
        error: error.message
      }
    }
  }
  
  // 刷新令牌
  refreshToken(refreshToken) {
    const result = this.verifyToken(refreshToken)
    
    if (!result.valid || result.decoded.type !== 'refresh') {
      throw new Error('无效的刷新令牌')
    }
    
    // 获取用户信息
    const user = this.getUserById(result.decoded.userId)
    
    // 生成新的访问令牌
    const newAccessToken = this.generateAccessToken(user)
    
    return {
      accessToken: newAccessToken,
      expiresIn: this.expiresIn
    }
  }
  
  // 认证中间件
  authenticate() {
    return (req, res, next) => {
      const token = this.extractToken(req)
      
      if (!token) {
        return res.status(401).json({
          error: 'Unauthorized',
          message: '未提供认证令牌'
        })
      }
      
      const result = this.verifyToken(token)
      
      if (!result.valid) {
        return res.status(401).json({
          error: 'Unauthorized',
          message: '令牌无效或已过期'
        })
      }
      
      // 将用户信息附加到请求对象
      req.user = result.decoded
      
      next()
    }
  }
  
  // 提取令牌
  extractToken(req) {
    // 从 Authorization 头提取
    const authHeader = req.headers.authorization
    
    if (authHeader && authHeader.startsWith('Bearer ')) {
      return authHeader.substring(7)
    }
    
    // 从查询参数提取
    if (req.query.token) {
      return req.query.token
    }
    
    // 从 Cookie 提取
    if (req.cookies && req.cookies.token) {
      return req.cookies.token
    }
    
    return null
  }
  
  // 获取用户信息
  getUserById(userId) {
    // 实际实现：从数据库查询
    return {
      id: userId,
      username: 'user123',
      role: 'user'
    }
  }
}

// 使用示例
const auth = new JWTAuthentication()

// 登录时生成令牌
app.post('/login', (req, res) => {
  const { username, password } = req.body
  
  // 验证用户名密码
  const user = authenticateUser(username, password)
  
  if (!user) {
    return res.status(401).json({ error: '用户名或密码错误' })
  }
  
  // 生成令牌
  const accessToken = auth.generateAccessToken(user)
  const refreshToken = auth.generateRefreshToken(user)
  
  res.json({
    accessToken,
    refreshToken,
    expiresIn: auth.expiresIn
  })
})

// 受保护的路由
app.get('/protected', auth.authenticate(), (req, res) => {
  res.json({
    message: '访问成功',
    user: req.user
  })
})

// RBAC (基于角色的访问控制)
class RBAC {
  constructor() {
    // 定义角色
    this.roles = {
      admin: {
        permissions: ['*'],  // 所有权限
        description: '超级管理员'
      },
      editor: {
        permissions: [
          'content:read',
          'content:write',
          'content:delete',
          'user:read'
        ],
        description: '编辑'
      },
      viewer: {
        permissions: [
          'content:read',
          'user:read'
        ],
        description: '查看者'
      }
    }
    
    // 用户角色映射
    this.userRoles = new Map()
  }
  
  // 分配角色
  assignRole(userId, role) {
    if (!this.roles[role]) {
      throw new Error(`角色 ${role} 不存在`)
    }
    
    if (!this.userRoles.has(userId)) {
      this.userRoles.set(userId, new Set())
    }
    
    this.userRoles.get(userId).add(role)
  }
  
  // 撤销角色
  revokeRole(userId, role) {
    if (this.userRoles.has(userId)) {
      this.userRoles.get(userId).delete(role)
    }
  }
  
  // 检查权限
  hasPermission(userId, permission) {
    const roles = this.userRoles.get(userId)
    
    if (!roles) return false
    
    for (const role of roles) {
      const permissions = this.roles[role].permissions
      
      // 通配符权限
      if (permissions.includes('*')) return true
      
      // 精确匹配
      if (permissions.includes(permission)) return true
      
      // 通配符匹配
      if (this.matchWildcard(permission, permissions)) return true
    }
    
    return false
  }
  
  // 通配符匹配
  matchWildcard(permission, permissions) {
    for (const perm of permissions) {
      if (perm.includes('*')) {
        const pattern = perm.replace('*', '.*')
        const regex = new RegExp(`^${pattern}$`)
        if (regex.test(permission)) return true
      }
    }
    
    return false
  }
  
  // 权限检查中间件
  requirePermission(permission) {
    return (req, res, next) => {
      const userId = req.user.userId
      
      if (!this.hasPermission(userId, permission)) {
        return res.status(403).json({
          error: 'Forbidden',
          message: '权限不足'
        })
      }
      
      next()
    }
  }
  
  // 获取用户所有权限
  getUserPermissions(userId) {
    const roles = this.userRoles.get(userId)
    if (!roles) return []
    
    const allPermissions = new Set()
    
    for (const role of roles) {
      const permissions = this.roles[role].permissions
      
      permissions.forEach(p => allPermissions.add(p))
    }
    
    return Array.from(allPermissions)
  }
}

// 使用示例
const rbac = new RBAC()

// 分配角色
rbac.assignRole('user123', 'editor')

// 检查权限
console.log(rbac.hasPermission('user123', 'content:write'))  // true
console.log(rbac.hasPermission('user123', 'user:delete'))   // false

// 在路由中使用
app.delete('/content/:id', 
  auth.authenticate(), 
  rbac.requirePermission('content:delete'),
  (req, res) => {
    res.json({ message: '内容删除成功' })
  }
)

// 审计日志系统
class AuditLogger {
  constructor() {
    this.logs = []
    this.sensitiveOperations = [
      'user:login',
      'user:logout',
      'user:delete',
      'permission:grant',
      'permission:revoke',
      'data:export',
      'data:delete',
      'config:change'
    ]
  }
  
  // 记录操作日志
  log(operation, details) {
    const entry = {
      id: this.generateId(),
      timestamp: new Date().toISOString(),
      operation,
      userId: details.userId,
      username: details.username,
      resource: details.resource,
      action: details.action,
      result: details.result,
      ipAddress: details.ipAddress,
      userAgent: details.userAgent,
      requestData: this.sanitizeData(details.requestData),
      responseData: this.sanitizeData(details.responseData)
    }
    
    // 保存日志
    this.logs.push(entry)
    this.persistLog(entry)
    
    // 敏感操作告警
    if (this.sensitiveOperations.includes(operation)) {
      this.alertSensitiveOperation(entry)
    }
    
    return entry
  }
  
  // 查询日志
  query(filters) {
    return this.logs.filter(log => {
      if (filters.userId && log.userId !== filters.userId) return false
      if (filters.operation && log.operation !== filters.operation) return false
      if (filters.startTime && new Date(log.timestamp) < new Date(filters.startTime)) return false
      if (filters.endTime && new Date(log.timestamp) > new Date(filters.endTime)) return false
      if (filters.result && log.result !== filters.result) return false
      return true
    })
  }
  
  // 数据脱敏
  sanitizeData(data) {
    if (!data) return data
    
    const sanitized = { ...data }
    const sensitiveFields = ['password', 'token', 'secret', 'apiKey']
    
    for (const field of sensitiveFields) {
      if (sanitized[field]) {
        sanitized[field] = '******'
      }
    }
    
    return sanitized
  }
  
  // 持久化日志
  persistLog(entry) {
    // 实际实现：写入数据库或日志文件
    console.log('审计日志:', entry)
  }
  
  // 敏感操作告警
  alertSensitiveOperation(entry) {
    console.log('敏感操作告警:', {
      operation: entry.operation,
      user: entry.username,
      timestamp: entry.timestamp
    })
    
    // 发送告警通知
    this.sendAlert(entry)
  }
  
  // 发送告警
  sendAlert(entry) {
    // 实际实现：发送邮件、短信、钉钉等
  }
  
  // 生成日志ID
  generateId() {
    return `audit-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
  }
  
  // 审计中间件
  middleware() {
    return (req, res, next) => {
      const startTime = Date.now()
      
      // 拦截响应
      const originalSend = res.send
      res.send = function(data) {
        const duration = Date.now() - startTime
        
        // 记录日志
        auditLogger.log(`${req.method}:${req.path}`, {
          userId: req.user?.userId || 'anonymous',
          username: req.user?.username || 'anonymous',
          resource: req.path,
          action: req.method,
          result: res.statusCode < 400 ? 'success' : 'failed',
          ipAddress: req.ip,
          userAgent: req.get('user-agent'),
          requestData: req.body,
          responseData: typeof data === 'string' ? data.substring(0, 200) : data
        })
        
        originalSend.call(this, data)
      }
      
      next()
    }
  }
}

// 使用示例
const auditLogger = new AuditLogger()

// 应用审计中间件
app.use(auditLogger.middleware())

// 手动记录敏感操作
app.post('/admin/delete-user', (req, res) => {
  // 执行删除操作
  deleteUser(req.body.userId)
  
  // 记录审计日志
  auditLogger.log('user:delete', {
    userId: req.user.userId,
    username: req.user.username,
    resource: `/users/${req.body.userId}`,
    action: 'DELETE',
    result: 'success',
    ipAddress: req.ip,
    userAgent: req.get('user-agent'),
    requestData: { targetUserId: req.body.userId }
  })
  
  res.json({ message: '用户删除成功' })
})

软件安全三层面：

┌─────────────────────────────────┐
│  1. 操作系统安全                 │
│     - 病毒防护                   │
│     - 木马检测                   │
│     - 补丁管理                   │
│     - 恶意脚本防护               │
├─────────────────────────────────┤
│  2. 数据库安全                   │
│     - SQL 注入防护               │
│     - 推理攻击防护               │
│     - 访问控制                   │
│     - 数据加密                   │
├─────────────────────────────────┤
│  3. Web 应用安全                 │
│     - XSS 防护                   │
│     - CSRF 防护                  │
│     - 重放攻击防护               │
│     - 敏感信息泄露防护           │
└─────────────────────────────────┘

//  不安全的 SQL 查询（存在注入风险）
const unsafeQuery = (username) => {
  const sql = `SELECT * FROM users WHERE username = '${username}'`
  // 攻击输入: ' OR '1'='1
  // 实际执行的 SQL: SELECT * FROM users WHERE username = '' OR '1'='1'
  // 结果：返回所有用户数据
}

//  安全的参数化查询
const safeQuery = async (username) => {
  const sql = 'SELECT * FROM users WHERE username = ?'
  const results = await db.query(sql, [username])
  return results
}

// SQL 注入防护类
class SQLInjectionProtection {
  constructor() {
    // 危险关键字黑名单
    this.blacklist = [
      'SELECT', 'INSERT', 'UPDATE', 'DELETE', 'DROP', 'EXEC',
      'UNION', 'OR', 'AND', '--', ';', '/*', '*/'
    ]
    
    // 正则表达式检测
    this.patterns = [
      /(\b(SELECT|INSERT|UPDATE|DELETE|DROP|EXEC)\b)/gi,
      /(UNION.*SELECT)/gi,
      /('|\")\s*(OR|AND)\s*('|\")/gi,
      /(;|--)/g,
      /(\/\*|\*\/)/g
    ]
  }
  
  // 检测 SQL 注入
  detect(input) {
    const detections = []
    
    // 黑名单检测
    for (const keyword of this.blacklist) {
      if (input.toUpperCase().includes(keyword)) {
        detections.push({
          type: 'blacklist',
          keyword,
          position: input.toUpperCase().indexOf(keyword)
        })
      }
    }
    
    // 正则表达式检测
    for (const pattern of this.patterns) {
      const matches = input.match(pattern)
      if (matches) {
        detections.push({
          type: 'pattern',
          pattern: pattern.toString(),
          matches
        })
      }
    }
    
    return {
      safe: detections.length === 0,
      detections
    }
  }
  
  // 清理输入
  sanitize(input) {
    let sanitized = input
    
    // 转义特殊字符
    sanitized = sanitized.replace(/'/g, "''")
    sanitized = sanitized.replace(/"/g, '\\"')
    sanitized = sanitized.replace(/\\/g, '\\\\')
    
    // 移除危险字符
    sanitized = sanitized.replace(/;/g, '')
    sanitized = sanitized.replace(/--/g, '')
    sanitized = sanitized.replace(/\/\*/g, '')
    sanitized = sanitized.replace(/\*\//g, '')
    
    return sanitized
  }
  
  // 防护中间件
  middleware() {
    return (req, res, next) => {
      // 检查请求参数
      const checkInput = (obj) => {
        for (const key in obj) {
          if (typeof obj[key] === 'string') {
            const result = this.detect(obj[key])
            
            if (!result.safe) {
              return res.status(400).json({
                error: 'SQL Injection Detected',
                message: '检测到潜在的 SQL 注入攻击',
                field: key
              })
            }
            
            // 清理输入
            obj[key] = this.sanitize(obj[key])
          } else if (typeof obj[key] === 'object') {
            checkInput(obj[key])
          }
        }
      }
      
      checkInput(req.body)
      checkInput(req.query)
      checkInput(req.params)
      
      next()
    }
  }
}

// XSS 防护
class XSSProtection {
  constructor() {
    // XSS 攻击模式
    this.patterns = [
      /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
      /javascript:/gi,
      /on\w+\s*=/gi,  // onclick=, onload= 等
      /<iframe/gi,
      /<object/gi,
      /<embed/gi,
      /expression\(.*?\)/gi
    ]
  }
  
  // 检测 XSS
  detect(input) {
    for (const pattern of this.patterns) {
      if (pattern.test(input)) {
        return {
          safe: false,
          pattern: pattern.toString(),
          matched: input.match(pattern)
        }
      }
    }
    
    return { safe: true }
  }
  
  // 转义 HTML
  escapeHtml(input) {
    const htmlEntities = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#x27;',
      '/': '&#x2F;'
    }
    
    return String(input).replace(/[&<>"'\/]/g, char => htmlEntities[char])
  }
  
  // 移除危险标签
  stripTags(input) {
    return input
      .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
      .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
      .replace(/<object\b[^<]*(?:(?!<\/object>)<[^<]*)*<\/object>/gi, '')
      .replace(/<embed\b[^>]*>/gi, '')
      .replace(/on\w+\s*=\s*["'][^"']*["']/gi, '')  // 移除事件处理属性
  }
  
  // CSP (内容安全策略) 设置
  setCSP(res) {
    res.setHeader('Content-Security-Policy', [
      "default-src 'self'",
      "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.example.com",
      "style-src 'self' 'unsafe-inline' https://cdn.example.com",
      "img-src 'self' data: https:",
      "font-src 'self' https://cdn.example.com",
      "connect-src 'self' https://api.example.com",
      "frame-ancestors 'none'",
      "base-uri 'self'",
      "form-action 'self'"
    ].join('; '))
  }
  
  // XSS 防护中间件
  middleware() {
    return (req, res, next) => {
      // 设置安全头
      this.setCSP(res)
      // 注：X-XSS-Protection 已被现代浏览器废弃，仅作为老旧浏览器兜底，防护应以 CSP 与输出编码为主
      res.setHeader('X-XSS-Protection', '1; mode=block')
      res.setHeader('X-Content-Type-Options', 'nosniff')
      
      // 检查和清理输入
      const sanitizeInput = (obj) => {
        for (const key in obj) {
          if (typeof obj[key] === 'string') {
            const result = this.detect(obj[key])
            
            if (!result.safe) {
              console.warn(`XSS 检测: 字段 ${key}, 模式: ${result.pattern}`)
            }
            
            // 清理输入
            obj[key] = this.escapeHtml(obj[key])
          }
        }
      }
      
      sanitizeInput(req.body)
      sanitizeInput(req.query)
      
      next()
    }
  }
}

// 使用示例
const xssProtection = new XSSProtection()

app.use(xssProtection.middleware())

// 在输出时再次转义
app.get('/user/:id', (req, res) => {
  const user = getUser(req.params.id)
  
  // 转义输出
  const safeUser = {
    name: xssProtection.escapeHtml(user.name),
    bio: xssProtection.escapeHtml(user.bio)
  }
  
  res.json(safeUser)
})

// CSRF 防护
const crypto = require('crypto')

class CSRFProtection {
  constructor() {
    this.secret = 'csrf-secret-key'
    this.tokenExpiry = 3600000  // 1小时
  }
  
  // 生成 CSRF Token
  generateToken(sessionId) {
    const timestamp = Date.now()
    const data = `${sessionId}:${timestamp}`
    
    const hash = crypto
      .createHmac('sha256', this.secret)
      .update(data)
      .digest('hex')
    
    const token = Buffer.from(`${data}:${hash}`).toString('base64')
    
    return {
      token,
      expiresAt: timestamp + this.tokenExpiry
    }
  }
  
  // 验证 CSRF Token
  verifyToken(token, sessionId) {
    try {
      const decoded = Buffer.from(token, 'base64').toString('utf8')
      const [tokenSessionId, timestamp, hash] = decoded.split(':')
      
      // 验证会话ID
      if (tokenSessionId !== sessionId) {
        return { valid: false, reason: '会话ID不匹配' }
      }
      
      // 验证时间戳
      if (Date.now() > parseInt(timestamp) + this.tokenExpiry) {
        return { valid: false, reason: 'Token 已过期' }
      }
      
      // 验证签名
      const data = `${tokenSessionId}:${timestamp}`
      const expectedHash = crypto
        .createHmac('sha256', this.secret)
        .update(data)
        .digest('hex')
      
      if (hash !== expectedHash) {
        return { valid: false, reason: '签名验证失败' }
      }
      
      return { valid: true }
    } catch (error) {
      return { valid: false, reason: 'Token 格式错误' }
    }
  }
  
  // CSRF 防护中间件
  middleware() {
    return (req, res, next) => {
      // 只检查修改操作
      const unsafeMethods = ['POST', 'PUT', 'DELETE', 'PATCH']
      
      if (unsafeMethods.includes(req.method)) {
        const token = req.body._csrf || 
                      req.get('X-CSRF-Token') ||
                      req.query._csrf
        
        const sessionId = req.session.id
        
        if (!token) {
          return res.status(403).json({
            error: 'CSRF Token Missing',
            message: '缺少 CSRF Token'
          })
        }
        
        const result = this.verifyToken(token, sessionId)
        
        if (!result.valid) {
          return res.status(403).json({
            error: 'CSRF Token Invalid',
            message: result.reason
          })
        }
      }
      
      next()
    }
  }
  
  // 生成 Token 路由
  tokenRoute() {
    return (req, res) => {
      const sessionId = req.session.id
      const { token, expiresAt } = this.generateToken(sessionId)
      
      res.json({
        csrfToken: token,
        expiresAt: new Date(expiresAt).toISOString()
      })
    }
  }
}

// 使用示例
const csrf = new CSRFProtection()

// 获取 CSRF Token
app.get('/api/csrf-token', csrf.tokenRoute())

// 应用 CSRF 防护
app.use(csrf.middleware())

// 受保护的路由
app.post('/api/update-profile', (req, res) => {
  // CSRF 验证通过
  res.json({ message: '更新成功' })
})

// 安全编码清单
const securityBestPractices = {
  // 输入验证
  inputValidation: [
    ' 验证所有用户输入',
    ' 使用白名单而非黑名单',
    ' 验证数据类型、长度、格式',
    ' 对文件上传进行严格限制'
  ],
  
  // 输出编码
  outputEncoding: [
    ' 对输出进行 HTML 编码',
    ' 对 URL 参数进行编码',
    ' 对 JavaScript 数据进行编码',
    ' 设置正确的 Content-Type'
  ],
  
  // 身份认证
  authentication: [
    ' 使用强密码策略',
    ' 实施多因素认证',
    ' 限制登录尝试次数',
    ' 使用安全的密码存储（bcrypt）'
  ],
  
  // 会话管理
  sessionManagement: [
    ' 使用安全的 Session ID',
    ' 设置 Cookie 的 HttpOnly 和 Secure 标志',
    ' 实施会话超时',
    ' 登出时销毁会话'
  ],
  
  // 访问控制
  accessControl: [
    ' 实施最小权限原则',
    ' 验证每个请求的权限',
    ' 避免直接对象引用',
    ' 记录访问日志'
  ],
  
  // 错误处理
  errorHandling: [
    ' 不向用户暴露敏感错误信息',
    ' 记录详细的错误日志',
    ' 使用统一的错误处理',
    ' 配置自定义错误页面'
  ]
}

// 设置安全响应头
const securityHeaders = (req, res, next) => {
  // 防止点击劫持
  res.setHeader('X-Frame-Options', 'DENY')
  
  // XSS 保护（该响应头已废弃，防护以 CSP 与输出编码为主，此处仅兼容老旧浏览器）
  res.setHeader('X-XSS-Protection', '1; mode=block')
  
  // 防止 MIME 类型嗅探
  res.setHeader('X-Content-Type-Options', 'nosniff')
  
  // HTTPS 强制
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains')
  
  // CSP
  res.setHeader('Content-Security-Policy', [
    "default-src 'self'",
    "script-src 'self'",
    "style-src 'self' 'unsafe-inline'"
  ].join('; '))
  
  // Referrer 策略
  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin')
  
  // 权限策略
  res.setHeader('Permissions-Policy', [
    'geolocation=()',
    'microphone=()',
    'camera=()'
  ].join(', '))
  
  next()
}

// 应用安全头
app.use(securityHeaders)