Cursor 安全插件链：构建实时 SAST/DAST 辅助分析工作流

Cursor 安全插件链：构建实时 SAST/DAST 辅助分析工作流

目录

• 摘要
• 一、开发安全左移核心理念与 Cursor 集成价值
  • 1.1 什么是"安全左移"
  • 1.2 SAST 与 DAST 基础概念
  • 1.3 Cursor IDE 在安全工作流中的定位
  • 1.4 集成价值与预期收益
• 二、基础环境搭建与必要安全插件安装
  • 2.1 开发环境准备
    • 2.1.1 操作系统要求
    • 2.1.2 Cursor IDE 安装与基础配置
    • 2.1.3 Node.js / Python 运行时环境
  • 2.2 核心安全插件安装
    • 2.2.1 Semgrep 插件安装与配置
    • 2.2.2 SonarLint 插件集成
    • 2.2.3 ESLint Security 插件
    • 2.2.4 Bandit（Python 安全扫描）
    • 2.2.5 OWASP ZAP 辅助工具
  • 2.3 插件链依赖关系与版本兼容性
• 三、配置自定义规则实现静态代码审计自动化
  • 3.1 Semgrep 规则文件结构详解
  • 3.2 编写第一条自定义 SAST 规则
    • 3.2.1 规则语法基础
    • 3.2.2 模式匹配与元变量
    • 3.2.3 规则严重等级定义
  • 3.3 多语言规则配置
    • 3.3.1 JavaScript/TypeScript 规则
    • 3.3.2 Python 规则
    • 3.3.3 Java 规则
  • 3.4 Cursor 中自动化触发配置
  • 3.5 规则测试与验证
• 四、构建动态交互测试流程辅助运行时检测
  • 4.1 DAST 基础原理与适用场景
  • 4.2 OWASP ZAP 本地代理配置
  • 4.3 Cursor 终端集成动态扫描
  • 4.4 API 端点自动化探测
  • 4.5 运行时漏洞报告解析
• 五、编写提示词引导 AI 识别常见漏洞模式
  • 5.1 Cursor AI 安全审查提示词设计原则
  • 5.2 SQL 注入识别提示词模板
  • 5.3 XSS 漏洞检测提示词模板
  • 5.4 认证与授权缺陷检测
  • 5.5 敏感信息泄露检测
  • 5.6 提示词链组合策略
• 六、实战演练：从代码编写到风险修复闭环
  • 6.1 项目初始化与场景设定
  • 6.2 编写含漏洞的示例代码
  • 6.3 SAST 扫描触发与结果分析
  • 6.4 AI 辅助漏洞解读
  • 6.5 修复代码编写与验证
  • 6.6 回归扫描确认修复有效
• 七、误报率优化策略与审计结果精准度提升
  • 7.1 误报产生的常见原因
  • 7.2 规则精细化调优
  • 7.3 上下文感知过滤
  • 7.4 白名单与抑制机制
  • 7.5 持续反馈循环建立
• 八、团队协作规范与安全检查流程标准化
  • 8.1 安全编码规范文档化
  • 8.2 Git Hooks 集成安全扫描
  • 8.3 Code Review 安全检查清单
  • 8.4 安全事件响应流程
  • 8.5 团队安全培训与知识共享
• 九、典型报错分析与插件链运行故障排查
  • 9.1 插件安装失败排查
  • 9.2 规则解析错误
  • 9.3 扫描超时与性能问题
  • 9.4 AI 提示词无响应处理
  • 9.5 网络代理与证书问题
  • 9.6 版本冲突解决
• 十、进阶技巧：扩展私有规则库与持续集成对接
  • 10.1 企业私有规则库搭建
  • 10.2 CI/CD 管道集成
  • 10.3 安全报告自动生成
  • 10.4 与漏洞管理平台对接
  • 10.5 自定义仪表盘与度量
• 常见陷阱与问题排除
• 总结
• 详细参考资料
• 附录
  • 附录 A：完整规则文件模板
  • 附录 B：提示词速查表
  • 附录 C：故障排查决策树
  • 附录 D：推荐学习资源

摘要

在软件安全领域，“安全左移”（Shift-Left Security）已成为现代开发团队的核心实践理念。其核心思想是将安全检测从传统的上线前测试阶段，前移至代码编写阶段，从而在漏洞产生的第一时间发现并修复，大幅降低修复成本与安全风险。

Cursor 作为新一代 AI 驱动的代码编辑器，凭借其强大的 AI 辅助能力、丰富的插件生态以及高度可定制的扩展机制，为构建"编码即安全"的开发工作流提供了理想平台。本文将手把手带你从零开始，在 Cursor 中搭建一套完整的 SAST（静态应用安全测试）与 DAST（动态应用安全测试）辅助分析工作流。

本教程涵盖环境搭建、插件安装配置、自定义安全规则编写、AI 提示词工程、实战漏洞修复演练、误报优化、团队协作规范、故障排查以及 CI/CD 集成等十大主题。无论你是刚接触安全开发的新手，还是希望提升团队安全实践水平的技术负责人，都能从本文中获得可直接落地的操作指南。

适用读者：前端/后端开发工程师、安全工程师、DevSecOps 从业者、技术团队负责人

前置要求：基本的编程经验（熟悉至少一门编程语言）、了解基本的 Web 安全概念

预计阅读与实践时间：完整阅读约 2-3 小时，动手实践约 1-2 天

一、开发安全左移核心理念与 Cursor 集成价值

1.1 什么是"安全左移"

“安全左移”（Shift-Left Security）是软件工程中的一个重要理念，其名称来源于将软件开发生命周期（SDLC）画成一条从左到右的时间轴：

需求分析 → 设计 → 编码 → 测试 → 部署 → 运维
←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←
传统安全检测位置（右侧）
→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→
安全左移后的检测位置（左侧）

传统模式的问题：

在传统开发流程中，安全测试通常在开发完成后的 QA 阶段或上线前进行。这意味着：

• 漏洞发现时，相关代码可能已经与其他模块深度耦合
• 修复一个早期引入的漏洞，可能需要修改大量后续代码
• 修复成本随时间呈指数级增长（IBM 研究显示，生产环境修复成本是设计阶段的 100 倍）
• 安全团队与开发团队之间存在信息断层

安全左移的核心实践：

1.2 SAST 与 DAST 基础概念

SAST（Static Application Security Testing，静态应用安全测试）

SAST 是一种在不运行程序的情况下，通过分析源代码、字节码或二进制文件来发现安全漏洞的技术。

工作原理：

源代码 → 词法分析 → 语法分析 → 构建 AST/数据流图 → 模式匹配/污点追踪 → 报告漏洞

核心能力：

• 模式匹配：检测已知危险函数调用（如 eval()、exec()）
• 数据流分析：追踪用户输入从入口到危险函数的传播路径
• 控制流分析：检查条件分支是否覆盖所有安全场景
• 污点追踪：标记不可信数据，监控其是否未经净化就进入敏感操作

优势：

• 无需运行程序，编码阶段即可检测
• 覆盖率高，可扫描所有代码路径
• 能精确定位到具体代码行

局限：

• 存在误报（将安全代码标记为漏洞）
• 无法检测运行时才暴露的问题
• 对动态语言支持有限

DAST（Dynamic Application Security Testing，动态应用安全测试）

DAST 是在程序运行状态下，通过模拟攻击者行为来发现安全漏洞的技术。

工作原理：

运行中的应用 ← HTTP请求（含攻击载荷） ← DAST工具
运行中的应用 → HTTP响应 → DAST工具 → 分析响应 → 报告漏洞

核心能力：

• SQL 注入探测
• XSS（跨站脚本）检测
• CSRF（跨站请求伪造）验证
• 目录遍历测试
• 认证绕过尝试
• 安全头部检查

优势：

• 检测运行时真实漏洞，误报率低
• 不依赖源代码，可测试任何 Web 应用
• 能发现配置类问题（如缺少安全头）

局限：

• 需要应用处于运行状态
• 覆盖率取决于爬虫能力
• 无法定位到具体代码行

SAST 与 DAST 互补关系

┌─────────────────────────────────────────────────┐
│ 安全检测覆盖矩阵 │
├──────────────────┬──────────────┬───────────────┤
│ 漏洞类型 │ SAST │ DAST │
├──────────────────┼──────────────┼───────────────┤
│ SQL 注入 │ ✓（代码层） │ ✓（运行时） │
│ XSS │ ✓（代码层） │ ✓（运行时） │
│ 硬编码密钥 │ ✓ │ ✗ │
│ 配置错误 │ ✗ │ ✓ │
│ 业务逻辑漏洞 │ 部分 │ 部分 │
│ 依赖库漏洞 │ ✓（SCA） │ ✗ │
│ 认证绕过 │ 部分 │ ✓ │
└──────────────────┴──────────────┴───────────────┘

1.3 Cursor IDE 在安全工作流中的定位

Cursor 是基于 VS Code 深度定制的 AI 代码编辑器，它在安全工作流中具有独特优势：

AI 原生能力：

• 内置 AI 对话（Ctrl+L），可实时询问代码安全问题
• 代码补全时自动考虑安全最佳实践
• 可选中代码片段让 AI 进行安全审查
• 支持自定义系统提示词，定制安全审查角色

插件生态兼容：

• 完全兼容 VS Code 插件市场
• 支持 Semgrep、SonarLint 等主流安全插件
• 终端集成，可直接运行命令行安全工具

工作流集成：

• 支持 .cursorrules 项目级 AI 配置
• Git 集成，可在提交前触发安全检查
• 任务系统，可配置自动化安全扫描任务

1.4 集成价值与预期收益

将 SAST/DAST 工具链集成到 Cursor 开发环境中，可以带来以下收益：

对开发者：

• 编码时即时获得安全反馈，无需等待代码审查
• AI 辅助理解漏洞原理，提升安全编码能力
• 减少后期返工，提高开发效率

对团队：

• 统一安全标准，降低人为遗漏
• 缩短漏洞修复周期（从周级降至分钟级）
• 建立可量化的安全度量体系

对组织：

• 降低安全事件发生概率
• 减少安全修复成本
• 满足合规要求（如等保、GDPR、SOC2）

量化预期：

二、基础环境搭建与必要安全插件安装

2.1 开发环境准备

2.1.1 操作系统要求

本教程支持以下操作系统：

硬件建议：

• 内存：至少 8GB（推荐 16GB，安全扫描工具较耗内存）
• 磁盘：至少 500MB 可用空间（插件+规则库）
• CPU：多核处理器有助于并行扫描

2.1.2 Cursor IDE 安装与基础配置

第一步：下载与安装

访问 Cursor 官方网站（cursor.com），根据操作系统下载对应版本：

# macOS (使用 Homebrew)
brew install –cask cursor

# Windows
# 下载安装包后双击运行，按向导完成安装

# Linux (Ubuntu/Debian)
wget https://download.cursor.com/linux/appimage/latest -O cursor.AppImage
chmod +x cursor.AppImage
./cursor.AppImage

第二步：初始配置

安装完成后，打开 Cursor 进行基础配置：

// settings.json – 通过 Ctrl+Shift+P → "Open Settings (JSON)" 打开
{
// 编辑器基础配置
"editor.fontSize": 14,
"editor.tabSize": 2,
"editor.formatOnSave": true,

// 终端配置（安全工具需要）
"terminal.integrated.defaultProfile.linux": "bash",
"terminal.integrated.defaultProfile.osx": "zsh",
"terminal.integrated.defaultProfile.windows": "PowerShell",

// 文件监视（SAST 实时扫描需要）
"files.watcherExclude": {
"**/node_modules/**": true,
"**/.git/**": true,
"**/dist/**": true,
"**/build/**": true
},

// 安全相关：禁止自动执行不受信任的工作区
"security.workspace.trust.enabled": true
}

第三步：安装必要的基础扩展

在 Cursor 中按 Ctrl+Shift+X 打开扩展市场，安装以下基础扩展：

• Python（如果开发 Python 项目）
• ESLint（如果开发 JavaScript/TypeScript 项目）
• Docker（如果需要容器化部署）
• GitLens（代码追溯，辅助安全审计）

2.1.3 Node.js / Python 运行时环境

安全插件链依赖运行时环境，请确保安装：

Node.js（v18+）：

# 使用 nvm 安装（推荐）
# macOS/Linux
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install 18
nvm use 18

# 验证安装
node –version # 应显示 v18.x.x 或更高
npm –version # 应显示 9.x.x 或更高

# Windows
# 访问 https://nodejs.org 下载 LTS 版本安装
# 或使用 winget:
winget install OpenJS.NodeJS.LTS

Python（3.9+）：

# macOS
brew install python@3.11

# Ubuntu/Debian
sudo apt update
sudo apt install python3.11 python3-pip python3-venv

# 验证安装
python3 –version # 应显示 3.11.x
pip3 –version

# Windows
winget install Python.Python.3.11

2.2 核心安全插件安装

2.2.1 Semgrep 插件安装与配置

Semgrep 是目前最流行的开源 SAST 工具之一，支持 30+ 编程语言，规则编写直观。

第一步：安装 Semgrep CLI

# 方式一：pip 安装（推荐）
pip3 install semgrep

# 方式二：macOS Homebrew
brew install semgrep

# 方式三：Docker（无需本地安装）
docker run –rm -v "${PWD}:/src" semgrep/semgrep semgrep –config=auto /src

# 验证安装
semgrep –version
# 应输出类似：semgrep version 1.67.0

第二步：安装 Cursor/VS Code Semgrep 扩展

第三步：配置 Semgrep 扩展

打开设置 JSON，添加 Semgrep 配置：

{
// Semgrep 扩展配置
"semgrep.path": "semgrep", // 如果不在 PATH 中，填写完整路径
"semgrep.scan.onType": true, // 输入时实时扫描
"semgrep.scan.onSave": true, // 保存时扫描
"semgrep.scan.configuration": [
"auto", // 自动选择规则
"./semgrep-rules/" // 本地自定义规则目录
],
"semgrep.severity.overrides": {
"INFO": "hint",
"WARNING": "warning",
"ERROR": "error"
},
// 排除不需要扫描的路径
"semgrep.exclude": [
"node_modules",
"dist",
"build",
".git",
"vendor",
"*.min.js",
"*.test.js"
]
}

第四步：验证 Semgrep 工作

创建一个测试文件 test-security.js：

// test-security.js – 用于验证 Semgrep 是否正常工作
// 这个文件故意包含一个安全问题

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

// 危险：直接使用用户输入构建 SQL 查询（SQL 注入漏洞）
app.get('/user', (req, res) => {
const userId = req.query.id;
// Semgrep 应该能检测到这里的 SQL 注入风险
const query = "SELECT * FROM users WHERE id = " + userId;
// 实际项目中这里会执行数据库查询
res.send(query);
});

app.listen(3000);

在 Cursor 中打开此文件，如果 Semgrep 配置正确，你应该能看到代码下方出现黄色/红色波浪线提示。

2.2.2 SonarLint 插件集成

SonarLint 是 SonarQube 的 IDE 插件版本，提供实时代码质量与安全检测。

安装步骤：

{
// SonarLint 配置
"sonarlint.connectedMode.project": {
// 如果有 SonarQube 服务器，配置连接
// 没有的话可以先使用独立模式
"connectionId": "",
"projectKey": ""
},
// 规则配置
"sonarlint.rules": {
// 启用所有安全热点规则
"javascript:S2076": { "level": "on" }, // OS 命令注入
"javascript:S2077": { "level": "on" }, // SQL 注入
"javascript:S2078": { "level": "on" }, // LDAP 注入
"javascript:S5131": { "level": "on" }, // XSS
"python:S2076": { "level": "on" },
"python:S2077": { "level": "on" }
},
// 分析触发
"sonarlint.analyzerProperties": {
"sonar.javascript.node.maxspace": "4096"
}
}

2.2.3 ESLint Security 插件

对于 JavaScript/TypeScript 项目，ESLint 安全插件是必备工具。

安装：

# 在项目目录中安装
npm install –save-dev eslint eslint-plugin-security eslint-plugin-no-unsanitized

配置 .eslintrc.json：

{
"env": {
"browser": true,
"node": true,
"es2022": true
},
"extends": [
"eslint:recommended",
"plugin:security/recommended-legacy",
"plugin:no-unsanitized/DOM"
],
"plugins": [
"security",
"no-unsanitized"
],
"rules": {
// 安全相关规则 – 设为 error 级别
"security/detect-eval-with-expression": "error",
"security/detect-child-process": "error",
"security/detect-disable-mustache-escape": "error",
"security/detect-no-csrf-before-method-override": "error",
"security/detect-non-literal-fs-filename": "warn",
"security/detect-non-literal-regexp": "warn",
"security/detect-non-literal-require": "error",
"security/detect-object-injection": "warn",
"security/detect-possible-timing-attacks": "error",
"security/detect-pseudoRandomBytes": "error",
"security/detect-unsafe-regex": "error",
"security/detect-buffer-noassert": "error",

// no-unsanitized 规则
"no-unsanitized/property": "error",
"no-unsanitized/method": "error"
}
}

2.2.4 Bandit（Python 安全扫描）

Bandit 是 Python 专用的 SAST 工具，能检测 Python 代码中的常见安全问题。

安装：

# pip 安装
pip3 install bandit

# 验证
bandit –version

Cursor 集成：

创建 .bandit 配置文件（项目根目录）：

# .bandit – Bandit 配置文件
[bandit]
# 排除的目录
exclude: /tests,/venv,/.git,/node_modules,/migrations

# 扫描目标
targets: ./src,./app

# 严重等级过滤（low, medium, high）
level: low

# 置信度过滤
confidence: low

# 输出格式
format: json

# 输出文件
output: ./reports/bandit-report.json

在 Cursor 终端中运行：

# 扫描整个项目
bandit -r ./src -f json -o ./reports/bandit-report.json

# 扫描单个文件
bandit ./src/app.py

# 只显示高严重性问题
bandit -r ./src -ll

# 使用自定义配置
bandit -r ./src -c .bandit

2.2.5 OWASP ZAP 辅助工具

OWASP ZAP（Zed Attack Proxy）是用于 DAST 的开源工具。

安装：

# macOS
brew install –cask owasp-zap

# Linux (Ubuntu)
sudo apt install zaproxy
# 或下载最新版
wget https://github.com/zaproxy/zaproxy/releases/download/v2.15.0/ZAP_2.15.0_Linux.tar.gz
tar -xzf ZAP_2.15.0_Linux.tar.gz

# Windows
# 从 https://www.zaproxy.org/download/ 下载安装包

# Docker 方式（推荐，无需本地安装）
docker pull ghcr.io/zaproxy/zaproxy:stable

Cursor 终端集成脚本（创建 scripts/dast-scan.sh）：

#!/bin/bash
# dast-scan.sh – 在 Cursor 终端中运行 DAST 扫描
# 用法: ./scripts/dast-scan.sh <目标URL>

TARGET_URL=${1:-"http://localhost:3000"}
REPORT_DIR="./reports/dast"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# 创建报告目录
mkdir -p ${REPORT_DIR}

echo "=========================================="
echo " OWASP ZAP DAST 扫描"
echo " 目标: ${TARGET_URL}"
echo " 时间: $(date)"
echo "=========================================="

# 使用 Docker 运行 ZAP 基线扫描
docker run –rm \\
–network="host" \\
-v $(pwd)/${REPORT_DIR}:/zap/reports \\
ghcr.io/zaproxy/zaproxy:stable \\
zap-baseline.py \\
-t ${TARGET_URL} \\
-r /zap/reports/zap-report-${TIMESTAMP}.html \\
-J /zap/reports/zap-report-${TIMESTAMP}.json \\
-c zap-rules.conf \\
-T 10 \\
-a

echo ""
echo "扫描完成！报告已保存至: ${REPORT_DIR}/"
echo "HTML 报告: ${REPORT_DIR}/zap-report-${TIMESTAMP}.html"
echo "JSON 报告: ${REPORT_DIR}/zap-report-${TIMESTAMP}.json"

2.3 插件链依赖关系与版本兼容性

以下是完整的插件链依赖关系图：

┌─────────────────────────────────────────────────────────┐
│ Cursor IDE │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Semgrep │ │ SonarLint │ │ ESLint │ │
│ │ Extension │ │ Extension │ │ Security │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Semgrep │ │ SonarQube │ │ Node.js │ │
│ │ CLI (Py) │ │ Analyzer │ │ Runtime │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
├─────────┼─────────────────┼─────────────────┼───────────┤
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Python 3.9+ Runtime │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Bandit │ │ OWASP ZAP │ ← 独立运行 │
│ │ (Python) │ │ (Java/Docker)│ │
│ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘

版本兼容性矩阵（截至 2026 年）：

三、配置自定义规则实现静态代码审计自动化

3.1 Semgrep 规则文件结构详解

Semgrep 规则使用 YAML 格式编写，存放在项目中的 semgrep-rules/ 目录下。一个完整的规则文件结构如下：

# semgrep-rules/custom-security.yaml
# 自定义安全规则文件

rules:
# 每条规则是一个列表项
– id: rule–unique–identifier # 规则唯一标识符（必填）
patterns: # 匹配模式（核心）
– pattern: |
dangerous_function(…)
message: | # 检测到问题时的提示信息（必填）
检测到潜在的安全问题：使用了危险函数。
请使用安全的替代方案。
languages: # 适用语言（必填）
– javascript
– typescript
severity: ERROR # 严重等级：INFO/WARNING/ERROR（必填）
metadata: # 元数据（可选但推荐）
category: security # 分类
cwe: "CWE-89" # CWE 编号
owasp: "A03:2021 Injection" # OWASP 分类
confidence: HIGH # 置信度
likelihood: HIGH # 可能性
impact: HIGH # 影响
subcategory:
– vuln # vuln / audit / guardrail
references: # 参考链接
– https://owasp.org/Top10/A03_2021–Injection/
technology:
– express # 相关技术栈
fix: | # 自动修复建议（可选）
safe_function(…)

规则文件目录结构建议：

project-root/
├── semgrep-rules/
│ ├── injection/ # 注入类漏洞
│ │ ├── sql-injection.yaml
│ │ ├── command-injection.yaml
│ │ └── ldap-injection.yaml
│ ├── xss/ # XSS 类漏洞
│ │ ├── reflected-xss.yaml
│ │ └── stored-xss.yaml
│ ├── auth/ # 认证授权类
│ │ ├── weak-crypto.yaml
│ │ ├── hardcoded-secrets.yaml
│ │ └── insecure-auth.yaml
│ ├── data-exposure/ # 数据泄露类
│ │ ├── sensitive-logging.yaml
│ │ └── insecure-storage.yaml
│ ├── config/ # 配置类
│ │ ├── cors-misconfiguration.yaml
│ │ └── missing-security-headers.yaml
│ └── custom/ # 业务自定义规则
│ ├── api-security.yaml
│ └── business-logic.yaml
├── .semgrepignore # 忽略文件
└── semgrep.yaml # 全局配置

3.2 编写第一条自定义 SAST 规则

3.2.1 规则语法基础

Semgrep 的匹配语法非常直观，它使用目标语言的实际代码语法来编写模式：

# semgrep-rules/first-rule.yaml
# 第一条自定义规则：检测 console.log 中的敏感信息

rules:
– id: no–sensitive–data–in–console
patterns:
# 匹配 console.log() 中包含特定变量的调用
– pattern: |
console.log(…, $SENSITIVE, …)
# 限定变量名包含敏感关键词
– metavariable-regex:
metavariable: $SENSITIVE
regex: .*(password|secret|token|apikey|api_key).*
message: >
检测到 console.log 中可能输出敏感信息 '$SENSITIVE'。
生产环境中不应将密码、密钥等敏感数据输出到控制台。
请使用日志脱敏处理或移除该输出。
languages:
– javascript
– typescript
severity: WARNING
metadata:
category: security
cwe: "CWE-532"
confidence: MEDIUM

3.2.2 模式匹配与元变量

Semgrep 支持多种匹配模式：

rules:
# 1. 精确匹配 – 匹配特定函数调用
– id: detect–eval–usage
pattern: eval($X)
message: "禁止使用 eval()，存在代码注入风险"
languages: [javascript]
severity: ERROR

# 2. 元变量匹配 – $X 匹配任意表达式
– id: detect–sql–concat
patterns:
– pattern: |
$QUERY = "…" + $INPUT
– metavariable-regex:
metavariable: $QUERY
regex: .*(sql|query|stmt).*
message: "检测到 SQL 查询字符串拼接，可能存在 SQL 注入"
languages: [javascript, python, java]
severity: ERROR

# 3. 模式内省略号 – … 匹配任意数量参数
– id: detect–exec–with–user–input
pattern: |
child_process.exec(…, $INPUT, …)
message: "exec() 接收外部输入可能导致命令注入"
languages: [javascript]
severity: ERROR

# 4. 否定模式 – 排除特定情况
– id: detect–hardcoded–secret–not–env
patterns:
– pattern: |
const $VAR = "$VALUE"
– metavariable-regex:
metavariable: $VAR
regex: .*(password|secret|key|token).*
– pattern-not: |
const $VAR = process.env.$ENV_VAR
– pattern-not: |
const $VAR = ""
message: "检测到硬编码的敏感信息，请使用环境变量"
languages: [javascript, typescript]
severity: ERROR

# 5. 数据流追踪（taint mode）
– id: taint–sql–injection
mode: taint
pattern-sources:
– pattern: req.query.$PARAM
– pattern: req.body.$PARAM
– pattern: req.params.$PARAM
pattern-sinks:
– pattern: db.query($SQL, …)
– pattern: connection.execute($SQL, …)
pattern-sanitizers:
– pattern: sanitize($X)
– pattern: escape($X)
message: "用户输入未经净化直接进入 SQL 查询"
languages: [javascript]
severity: ERROR

3.2.3 规则严重等级定义

# 严重等级使用指南
severity: INFO # 信息提示：最佳实践建议，不阻塞开发
severity: WARNING # 警告：潜在风险，建议修复
severity: ERROR # 错误：高危漏洞，必须修复

# 在 Cursor 中的显示效果：
# INFO → 灰色提示（不干扰编码）
# WARNING → 黄色波浪线（引起注意）
# ERROR → 红色波浪线（必须处理）

3.3 多语言规则配置

3.3.1 JavaScript/TypeScript 规则

# semgrep-rules/injection/sql-injection-js.yaml
rules:
# 检测 Express 中的 SQL 注入
– id: express–sql–injection–string–concat
patterns:
– pattern-either:
# 模式1：字符串拼接
– pattern: |
$DB.query("…" + $INPUT + "…", …)
# 模式2：模板字符串（无参数化）
– pattern: |
$DB.query(`…${$INPUT}…`, …)
# 模式3：字符串拼接后传入
– pattern: |
const $SQL = "…" + $INPUT + "…";
…
$DB.query($SQL, …)
– pattern-not: |
$DB.query("…", [$PARAM], …)
message: >
检测到 SQL 查询使用字符串拼接构造。
请使用参数化查询（Prepared Statement）防止 SQL 注入。

修复示例：
✗ db.query("SELECT * FROM users WHERE id = " + userId)
✓ db.query("SELECT * FROM users WHERE id = ?", [userId])
languages: [javascript, typescript]
severity: ERROR
metadata:
cwe: "CWE-89"
owasp: "A03:2021"
category: security
confidence: HIGH
fix: |
$DB.query("…", [$INPUT], …)

# 检测命令注入
– id: js–command–injection
patterns:
– pattern-either:
– pattern: |
require('child_process').exec($CMD)
– pattern: |
require('child_process').execSync($CMD)
– pattern: |
import { exec } from 'child_process';
…
exec($CMD)
– pattern-not: |
exec("ls") # 排除硬编码的安全命令
message: >
检测到使用 child_process.exec() 执行命令。
如果命令包含用户输入，将导致命令注入漏洞。
请使用 execFile() 或 spawn() 并传入参数数组。
languages: [javascript, typescript]
severity: ERROR
metadata:
cwe: "CWE-78"
confidence: MEDIUM

# 检测 XSS – innerHTML 赋值
– id: js–xss–innerhtml
patterns:
– pattern: |
$EL.innerHTML = $VALUE
– pattern-not: |
$EL.innerHTML = ""
– pattern-not: |
$EL.innerHTML = "…" # 纯字符串字面量
message: >
检测到直接设置 innerHTML，如果 $VALUE 包含用户输入，
将导致存储型/反射型 XSS 漏洞。
请使用 textContent 或 DOMPurify.sanitize() 处理。
languages: [javascript, typescript]
severity: ERROR
metadata:
cwe: "CWE-79"

3.3.2 Python 规则

# semgrep-rules/injection/sql-injection-python.yaml
rules:
# Python SQL 注入检测
– id: python–sql–injection–format
patterns:
– pattern-either:
# f-string 格式化
– pattern: |
$CURSOR.execute(f"…{$VAR}…")
# % 格式化
– pattern: |
$CURSOR.execute("…%s…" % $VAR)
# .format()
– pattern: |
$CURSOR.execute("…{}…".format($VAR))
# 字符串拼接
– pattern: |
$CURSOR.execute("…" + $VAR + "…")
– pattern-not: |
$CURSOR.execute("…", ($VAR,))
– pattern-not: |
$CURSOR.execute("…", [$VAR])
message: >
检测到 SQL 查询使用字符串格式化构造。
请使用参数化查询：cursor.execute("SELECT … WHERE id = %s", (user_id,))
languages: [python]
severity: ERROR
metadata:
cwe: "CWE-89"
confidence: HIGH

# Python 命令注入
– id: python–command–injection
patterns:
– pattern-either:
– pattern: os.system($CMD)
– pattern: os.popen($CMD)
– pattern: subprocess.call($CMD, shell=True, …)
– pattern: subprocess.run($CMD, shell=True, …)
– pattern: subprocess.Popen($CMD, shell=True, …)
message: >
检测到可能的命令注入风险。
os.system() 和 shell=True 会使命令经过 shell 解释，
如果包含用户输入则存在命令注入风险。
请使用 subprocess.run([…], shell=False) 并传入参数列表。
languages: [python]
severity: ERROR
metadata:
cwe: "CWE-78"

# Python 不安全的反序列化
– id: python–insecure–deserialization
patterns:
– pattern-either:
– pattern: pickle.loads($DATA)
– pattern: pickle.load($FILE)
– pattern: yaml.load($DATA)
– pattern-not: |
yaml.load($DATA, Loader=yaml.SafeLoader)
– pattern-not: |
yaml.safe_load($DATA)
message: >
检测到不安全的反序列化操作。
pickle 和 yaml.load() 可被利用执行任意代码。
请使用 yaml.safe_load() 或添加数据验证。
languages: [python]
severity: ERROR
metadata:
cwe: "CWE-502"

# Python 硬编码密钥
– id: python–hardcoded–secret
patterns:
– pattern: |
$VAR = "$VALUE"
– metavariable-regex:
metavariable: $VAR
regex: (?i).*(password|passwd|secret|api_key|apikey|token|private_key).*
– metavariable-regex:
metavariable: $VALUE
regex: .{8,} # 至少8个字符，排除空字符串
– pattern-not: |
$VAR = os.environ.get(…)
– pattern-not: |
$VAR = os.getenv(…)
message: >
检测到硬编码的敏感信息。
请使用环境变量或密钥管理服务存储敏感信息。
languages: [python]
severity: ERROR
metadata:
cwe: "CWE-798"

3.3.3 Java 规则

# semgrep-rules/injection/sql-injection-java.yaml
rules:
# Java SQL 注入
– id: java–sql–injection
patterns:
– pattern-either:
– pattern: |
$STMT.executeQuery("…" + $INPUT + "…")
– pattern: |
$STMT.executeUpdate("…" + $INPUT + "…")
– pattern: |
$CONN.createStatement().executeQuery("…" + $INPUT + "…")
– pattern-not: |
$CONN.prepareStatement("…")
message: >
检测到 SQL 语句拼接。请使用 PreparedStatement 参数化查询。
✗ stmt.executeQuery("SELECT * FROM users WHERE id = " + userId)
✓ PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
ps.setString(1, userId);
languages: [java]
severity: ERROR
metadata:
cwe: "CWE-89"

# Java 不安全的随机数
– id: java–insecure–random
patterns:
– pattern: new Random(…)
– pattern-not-inside: |
// 测试代码中允许
@Test
…
message: >
检测到使用 java.util.Random，该类不是密码学安全的。
安全场景请使用 java.security.SecureRandom。
languages: [java]
severity: WARNING
metadata:
cwe: "CWE-330"

3.4 Cursor 中自动化触发配置

在 Cursor 中配置保存时自动触发安全扫描：

方式一：通过 Semgrep 扩展设置（已在 2.2.1 配置）

方式二：通过 VS Code Tasks 配置

创建 .vscode/tasks.json：

{
"version": "2.0.0",
"tasks": [
{
"label": "Semgrep: 扫描当前文件",
"type": "shell",
"command": "semgrep",
"args": [
"–config", "auto",
"–config", "./semgrep-rules/",
"–error",
"${file}"
],
"group": "test",
"presentation": {
"reveal": "silent",
"panel": "dedicated",
"clear": true
},
"problemMatcher": {
"owner": "semgrep",
"fileLocation": "relative",
"pattern": {
"regexp": "^(.+):(\\\\d+):(\\\\d+):\\\\s+(.+)$",
"file": 1,
"line": 2,
"column": 3,
"message": 4
}
}
},
{
"label": "Semgrep: 全项目扫描",
"type": "shell",
"command": "semgrep",
"args": [
"–config", "auto",
"–config", "./semgrep-rules/",
"–json",
"–output", "./reports/semgrep-report.json",
"."
],
"group": "test",
"presentation": {
"reveal": "always",
"panel": "dedicated"
}
},
{
"label": "Bandit: Python 安全扫描",
"type": "shell",
"command": "bandit",
"args": [
"-r", "./src",
"-f", "custom",
"–msg-template", "{abspath}:{line}: [{severity}] {msg} ({test_id})"
],
"group": "test",
"presentation": {
"reveal": "always",
"panel": "dedicated"
}
},
{
"label": "ESLint: 安全规则检查",
"type": "shell",
"command": "npx",
"args": [
"eslint",
"–ext", ".js,.ts,.jsx,.tsx",
"–rule", "security/detect-eval-with-expression: error",
"."
],
"group": "test"
},
{
"label": "安全扫描: 全部",
"dependsOn": [
"Semgrep: 全项目扫描",
"ESLint: 安全规则检查"
],
"group": {
"kind": "test",
"isDefault": true
}
}
]
}

方式三：配置保存时自动运行（通过扩展设置）

// settings.json 追加
{
// 保存时运行任务
"tasks.autoRun": true,

// 文件保存时触发
"[javascript]": {
"editor.codeActionsOnSave": {
"source.fixAll.eslint": "explicit"
}
},
"[typescript]": {
"editor.codeActionsOnSave": {
"source.fixAll.eslint": "explicit"
}
}
}

3.5 规则测试与验证

编写规则后，必须测试其正确性：

# 测试单条规则
semgrep –config semgrep-rules/injection/sql-injection-js.yaml –test

# 使用测试用例验证
# 创建测试文件：semgrep-rules/injection/test-sql-injection.js

# 测试文件内容示例（包含注释标记）：

// semgrep-rules/injection/test-sql-injection.js
// 测试用例文件 – 用于验证规则准确性

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

const db = mysql.createConnection({});

// ruleid: express-sql-injection-string-concat
// ↑ 这行注释告诉 Semgrep 下一行应该被匹配
app.get('/user', (req, res) => {
const userId = req.query.id;
db.query("SELECT * FROM users WHERE id = " + userId);
});

// ruleid: express-sql-injection-string-concat
app.get('/search', (req, res) => {
const keyword = req.query.q;
db.query(`SELECT * FROM products WHERE name LIKE '%${keyword}%'`);
});

// ok: express-sql-injection-string-concat
// ↑ 这行注释告诉 Semgrep 下一行不应该被匹配
app.get('/safe-user', (req, res) => {
const userId = req.query.id;
db.query("SELECT * FROM users WHERE id = ?", [userId]);
});

// ok: express-sql-injection-string-concat
app.get('/safe-search', (req, res) => {
const keyword = req.query.q;
db.query("SELECT * FROM products WHERE name LIKE ?", [`%${keyword}%`]);
});

# 运行测试
semgrep –config semgrep-rules/injection/sql-injection-js.yaml \\
–test semgrep-rules/injection/

# 期望输出：
# ✓ express-sql-injection-string-concat
# 2/2 findings matched (2 true positives, 0 false positives)
# All tests passed!

四、构建动态交互测试流程辅助运行时检测

4.1 DAST 基础原理与适用场景

DAST（动态应用安全测试）通过向运行中的应用发送恶意请求并分析响应来发现漏洞。

适用场景：

• Web API 安全测试
• 表单输入验证测试
• 认证/授权流程测试
• 安全配置检查（CORS、安全头等）
• 会话管理测试

不适用场景：

• 代码逻辑审查（应使用 SAST）
• 第三方依赖漏洞（应使用 SCA）
• 加密算法正确性验证

4.2 OWASP ZAP 本地代理配置

配置 Cursor 终端代理：

# 启动 ZAP 作为本地代理
# 方式一：直接启动
zap.sh -daemon -port 8080 -config api.disablekey=true

# 方式二：Docker 启动（推荐）
docker run -d –name zap-proxy \\
-p 8080:8080 \\
-p 8090:8090 \\
ghcr.io/zaproxy/zaproxy:stable \\
zap.sh -daemon -port 8080 -config api.disablekey=true

创建 ZAP 配置文件 zap-config.conf：

# zap-config.conf – ZAP 扫描配置
# 扫描策略
scanner.strength=HIGH
scanner.threshold=MEDIUM

# 排除路径（不扫描静态资源）
globalexcludeurl=.*\\\\.css
globalexcludeurl=.*\\\\.js
globalexcludeurl=.*\\\\.png
globalexcludeurl=.*\\\\.jpg
globalexcludeurl=.*\\\\.gif
globalexcludeurl=.*\\\\.ico

# 认证配置（如果应用需要登录）
# authentication.method=form
# authentication.loginurl=http://localhost:3000/login
# authentication.username=admin
# authentication.password=admin123

# 扫描超时设置
scanner.timeout=300
spider.maxduration=10

4.3 Cursor 终端集成动态扫描

创建 scripts/dast-workflow.sh：

#!/bin/bash
# dast-workflow.sh – 完整的 DAST 工作流脚本
# 在 Cursor 终端中运行: ./scripts/dast-workflow.sh

set -e # 遇到错误立即退出

# ==================== 配置区 ====================
TARGET_URL="${1:-http://localhost:3000}"
ZAP_PORT=8080
REPORT_DIR="./reports/dast"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
SCAN_TIMEOUT=300 # 扫描超时（秒）
# ================================================

echo "╔══════════════════════════════════════════╗"
echo "║ DAST 动态安全扫描工作流 ║"
echo "╠══════════════════════════════════════════╣"
echo "║ 目标: ${TARGET_URL}"
echo "║ 时间: $(date '+%Y-%m-%d %H:%M:%S')"
echo "║ 报告: ${REPORT_DIR}/"
echo "╚══════════════════════════════════════════╝"
echo ""

# 步骤1：创建报告目录
mkdir -p ${REPORT_DIR}

# 步骤2：检查目标是否可达
echo "[1/6] 检查目标可达性…"
if ! curl -s -o /dev/null -w "%{http_code}" ${TARGET_URL} | grep -q "200\\|301\\|302"; then
echo "❌ 错误：目标 ${TARGET_URL} 不可达！"
echo " 请确保应用已启动。"
exit 1
fi
echo "✅ 目标可达"

# 步骤3：启动 ZAP（如果未运行）
echo "[2/6] 检查 ZAP 代理状态…"
if ! curl -s http://localhost:${ZAP_PORT}/JSON/core/view/version/ > /dev/null 2>&1; then
echo " 启动 ZAP 代理…"
docker run -d –name zap-scan \\
–network="host" \\
ghcr.io/zaproxy/zaproxy:stable \\
zap.sh -daemon -port ${ZAP_PORT} -config api.disablekey=true

# 等待 ZAP 启动
echo " 等待 ZAP 启动…"
sleep 15
fi
echo "✅ ZAP 代理就绪"

# 步骤4：执行爬虫（Spider）
echo "[3/6] 执行网站爬虫…"
SPIDER_ID=$(curl -s "http://localhost:${ZAP_PORT}/JSON/spider/action/scan/?url=${TARGET_URL}" | \\
python3 -c "import sys,json; print(json.load(sys.stdin)['scan'])")

# 等待爬虫完成
while true; do
PROGRESS=$(curl -s "http://localhost:${ZAP_PORT}/JSON/spider/view/status/?scanId=${SPIDER_ID}" | \\
python3 -c "import sys,json; print(json.load(sys.stdin)['status'])")
echo " 爬虫进度: ${PROGRESS}%"
if [ "$PROGRESS" = "100" ]; then
break
fi
sleep 5
done
echo "✅ 爬虫完成"

# 步骤5：执行主动扫描
echo "[4/6] 执行主动安全扫描（这可能需要几分钟）…"
SCAN_ID=$(curl -s "http://localhost:${ZAP_PORT}/JSON/ascan/action/scan/?url=${TARGET_URL}" | \\
python3 -c "import sys,json; print(json.load(sys.stdin)['scan'])")

# 等待扫描完成
ELAPSED=0
while true; do
PROGRESS=$(curl -s "http://localhost:${ZAP_PORT}/JSON/ascan/view/status/?scanId=${SCAN_ID}" | \\
python3 -c "import sys,json; print(json.load(sys.stdin)['status'])")
echo " 扫描进度: ${PROGRESS}%"
if [ "$PROGRESS" = "100" ]; then
break
fi
sleep 10
ELAPSED=$((ELAPSED + 10))
if [ $ELAPSED -ge $SCAN_TIMEOUT ]; then
echo "⚠️ 扫描超时，使用当前结果"
break
fi
done
echo "✅ 主动扫描完成"

# 步骤6：生成报告
echo "[5/6] 生成安全报告…"

# HTML 报告
curl -s "http://localhost:${ZAP_PORT}/OTHER/core/other/htmlreport/" > \\
"${REPORT_DIR}/zap-report-${TIMESTAMP}.html"

# JSON 报告
curl -s "http://localhost:${ZAP_PORT}/JSON/core/view/alerts/?baseurl=${TARGET_URL}" > \\
"${REPORT_DIR}/zap-alerts-${TIMESTAMP}.json"

# 解析并输出摘要
echo "[6/6] 扫描结果摘要："
echo "─────────────────────────────────────────"
python3 << 'EOF'
import json, sys

try:
with open(f"${REPORT_DIR}/zap-alerts-${TIMESTAMP}.json") as f:
data = json.load(f)

alerts = data.get('alerts', [])

# 按风险等级统计
risk_count = {'High': 0, 'Medium': 0, 'Low': 0, 'Informational': 0}
for alert in alerts:
risk = alert.get('risk', 'Informational')
risk_count[risk] = risk_count.get(risk, 0) + 1

print(f" 🔴 高危: {risk_count['High']}")
print(f" 🟠 中危: {risk_count['Medium']}")
print(f" 🟡 低危: {risk_count['Low']}")
print(f" 🔵 信息: {risk_count['Informational']}")
print(f" ─────────────────")
print(f" 总计: {len(alerts)} 个发现")

# 输出高危详情
if risk_count['High'] > 0:
print(f"\\n ⚠️ 高危漏洞详情：")
for alert in alerts:
if alert.get('risk') == 'High':
print(f" – {alert.get('name')}")
print(f" URL: {alert.get('url')}")
print(f" 描述: {alert.get('description', '')[:100]}…")
print()
except Exception as e:
print(f" 解析报告时出错: {e}")
EOF

echo ""
echo "══════════════════════════════════════════"
echo "扫描完成！"
echo "HTML 报告: ${REPORT_DIR}/zap-report-${TIMESTAMP}.html"
echo "JSON 数据: ${REPORT_DIR}/zap-alerts-${TIMESTAMP}.json"
echo "══════════════════════════════════════════"

4.4 API 端点自动化探测

对于 REST API 项目，可以使用专门的 API 扫描脚本：

#!/usr/bin/env python3
"""
api_security_scanner.py – API 端点安全扫描器
在 Cursor 终端中运行: python3 scripts/api_security_scanner.py

功能：
– 自动发现 API 端点
– 测试常见注入点
– 检查安全头部
– 验证认证机制
"""

import requests
import json
import time
from datetime import datetime
from urllib.parse import urljoin, urlparse
from typing import List, Dict, Optional

class APISecurityScanner:
"""API 安全扫描器"""

def __init__(self, base_url: str, auth_token: Optional[str] = None):
self.base_url = base_url.rstrip('/')
self.auth_token = auth_token
self.findings: List[Dict] = []
self.session = requests.Session()

if auth_token:
self.session.headers['Authorization'] = f'Bearer {auth_token}'

def check_security_headers(self, url: str) –> None:
"""检查安全响应头"""
try:
response = self.session.get(url, timeout=10)
headers = response.headers

# 应该存在的安全头
required_headers = {
'X-Content-Type-Options': 'nosniff',
'X-Frame-Options': None, # DENY 或 SAMEORIGIN
'X-XSS-Protection': None, # 1; mode=block
'Strict-Transport-Security': None, # max-age=…
'Content-Security-Policy': None,
}

# 不应该存在的头
forbidden_headers = ['Server', 'X-Powered-By']

for header, expected in required_headers.items():
if header not in headers:
self._add_finding(
severity='MEDIUM',
title=f'缺少安全头: {header}',
url=url,
description=f'响应中缺少 {header} 头',
recommendation=f'添加 {header} 响应头'
)

for header in forbidden_headers:
if header in headers:
self._add_finding(
severity='LOW',
title=f'信息泄露头: {header}',
url=url,
description=f'响应包含 {header}: {headers[header]}',
recommendation=f'移除 {header} 响应头'
)

except requests.RequestException as e:
print(f" ⚠️ 请求失败: {url} – {e}")

def test_sql_injection(self, url: str, params: Dict) –> None:
"""测试 SQL 注入"""
sqli_payloads = [
"' OR '1'='1",
"1' OR '1'='1'–",
"1; DROP TABLE users–",
"' UNION SELECT NULL–",
]

for param, value in params.items():
for payload in sqli_payloads:
test_params = params.copy()
test_params[param] = payload

try:
response = self.session.get(url, params=test_params, timeout=10)

# 检查响应中是否有 SQL 错误信息
sql_errors = ['sql', 'syntax', 'mysql', 'postgresql', 'oracle',
'sqlite', 'error', 'exception']
response_lower = response.text.lower()

if any(err in response_lower for err in sql_errors):
self._add_finding(
severity='HIGH',
title='潜在 SQL 注入',
url=url,
description=f'参数 {param} 可能存在 SQL 注入',
evidence=f'Payload: {payload}',
recommendation='使用参数化查询'
)
except requests.RequestException:
pass

def test_xss(self, url: str, params: Dict) –> None:
"""测试 XSS"""
xss_payloads = [
'<script>alert(1)</script>',
'"><img src=x onerror=alert(1)>',
"javascript:alert(1)",
]

for param, value in params.items():
for payload in xss_payloads:
test_params = params.copy()
test_params[param] = payload

try:
response = self.session.get(url, params=test_params, timeout=10)

# 检查 payload 是否被原样反射
if payload in response.text:
self._add_finding(
severity='HIGH',
title='反射型 XSS',
url=url,
description=f'参数 {param} 存在 XSS 漏洞',
evidence=f'Payload 被原样反射: {payload}',
recommendation='对所有输出进行 HTML 编码'
)
except requests.RequestException:
pass

def _add_finding(self, severity: str, title: str, url: str,
description: str, evidence: str = '',
recommendation: str = '') –> None:
"""添加发现"""
finding = {
'severity': severity,
'title': title,
'url': url,
'description': description,
'evidence': evidence,
'recommendation': recommendation,
'timestamp': datetime.now().isoformat()
}
self.findings.append(finding)

# 实时输出
icon = {'HIGH': '🔴', 'MEDIUM': '🟠', 'LOW': '🟡', 'INFO': '🔵'}
print(f" {icon.get(severity, '⚪')} [{severity}] {title}")
print(f" URL: {url}")

def generate_report(self, output_path: str) –> None:
"""生成 JSON 报告"""
report = {
'scan_info': {
'target': self.base_url,
'timestamp': datetime.now().isoformat(),
'total_findings': len(self.findings)
},
'findings': self.findings
}

with open(output_path, 'w', encoding='utf-8') as f:
json.dump(report, f, ensure_ascii=False, indent=2)

print(f"\\n📄 报告已保存: {output_path}")

# ==================== 使用示例 ====================
if __name__ == '__main__':
# 配置扫描目标
TARGET = 'http://localhost:3000'

print("╔══════════════════════════════════════╗")
print("║ API 安全扫描器 v1.0 ║")
print("╚══════════════════════════════════════╝")
print(f"\\n目标: {TARGET}")
print(f"时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\\n")

scanner = APISecurityScanner(TARGET)

# 1. 检查安全头
print("[1/3] 检查安全响应头…")
scanner.check_security_headers(TARGET)

# 2. 测试 SQL 注入
print("\\n[2/3] 测试 SQL 注入…")
scanner.test_sql_injection(
f"{TARGET}/api/users",
{'id': '1', 'name': 'test'}
)

# 3. 测试 XSS
print("\\n[3/3] 测试 XSS…")
scanner.test_xss(
f"{TARGET}/api/search",
{'q': 'test', 'filter': 'all'}
)

# 生成报告
scanner.generate_report('./reports/dast/api-scan-report.json')

print("\\n✅ 扫描完成！")

4.5 运行时漏洞报告解析

创建一个报告解析脚本，将 DAST 结果转化为可操作的修复建议：

#!/usr/bin/env python3
"""
parse_dast_report.py – 解析 DAST 扫描报告并生成修复建议
"""

import json
import sys
from pathlib import Path

def parse_zap_report(report_path: str) –> dict:
"""解析 ZAP JSON 报告"""
with open(report_path, 'r') as f:
data = json.load(f)

alerts = data.get('alerts', [])

# 按 CWE 分类
cwe_mapping = {}
for alert in alerts:
cwe_id = alert.get('cweid', 'N/A')
if cwe_id not in cwe_mapping:
cwe_mapping[cwe_id] = []
cwe_mapping[cwe_id].append({
'name': alert.get('name'),
'risk': alert.get('risk'),
'url': alert.get('url'),
'description': alert.get('description', '')[:200],
'solution': alert.get('solution', '')[:200]
})

return cwe_mapping

def generate_fix_suggestions(cwe_mapping: dict) –> str:
"""生成修复建议"""
suggestions = []
suggestions.append("# DAST 扫描修复建议\\n")
suggestions.append(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M')}\\n")

for cwe_id, alerts in cwe_mapping.items():
suggestions.append(f"\\n## CWE-{cwe_id}")
for alert in alerts:
suggestions.append(f"- **{alert['name']}** [{alert['risk']}]")
suggestions.append(f" – URL: {alert['url']}")
suggestions.append(f" – 修复: {alert['solution']}")

return '\\n'.join(suggestions)

if __name__ == '__main__':
if len(sys.argv) < 2:
print("用法: python3 parse_dast_report.py <report.json>")
sys.exit(1)

report_path = sys.argv[1]
cwe_mapping = parse_zap_report(report_path)
suggestions = generate_fix_suggestions(cwe_mapping)

# 输出到文件
output_path = './reports/dast/fix-suggestions.md'
Path(output_path).parent.mkdir(parents=True, exist_ok=True)
with open(output_path, 'w') as f:
f.write(suggestions)

print(f"修复建议已生成: {output_path}")

五、编写提示词引导 AI 识别常见漏洞模式

5.1 Cursor AI 安全审查提示词设计原则

在 Cursor 中，AI 可以成为强大的安全审查助手。设计有效的安全提示词需要遵循以下原则：

原则一：明确角色与目标

你是一位资深应用安全工程师，专注于代码安全审查…

原则二：提供具体上下文

请审查以下 Node.js Express 代码，关注 OWASP Top 10 漏洞…

原则三：指定输出格式

请以表格形式输出：漏洞类型 | 严重等级 | 代码位置 | 修复建议

原则四：限定范围避免幻觉

只报告你确定的安全问题，不要猜测或过度推断…

5.2 SQL 注入识别提示词模板

在 Cursor 中按 Ctrl+L 打开 AI 对话，使用以下提示词：

# 角色设定
你是一位专注于数据库安全的资深安全工程师，精通 SQL 注入攻击与防御。

# 任务
请审查以下代码，识别所有潜在的 SQL 注入漏洞。

# 审查要点
1. 是否存在字符串拼接构造 SQL 语句
2. 用户输入是否直接进入查询而未参数化
3. ORM 使用是否存在 raw query 注入风险
4. 存储过程调用是否安全
5. 动态表名/列名是否有白名单验证

# 输出格式
对每个发现的问题，请提供：
– 📍 位置：文件名 + 行号
– 🔴 严重等级：Critical/High/Medium/Low
– 📝 问题描述：具体说明漏洞原理
– 💡 修复方案：给出具体修复代码
– 📚 参考：相关 CWE 编号

# 注意事项
– 只报告确定的问题，不确定的标注为"需要人工确认"
– 如果使用了参数化查询，不要误报
– 考虑框架自带的防护机制（如 Sequelize 的参数化）

# 待审查代码
[在此粘贴代码或选中代码后发送]

5.3 XSS 漏洞检测提示词模板

# 角色设定
你是一位 Web 前端安全专家，精通各类 XSS 攻击向量与防御策略。

# 任务
审查以下前端/后端代码，识别所有 XSS（跨站脚本）漏洞。

# 审查维度
1. **反射型 XSS**：用户输入是否未经编码直接输出到 HTML
2. **存储型 XSS**：数据库存储的内容在展示时是否转义
3. **DOM 型 XSS**：前端 JS 是否直接使用 innerHTML/document.write
4. **事件处理**：onerror/onclick 等事件属性是否可注入
5. **URL 注入**：href/src 属性是否可被 javascript: 协议利用

# 特别关注
– React 中的 dangerouslySetInnerHTML
– Vue 中的 v-html 指令
– Angular 中的 [innerHTML] 绑定
– 模板引擎的 raw/unescaped 输出（如 {{{ }}} in Handlebars）
– URL 参数直接插入 DOM

# 输出要求
对每个发现：
1. 漏洞类型（反射型/存储型/DOM型）
2. 攻击向量示例
3. 影响范围评估
4. 具体修复代码（包含转义函数推荐）
5. 防御纵深建议（CSP 配置等）

5.4 认证与授权缺陷检测

# 角色设定
你是一位身份认证与访问控制安全专家。

# 任务
审查以下代码中的认证（Authentication）和授权（Authorization）实现。

# 检查清单
## 认证相关
– [ ] 密码是否使用 bcrypt/argon2 哈希（非 MD5/SHA1）
– [ ] 是否有暴力破解防护（速率限制/账户锁定）
– [ ] Session/Token 是否设置合理过期时间
– [ ] 登录失败是否返回统一错误信息（不暴露用户是否存在）
– [ ] 密码重置流程是否安全

## 授权相关
– [ ] 是否存在越权访问（水平/垂直）
– [ ] API 端点是否都有权限校验
– [ ] 是否存在 IDOR（不安全的直接对象引用）
– [ ] JWT 是否验证签名和过期时间
– [ ] 敏感操作是否有二次确认

## 会话管理
– [ ] Cookie 是否设置 HttpOnly/Secure/SameSite
– [ ] 是否有 CSRF 防护
– [ ] 登出是否真正销毁会话

# 输出
按 OWASP 分类输出，每个问题附带修复代码示例。

5.5 敏感信息泄露检测

# 角色设定
你是一位数据安全与隐私保护专家。

# 任务
审查代码中是否存在敏感信息泄露风险。

# 检查项
1. **硬编码凭证**：密码、API Key、Token 是否硬编码在源码中
2. **日志泄露**：日志中是否记录敏感数据（密码、身份证号、银行卡号）
3. **错误信息**：异常处理是否暴露系统内部信息（堆栈、路径、版本）
4. **前端泄露**：源代码/注释中是否包含内部 URL、测试账号
5. **配置泄露**：.env 文件是否被忽略、调试模式是否关闭
6. **响应泄露**：API 响应是否返回多余敏感字段
7. **版本信息**：是否暴露框架/库版本号

# 正则模式参考
– API Key: /[A-Za-z0-9_\\-]{32,}/
– AWS Key: /AKIA[0-9A-Z]{16}/
– 私钥: /—–BEGIN (RSA|EC) PRIVATE KEY—–/
– 密码字段: /password\\s*[:=]\\s*['"][^'"]+['"]/

# 输出
对每个发现标注：泄露类型、影响等级、修复方案、预防措施

5.6 提示词链组合策略

将多个安全提示词组合成完整的审查流程，形成系统化的安全分析链条：

完整安全审查提示词链（分步执行）：

# 完整安全审查提示词链（在 Cursor 中按步骤执行）

## 第一步：快速扫描（Ctrl+L 打开 AI 对话）
"请快速扫描这段代码，列出所有潜在的安全问题，按严重性排序。
不需要详细解释，只需要列出问题类型和位置。格式如下：
1. [Critical] 文件:行号 – 问题简述
2. [High] 文件:行号 – 问题简述
…"

## 第二步：深入分析（针对第一步发现的问题）
"针对你发现的第 N 个问题 [具体问题]，请详细分析：
1. 攻击者如何利用这个漏洞？给出具体的攻击步骤和 payload
2. 这个漏洞的影响范围有多大？
3. 请给出完整的修复代码
4. 如何验证修复是否有效？"

## 第三步：防御加固
"在修复上述问题的基础上，请建议额外的防御措施：
1. 需要添加哪些安全头？
2. 是否需要添加速率限制？
3. 日志记录应如何调整？
4. 是否需要添加额外的输入验证？"

## 第四步：回归验证
"请审查修复后的代码，确认：
1. 原始漏洞是否已完全修复？
2. 修复是否引入了新的安全问题？
3. 修复是否影响了正常业务逻辑？
4. 是否有遗漏的攻击向量？"

提示词链的 .cursorrules 配置：

将安全审查角色固化到项目配置中，创建项目根目录下的 .cursorrules 文件：

<!– .cursorrules – 项目级 AI 安全审查配置 –>

# 项目安全审查规则

## 角色定义
你是一位资深应用安全工程师，在辅助编码时始终关注安全性。

## 编码时的安全准则
1. 所有用户输入必须验证和净化
2. 数据库操作必须使用参数化查询
3. 禁止使用 eval()、exec() 等危险函数
4. 敏感数据必须加密存储
5. API 端点必须有认证和授权检查
6. 错误处理不得暴露内部信息
7. 日志中不得记录敏感数据

## 代码生成时的安全检查
当生成代码时，自动考虑：
– 输入验证是否完整
– 是否存在注入风险
– 错误处理是否安全
– 是否有适当的访问控制
– 依赖是否安全

## 审查输出格式
发现安全问题时，使用以下格式：
⚠️ [严重等级] 问题描述
📍 位置：文件:行号
💡 修复建议：具体方案
📚 参考：CWE/OWASP 编号

## 技术栈特定规则
– Express.js: 必须使用 helmet()，所有路由需要输入验证
– React: 禁止 dangerouslySetInnerHTML，使用 DOMPurify
– Python: 使用参数化查询，禁止 os.system()
– 数据库: 所有查询必须参数化，禁止字符串拼接

组合提示词实战示例：

# 场景：审查一个用户注册接口

## 提示词 1（初始扫描）：
"审查以下 Express.js 用户注册代码，检查 OWASP Top 10 中的所有相关漏洞：

```javascript
app.post('/register', async (req, res) => {
const { username, email, password } = req.body;
const query = `INSERT INTO users (username, email, password)
VALUES ('${username}', '${email}', '${password}')`;
await db.execute(query);
res.send('注册成功');
});
```"

## 期望 AI 输出：
1. [Critical] SQL 注入 – 字符串拼接构造 SQL
2. [Critical] 明文密码存储 – 未使用哈希
3. [High] 缺少输入验证 – 未验证 email 格式
4. [Medium] 缺少速率限制 – 可被暴力注册
5. [Low] 响应信息过于简单 – 缺少适当状态码

## 提示词 2（深入修复）：
"请给出完整的修复代码，包含：
1. 参数化查询
2. bcrypt 密码哈希
3. 输入验证（使用 express-validator）
4. 速率限制
5. 适当的错误处理"

六、实战演练：从代码编写到风险修复闭环

6.1 项目初始化与场景设定

本节通过一个完整的实战项目，演示从代码编写到漏洞发现、修复、验证的完整闭环。

场景设定：构建一个简单的博客系统 API，包含用户管理、文章发布、评论功能。

项目初始化：

# 创建项目目录
mkdir secure-blog-api && cd secure-blog-api

# 初始化 Node.js 项目
npm init -y

# 安装依赖
npm install express mysql2 bcrypt jsonwebtoken helmet cors express-validator
npm install –save-dev nodemon eslint eslint-plugin-security semgrep

# 创建项目结构
mkdir -p src/{routes,controllers,middleware,models,utils}
mkdir -p tests
mkdir -p semgrep-rules/{injection,xss,auth}
mkdir -p scripts
mkdir -p reports

项目结构：

secure-blog-api/
├── src/
│ ├── app.js # 应用入口
│ ├── routes/
│ │ ├── auth.js # 认证路由
│ │ ├── posts.js # 文章路由
│ │ └── comments.js # 评论路由
│ ├── controllers/
│ │ ├── authController.js
│ │ ├── postController.js
│ │ └── commentController.js
│ ├── middleware/
│ │ ├── auth.js # 认证中间件
│ │ ├── validate.js # 输入验证中间件
│ │ └── errorHandler.js # 错误处理中间件
│ ├── models/
│ │ └── db.js # 数据库连接
│ └── utils/
│ ├── sanitize.js # 输入净化工具
│ └── logger.js # 安全日志工具
├── semgrep-rules/ # 自定义安全规则
├── scripts/ # 自动化脚本
├── tests/ # 测试文件
├── reports/ # 扫描报告
├── .eslintrc.json
├── .cursorrules
├── .semgrepignore
└── package.json

6.2 编写含漏洞的示例代码

为了演示完整的安全工作流，我们先编写一段故意包含漏洞的代码（仅用于教学演示）：

// src/controllers/authController.js
// ⚠️ 警告：此文件包含多个安全漏洞，仅用于教学演示！
// 实际项目中绝对不要这样编写代码！

const db = require('../models/db');
const jwt = require('jsonwebtoken');

// 漏洞1：硬编码密钥
const SECRET_KEY = "my-super-secret-key-12345";

// 漏洞2：SQL 注入 – 字符串拼接
exports.login = async (req, res) => {
const { username, password } = req.body;

// 危险：直接拼接用户输入到 SQL 语句
const query = `SELECT * FROM users WHERE username = '${username}' AND password = '${password}'`;

try {
const [rows] = await db.execute(query);

if (rows.length > 0) {
// 漏洞3：JWT 未设置过期时间
const token = jwt.sign({ userId: rows[0].id, role: rows[0].role }, SECRET_KEY);

// 漏洞4：返回过多用户信息
res.json({
success: true,
token: token,
user: rows[0] // 包含密码哈希等敏感信息
});
} else {
// 漏洞5：错误信息暴露用户是否存在
res.status(401).json({ error: '用户名不存在' });
}
} catch (error) {
// 漏洞6：暴露详细错误信息
res.status(500).json({ error: error.message, stack: error.stack });
}
};

// 漏洞7：缺少输入验证
exports.register = async (req, res) => {
const { username, email, password } = req.body;

// 漏洞8：明文存储密码
const query = `INSERT INTO users (username, email, password) VALUES ('${username}', '${email}', '${password}')`;

try {
await db.execute(query);
res.json({ success: true, message: '注册成功' });
} catch (error) {
res.status(500).json({ error: error.message });
}
};

// src/controllers/postController.js
// ⚠️ 同样包含安全漏洞的教学代码

const db = require('../models/db');

// 漏洞9：存储型 XSS – 未净化用户输入
exports.createPost = async (req, res) => {
const { title, content, authorId } = req.body;

// 直接将用户输入存入数据库，未做任何净化
const query = `INSERT INTO posts (title, content, author_id) VALUES (?, ?, ?)`;

try {
const [result] = await db.execute(query, [title, content, authorId]);
res.json({ success: true, postId: result.insertId });
} catch (error) {
res.status(500).json({ error: error.message });
}
};

// 漏洞10：IDOR – 未验证资源所有权
exports.getPost = async (req, res) => {
const postId = req.params.id;

// 任何人都可以访问任何文章，未验证权限
const query = `SELECT * FROM posts WHERE id = ${postId}`;

try {
const [rows] = await db.execute(query);
if (rows.length > 0) {
// 漏洞11：直接输出未转义的 HTML 内容
res.json({ success: true, post: rows[0] });
} else {
res.status(404).json({ error: '文章不存在' });
}
} catch (error) {
res.status(500).json({ error: error.message });
}
};

// 漏洞12：批量赋值 – 未限制可更新字段
exports.updatePost = async (req, res) => {
const postId = req.params.id;
const updates = req.body; // 接受所有字段

// 构造动态 UPDATE 语句
const fields = Object.keys(updates).map(key => `${key} = '${updates[key]}'`).join(', ');
const query = `UPDATE posts SET ${fields} WHERE id = ${postId}`;

try {
await db.execute(query);
res.json({ success: true });
} catch (error) {
res.status(500).json({ error: error.message });
}
};

// 漏洞13：命令注入
exports.exportPost = async (req, res) => {
const { format, filename } = req.query;
const { exec } = require('child_process');

// 危险：用户输入直接进入命令
exec(`pandoc posts/${filename} -o exports/${filename}.${format}`, (error, stdout) => {
if (error) {
res.status(500).json({ error: error.message });
} else {
res.download(`exports/${filename}.${format}`);
}
});
};

6.3 SAST 扫描触发与结果分析

在 Cursor 中触发扫描：

方法一：保存文件时自动触发（已配置 Semgrep 扩展）

方法二：手动在终端运行：

# 在 Cursor 终端中执行
# 扫描整个 src 目录
semgrep –config auto –config ./semgrep-rules/ ./src –json > reports/semgrep-scan.json

# 查看人类可读的结果
semgrep –config auto –config ./semgrep-rules/ ./src

预期扫描结果：

┌─────────────────────────────────────────────────────────────────┐
│ Semgrep 扫描结果 – secure-blog-api │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 🔴 ERROR: sql-injection-string-concat │
│ src/controllers/authController.js:14 │
│ > const query = `SELECT * FROM users WHERE username = … │
│ │
│ 🔴 ERROR: sql-injection-string-concat │
│ src/controllers/authController.js:30 │
│ > const query = `INSERT INTO users … │
│ │
│ 🔴 ERROR: hardcoded-secret │
│ src/controllers/authController.js:7 │
│ > const SECRET_KEY = "my-super-secret-key-12345"; │
│ │
│ 🔴 ERROR: plaintext-password-storage │
│ src/controllers/authController.js:30 │
│ > INSERT INTO users … password … │
│ │
│ 🔴 ERROR: command-injection │
│ src/controllers/postController.js:62 │
│ > exec(`pandoc posts/${filename}…`) │
│ │
│ 🟠 WARNING: missing-input-validation │
│ src/controllers/authController.js:27 │
│ > exports.register = async (req, res) => { │
│ │
│ 🟠 WARNING: excessive-data-exposure │
│ src/controllers/authController.js:19 │
│ > user: rows[0] │
│ │
│ 🟡 INFO: missing-rate-limiting │
│ src/controllers/authController.js:12 │
│ > exports.login = async (req, res) => { │
│ │
│ 总计: 5 ERROR, 2 WARNING, 1 INFO │
└─────────────────────────────────────────────────────────────────┘

6.4 AI 辅助漏洞解读

在 Cursor 中选中问题代码，按 Ctrl+L 打开 AI 对话：

提示词：

请解释这个 SQL 注入漏洞的攻击原理，并给出具体的攻击 payload 示例。
然后提供完整的修复代码。

AI 预期回复（示例）：

## 漏洞分析：SQL 注入

### 攻击原理
当前代码使用模板字符串直接拼接用户输入：
```javascript
const query = `SELECT * FROM users WHERE username = '${username}' AND password = '${password}'`;

攻击者可以输入以下用户名：

admin' —

这使得 SQL 变为：

SELECT * FROM users WHERE username = 'admin' –' AND password = ''

— 注释掉了密码检查，攻击者无需密码即可登录。

• 更危险的 Payload

  ' UNION SELECT id, username, password, 'admin' FROM users —

  可以获取所有用户数据。

• 修复代码 [完整修复代码见下一节]

6.5 修复代码编写与验证

修复后的 authController.js：

// src/controllers/authController.js
// ✅ 修复后的安全版本

const db = require('../models/db');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');
const { body, validationResult } = require('express-validator');
const { sanitizeInput } = require('../utils/sanitize');
const { logger } = require('../utils/logger');

// ✅ 修复1：密钥从环境变量读取
const SECRET_KEY = process.env.JWT_SECRET_KEY;
const SALT_ROUNDS = 12; // bcrypt 盐值轮数

// 输入验证规则
const loginValidation = [
body('username')
.trim()
.isLength({ min: 3, max: 50 })
.withMessage('用户名长度必须在3-50个字符之间')
.matches(/^[a-zA-Z0-9_]+$/)
.withMessage('用户名只能包含字母、数字和下划线'),
body('password')
.isLength({ min: 8, max: 128 })
.withMessage('密码长度必须在8-128个字符之间')
];

const registerValidation = [
body('username')
.trim()
.isLength({ min: 3, max: 50 })
.matches(/^[a-zA-Z0-9_]+$/),
body('email')
.trim()
.isEmail()
.withMessage('请输入有效的邮箱地址')
.normalizeEmail(),
body('password')
.isLength({ min: 8, max: 128 })
.matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&]).+$/)
.withMessage('密码必须包含大小写字母、数字和特殊字符')
];

/**
* 用户登录
* ✅ 修复2：使用参数化查询防止 SQL 注入
* ✅ 修复3：使用 bcrypt 验证密码哈希
* ✅ 修复4：JWT 设置过期时间
* ✅ 修复5：统一错误信息，不暴露用户是否存在
* ✅ 修复6：安全的错误处理
*/
exports.login = [
loginValidation,
async (req, res) => {
// 检查验证结果
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({
success: false,
errors: errors.array().map(e => ({
field: e.path,
message: e.msg
}))
});
}

const { username, password } = req.body;

try {
// ✅ 参数化查询 – 防止 SQL 注入
const query = 'SELECT id, username, email, password_hash, role, created_at FROM users WHERE username = ?';
const [rows] = await db.execute(query, [username]);

if (rows.length === 0) {
// ✅ 统一错误信息 – 不暴露用户是否存在
logger.warn(`登录失败 – 用户不存在: ${sanitizeInput(username)}`);
return res.status(401).json({
success: false,
error: '用户名或密码错误' // 统一错误信息
});
}

const user = rows[0];

// ✅ 使用 bcrypt 比较密码哈希
const isPasswordValid = await bcrypt.compare(password, user.password_hash);

if (!isPasswordValid) {
logger.warn(`登录失败 – 密码错误: ${sanitizeInput(username)}`);
return res.status(401).json({
success: false,
error: '用户名或密码错误' // 与上面相同的错误信息
});
}

// ✅ JWT 设置过期时间（2小时）
const token = jwt.sign(
{
userId: user.id,
role: user.role
// 不包含敏感信息
},
SECRET_KEY,
{
expiresIn: '2h', // 2小时过期
algorithm: 'HS256'
}
);

// ✅ 只返回必要的用户信息
res.json({
success: true,
token: token,
user: {
id: user.id,
username: user.username,
email: user.email,
role: user.role
// 不返回 password_hash 等敏感字段
}
});

logger.info(`用户登录成功: ${user.id}`);

} catch (error) {
// ✅ 安全的错误处理 – 不暴露内部信息
logger.error(`登录处理错误: ${error.message}`);
res.status(500).json({
success: false,
error: '服务器内部错误，请稍后重试'
});
}
}
];

/**
* 用户注册
* ✅ 修复7：完整的输入验证
* ✅ 修复8：bcrypt 哈希密码
*/
exports.register = [
registerValidation,
async (req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({
success: false,
errors: errors.array().map(e => ({
field: e.path,
message: e.msg
}))
});
}

const { username, email, password } = req.body;

try {
// 检查用户名是否已存在
const [existing] = await db.execute(
'SELECT id FROM users WHERE username = ? OR email = ?',
[username, email]
);

if (existing.length > 0) {
return res.status(409).json({
success: false,
error: '用户名或邮箱已被注册'
});
}

// ✅ 使用 bcrypt 哈希密码
const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);

// ✅ 参数化查询
await db.execute(
'INSERT INTO users (username, email, password_hash) VALUES (?, ?, ?)',
[username, email, passwordHash]
);

logger.info(`新用户注册: ${username}`);

res.status(201).json({
success: true,
message: '注册成功'
});

} catch (error) {
logger.error(`注册处理错误: ${error.message}`);
res.status(500).json({
success: false,
error: '注册失败，请稍后重试'
});
}
}
];

修复后的 postController.js：

// src/controllers/postController.js
// ✅ 修复后的安全版本

const db = require('../models/db');
const DOMPurify = require('isomorphic-dompurify');
const { body, param, validationResult } = require('express-validator');
const { sanitizeInput } = require('../utils/sanitize');
const { logger } = require('../utils/logger');
const path = require('path');

// 允许更新的字段白名单
const ALLOWED_UPDATE_FIELDS = ['title', 'content', 'status'];

/**
* 创建文章
* ✅ 修复9：输入净化防止 XSS
*/
exports.createPost = [
body('title')
.trim()
.isLength({ min: 1, max: 200 })
.withMessage('标题长度必须在1-200个字符之间'),
body('content')
.trim()
.isLength({ min: 1, max: 50000 })
.withMessage('内容长度必须在1-50000个字符之间'),
async (req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({
success: false,
errors: errors.array()
});
}

const { title, content } = req.body;
// 从 JWT token 中获取用户ID（而非请求体）
const authorId = req.user.userId;

try {
// ✅ 净化 HTML 内容防止存储型 XSS
const sanitizedContent = DOMPurify.sanitize(content, {
ALLOWED_TAGS: ['p', 'br', 'strong', 'em', 'u', 'a', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'code', 'pre'],
ALLOWED_ATTR: ['href', 'target', 'rel'],
// 禁止 javascript: 协议
ALLOW_DATA_ATTR: false
});

// ✅ 参数化查询
const [result] = await db.execute(
'INSERT INTO posts (title, content, author_id, created_at) VALUES (?, ?, ?, NOW())',
[sanitizeInput(title), sanitizedContent, authorId]
);

logger.info(`文章创建成功: ID=${result.insertId}, 作者=${authorId}`);

res.status(201).json({
success: true,
postId: result.insertId
});

} catch (error) {
logger.error(`创建文章失败: ${error.message}`);
res.status(500).json({
success: false,
error: '创建文章失败'
});
}
}
];

/**
* 获取文章
* ✅ 修复10：参数化查询 + 输入验证
*/
exports.getPost = [
param('id')
.isInt({ min: 1 })
.withMessage('无效的文章ID'),
async (req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({
success: false,
error: '无效的文章ID'
});
}

const postId = parseInt(req.params.id, 10);

try {
// ✅ 参数化查询
const [rows] = await db.execute(
'SELECT id, title, content, author_id, created_at, updated_at FROM posts WHERE id = ? AND status = ?',
[postId, 'published']
);

if (rows.length === 0) {
return res.status(404).json({
success: false,
error: '文章不存在'
});
}

res.json({
success: true,
post: rows[0]
});

} catch (error) {
logger.error(`获取文章失败: ${error.message}`);
res.status(500).json({
success: false,
error: '获取文章失败'
});
}
}
];

/**
* 更新文章
* ✅ 修复11：字段白名单 + 所有权验证
* ✅ 修复12：参数化动态查询
*/
exports.updatePost = [
param('id').isInt({ min: 1 }),
body('title').optional().trim().isLength({ min: 1, max: 200 }),
body('content').optional().trim().isLength({ min: 1, max: 50000 }),
body('status').optional().isIn(['draft', 'published', 'archived']),
async (req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({
success: false,
errors: errors.array()
});
}

const postId = parseInt(req.params.id, 10);
const userId = req.user.userId;

try {
// ✅ 验证资源所有权
const [ownership] = await db.execute(
'SELECT id FROM posts WHERE id = ? AND author_id = ?',
[postId, userId]
);

if (ownership.length === 0) {
return res.status(403).json({
success: false,
error: '无权修改此文章'
});
}

// ✅ 字段白名单过滤
const updates = {};
for (const [key, value] of Object.entries(req.body)) {
if (ALLOWED_UPDATE_FIELDS.includes(key)) {
updates[key] = key === 'content' ? DOMPurify.sanitize(value) : sanitizeInput(value);
}
}

if (Object.keys(updates).length === 0) {
return res.status(400).json({
success: false,
error: '没有有效的更新字段'
});
}

// ✅ 安全的动态查询构建
const setClauses = Object.keys(updates).map(key => `${key} = ?`);
const values = Object.values(updates);
values.push(postId);

await db.execute(
`UPDATE posts SET ${setClauses.join(', ')}, updated_at = NOW() WHERE id = ?`,
values
);

logger.info(`文章更新: ID=${postId}, 用户=${userId}`);

res.json({ success: true });

} catch (error) {
logger.error(`更新文章失败: ${error.message}`);
res.status(500).json({
success: false,
error: '更新文章失败'
});
}
}
];

/**
* 导出文章
* ✅ 修复13：移除命令注入风险，使用安全的文件操作
*/
exports.exportPost = [
param('id').isInt({ min: 1 }),
async (req, res) => {
const postId = parseInt(req.params.id, 10);
const format = req.query.format;

// ✅ 白名单验证导出格式
const ALLOWED_FORMATS = ['pdf', 'html', 'markdown'];
if (!ALLOWED_FORMATS.includes(format)) {
return res.status(400).json({
success: false,
error: '不支持的导出格式'
});
}

try {
const [rows] = await db.execute(
'SELECT title, content FROM posts WHERE id = ?',
[postId]
);

if (rows.length === 0) {
return res.status(404).json({
success: false,
error: '文章不存在'
});
}

// ✅ 使用安全的文件生成方式，而非 shell 命令
const safeFilename = `post_${postId}_${Date.now()}.${format}`;
const outputPath = path.join(__dirname, '../../exports', safeFilename);

// 使用 Node.js 库生成文件（而非 exec 命令）
// 具体实现取决于格式…

res.json({
success: true,
downloadUrl: `/exports/${safeFilename}`
});