zebbern/pocmap
GitHub: zebbern/pocmap
一款面向 AI Agent 优化的安全工具包，支持多源聚合查询 CVE 漏洞情报、PoC 利用代码及漏洞赏金报告。
Stars: 2 | Forks: 0
# PocMap
[](https://github.com/zebbern/pocmap)
[](https://www.python.org/downloads/)
[](LICENSE)
[](https://docs.pydantic.dev/)
专为 AI agent 优化的 CVE 漏洞利用发现工具包，面向漏洞赏金猎人和安全专业人员。通过单一界面查找 PoC 漏洞利用、CTF 实验室、漏洞赏金报告以及漏洞情报。
## 核心功能
- **多源发现**：同时查询 GitHub、Exploit-DB、Metasploit、Nuclei、CTF 实验室和漏洞赏金平台
- **结构化 Pydantic 模型**：所有数据均经过验证和序列化，提供完整的类型安全和 JSON Schema 支持
- **MCP Server 集成**：通过 Model Context Protocol 为 Claude Desktop、Cursor 和其他 AI agent 提供 19 个 AI 原生工具
- **漏洞赏金工具包**：为猎人提供完整的工具包，包含检查清单、工作流、报告模板、优先级排序引擎和范围管理
- **富文本 CLI**：具有彩色表格、进度条和批量处理的交互式终端界面
- **并发处理**：基于线程池的批量 CVE 处理，带有指数退避重试机制
- **报告生成**：具有 DataTables、JSON 导出和独立 CSS 的交互式 HTML 报告
- **安全加固**：SSRF 防护、Jinja2 沙盒模板、路径遍历预防、输入验证
## 安装
```
# 从 PyPI 安装
pip install pocmap
# 或以开发模式安装
git clone https://github.com/zebbern/pocmap.git
cd pocmap
pip install -e .
# 带 async 支持
pip install -e ".[async]"
# 带开发依赖
pip install -e ".[dev]"
# 验证安装
pocmap --version
```
**环境要求：**
- Python 3.10+
- 依赖项：pydantic>=2.0, requests>=2.28, typer>=0.9, rich>=13.0
**可选配置：**
- `GITHUB_API_TOKEN` - 用于提高速率限制的 GitHub PAT（推荐）
- `NVD_API_KEY` - 用于提高速率限制的 NVD API 密钥
## 快速开始
```
# 查询单个 CVE
pocmap lookup CVE-2021-44228
# 显示完整描述和参考链接
pocmap lookup CVE-2021-44228 --description
# 按编程语言过滤 PoC
pocmap lookup CVE-2021-44228 --language Python
# 从文件中处理多个 CVE
pocmap bulk cves.txt --output ./reports
# 搜索 CTF 实验室以进行实践练习
pocmap labs CVE-2021-44228
# 搜索 bug bounty 报告
pocmap bugbounty CVE-2021-44228
# 获取某个 CVE 的 CPE（受影响的产品）
pocmap cpes CVE-2021-44228
# 将 CPE 转换为 CVE
pocmap cpe2cve "cpe:2.3:a:apache:log4j:2.0"
# 导出 JSON schema 用于 AI agent 集成
pocmap schemas --output ./schemas
# 查找过去 24 小时内最新发布的 CVE
pocmap latest
# 查找过去 7 天内带有 PoC 的近期严重 CVE
pocmap latest --since 7d --severity critical --only-with-poc
# 按名称发现影响某个产品的 CVE
pocmap discover "Apache Struts"
# 发现特定产品版本的 CVE
pocmap discover "Log4j" --version 2.x
# 显示包含所有选项的帮助
pocmap --help
```
## Python API
### CVE 信息查询
```
from pocmap.services.cve_service import CVEService
cve_svc = CVEService()
info = cve_svc.get_cve_info("CVE-2021-44228")
print(info.id) # "CVE-2021-44228"
print(info.description) # Full vulnerability description
print(info.cvss.base_score) # 10.0
print(info.cvss.severity.value) # "CRITICAL"
print(info.cvss.vector_string) # "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H"
print(info.epss) # 97.53 (exploitation probability)
print(info.kev_status) # True (in CISA KEV catalog)
print(info.cwes) # ["CWE-77", "CWE-94"]
print(info.vendor) # "Apache"
print(info.product) # "Log4j"
print(info.publication_date) # "2021-12-10"
```
### 漏洞利用发现
```
from pocmap.services.exploit_service import ExploitService
exploit_svc = ExploitService()
# 查找所有来源中的所有 exploit
exploits = exploit_svc.find_exploits("CVE-2021-44228")
for ex in exploits:
print(f"[{ex.source.value}] {ex.title}")
print(f" URL: {ex.url}")
print(f" Language: {ex.language} | Stars: {ex.stars} | Forks: {ex.forks}")
# 按编程语言过滤
python_pocs = exploit_svc.filter_by_language(exploits, "Python")
go_pocs = exploit_svc.filter_by_language(exploits, "Go")
# 获取 GitHub repo 的 README
readme = exploit_svc.get_readme("https://github.com/example/poc")
```
### 实验室环境
```
from pocmap.services.lab_service import LabService
lab_svc = LabService()
labs = lab_svc.find_labs("CVE-2021-44228")
for lab in labs:
print(f"[{lab.platform.value}] {lab.name}: {lab.url}")
if lab.setup_instructions:
print(f" Setup: {lab.setup_instructions}")
```
### 漏洞赏金报告
```
from pocmap.services.bb_service import BugBountyService
bb_svc = BugBountyService()
reports = bb_svc.find_reports("CVE-2021-44228")
for report in reports:
print(f"[{report.source.value}] {report.title}")
print(f" URL: {report.url} | PoC included: {report.has_poc}")
```
### 报告生成
```
from pocmap.services.report_service import ReportService
report_svc = ReportService()
# 单个 CVE 报告
entry = report_svc.generate_report("CVE-2021-44228")
print(entry.to_json())
# 带有 JSON 和 HTML 输出的批量报告
multi = report_svc.generate_bulk_report([
"CVE-2021-44228",
"CVE-2023-38408",
"CVE-2024-21413",
])
report_svc.save_json_report(multi, "./output")
report_svc.save_html_report(multi, "./output")
```
### 面向 AI Agent 的 Schema 导出
```
from pocmap.models import export_schemas
paths = export_schemas("./schemas")
# 生成：CVSSScore.json, CVEInfo.json, Exploit.json,
# LabEnvironment.json, BugBountyReport.json,
# CPEInfo.json, ReportEntry.json, MultiReport.json
```
## 漏洞赏金工具包
`pocmap.bugbounty` 模块为漏洞赏金猎人提供了一个全面的工具包：
### 结构化检查清单
按阶段划分的检查清单，具有 P0-P4 优先级、完成情况跟踪和时间估算：
```
from pocmap.bugbounty import (
ReconnaissanceChecklist,
CVEResearchChecklist,
ExploitationChecklist,
ReportingChecklist,
)
# 创建并跟踪清单
checklist = ReconnaissanceChecklist()
checklist.items[0].complete(notes="Subdomain enumeration complete")
print(checklist.completion_status()) # Progress percentage
```
### 方法论工作流
结构化、可重复的工作流，带有进入/退出标准和难度评级：
```
from pocmap.bugbounty import (
CVEToBountyWorkflow, # CVE -> bug bounty pipeline
ZeroDayHuntingWorkflow, # Proactive vulnerability discovery
PatchGapAnalysisWorkflow, # Patch timing gap exploitation
)
workflow = CVEToBountyWorkflow()
result = workflow.execute_phase("recon", context={"target": "example.com"})
```
### 报告模板
适用于 HackerOne、Bugcrowd 和内部评估的特定平台报告模板：
```
from pocmap.bugbounty import HackerOneTemplate, BugcrowdTemplate
template = HackerOneTemplate()
report = template.render(
cve_data=cve_info,
impact="Remote code execution achieved via crafted JNDI lookup",
steps_to_reproduce=[
"1. Identify Log4j 2.x instance",
"2. Send crafted payload to vulnerable endpoint",
"3. Observe DNS callback confirming RCE",
],
)
```
### 优先级排序引擎
具有赏金潜力估算的多策略 CVE 优先级排序：
```
from pocmap.bugbounty import prioritize_cves, calculate_bounty_potential
# 按综合得分排序（CVSS + EPSS + KEV + exploit 可用性）
sorted_cves = prioritize_cves(cve_list, strategy="composite")
# 或按特定因素优先排序
sorted_cves = prioritize_cves(cve_list, strategy="epss") # Exploitation probability
sorted_cves = prioritize_cves(cve_list, strategy="kev_first") # Known exploited first
sorted_cves = prioritize_cves(cve_list, strategy="bounty_potential")
# 预估 bounty 潜力
for cve in sorted_cves[:10]:
bounty = calculate_bounty_potential(cve)
print(f"{cve['id']}: potential=${bounty['estimate']}")
```
### 范围管理
解析并管理漏洞赏金项目范围，将 CVE 匹配到范围内的资产：
```
from pocmap.bugbounty import ScopeManager, Asset
scope = ScopeManager()
scope.add_program(
platform="hackerone",
program="example",
in_scope=["*.example.com", "api.example.com"],
out_of_scope=["*.internal.example.com"],
)
# 从文件解析范围
scope.parse_scope_file("scope.txt")
# 查找影响范围内资产的 CVE
matches = scope.match_cves_to_scope(cve_list)
```
### 行动手册
用于结构化工作流的 JSON 行动手册：
```
from pocmap.bugbounty.playbooks import load_playbook, list_playbooks
# 列出可用的 playbook
for pb in list_playbooks():
print(f"{pb['name']}: {pb['description']} ({pb['difficulty']})")
# 加载并执行 playbook
playbook = load_playbook("cve-assessment")
for phase in playbook["phases"]:
print(f"Phase {phase['phase_id']}: {phase['name']}")
for step in phase["steps"]:
print(f" [{step['priority']}] {step['description']}")
```
可用的行动手册：
- **cve-assessment**：包含风险评分和修复措施的完整 CVE 评估工作流
- **rapid-response**：针对关键/KEV CVE 的应急响应工作流，包含限时操作
- **bb-submission**：从发现到报告的完整漏洞赏金提交流水线
## 最新 CVE 发现
监控新发布的漏洞，并根据严重程度、可利用性和时间窗口进行过滤。非常适合安全简报、威胁情报订阅和主动漏洞管理。
### `pocmap latest`
```
# 过去 24 小时内的近期 CVE（默认）
pocmap latest
# 指定相对时间窗口
pocmap latest --since 7d
pocmap latest --since 30d
pocmap latest --since 1h
# 明确的日期范围
pocmap latest --from 2024-01-01 --to 2024-01-31
# 仅包含 GitHub 上已知 PoC 的 CVE
pocmap latest --only-with-poc
# 仅 CISA KEV 条目
pocmap latest --kev-only
# 最低 EPSS 得分过滤器
pocmap latest --min-epss 50.0
# 按严重级别过滤（以逗号分隔）
pocmap latest --severity critical,high
# 对结果排序
pocmap latest --sort cve_date # newest first (default)
pocmap latest --sort severity # highest severity first
pocmap latest --sort epss # highest EPSS first
# 限制结果数量并保存为 JSON
pocmap latest --since 7d --severity critical --only-with-poc --limit 10 --output ./report.json
```
**选项：**
| 选项 | 描述 |
|--------|-------------|
| `--since` | 相对时间窗口：`1h`, `24h`, `7d`, `30d` |
| `--from` | `YYYY-MM-DD` 格式的开始日期（覆盖 `--since`） |
| `--to` | `YYYY-MM-DD` 格式的结束日期 |
| `--only-with-poc` | 仅返回在 GitHub 上有已知 PoC 的 CVE |
| `--kev-only` | 仅返回 CISA 已知被利用漏洞 |
| `--min-epss` | 最低 EPSS 分数 (0-100)，例如 `50.0` 表示 EPSS >= 50% |
| `--severity` | 以逗号分隔的严重程度：`critical`, `high`, `medium`, `low` |
| `--sort` | 排序方式：`cve_date`, `severity` 或 `epss` |
| `--limit` | 最大结果数 (1-100，默认：50) |
| `--output` | 将 JSON 报告保存到文件 |
**输出包含：** CVE ID、描述、CVSS 严重程度/分数、EPSS、KEV 状态、供应商、产品、发布日期、PoC 可用性以及 PoC 来源计数。
## 产品发现
无需 CVE ID 即可查找影响特定产品的所有 CVE。使用模糊产品名称匹配、版本约束解析和 NVD 关键字搜索。
### `pocmap discover`
```
# 按名称发现某个产品的 CVE
pocmap discover "Apache Struts"
# 带版本通配符
pocmap discover "Log4j" --version 2.x
# 确切的版本
pocmap discover "nginx" --version 1.20.1
# 带 vendor 提示
pocmap discover "struts" --vendor apache --version 2.x
# 将结果保存为 JSON
pocmap discover "Apache Struts" --version 2.x --output ./struts-cves.json
```
**选项：**
| 选项 | 描述 |
|--------|-------------|
| `--version`, `-v` | 版本约束：`2.x`, `2.14.1`, `>= 2.0` |
| `--vendor` | 供应商名称提示：`apache`, `microsoft`, `google` |
| `--limit` | 要分析的最大 CVE 数 (1-100，默认：50) |
| `--output`, `-o` | 将 JSON 报告保存到文件 |
### 产品别名系统
发现命令可识别常见的产品别名和缩写，因此您无需知道确切的标准产品名称：
| 别名输入 | 解析后的产品 |
|-------------|-----------------|
| `struts` | Apache Struts |
| `log4j`, `log4j2` | Log4j |
| `httpd`, `apache2` | Apache HTTP Server |
| `k8s`, `kube` | Kubernetes |
| `postgres`, `pgsql` | PostgreSQL |
| `es`, `elastic` | Elasticsearch |
| `nodejs`, `node` | Node.js |
| `ghe` | GitHub Enterprise |
| `ror` | Ruby on Rails |
| `wp` | WordPress |
| `ie`, `msie` | Internet Explorer |
别名通过与包含 60 多个产品的精选映射表进行模糊匹配来解析。您也可以使用部分匹配（例如，"apache struts" 会被拆分为供应商=`apache` + 产品=`struts`）。
### 版本约束格式
| 格式 | 示例 | 含义 |
|--------|---------|---------|
| 通配符 | `2.x` | 主版本 2 中的任何版本 |
| 精确版本 | `2.14.1` | 精确到版本 2.14.1 |
| 主版本.次版本 | `2.14` | 版本 2.14.x |
| 范围 (>=) | `>= 2.0` | 版本 2.0 及以上 |
| 范围 (<=) | `<= 1.20` | 版本 1.20 及以下 |
| 范围 (>) | `> 1.0` | 高于版本 1.0 |
| 范围 (<) | `< 3.0` | 低于版本 3.0 |
| 无（省略） | - | 任何版本 |
结果被划分为三个置信度等级：
- **已确认**：供应商与产品完全匹配且满足版本约束
- **可能**：供应商或产品匹配，但版本信息不明确
- **数据不足**：CVE 缺乏足够的产品/版本信息
## AI Agent 集成
PocMap 包含一个完整的 MCP (Model Context Protocol) server，暴露 19 个 AI 原生工具，用于与 Claude Desktop、Cursor 和其他兼容 MCP 的客户端集成。
### Claude Desktop 的 MCP Server 设置
添加到您的 Claude Desktop 配置文件中：
**Windows:** `%APPDATA%/Claude/claude_desktop_config.json`
```
{
"mcpServers": {
"pocmap": {
"command": "python",
"args": ["/path/to/pocmap/mcp_server.py"],
"env": {
"GITHUB_API_TOKEN": "ghp_xxxxxxxxxxxx",
"NVD_API_KEY": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}
}
}
}
```
### 运行 MCP Server
MCP server 需要 `server` 扩展中附带的 FastMCP SDK。请先安装它：
```
pip install -e ".[server]"
```
```
# STDIO transport（默认，用于 Claude Desktop）
python mcp_server.py
# 端口 8000 上的 SSE transport
python mcp_server.py --transport sse
# HTTP transport
python mcp_server.py --transport http --host 0.0.0.0 --port 9000
# Debug 模式
python mcp_server.py --debug
```
### MCP 工具（共 19 个）
| 工具 | 类别 | 描述 |
|------|----------|-------------|
| `lookup_cve` | CVE Intel | 来自 NVD、CVE.org、CISA KEV、EPSS 的完整 CVE 详情 |
| `get_epss_score` | CVE Intel | EPSS 利用概率分数 (0.0-1.0) 及风险等级 |
| `check_kev_status` | CVE Intel | 检查 CISA 已知被利用漏洞目录状态 |
| `find_github_pocs` | Exploits | 包含星标、语言和分支的 GitHub PoC 仓库 |
| `find_metasploit_module` | Exploits | Metasploit 模块可用性及 msfconsole 命令 |
| `find_exploitdb_entry` | Exploits | 包含 searchsploit 命令的 ExploitDB 条目 |
| `find_nuclei_template` | Exploits | 用于检测/验证的 Nuclei 扫描器模板 |
| `find_bug_bounty_reports` | Research | 来自 HackerOne、PentesterLand 的漏洞赏金报告 |
| `find_practice_labs` | Labs | Vulhub、HackTheBox、TryHackMe 上的 CTF 实验室 |
| `find_vulhub_docker` | Labs | Vulhub Docker Compose 环境及设置步骤 |
| `find_recent_exploits` | Discovery | 新发布的 CVE，带有 PoC/KEV/严重程度过滤 |
| `discover_product_cves` | Discovery | 根据产品名称及版本约束查找 CVE |
| `cve_to_cpe` | Conversion | 将 CVE 转换为受影响的 CPE 标识符 |
| `cpe_to_cve` | Conversion | 查找影响特定产品 (CPE) 的所有 CVE |
| `generate_json_report` | Reports | 针对 CVE 的综合 JSON 报告 |
| `generate_html_report` | Reports | 带有样式化卡片的独立 HTML 报告 |
| `get_cve_assessment_playbook` | Playbooks | 完整的 CVE 评估工作流行动手册 |
| `get_rapid_response_playbook` | Playbooks | 针对关键 CVE 的应急响应行动手册 |
| `get_bug_bounty_playbook` | Playbooks | 漏洞赏金提交流程行动手册 |
### MCP 资源
| 资源 | URI 模式 | 内容 |
|----------|-------------|---------|
| CVE 信息 | `cve://{cve_id}` | 人类可读文本格式的完整 CVE 详情 |
| Exploits | `exploits://{cve_id}` | 所有可用的漏洞利用和 PoC |
| 报告 | `report://{cve_id}` | 生成的漏洞报告 (JSON) |
### MCP 提示词
| 提示词 | 描述 |
|--------|-------------|
| `vulnerability_assessment` | 5 阶段结构化 CVE 评估工作流 |
| `exploit_research` | 侧重于检测工程化的深度漏洞利用分析 |
| `bug_bounty_analysis` | 基于漏洞赏金报告的真实影响分析 |
### Agent 工作流示例
```
User: "Should I prioritize CVE-2021-44228, CVE-2023-38408, or CVE-2024-21413?"
Agent:
1. lookup_cve("CVE-2021-44228") -> CVSS 10.0 CRITICAL, EPSS 0.9753, KEV=true
2. lookup_cve("CVE-2023-38408") -> CVSS 9.8 CRITICAL, EPSS 0.3124, KEV=true
3. lookup_cve("CVE-2024-21413") -> CVSS 8.8 HIGH, EPSS 0.8912, KEV=true
4. get_epss_score for each -> Confirm exploitation probabilities
5. find_github_pocs for each -> Count available exploits
6. check_kev_status for each -> Confirm KEV status
7. Prioritize: Log4j (highest EPSS + most exploits) > CVE-2024-21413 > CVE-2023-38408
```
## JSON Schema
导出所有数据模型的结构化 JSON schema，以便与 AI agent、验证流水线和外部工具集成：
```
from pocmap.models import export_schemas
paths = export_schemas("./schemas")
for p in paths:
print(f" {p.name}")
# CVSSScore.json
# CVEInfo.json
# Exploit.json
# LabEnvironment.json
# BugBountyReport.json
# CPEInfo.json
# ReportEntry.json
# MultiReport.json
```
将这些 schema 用于：
- **AI Agent 上下文**：向 AI agent 提供 schema 文件，以便它们理解数据结构
- **验证流水线**：根据 schema 验证传入/传出的数据
- **API 文档**：根据 schema 自动生成 API 文档
- **类型生成**：根据 JSON schema 生成 TypeScript、Go 或 Rust 类型
## 架构
```
+------------------+ +------------------+ +------------------+
| CLI Layer | | MCP Server | | Python API |
| (Typer/Rich) | | (FastMCP/19 | | (Services) |
+------------------+ | Tools) | +------------------+
| +------------------+ |
| | |
v v v
+------------------+ +------------------+ +------------------+
| Service Layer |<--->| Service Layer |<--->| Service Layer |
| | | | | |
| CVEService | | ExploitService | | ReportService |
| BugBountyService| | LabService | | + 3 more |
+------------------+ +------------------+ +------------------+
| | |
v v v
+------------------+ +------------------+ +------------------+
| Client Layer | | Client Layer | | Models Layer |
| | | | | |
| NVDClient | | GitHubClient | | CVEInfo |
| CVEOrgClient | | ExploitClient | | Exploit |
| + others | | + others | | + 6 more |
+------------------+ +------------------+ +------------------+
| |
v v
+-------------------------------------------------------------+
| External Data Sources |
| NVD API CVE.org CISA KEV EPSS GitHub ExploitDB etc. |
+-------------------------------------------------------------+
```
**分层架构：**
1. **表示层**：CLI (`cli.py`) + MCP Server (`mcp_server.py`)
2. **服务层**：业务逻辑（7 个服务：CVE、Exploit、Lab、Report、Bug Bounty、Recent、Product Discovery）
3. **客户端层**：外部 API 客户端（NVD、GitHub、CVE.org、ExploitDB 等）
4. **模型层**：8 个 Pydantic 模型，带有完整的验证和 JSON Schema 支持
5. **实用程序层**：带有重试机制的 HTTP 客户端、格式化程序、验证器、配置
6. **工具包层**：漏洞赏金猎人工具包（检查清单、方法论、模板、优先级排序、范围、自动化）
## 安全特性
### SSRF 防护
所有 HTTP 请求通过 `is_safe_url()` 验证，该验证会阻止：
- 内部主机：`localhost`、`127.0.0.1`、`0.0.0.0`、`::1`
- 云元数据端点：`169.254.169.254` (AWS)、`metadata.google.internal` (GCP)
- 私有 IP 范围、环回、链路本地和保留地址
- 非 HTTP(S) 协议：`file://`、`ftp://`、`gopher://`、`dict://`
### 沙盒模板
Jinja2 模板使用 `SandboxedEnvironment` 和 `BaseLoader`（无文件系统访问权限），并为 HTML/XML 上下文启用 `select_autoescape`。防止服务器端模板注入 (SSTI) 攻击。
### 路径遍历防护
文件操作使用 `_safe_path()`，它会规范化路径并验证它们是否保留在基础目录内。如果检测到遍历尝试，将引发 `ValueError`。
### 输入验证
- CVE ID 根据 `^CVE-\d{4}-\d+$` 正则表达式模式进行验证
- CPE 字符串经过严格的格式验证解析
- 最大批量大小限制（100 个 CVE）可防止 DoS
- 所有输入在进行外部 API 调用之前都会进行净化
### XSS 防护
- HTML 报告生成使用自动转义的模板渲染
- 所有面向用户的输出均经过适当的转义
- 生成的 HTML 报告中不执行内联 JavaScript
## 配置
配置从环境变量（以 `POCMAP_` 为前缀）和可选的 `.env` 文件中加载：
```
# 创建 .env 文件
cat > .env << 'EOF'
GITHUB_API_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx
NVD_API_KEY=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
POCMAP_HTTP_TIMEOUT=30
POCMAP_MAX_RETRIES=3
POCMAP_BACKOFF_FACTOR=1.5
POCMAP_THREAD_POOL_SIZE=10
POCMAP_LOG_LEVEL=INFO
EOF
```
| 变量 | 默认值 | 描述 |
|----------|---------|-------------|
| `GITHUB_API_TOKEN` | None | 用于提高速率限制的 GitHub 个人访问令牌 |
| `NVD_API_KEY` | None | 用于提高速率限制的 NVD API 密钥 |
| `POCMAP_HTTP_TIMEOUT` | 30 | HTTP 请求超时时间（以秒为单位） |
| `POCMAP_MAX_RETRIES` | 3 | 失败请求的最大重试次数 |
| `POCMAP_BACKOFF_FACTOR` | 1.5 | 指数退避乘数 |
| `POCMAP_THREAD_POOL_SIZE` | 10 | 批量操作的工作线程数 |
| `POCMAP_LOG_LEVEL` | INFO | 日志详细程度 (DEBUG, INFO, WARNING, ERROR) |
### 添加新的 Exploit 来源
可以通过插件模式注册新的 exploit 来源：
1. 在 `src/pocmap/clients/` 中创建一个新客户端：
```
# src/pocmap/clients/my_source_client.py
from pocmap.models import Exploit, ExploitSource
class MySourceClient:
"""Client for My Exploit Source."""
SOURCE = ExploitSource.OTHER # or add to enum
def search(self, cve_id: str) -> list[Exploit]:
# Implement search logic
return []
```
2. 将其集成到 `src/pocmap/services/exploit_service.py` 中的 `ExploitService`：
```
from pocmap.clients.my_source_client import MySourceClient
class ExploitService:
def __init__(self):
self._my_source = MySourceClient()
def find_exploits(self, cve_id: str) -> list[Exploit]:
exploits = []
exploits.extend(self._my_source.search(cve_id))
# ... existing sources
return exploits
```
3. 添加测试和文档。
### 开发设置
```
git clone https://github.com/zebbern/pocmap.git
cd pocmap
python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"
# 运行测试
pytest -v
# 运行 type checker
mypy src/pocmap
# 运行 linter
ruff check src/pocmap
```
## 许可证
MIT 许可证 - 详情请参阅 [LICENSE](LICENSE) 文件。
*PocMap 并非武器。它是为安全专业人员和漏洞赏金猎人提供的研究和防御工具。请始终在适用法律和项目范围的限制内操作。*
标签：逆向工具