Ruoyi-Scan 用户指南#

# 1. 克隆仓库
git clone https://github.com/xiabai2008/Ruoyi-Scan.git
cd Ruoyi-Scan

# 2. 可编辑模式安装（修改源码即时生效）
pip install -e .

# 3. 按需安装可选依赖（开发场景推荐 dev + all）
pip install -e ".[dev,all]"

# 4. 按需安装特定功能组（推荐生产环境，减小依赖体积）
pip install -e ".[report]"          # PDF / Word / Excel 报告增强
pip install -e ".[serve]"           # FastAPI Web API + WebSocket + Web 控制台
pip install -e ".[distributed]"     # Redis 分布式扫描（master/worker）
pip install -e ".[async]"           # aiohttp 异步 HTTP 引擎
pip install -e ".[yaml]"            # --config YAML 配置文件支持
pip install -e ".[lab]"             # 内置 Flask 靶场环境

# 5. 组合安装
pip install -e ".[report,serve,yaml]"

# 6. 直接通过 main.py 运行
python main.py -p http://target:8080/

# 7. 运行测试验证安装
python -m pytest tests/ -q
python tests/regression_ruoyi.py
python tests/regression_spring.py

docker build -t ruoyi-scan .

# 基本扫描
docker run --rm ruoyi-scan -p http://target:8080/

# 扫描并将报告挂载到宿主机
docker run --rm -v "$(pwd)/reports:/app/reports" ruoyi-scan \
  -p http://target:8080/ --report /app/reports --report-format all

# 使用环境变量传递 API Key
docker run --rm -e RUOYI_SCAN_API_KEY=your-secret ruoyi-scan \
  -p http://target:8080/ --api-key your-secret

docker run --rm -p 8000:8000 ruoyi-scan \
  --serve --host 0.0.0.0 --port 8000

# 带鉴权
docker run --rm -p 8000:8000 \
  -e RUOYI_SCAN_API_KEY=your-secret \
  ruoyi-scan --serve --host 0.0.0.0 --port 8000 --api-key your-secret

# 启动全部服务（扫描器 + API + 2 个签名靶场）
docker compose up -d

# 扫描内置靶场
docker compose run --rm scanner -p http://lab-ruoyi:8080/ --report /app/reports

# 启动监控栈（Prometheus + Grafana）
docker compose --profile monitor up -d
# Grafana:      http://localhost:3000  (admin/admin)
# Prometheus:   http://localhost:9090

# 清理
docker compose down

# 1. 基础漏洞扫描
ruoyi-scan -p http://target:8080/

# 2. 跳过指纹识别，手动指定 CMS
ruoyi-scan -p http://target:8080/ --cms ruoyi
ruoyi-scan -p http://target:8080/ --cms spring

# 3. 指定插件类别（缩小检测范围）
ruoyi-scan -p http://target:8080/ --category ruoyi
ruoyi-scan -p http://target:8080/ --category spring
ruoyi-scan -p http://target:8080/ --category common

# 4. 配合并发与限速（生产环境推荐）
ruoyi-scan -p http://target:8080/ --threads 10 --rate 20 --timeout 10

# 5. 通过代理扫描（如 BurpSuite 调试）
ruoyi-scan -p http://target:8080/ --proxy http://127.0.0.1:8080

# 6. 启用 WAF 自动绕过
ruoyi-scan -p http://target:8080/ --bypass-waf auto

# 7. 生成全格式报告
ruoyi-scan -p http://target:8080/ --report ./reports --report-format all

# 8. 启用 OAST 带外检测（盲漏洞）
ruoyi-scan -p http://target:8080/ --oast

# 9. 启用业务逻辑检测（IDOR / 越权 / 参数篡改 / 竞争条件）
ruoyi-scan -p http://target:8080/ --logic-scan

# 1. 基础目录扫描
ruoyi-scan -m http://target:8080/

# 2. 高并发扫描（注意目标承受能力）
ruoyi-scan -m http://target:8080/ --threads 20 --rate 50

# 3. 通过代理池轮换 IP（避免被封）
ruoyi-scan -m http://target:8080/ \
  --proxy-file proxies.txt --proxy-rotate round-robin

# 4. 结合爬虫深入发现
ruoyi-scan -m http://target:8080/ --crawl --crawl-depth 3 --crawl-max-pages 100

# 5. 子域名枚举 + 目录扫描
ruoyi-scan -m http://target.com/ --subdomain

# 6. JS 端点提取（从 JS 文件中提取 API 路径）
ruoyi-scan -m http://target:8080/ --js-extract

# 1. 综合扫描（一站式）
ruoyi-scan -u http://target:8080/

# 2. 指定口令字典级别
ruoyi-scan -u http://target:8080/ --pass-level top100     # 快速
ruoyi-scan -u http://target:8080/ --pass-level top1000    # 平衡
ruoyi-scan -u http://target:8080/ --pass-level full       # 全量（耗时较长）

# 3. 综合扫描 + 端口扫描 + 服务识别
ruoyi-scan -u http://target:8080/ --portscan

# 4. 综合扫描 + 业务逻辑漏洞检测
ruoyi-scan -u http://target:8080/ --logic-scan \
  --logic-endpoints endpoints.txt --logic-concurrency 20

# 5. 综合扫描 + 全格式报告
ruoyi-scan -u http://target:8080/ --report ./reports --report-format all --lang zh

# 6. 使用 deep 模板（深度扫描）
ruoyi-scan -u http://target:8080/ --template deep

# 1. 基础登录爆破
ruoyi-scan -l http://target:8080/login

# 2. 指定字典级别
ruoyi-scan -l http://target:8080/login --pass-level top1000

# 3. 全量字典爆破（耗时较长）
ruoyi-scan -l http://target:8080/login --pass-level full --threads 5 --rate 10

# 4. 通过代理爆破（避免触发 WAF）
ruoyi-scan -l http://target:8080/login --proxy http://127.0.0.1:8080

# 每行一个目标 URL，# 开头为注释，空行自动忽略
# 支持 http/https，可带端口

# 若依系统
http://10.0.0.1:8080/
http://10.0.0.2:8080/
https://ruoyi.example.com/

# Spring Boot 系统
http://10.0.0.3:9090/
http://spring.example.com/

# 带路径的目标
http://10.0.0.4:8080/ruoyi/

# 1. 批量漏洞扫描
ruoyi-scan -f targets.txt -p --report ./batch_reports

# 2. 批量综合扫描（耗时较长，建议配合分布式）
ruoyi-scan -f targets.txt -u --report ./batch_reports --report-format all

# 3. 批量扫描 + 限速（避免对网络造成压力）
ruoyi-scan -f targets.txt -p --threads 20 --rate 100 --timeout 10

# 4. 批量扫描 + 异步引擎（千级目标推荐）
ruoyi-scan -f targets.txt -p --async --async-workers 50

# 5. 批量扫描 + 分布式（万级目标推荐）
# 见「分布式扫描」章节

# 6. 批量扫描 + CI 模式（合规检查）
ruoyi-scan -f targets.txt -p --ci --severity-threshold high

# 1. 启动被动代理（默认 127.0.0.1:8080）
ruoyi-scan --passive

# 2. 自定义监听地址与端口
ruoyi-scan --passive --passive-host 0.0.0.0 --passive-port 9090

# 3. 启用报告输出
ruoyi-scan --passive --report ./passive_reports --report-format all

# Windows
chrome.exe --proxy-server="http://127.0.0.1:8080"

# Linux / macOS
google-chrome --proxy-server="http://127.0.0.1:8080"

# Ruoyi-Scan 作为下游，BurpSuite 作为上游
ruoyi-scan --passive --passive-port 8080 --proxy http://127.0.0.1:8888
# 浏览器 → Ruoyi-Scan(8080) → BurpSuite(8888) → 目标

pip install "ruoyi-scan[yaml]"
# 或
pip install pyyaml

# Ruoyi-Scan 完整配置文件示例
# 所有字段均可选，未配置的字段使用默认值

# ── 扫描模式 ──
# mode: p | m | u | l | passive | serve
# 与 CLI 的 -p/-m/-u/-l/--passive/--serve 对应
mode: p
target: http://target:8080/
targets_file: targets.txt        # 批量扫描目标文件（mode 为批量时使用）
cms: ruoyi                        # 手动指定 CMS，留空则自动指纹识别
category: ruoyi                   # 插件类别 ruoyi/spring/common

# ── 扫描模板 ──
template: deep                    # quick/deep/compliance/dengbao

# ── 网络与并发 ──
threads: 10                       # 并发线程数
rate: 20                          # 每秒请求数（0=不限速）
timeout: 10                       # 请求超时秒数
proxy: http://127.0.0.1:8080      # 代理地址
proxy_file: proxies.txt           # 代理池文件
proxy_rotate: round-robin         # 代理轮换策略 round-robin/random/least-fail
debug: false                      # 调试模式

# ── 信息收集 ──
crawl: true                       # 启用主动爬虫
crawl_depth: 3                    # 爬虫最大深度
crawl_max_pages: 100              # 爬虫最大页面数
subdomain: false                  # 子域名枚举
js_extract: true                  # JS 端点提取
portscan: false                   # 端口扫描
ports: "22,80,443,3306,6379,8080" # 自定义端口列表

# ── 登录爆破 ──
pass_level: top1000               # 口令字典级别 top100/top1000/full

# ── WAF 绕过 ──
bypass_waf: auto                  # auto/on/off

# ── 漏洞利用链 ──
chain: ruoyi_sql_to_rce           # 执行指定的利用链

# ── 认证扫描 ──
auth:
  - "cookie: SESSIONID=abc123"
  - "bearer: eyJhbGciOi..."
auth_file: auth.txt               # 从文件加载认证信息
auth_login: "admin:admin123"      # 自动登录

# ── 报告输出 ──
report: ./reports                 # 报告输出目录
report_format: all                # html/json/csv/pdf/docx/xlsx/sarif/all
no_dedup: false                   # 关闭结果去重
lang: zh                          # 报告语言 zh/en
diff: old_report.json             # 与历史扫描对比
save_baseline: false              # 保存为基线

# ── OAST 带外检测 ──
oast: false                       # 启用 OAST

# ── 业务逻辑检测 ──
logic_scan: false                 # 业务逻辑漏洞检测
logic_endpoints: endpoints.txt    # 业务端点列表
logic_concurrency: 20             # 竞争条件检测并发数

# ── 异步引擎 ──
async: false                      # 启用异步引擎
async_workers: 10                 # 异步并发线程数

# ── 分布式扫描 ──
distributed: standalone           # master/worker/standalone
redis_url: redis://localhost:6379/0
distributed_rate: 100             # 分布式全局限速
worker_max_tasks: 0               # Worker 最大任务数
distributed_timeout: 600          # 分布式超时秒数

# ── 结果缓存 ──
cache: true                       # 启用 SQLite 缓存
cache_ttl: 3600                   # 缓存有效期秒数
cache_db: ./cache/scan_cache.db   # 缓存数据库路径

# ── Web API 服务 ──
serve: false
host: 0.0.0.0
port: 8000
api_key: your-secret-key
cors_origins: "https://scanner.internal,https://admin.internal"
db_path: ./data/tasks.db

# ── CI/CD 集成 ──
ci: false                         # CI 模式
severity_threshold: high          # CI 失败阈值 low/medium/high

# ── SIEM 集成 ──
siem_export: ecs                  # ecs/cef/leef/json
siem_output: ./siem/events.json
siem_syslog: "10.0.0.100:514"
siem_protocol: udp                # udp/tcp

# ── 通知 ──
notify:
  - "webhook:https://hooks.slack.com/services/xxx"
  - "mail:security@example.com"

# 加载配置文件运行
ruoyi-scan --config config.yaml

# 配置文件 + CLI 参数混用（CLI 优先级更高）
ruoyi-scan --config config.yaml -p http://other-target:8080/ --threads 20

# 配置文件中的 threads=10 会被 CLI 的 --threads 20 覆盖
# 配置文件中的 target 会被 CLI 的 -p 参数覆盖

# 列出所有可用模板及其参数
ruoyi-scan --template-list

可用扫描模板：
┌──────────────┬──────────────────┬─────────────────────────┐
│ 模板名称     │ 用途             │ 关键参数                │
├──────────────┼──────────────────┼─────────────────────────┤
│ quick        │ 快速扫描         │ threads=5 rate=20       │
│ deep         │ 深度扫描         │ threads=20 rate=50      │
│ compliance   │ 合规扫描         │ report=sarif cve=on     │
│ dengbao      │ 等保专项         │ report=html+pdf lang=zh │
└──────────────┴──────────────────┴─────────────────────────┘

# 快速扫描（CI 流水线推荐）
ruoyi-scan -p http://target:8080/ --template quick

# 深度扫描（完整渗透测试）
ruoyi-scan -u http://target:8080/ --template deep

# 合规扫描（生成 SARIF + OWASP 映射）
ruoyi-scan -p http://target:8080/ --template compliance

# 等保专项（生成中文 HTML + PDF 报告）
ruoyi-scan -p http://target:8080/ --template dengbao

# 模板 + CLI 参数混用（CLI 覆盖模板参数）
ruoyi-scan -p http://target:8080/ --template deep --threads 30 --rate 100

ruoyi-scan --config my_template.yaml -p http://target:8080/

# my_deep.yaml — 基于 deep 模板，调整并发与限速
template: deep        # 继承 deep 模板
threads: 30            # 覆盖并发数
rate: 100              # 覆盖限速
crawl_depth: 5         # 加深爬虫深度

ruoyi-scan --config my_deep.yaml -u http://target:8080/

from core.runner import ScanRunner

runner = ScanRunner(
    target="http://target:8080/",
    template="deep",
    threads=30,
    rate=100,
)
runner.run()

# 自动模式（默认，推荐）
ruoyi-scan -p http://target:8080/ --bypass-waf auto

# 强制启用
ruoyi-scan -p http://target:8080/ --bypass-waf on

# 禁用绕过
ruoyi-scan -p http://target:8080/ --bypass-waf off

WAF 绕过策略统计：
┌────────────────┬──────────┬──────────┬──────────┐
│ 策略           │ 尝试次数 │ 成功次数 │ 成功率   │
├────────────────┼──────────┼──────────┼──────────┤
│ 大小写混淆     │ 15       │ 12       │ 80.0%    │
│ URL 编码       │ 15       │ 10       │ 66.7%    │
│ 双重 URL 编码  │ 10       │ 8        │ 80.0%    │
│ 注释混淆       │ 12       │ 9        │ 75.0%    │
│ ...            │ ...      │ ...      │ ...      │
└────────────────┴──────────┴──────────┴──────────┘

# 列出所有可用的漏洞利用链
ruoyi-scan --chain-list
# 或
ruoyi-scan --chain list

可用漏洞利用链：
┌─────────────────────────────┬────────────────────────────┬─────────────────────┐
│ 链名称                      │ 描述                       │ 步骤数              │
├─────────────────────────────┼────────────────────────────┼─────────────────────┤
│ ruoyi_sql_to_rce            │ SQL 注入 → 文件写入 → RCE  │ 3                   │
│ ruoyi_nacos_to_dbcreds      │ Nacos 未授权 → DB 凭据泄露 │ 2                   │
│ ruoyi_defaultpw_to_webshell │ 默认口令 → Webshell 上传   │ 2                   │
└─────────────────────────────┴────────────────────────────┴─────────────────────┘

# 执行指定的利用链
ruoyi-scan --chain ruoyi_sql_to_rce -u http://target:8080/

# 执行链 + 生成报告
ruoyi-scan --chain ruoyi_nacos_to_dbcreds -u http://target:8080/ \
  --report ./reports --report-format all

# 执行链 + WAF 绕过
ruoyi-scan --chain ruoyi_defaultpw_to_webshell -u http://target:8080/ \
  --bypass-waf auto

SQL 注入漏洞（如 druid 监控页未授权 / SQL 注入点）
    ↓
通过 SQL 注入写入 Webshell 到 Web 目录
    ↓
通过 Webshell 执行任意命令（RCE）

Nacos 未授权访问（/nacos/v1/auth/users?pageNo=1&pageSize=1）
    ↓
读取 Nacos 配置文件，提取数据库账号密码

使用若依默认口令（admin/admin123）登录后台
    ↓
利用文件上传功能上传 Webshell

ruoyi_sql_to_rce 的 DAG 结构：

[SQL 注入检测] ──CONFIRMED──> [文件写入] ──CONFIRMED──> [RCE 验证]
       │                          │
       └──SAFE/UNKNOWN──> 终止     └──SAFE/UNKNOWN──> 终止

# 1. 生成单一格式报告
ruoyi-scan -p http://target:8080/ --report ./reports --report-format html
ruoyi-scan -p http://target:8080/ --report ./reports --report-format json
ruoyi-scan -p http://target:8080/ --report ./reports --report-format pdf
ruoyi-scan -p http://target:8080/ --report ./reports --report-format sarif

# 2. 生成全部格式报告（推荐）
ruoyi-scan -p http://target:8080/ --report ./reports --report-format all

# 3. 生成中文报告（默认）
ruoyi-scan -p http://target:8080/ --report ./reports --report-format all --lang zh

# 4. 生成英文报告
ruoyi-scan -p http://target:8080/ --report ./reports --report-format all --lang en

# 5. 关闭结果去重（保留原始记录）
ruoyi-scan -p http://target:8080/ --report ./reports --no-dedup

ruoyi-scan -p http://target:8080/ --report ./reports --report-format all

reports/
├── report_<target>_<timestamp>.html
├── report_<target>_<timestamp>.json
├── report_<target>_<timestamp>.csv
├── report_<target>_<timestamp>.pdf
├── report_<target>_<timestamp>.docx
├── report_<target>_<timestamp>.xlsx
└── report_<target>_<timestamp>.sarif

# 中文报告（默认）
ruoyi-scan -p http://target:8080/ --report ./reports --report-format html --lang zh

# 英文报告
ruoyi-scan -p http://target:8080/ --report ./reports --report-format html --lang en

# 1. 第一次扫描，保存为基线
ruoyi-scan -p http://target:8080/ --report ./reports --report-format json --save-baseline

# 2. 整改后第二次扫描，与基线对比
ruoyi-scan -p http://target:8080/ --report ./reports --report-format json \
  --diff ./reports/report_target_20260701.json

# 3. 仅对比两个 JSON 报告（不执行扫描）
ruoyi-scan --diff-only old_report.json new_report.json

pip install "ruoyi-scan[serve]"

# 1. 基本启动（默认 0.0.0.0:8000）
ruoyi-scan --serve

# 2. 自定义监听地址与端口
ruoyi-scan --serve --host 0.0.0.0 --port 9000

# 3. 启用 API Key 鉴权
ruoyi-scan --serve --api-key your-secret-key

# 4. 配置 CORS（允许前端跨域访问）
ruoyi-scan --serve --cors-origins "https://scanner.internal,https://admin.internal"

# 5. 自定义任务数据库路径
ruoyi-scan --serve --db-path ./data/tasks.db

# 6. Docker 启动
docker run --rm -p 8000:8000 ruoyi-scan \
  --serve --host 0.0.0.0 --port 8000 --api-key your-secret

# 启动带鉴权的服务
ruoyi-scan --serve --api-key your-secret-key

# 调用 API 时携带 Key
curl -H "X-API-Key: your-secret-key" http://localhost:8000/api/v1/tasks

# 也可通过环境变量配置
export RUOYI_SCAN_API_KEY=your-secret-key
ruoyi-scan --serve

// JavaScript 示例（有 Key 模式：子协议数组第二项为密钥；无 Key 模式仅需第一个参数）
const ws = new WebSocket(
    "ws://localhost:8000/ws/scan/your-task-id",
    ["ruoyi-scan-api-key", "your-secret-key"],
);

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log("事件类型:", data.type);
  console.log("事件数据:", data.payload);
};

// 事件类型示例：
// { type: "scan_started",  payload: { task_id, target, mode } }
// { type: "fingerprint",   payload: { task_id, cms, version } }
// { type: "vuln_found",    payload: { task_id, vuln_id, severity, name } }
// { type: "scan_progress", payload: { task_id, progress, current_poc } }
// { type: "scan_finished", payload: { task_id, total_vulns, duration } }

import websockets
import asyncio
import json

async def listen():
    # 有 Key 模式：subprotocols 第二项为密钥；无 Key 模式可省略
    uri = "ws://localhost:8000/ws/scan/your-task-id"
    async with websockets.connect(uri, subprotocols=["ruoyi-scan-api-key", "your-secret-key"]) as ws:
        async for message in ws:
            event = json.loads(message)
            print(f"[{event['type']}] {event['payload']}")

asyncio.run(listen())

# 1. Cookie 认证（最常用）
ruoyi-scan -p http://target:8080/ --auth "cookie: SESSIONID=abc123; JSESSIONID=xyz789"

# 2. Token 认证（如自定义 Header）
ruoyi-scan -p http://target:8080/ --auth "token: X-Token:my-token-value"

# 3. Bearer 认证（JWT 等）
ruoyi-scan -p http://target:8080/ --auth "bearer: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

# 4. 组合多种认证
ruoyi-scan -p http://target:8080/ \
  --auth "cookie: SESSIONID=abc123" \
  --auth "bearer: eyJhbGciOi..."

# 5. 认证扫描 + 漏洞检测 + 报告
ruoyi-scan -p http://target:8080/ \
  --auth "cookie: SESSIONID=abc123" \
  --report ./reports --report-format all

# 1. 创建认证文件 auth.txt
cat > auth.txt << 'EOF'
cookie: SESSIONID=abc123; JSESSIONID=xyz789
bearer: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
EOF

# 2. 从文件加载认证
ruoyi-scan -p http://target:8080/ --auth-file auth.txt

# 3. 批量扫描时复用认证
ruoyi-scan -f targets.txt -p --auth-file auth.txt --report ./reports

# 1. 自动登录（用户名:密码）
ruoyi-scan -p http://target:8080/ --auth-login "admin:admin123"

# 2. 自动登录 + 综合扫描
ruoyi-scan -u http://target:8080/ --auth-login "admin:Password123!"

# 3. 自动登录 + 验证码自动识别
ruoyi-scan -p http://target:8080/ --auth-login "admin:admin123"
# （扫描器自动检测验证码并调用 OCR）

# 4. 自动登录 + 报告
ruoyi-scan -p http://target:8080/ --auth-login "admin:admin123" \
  --report ./reports --report-format all

pip install "ruoyi-scan[distributed]"
# 或
pip install redis

# Docker 启动 Redis
docker run -d --name redis -p 6379:6379 redis:7

# 或使用 docker-compose
# 见项目 docker-compose.yml

# 通过 CLI 参数
ruoyi-scan --distributed master --redis-url redis://localhost:6379/0

# 通过环境变量
export REDIS_URL=redis://localhost:6379/0
ruoyi-scan --distributed master

# 通过配置文件（config.yaml）
# distributed: master
# redis_url: redis://localhost:6379/0

redis://[:password@]host:port/db
redis://localhost:6379/0                    # 无密码
redis://:mypassword@localhost:6379/0        # 带密码
redis://user:mypassword@redis-host:6379/0   # ACL 用户
rediss://localhost:6379/0                   # TLS 加密

# 1. 启动 Master，分发批量目标
ruoyi-scan --distributed master \
  --redis-url redis://localhost:6379/0 \
  -f targets.txt -p

# 2. 配置全局限速（所有 Worker 共享）
ruoyi-scan --distributed master \
  --redis-url redis://localhost:6379/0 \
  -f targets.txt -p \
  --distributed-rate 1000

# 3. 配置超时（默认 600 秒）
ruoyi-scan --distributed master \
  --redis-url redis://localhost:6379/0 \
  -f targets.txt -p \
  --distributed-timeout 3600

# 1. 启动 Worker（可启动多个）
ruoyi-scan --distributed worker \
  --redis-url redis://localhost:6379/0

# 2. 限制 Worker 最大任务数（执行完毕自动退出）
ruoyi-scan --distributed worker \
  --redis-url redis://localhost:6379/0 \
  --worker-max-tasks 100

# 3. Worker 也配置并发与限速
ruoyi-scan --distributed worker \
  --redis-url redis://localhost:6379/0 \
  --threads 10 --rate 20

# 4. 多机部署：在多台服务器上分别启动 Worker
# 服务器 A
ruoyi-scan --distributed worker --redis-url redis://redis-host:6379/0
# 服务器 B
ruoyi-scan --distributed worker --redis-url redis://redis-host:6379/0

# 假设有 10 个 Worker，希望总计 1000 QPS
# Master 配置全局限速
ruoyi-scan --distributed master \
  --redis-url redis://localhost:6379/0 \
  -f targets.txt -p \
  --distributed-rate 1000

# 每个 Worker 无需单独配置 rate，由 Master 统一调度
ruoyi-scan --distributed worker \
  --redis-url redis://localhost:6379/0

# 显式指定 standalone（默认）
ruoyi-scan --distributed standalone -f targets.txt -p

# Redis 连接失败时自动降级为 standalone
ruoyi-scan --distributed master --redis-url redis://unavailable:6379/0
# 日志输出：Redis 连接失败，降级为 standalone 模式

                    ┌─────────────┐
                    │   Master    │
                    │  (调度节点)  │
                    └──────┬──────┘
                           │
                    ┌──────┴──────┐
                    │   Redis     │
                    │  (任务队列)  │
                    └──────┬──────┘
                           │
          ┌────────────────┼────────────────┐
          │                │                │
   ┌──────┴──────┐  ┌──────┴──────┐  ┌──────┴──────┐
   │   Worker 1  │  │   Worker 2  │  │   Worker N  │
   │ (执行节点)   │  │ (执行节点)   │  │ (执行节点)   │
   └─────────────┘  └─────────────┘  └─────────────┘

# 1. CI 模式（默认阈值 high，发现高危及以上漏洞则失败）
ruoyi-scan -p http://target:8080/ --ci

# 2. 自定义阈值
ruoyi-scan -p http://target:8080/ --ci --severity-threshold high      # 高危及以上失败
ruoyi-scan -p http://target:8080/ --ci --severity-threshold medium    # 中危及以上失败
ruoyi-scan -p http://target:8080/ --ci --severity-threshold low       # 低危及以上失败

# 3. CI 模式 + SARIF 报告（GitHub/GitLab 原生展示）
ruoyi-scan -p http://target:8080/ --ci --report ./reports --report-format sarif

# 4. CI 模式 + quick 模板（快速扫描，适合每次提交触发）
ruoyi-scan -p http://target:8080/ --ci --template quick --report-format sarif

Critical > High > Medium > Low > Info

# 1. 生成 GitHub Actions 配置
ruoyi-scan --ci-init github
# 生成 .github/workflows/ruoyi-scan.yml

# 2. 生成 GitLab CI 配置
ruoyi-scan --ci-init gitlab
# 生成 .gitlab-ci.yml

# 3. 生成 Jenkins Pipeline 配置
ruoyi-scan --ci-init jenkins
# 生成 Jenkinsfile

# .github/workflows/ruoyi-scan.yml
name: Ruoyi-Scan Security Check

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  schedule:
    # 每天凌晨 2 点定时扫描
    - cron: '0 18 * * *'  # UTC 时间，对应北京时间 02:00

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install Ruoyi-Scan
        run: |
          git clone https://github.com/xiabai2008/Ruoyi-Scan.git
          cd Ruoyi-Scan
          pip install -e ".[report]"  # 含 PDF/Word/Excel 报告

      - name: Run Security Scan
        env:
          TARGET_URL: ${{ secrets.TARGET_URL }}
        run: |
          ruoyi-scan -p "$TARGET_URL" \
            --ci \
            --severity-threshold high \
            --template quick \
            --report ./reports \
            --report-format sarif,json

      - name: Upload SARIF Report
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: ./reports/report.sarif

      - name: Upload Artifacts
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: security-reports
          path: ./reports/
          retention-days: 30

# .gitlab-ci.yml
stages:
  - security

ruoyi-scan:
  stage: security
  image: python:3.11
  script:
    - git clone https://github.com/xiabai2008/Ruoyi-Scan.git
    - cd Ruoyi-Scan && pip install -e .
    - ruoyi-scan -p "$TARGET_URL" --ci --severity-threshold high --template quick
  artifacts:
    when: always
    paths:
      - ./reports/
    expire_in: 30 days
  only:
    - main
    - schedules

// Jenkinsfile
pipeline {
    agent any
    stages {
        stage('Security Scan') {
            steps {
                sh 'git clone https://github.com/xiabai2008/Ruoyi-Scan.git && cd Ruoyi-Scan && pip install -e .'
                sh '''
                    ruoyi-scan -p ${TARGET_URL} \
                      --ci \
                      --severity-threshold high \
                      --template quick \
                      --report ./reports \
                      --report-format all
                '''
            }
            post {
                always {
                    archiveArtifacts artifacts: 'reports/**', allowEmptyArchive: true
                }
            }
        }
    }
}

# 1. 启用缓存（默认 TTL 3600 秒 = 1 小时）
ruoyi-scan -p http://target:8080/ --cache

# 2. 自定义 TTL（如 24 小时）
ruoyi-scan -p http://target:8080/ --cache --cache-ttl 86400

# 3. 自定义缓存数据库路径
ruoyi-scan -p http://target:8080/ --cache --cache-db ./cache/scan_cache.db

# 4. 查看缓存统计（命中率、条目数、占用空间）
ruoyi-scan --cache-stats --cache-db ./cache/scan_cache.db

# 5. 清除过期缓存
ruoyi-scan --cache-clear --cache-db ./cache/scan_cache.db

# 6. 清除全部缓存
ruoyi-scan --cache-clear-all --cache-db ./cache/scan_cache.db

# 7. 批量扫描 + 缓存（强烈推荐）
ruoyi-scan -f targets.txt -p --cache --cache-ttl 86400

缓存统计：
  数据库路径: ./cache/scan_cache.db
  总条目数:   1,234
  有效条目:   1,100
  过期条目:   134
  命中率:     87.5%
  占用空间:   2.3 MB
  最旧条目:   2026-07-15 10:30:00
  最新条目:   2026-07-21 14:20:00

# 1. 默认并发（5 线程）
ruoyi-scan -p http://target:8080/

# 2. 提高并发（10 线程，推荐生产环境）
ruoyi-scan -p http://target:8080/ --threads 10

# 3. 高并发（20 线程，注意目标承受能力）
ruoyi-scan -p http://target:8080/ --threads 20

# 4. 批量扫描高并发
ruoyi-scan -f targets.txt -p --threads 20

# 5. 调试模式（单线程，便于排查）
ruoyi-scan -p http://target:8080/ --threads 1 --debug

# 1. 不限速（默认）
ruoyi-scan -p http://target:8080/ --rate 0

# 2. 限速 20 QPS（推荐生产环境）
ruoyi-scan -p http://target:8080/ --rate 20

# 3. 保守限速（10 QPS，适合敏感目标）
ruoyi-scan -p http://target:8080/ --rate 10

# 4. 并发 + 限速组合
ruoyi-scan -p http://target:8080/ --threads 20 --rate 50

# 5. 批量扫描 + 全局限速
ruoyi-scan -f targets.txt -p --threads 20 --rate 100

pip install "ruoyi-scan[async]"
# 或
pip install aiohttp

# 1. 启用异步引擎（默认 10 workers）
ruoyi-scan -p http://target:8080/ --async

# 2. 自定义异步并发数
ruoyi-scan -p http://target:8080/ --async --async-workers 50

# 3. 异步引擎 + 批量扫描（千级目标推荐）
ruoyi-scan -f targets.txt -p --async --async-workers 100

# 4. 异步引擎 + 限速
ruoyi-scan -f targets.txt -p --async --async-workers 100 --rate 500

# 5. 异步引擎 + 缓存（万级目标最优组合）
ruoyi-scan -f targets.txt -p \
  --async --async-workers 100 \
  --rate 1000 \
  --cache --cache-ttl 86400

# 1. 单目标快速扫描
ruoyi-scan -p http://target:8080/ --threads 10 --rate 20

# 2. 单目标深度扫描
ruoyi-scan -u http://target:8080/ --template deep --threads 20 --rate 50

# 3. 小批量扫描（<100 目标）
ruoyi-scan -f targets.txt -p --threads 20 --rate 100 --cache

# 4. 中批量扫描（100~1000 目标）
ruoyi-scan -f targets.txt -p --async --async-workers 50 --rate 200 --cache

# 5. 大批量扫描（1000+ 目标，分布式）
# Master 节点
ruoyi-scan --distributed master --redis-url redis://redis:6379/0 \
  -f targets.txt -p --distributed-rate 1000
# Worker 节点（多机部署）
ruoyi-scan --distributed worker --redis-url redis://redis:6379/0 \
  --async --async-workers 50

# 6. CI 流水线（快速 + SARIF）
ruoyi-scan -p http://target:8080/ --ci --template quick \
  --report-format sarif --threads 10 --rate 20