𝑻𝒆𝒏𝑪𝒍𝒂𝒘正在头脑风暴···
𝑻𝒆𝒏𝑲𝒊𝑺𝒆𝒀𝒂の𝑨𝒈𝒆𝒏𝒕助手
𝑻𝒆𝒏-𝒇𝒍𝒂𝒔𝒉

Web安全防护完全指南

还记得我第一次遭遇XSS攻击时的惊慌，用户的个人信息在眼皮底下被窃取，那种无力感至今记忆犹新。从那以后，我下定决心要深入学习Web安全防护。今天，我想把这些年的经验分享给大家，帮助大家构建更安全的Web应用。

一、Web安全概述

为什么Web安全很重要？

Web安全就像是网站的门锁和保安。一个不安全的网站就像一个没有上锁的房子，黑客可以轻易进入，窃取你的数据、破坏你的系统，甚至利用你的服务器攻击其他网站。

// 不安全的代码 - 容易遭受XSS攻击
function displayUserInput(input) {
  document.getElementById('output').innerHTML = input
}

// 用户输入：<script>alert('XSS攻击')</script>
// 这段代码会直接被执行，可能导致恶意脚本执行

主要威胁类型

  1. 客户端攻击：XSS、CSRF、点击劫持
  2. 服务器端攻击：SQL注入、文件上传漏洞、命令注入
  3. 网络攻击：中间人攻击、DDoS攻击
  4. 业务逻辑攻击：越权访问、支付漏洞

安全防护的分层思想

graph TD
    A[用户输入] --> B[输入验证]
    B --> C[参数编码]
    C --> D[输出转义]
    D --> E[安全配置]
    E --> F[监控审计]

二、客户端安全

XSS（跨站脚本攻击）

原理和危害

XSS是最常见的Web安全漏洞之一。攻击者通过在网页中注入恶意脚本，当其他用户访问该页面时，恶意脚本会在用户的浏览器中执行。

<!-- 危险示例 -->
<div id="userComment">
  用户评论：<script>alert('XSS攻击')</script>
</div>

<!-- 安全示例 -->
<div id="userComment">
  用户评论：&lt;script&gt;alert('XSS攻击')&lt;/script&gt;
</div>

防护措施

// 1. 输入验证
function sanitizeInput(input) {
  // 移除或转义特殊字符
  return input
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;')
}

// 2. 输出转义
function escapeHtml(unsafe) {
  return unsafe
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;')
}

// 3. 使用安全的DOM操作
function createSafeElement(content) {
  const temp = document.createElement('div')
  temp.textContent = content  // 自动转义HTML
  return temp
}

React中的XSS防护

// ✅ 安全的React组件
function SafeComponent({ content }) {
  // React默认会转义内容，所以是安全的
  return <div>{content}</div>
}

// 危险的React组件
function UnsafeComponent({ content }) {
  // 直接使用dangerouslySetInnerHTML非常危险
  return <div dangerouslySetInnerHTML={{ __html: content }} />
}

CSRF（跨站请求伪造）

原理和危害

CSRF攻击利用用户已登录的身份，在不知情的情况下执行恶意操作。

// 危险的API端点
// 没有验证用户意图的转账接口
function transferMoney(req, res) {
  const { to, amount } = req.body
  // 直接执行转账，没有验证来源
  res.json({ success: true, message: `转账${amount}元到${to}` })
}

// 攻击者构造的恶意页面
// <img src="http://bank.com/transfer?to=hacker&amount=10000" onerror="alert('转账成功')">

防护措施

// 1. CSRF Token
const csrf = require('csurf')
const csrfProtection = csrf({ cookie: true })

// 在表单中添加CSRF Token
function generateCSRFToken() {
  return crypto.randomBytes(32).toString('hex')
}

// 2. SameSite Cookie
app.use(cookieSession({
  secret: 'your-secret',
  cookie: {
    secure: true,
    httpOnly: true,
    sameSite: 'strict'
  }
}))

// 3. 验证Referer和Origin
function checkReferer(req, res, next) {
  const referer = req.get('referer')
  const allowedDomains = ['https://yourdomain.com', 'https://www.yourdomain.com']
  
  if (!allowedDomains.some(domain => referer?.startsWith(domain))) {
    return res.status(403).json({ error: 'Invalid referer' })
  }
  
  next()
}

点击劫持（Clickjacking）

原理和危害

攻击者通过透明的iframe覆盖在目标网站之上，诱导用户点击隐藏的恶意按钮。

<!-- 恶意页面 -->
<style>
  iframe {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    opacity: 0.01;
    z-index: 2;
  }
  
  button {
    position: absolute;
    top: 100px;
    left: 50px;
    z-index: 1;
  }
</style>

<iframe src="https://target-site.com"></iframe>
<button onclick="alert('被点击了！')">点击我获取优惠券</button>

防护措施

<!-- 1. X-Frame-Options -->
<meta http-equiv="X-Frame-Options" content="DENY">

<!-- 2. CSP Frame-ancestors -->
<meta http-equiv="Content-Security-Policy" content="frame-ancestors 'none'">

<!-- 3. JavaScript检测 -->
<script>
  if (window.top !== window.self) {
    // 如果页面在iframe中，重定向或警告
    window.top.location.href = window.location.href
  }
</script>

三、服务器端安全

SQL注入防护

原理和危害

攻击者通过构造恶意的SQL语句，获取或修改数据库中的数据。

// 危险的查询 - 容易遭受SQL注入
function getUser(username) {
  const query = `SELECT * FROM users WHERE username = '${username}'`
  // 如果 username 是 'admin' OR '1'='1'，就会返回所有用户
}

// 安全的查询 - 使用参数化查询
function getUserSafe(username) {
  const query = 'SELECT * FROM users WHERE username = ?'
  const params = [username]
  // 使用参数化查询，输入会被正确转义
}

防护措施

// 1. 使用ORM（推荐）
const { Sequelize } = require('sequelize')

const sequelize = new Sequelize('database', 'username', 'password', {
  dialect: 'mysql'
})

// ORM会自动处理SQL注入防护
User.findOne({ where: { username: req.body.username } })

// 2. 参数化查询
const mysql = require('mysql2/promise')

async function getUser(username) {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'password',
    database: 'mydb'
  })
  
  const [rows] = await connection.execute(
    'SELECT * FROM users WHERE username = ?',
    [username]
  )
  
  return rows
}

// 3. 输入验证
function validateInput(input) {
  // 只允许字母、数字和下划线
  if (!/^[a-zA-Z0-9_]+$/.test(input)) {
    throw new Error('Invalid input')
  }
  return input
}

文件上传安全

原理和危害

不安全的文件上传可能导致任意代码执行、服务器被控制等严重问题。

// 危险的文件上传
app.post('/upload', (req, res) => {
  const file = req.files.file
  const filename = file.name
  const uploadPath = `./uploads/${filename}`
  
  // 没有验证文件类型
  file.mv(uploadPath, (err) => {
    if (err) return res.status(500).send(err)
    res.send('File uploaded successfully')
  })
})

防护措施

// 1. 文件类型验证
const multer = require('multer')
const path = require('path')

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/')
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9)
    cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname))
  }
})

const fileFilter = (req, file, cb) => {
  // 只允许图片文件
  const allowedTypes = ['image/jpeg', 'image/png', 'image/gif']
  
  if (allowedTypes.includes(file.mimetype)) {
    cb(null, true)
  } else {
    cb(new Error('Invalid file type'), false)
  }
}

const upload = multer({
  storage: storage,
  fileFilter: fileFilter,
  limits: {
    fileSize: 5 * 1024 * 1024 // 5MB限制
  }
})

// 2. 文件名随机化
function generateSecureFilename(originalName) {
  const ext = path.extname(originalName)
  const random = crypto.randomBytes(8).toString('hex')
  return `${random}${ext}`
}

// 3. 隔离上传目录
app.post('/upload', upload.single('file'), (req, res) => {
  if (!req.file) {
    return res.status(400).send('No file uploaded')
  }
  
  // 文件存储在隔离目录
  const filePath = `/safe/uploads/${req.file.filename}`
  res.json({ message: 'File uploaded', path: filePath })
})

身份认证安全

弱密码问题

// 不安全的密码存储
const users = {
  'admin': '123456', // 明文存储
  'user': 'password' // 弱密码
}

// 安全的密码存储
const bcrypt = require('bcrypt')

async function hashPassword(password) {
  const saltRounds = 10
  const salt = await bcrypt.genSalt(saltRounds)
  return await bcrypt.hash(password, salt)
}

async function verifyPassword(password, hashedPassword) {
  return await bcrypt.compare(password, hashedPassword)
}

防护措施

// 1. 强密码策略
const passwordValidator = require('password-validator')

const schema = new passwordValidator()
schema
  .is().min(8)
  .has().uppercase()
  .has().lowercase()
  .has().digits()
  .has().symbols()
  .has().not().spaces()

function validatePassword(password) {
  return schema.validate(password)
}

// 2. 登录限制
const rateLimit = require('express-rate-limit')

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分钟
  max: 5, // 最多5次尝试
  message: 'Too many login attempts, please try again later'
})

// 3. 多因素认证
const speakeasy = require('speakeasy')

function generate2FASecret(user) {
  const secret = speakeasy.generateSecret({
    name: `YourApp (${user.email})`,
    issuer: 'YourApp'
  })
  
  return secret
}

function verify2FA(token, secret) {
  return speakeasy.totp.verify({
    secret: secret.base32,
    encoding: 'base32',
    token: token
  })
}

四、网络安全防护

HTTPS和TLS

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

const options = {
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.crt')
}

const server = https.createServer(options, (req, res) => {
  res.writeHead(200)
  res.end('Hello, secure world!')
})

server.listen(443)

// HSTS（HTTP Strict Transport Security）
const helmet = require('helmet')

app.use(helmet.hsts({
  maxAge: 31536000,
  includeSubDomains: true,
  preload: true
}))

安全头部设置

// helmet中间件
const helmet = require('helmet')

app.use(helmet())

// 1. XSS防护
app.use(helmet.xssFilter())

// 2. 点击劫持防护
app.use(helmet.frameguard({ action: 'deny' }))

// 3. MIME类型嗅探防护
app.use(helmet.noSniff())

// 4. 禁用服务器信息
app.disable('x-powered-by')

// 5. CSP（内容安全策略）
app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    styleSrc: ["'self'", "'unsafe-inline'"],
    scriptSrc: ["'self'"],
    imgSrc: ["'self'", "data:", "https:"],
    frameSrc: ["'self'"]
  }
}))

输入验证和输出编码

// 输入验证
const { body, validationResult } = require('express-validator')

app.post('/register', [
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }),
  body('username').isAlphanumeric().withMessage('Username must be alphanumeric')
], (req, res) => {
  const errors = validationResult(req)
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() })
  }
  
  // 处理注册逻辑
})

// 输出编码
const sanitizeHtml = require('sanitize-html')

function sanitizeUserContent(content) {
  return sanitizeHtml(content, {
    allowedTags: ['h1', 'h2', 'p', 'strong', 'em', 'ul', 'ol', 'li', 'a'],
    allowedAttributes: {
      'a': ['href', 'title']
    }
  })
}

五、安全监控和审计

日志记录

// Winston日志配置
const winston = require('winston')

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

// 记录安全事件
function logSecurityEvent(event) {
  logger.warn({
    type: 'security_event',
    timestamp: new Date().toISOString(),
    event: event,
    ip: req.ip,
    userAgent: req.get('User-Agent')
  })
}

// 记录认证失败
app.post('/login', (req, res) => {
  const { username, password } = req.body
  
  // 模拟验证
  if (username !== 'admin' || password !== 'password') {
    logSecurityEvent({
      action: 'login_failed',
      username: username
    })
    return res.status(401).json({ error: 'Invalid credentials' })
  }
  
  // 登录成功
  logSecurityEvent({
    action: 'login_success',
    username: username
  })
  
  res.json({ success: true })
})

入侵检测

// 监控异常请求模式
const request = require('request-promise-native')

class IDS {
  constructor() {
    this.suspiciousIPs = new Set()
    this.blockedIPs = new Set()
  }

  async checkIP(ip) {
    // 检查IP是否在黑名单中
    if (this.blockedIPs.has(ip)) {
      throw new Error('IP blocked')
    }

    // 调用外部威胁情报API
    try {
      const response = await request({
        uri: `https://api.abuseipdb.com/api/v2/check`,
        method: 'GET',
        qs: {
          maxResults: '10',
          verbose: 'true',
          ip: ip
        },
        headers: {
          'Key': 'YOUR_API_KEY',
          'Accept': 'application/json'
        },
        json: true
      })

      if (response.data.abuseConfidenceScore > 50) {
        this.suspiciousIPs.add(ip)
        return true
      }
    } catch (error) {
      console.error('IDS check failed:', error)
    }

    return false
  }

  async monitorRequest(req, res, next) {
    const ip = req.ip

    try {
      const isSuspicious = await this.checkIP(ip)
      
      if (isSuspicious) {
        logSecurityEvent({
          action: 'suspicious_request',
          ip: ip,
          path: req.path,
          userAgent: req.get('User-Agent')
        })
        
        // 临时封禁可疑IP
        this.blockedIPs.add(ip)
        setTimeout(() => this.blockedIPs.delete(ip), 3600000) // 1小时后解封
        
        return res.status(403).json({ error: 'Access denied' })
      }

      next()
    } catch (error) {
      logSecurityEvent({
        action: 'ids_error',
        ip: ip,
        error: error.message
      })
      next()
    }
  }
}

// 使用IDS中间件
const ids = new IDS()
app.use(ids.monitorRequest.bind(ids))

安全扫描工具

// 定期安全扫描
const { exec } = require('child_process')

function runSecurityScan() {
  // 1. 依赖漏洞扫描
  exec('npm audit --audit-level moderate', (error, stdout, stderr) => {
    if (error) {
      console.error('Dependency scan failed:', stderr)
      return
    }
    console.log('Dependency scan results:', stdout)
  })

  // 2. 代码扫描（使用ESLint安全规则）
  exec('eslint src --rule "security/detect-object-injection: error"', (error, stdout, stderr) => {
    if (error) {
      console.error('Code scan failed:', stderr)
      return
    }
    console.log('Code scan results:', stdout)
  })

  // 3. 配置检查
  checkSecurityConfig()
}

function checkSecurityConfig() {
  const fs = require('fs')
  const path = require('path')

  // 检查敏感信息是否在代码中
  const files = ['src', 'config'].map(dir => fs.readdirSync(dir, { recursive: true }))
  
  files.forEach(fileList => {
    fileList.forEach(file => {
      const filePath = Array.isArray(file) ? file.join('/') : file
      const content = fs.readFileSync(filePath, 'utf8')
      
      // 检查API密钥
      const apiKeyPattern = /api[_-]?key|secret|password/i
      if (apiKeyPattern.test(content)) {
        console.warn(`Potential secret found in ${filePath}`)
      }
    })
  })
}

// 定期执行
setInterval(runSecurityScan, 24 * 60 * 60 * 1000) // 每天扫描一次

六、安全测试

自动化安全测试

// Jest安全测试示例
describe('Security Tests', () => {
  test('should prevent SQL injection', () => {
    const input = "admin' OR '1'='1"
    const query = `SELECT * FROM users WHERE username = '${input}'`
    
    // 这个测试应该失败，因为代码存在SQL注入漏洞
    expect(query).not.toContain("' OR '1'='1'")
  })

  test('should validate input', () => {
    const validateEmail = (email) => {
      const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
      return re.test(email)
    }

    expect(validateEmail('test@example.com')).toBe(true)
    expect(validateEmail('invalid-email')).toBe(false)
  })

  test('should escape output', () => {
    const escapeHtml = (str) => {
      return str
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
    }

    const maliciousInput = '<script>alert("XSS")</script>'
    const escaped = escapeHtml(maliciousInput)
    
    expect(escaped).not.toContain('<script>')
    expect(escaped).toContain('&lt;script&gt;')
  })
})

渗透测试清单

## Web应用渗透测试清单

### 1. 认证测试
- [ ] 弱密码测试
- [ ] 会话管理测试
- [ ] 密码重置功能测试
- [ ] 多因素认证测试

### 2. 授权测试
- [ ] 水平越权测试
- [ ] 垂直越权测试
- [ ] 访问控制测试
- [ ] API权限测试

### 3. 数据验证测试
- [ ] 输入验证测试
- [ ] 输出编码测试
- [ ] 文件上传测试
- [ ] 文件包含测试

### 4. 业务逻辑测试
- [ ] 支付流程测试
- [ ] 表单篡改测试
- [ ] 并发操作测试
- [ ] 业务规则绕过测试

### 5. 网络层测试
- [ ] HTTPS配置测试
- [ ] 安全头测试
- [ ] CORS配置测试
- [ ] CSRF保护测试

七、实际应用案例

案例：安全的用户注册系统

// models/User.js
const bcrypt = require('bcrypt')
const { ValidationError } = require('./errors')

const SALT_ROUNDS = 10

class User {
  constructor(data) {
    this.username = data.username
    this.email = data.email
    this.password = data.password
    this.createdAt = new Date()
  }

  async setPassword(password) {
    if (!this.validatePassword(password)) {
      throw new ValidationError('Password does not meet requirements')
    }
    
    this.password = await bcrypt.hash(password, SALT_ROUNDS)
  }

  validatePassword(password) {
    // 密码复杂度检查
    const minLength = 8
    const hasUppercase = /[A-Z]/.test(password)
    const hasLowercase = /[a-z]/.test(password)
    const hasNumbers = /\d/.test(password)
    const hasSpecial = /[!@#$%^&*]/.test(password)

    return password.length >= minLength &&
           hasUppercase &&
           hasLowercase &&
           hasNumbers &&
           hasSpecial
  }

  async comparePassword(password) {
    return await bcrypt.compare(password, this.password)
  }

  toJSON() {
    // 移除敏感信息
    const { password, ...userWithoutPassword } = this
    return userWithoutPassword
  }
}

module.exports = User
// controllers/authController.js
const User = require('../models/User')
const { ValidationError, AuthenticationError } = require('../errors')
const { generateToken } = require('../utils/auth')

class AuthController {
  async register(req, res) {
    try {
      const { username, email, password } = req.body

      // 输入验证
      if (!username || !email || !password) {
        throw new ValidationError('All fields are required')
      }

      // 检查用户是否已存在
      const existingUser = await User.findOne({ 
        $or: [{ username }, { email }] 
      })

      if (existingUser) {
        throw new ValidationError('Username or email already exists')
      }

      // 创建用户
      const user = new User({ username, email })
      await user.setPassword(password)
      await user.save()

      // 生成token
      const token = generateToken(user)

      res.status(201).json({
        success: true,
        message: 'User registered successfully',
        token,
        user: user.toJSON()
      })
    } catch (error) {
      if (error instanceof ValidationError) {
        return res.status(400).json({ error: error.message })
      }
      
      console.error('Registration error:', error)
      res.status(500).json({ error: 'Internal server error' })
    }
  }

  async login(req, res) {
    try {
      const { username, password } = req.body

      if (!username || !password) {
        throw new ValidationError('Username and password are required')
      }

      // 查找用户
      const user = await User.findOne({ username })
      if (!user) {
        throw new AuthenticationError('Invalid credentials')
      }

      // 验证密码
      const isPasswordValid = await user.comparePassword(password)
      if (!isPasswordValid) {
        throw new AuthenticationError('Invalid credentials')
      }

      // 记录登录事件
      console.log(`User logged in: ${username}`)

      // 生成token
      const token = generateToken(user)

      res.json({
        success: true,
        message: 'Login successful',
        token,
        user: user.toJSON()
      })
    } catch (error) {
      if (error instanceof ValidationError || error instanceof AuthenticationError) {
        return res.status(401).json({ error: error.message })
      }
      
      console.error('Login error:', error)
      res.status(500).json({ error: 'Internal server error' })
    }
  }
}

module.exports = new AuthController()

案例：安全的文件上传系统

// middleware/upload.js
const multer = require('multer')
const path = require('path')
const crypto = require('crypto')

// 配置存储
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    // 创建安全目录
    const uploadDir = 'uploads'
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true })
    }
    cb(null, uploadDir)
  },
  filename: function (req, file, cb) {
    // 生成随机文件名
    const randomBytes = crypto.randomBytes(16)
    const fileName = randomBytes.toString('hex') + path.extname(file.originalname)
    cb(null, fileName)
  }
})

// 文件过滤器
const fileFilter = (req, file, cb) => {
  // 允许的文件类型
  const allowedTypes = [
    'image/jpeg',
    'image/png',
    'image/gif',
    'application/pdf',
    'text/plain'
  ]

  if (allowedTypes.includes(file.mimetype)) {
    cb(null, true)
  } else {
    cb(new Error('Invalid file type'), false)
  }
}

// 创建multer实例
const upload = multer({
  storage: storage,
  fileFilter: fileFilter,
  limits: {
    fileSize: 10 * 1024 * 1024, // 10MB
    files: 5 // 最多5个文件
  }
})

// 验证文件内容（防止文件类型伪造）
const validateFileContent = async (file) => {
  const fs = require('fs')
  const fileType = require('file-type')

  const buffer = fs.readFileSync(file.path)
  const type = await fileType.fromBuffer(buffer)

  // 验证实际文件类型与声明类型是否匹配
  if (type && type.mime !== file.mimetype) {
    throw new Error('File type mismatch')
  }

  return true
}

module.exports = { upload, validateFileContent }
// controllers/uploadController.js
const fs = require('fs')
const path = require('path')
const { validateFileContent } = require('../middleware/upload')
const { ValidationError } = require('../errors')

class UploadController {
  async uploadSingle(req, res) {
    try {
      if (!req.file) {
        throw new ValidationError('No file uploaded')
      }

      // 验证文件内容
      await validateFileContent(req.file)

      const fileUrl = `/uploads/${req.file.filename}`
      
      res.json({
        success: true,
        message: 'File uploaded successfully',
        file: {
          originalName: req.file.originalname,
          filename: req.file.filename,
          path: fileUrl,
          size: req.file.size,
          mimetype: req.file.mimetype
        }
      })
    } catch (error) {
      // 删除上传的文件
      if (req.file && fs.existsSync(req.file.path)) {
        fs.unlinkSync(req.file.path)
      }

      if (error instanceof ValidationError) {
        return res.status(400).json({ error: error.message })
      }

      console.error('Upload error:', error)
      res.status(500).json({ error: 'Internal server error' })
    }
  }

  async download(req, res) {
    try {
      const { filename } = req.params
      
      // 安全检查：防止路径遍历攻击
      const safeFilename = path.basename(filename)
      const filePath = path.join('uploads', safeFilename)

      if (!fs.existsSync(filePath)) {
        throw new ValidationError('File not found')
      }

      // 设置下载头
      res.download(filePath, safeFilename, (err) => {
        if (err) {
          console.error('Download error:', err)
        }
      })
    } catch (error) {
      if (error instanceof ValidationError) {
        return res.status(404).json({ error: error.message })
      }

      console.error('Download error:', error)
      res.status(500).json({ error: 'Internal server error' })
    }
  }

  async delete(req, res) {
    try {
      const { filename } = req.params
      
      // 安全检查：防止路径遍历攻击
      const safeFilename = path.basename(filename)
      const filePath = path.join('uploads', safeFilename)

      if (!fs.existsSync(filePath)) {
        throw new ValidationError('File not found')
      }

      fs.unlinkSync(filePath)

      res.json({
        success: true,
        message: 'File deleted successfully'
      })
    } catch (error) {
      if (error instanceof ValidationError) {
        return res.status(404).json({ error: error.message })
      }

      console.error('Delete error:', error)
      res.status(500).json({ error: 'Internal server error' })
    }
  }
}

module.exports = new UploadController()

八、总结与最佳实践

安全防护的核心原则

  1. 深度防御：不要依赖单一的安全措施，采用多层防护
  2. 最小权限：每个组件只拥有完成其功能所需的最小权限
  3. 白名单优于黑名单：明确允许什么，而不是禁止什么
  4. 安全默认原则：默认情况下应该是最安全的配置

开发中的安全实践

// 安全开发检查清单
/*
✓ 输入验证和净化
✓ 输出编码和转义
✓ 参数化查询
✓ 认证和授权
✓ 会话管理
✓ 密码安全
✓ 文件上传安全
✓ 错误处理
✓ 日志记录
✓ 定期安全测试
✓ 依赖库安全
✓ 配置安全
✓ 网络安全
✓ 数据保护
*/

// 安全开发工具推荐
/*
1. 代码扫描：SonarQube, ESLint插件, Semgrep
2. 依赖检查：Snyk, Dependabot, npm audit
3. 渗透测试：OWASP ZAP, Burp Suite, Metasploit
4. 监控工具：ELK Stack, Prometheus, Grafana
*/

持续改进

Web安全是一个持续的过程，需要不断学习和改进：

  1. 定期更新：及时更新依赖库和安全补丁
  2. 安全培训：团队成员需要接受安全意识培训
  3. 代码审查：进行严格的安全代码审查
  4. 漏洞奖励：建立漏洞奖励计划，鼓励发现安全问题

记住，安全不是一次性的任务，而是整个开发生命周期中需要持续关注的重要环节。建立一个安全的文化，让安全意识融入到每个开发决策中。

如果你在实际应用中遇到任何安全问题，欢迎在评论区留言交流。祝大家开发顺利，系统安全！🔒

最后更新：2026年5月14日
分类：Web安全 | 网络安全 | 前端安全 | 后端安全 | 防护措施