Files
Agent-Workbench/docs/original-purge-load-evidence/upstream/lib/redteam/schema.js
T
2026-11-02 21:20:40 +08:00

631 lines
33 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { DatabaseSync } from 'node:sqlite'
/* 计分/判定规则的唯一实现在 score-rules.js;本文件只留 DDL 与迁移。
migrate() 里用到的 parseTargetPort 也从那里取,不再保留副本。 */
import { parseTargetPort } from './score-rules.js'
/**
* 事实库 schema 与增量迁移(零依赖)。
*
* 从 core.js 抽出来的模块:**DDL 与迁移是"数据形状"的唯一定义处**,
* 与"怎么用这些数据"(RedteamStore 的方法)分开之后,
* 看 schema 不用翻过 500 行计分逻辑,改表结构也不会误碰业务代码。
*
* 两处迁移遵循同一条纪律:**先查 PRAGMA 再 ADD COLUMN**,可重复执行、老库不用重建。
* 读不到表结构一律按"没有这一列"处理(返回 false),交给 ensure 去尝试 ALTER;
* 反过来当成"列已存在"会让迁移被静默跳过,故障点从"迁移失败"漂到远端 SQL 执行处。
*/
/* ------------------------------------------------------------------ FTS5 能力检测 */
/**
* 本机 `node:sqlite` 是否带 FTS5。
*
* **必须检测**:FTS5 是编译期选项,不同 Node 构建并不一致 ——
* Node 22.14 的 `node:sqlite` 没有(`no such module: fts5`),22.23 有。
* 因此不能假定它存在:CI 与本地 Node 版本不一致时,整个 DDL 都建不起来。
* 语义:只有 FTS5 缺席时才降级成 LIKE 检索 —— 装了 FTS5 的机器行为完全不变。
*
* `REDTEAM_NO_FTS5=1` 可强制走降级路径:CI 的 Node 一旦换了带 FTS5 的版本,
* 降级分支就再没人执行了,得留一个能主动触发它的开关(见 test/fts-fallback.test.mjs)。
*/
export const HAS_FTS5 = (() => {
if (process.env.REDTEAM_NO_FTS5 === '1') return false
try {
const probe = new DatabaseSync(':memory:')
try {
probe.exec('CREATE VIRTUAL TABLE __fts5_probe USING fts5(x)')
return true
} finally {
probe.close()
}
} catch {
return false
}
})()
/* ------------------------------------------------------------------ FTS 虚拟表 DDL */
/**
* 两张全文检索虚拟表。**单独导出**,因为它们依赖 FTS5:
* FTS5 缺席的构建上建表会抛 `no such module: fts5`,把整份 DDL 一起带崩。
* 调用方按 `HAS_FTS5` 决定是否拼进 DDL(见 core.js 的 db() / kb())。
*/
export const ASSET_FTS_DDL = `
CREATE VIRTUAL TABLE IF NOT EXISTS asset_fts USING fts5(
asset_id UNINDEXED, ip, names, banners, titles, fingerprints
);
`
export const POC_FTS_DDL = `
CREATE VIRTUAL TABLE IF NOT EXISTS poc_fts USING fts5(
poc_id UNINDEXED, title, cve, component, versions, tags, description, content
);
`
/* ------------------------------------------------------------------ 靶标库 schema */
export const DDL = `
PRAGMA journal_mode = WAL;
PRAGMA foreign_keys = ON;
PRAGMA busy_timeout = 5000;
CREATE TABLE IF NOT EXISTS scan_run (
id INTEGER PRIMARY KEY AUTOINCREMENT,
agent_session_id TEXT, tool TEXT, argv TEXT,
started_at TEXT, finished_at TEXT, status TEXT DEFAULT 'running'
);
CREATE TABLE IF NOT EXISTS segment (
cidr TEXT PRIMARY KEY, ip_start TEXT, ip_end TEXT,
org TEXT, asn TEXT, country TEXT, city TEXT,
source TEXT, first_seen TEXT, last_seen TEXT
);
CREATE TABLE IF NOT EXISTS asset (
id INTEGER PRIMARY KEY AUTOINCREMENT,
segment_cidr TEXT NOT NULL, ip TEXT NOT NULL, ip_int INTEGER,
state TEXT DEFAULT 'unknown', primary_name TEXT, confidence REAL,
first_seen TEXT, last_seen TEXT, discovered_at TEXT,
test_status TEXT DEFAULT 'untested', test_notes TEXT, test_surface TEXT,
test_updated_at TEXT, test_updated_by TEXT, blocked_count INTEGER DEFAULT 0,
priority TEXT, potential TEXT, assess_reason TEXT, assessed_at TEXT, assessed_by TEXT,
UNIQUE(segment_cidr, ip)
);
CREATE TABLE IF NOT EXISTS asset_name (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER NOT NULL, name TEXT NOT NULL, kind TEXT,
provenance TEXT, tool TEXT, first_seen TEXT, last_seen TEXT,
UNIQUE(asset_id, name, kind)
);
CREATE TABLE IF NOT EXISTS port (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER NOT NULL, proto TEXT DEFAULT 'tcp', port INTEGER NOT NULL,
state TEXT DEFAULT 'open', provenance TEXT, tool TEXT, banner TEXT,
url TEXT, title TEXT,
first_seen TEXT, last_seen TEXT,
UNIQUE(asset_id, proto, port)
);
CREATE TABLE IF NOT EXISTS service (
id INTEGER PRIMARY KEY AUTOINCREMENT,
port_id INTEGER NOT NULL, name TEXT, product TEXT, version TEXT, cpe TEXT,
provenance TEXT, tool TEXT, first_seen TEXT, last_seen TEXT
);
CREATE TABLE IF NOT EXISTS fingerprint (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER NOT NULL, port_id INTEGER,
category TEXT, vendor TEXT, product TEXT, version TEXT,
evidence TEXT, confidence REAL, provenance TEXT, tool TEXT,
first_seen TEXT, last_seen TEXT
);
CREATE TABLE IF NOT EXISTS observation (
id INTEGER PRIMARY KEY AUTOINCREMENT,
entity_kind TEXT NOT NULL, entity_id INTEGER NOT NULL,
attr TEXT, value TEXT, provenance TEXT, tool TEXT,
scan_run_id INTEGER, collected_at TEXT, raw_ref TEXT
);
CREATE TABLE IF NOT EXISTS edge (
id INTEGER PRIMARY KEY AUTOINCREMENT,
src_kind TEXT NOT NULL, src_id TEXT NOT NULL,
dst_kind TEXT NOT NULL, dst_id TEXT NOT NULL,
relation TEXT NOT NULL, confidence REAL, scan_run_id INTEGER,
first_seen TEXT, last_seen TEXT,
UNIQUE(src_kind, src_id, dst_kind, dst_id, relation)
);
CREATE TABLE IF NOT EXISTS tag (
entity_kind TEXT NOT NULL, entity_id INTEGER NOT NULL, tag TEXT NOT NULL,
note TEXT, created_by TEXT, created_at TEXT,
PRIMARY KEY (entity_kind, entity_id, tag)
);
CREATE TABLE IF NOT EXISTS vuln (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER, port_id INTEGER, cve TEXT, title TEXT, severity TEXT,
source TEXT, confidence REAL, status TEXT, evidence TEXT, target TEXT,
found_by_agent TEXT, found_at TEXT, gained TEXT, agent TEXT
);
/* 得分点:来自攻防演练得分规则,用户可编辑(分值、启用、分类) */
CREATE TABLE IF NOT EXISTS score_point (
id INTEGER PRIMARY KEY AUTOINCREMENT,
code TEXT UNIQUE,
name TEXT NOT NULL,
category TEXT,
points INTEGER DEFAULT 0,
max_hits INTEGER DEFAULT 1,
description TEXT,
enabled INTEGER DEFAULT 1,
sort_order INTEGER DEFAULT 0,
created_at TEXT, updated_at TEXT,
/* ── 按《突破入侵类得分规则》新增的判定字段(v0.11.0)────────────────────
rule:规则号(RULE 1…25);**同一 rule 的得分点共用该规则的得分上限**
tier:同规则内的档位(普通权限/管理员权限/加成分…),面板与报告按它分组展示
cap:该 rule 的累计得分上限(0 = 不设上限)
dedup_scope:计分口径 service(同资产同端口只算最高一条) / system(同系统只算最高权限一次)
/ target(整个目标只算一次) / none(按台卡节点数累加)
legacy:1 = 旧版得分点(迁移后保留但停用,只作历史参照,不参与新口径计分) */
/* src:《突破入侵类得分规则(合并版)》里的原序号(合并行写首个原序号),仅用于与原表对账 */
src INTEGER,
rule INTEGER,
tier TEXT,
cap INTEGER DEFAULT 0,
dedup_scope TEXT DEFAULT 'service',
legacy INTEGER DEFAULT 0,
/* builtin:1 = 随《突破入侵类得分规则》分发的内置得分点(分值/上限/口径由规则锁定,
用户只能改「启用/停用」);0 = 用户自建点(可任意编辑,且不会被播种逻辑清掉)。
判定内置**必须看这个标志位**,不能用 code 名单:用户自建的得分点一旦被判成旧体系残留,
会在下次读取得分面板时连同命中一起删掉,而写入侧仍返回成功。 */
builtin INTEGER DEFAULT 0
);
/* 得分记录:某个得分点在某个目标上被拿下 */
/* 作战阶段:全链路攻击路径图的五个阶段(内容可编辑) */
CREATE TABLE IF NOT EXISTS stage (
code TEXT PRIMARY KEY,
name TEXT NOT NULL,
subtitle TEXT,
color TEXT,
goal TEXT,
sections TEXT,
tools TEXT,
transition TEXT,
sort_order INTEGER DEFAULT 0,
updated_at TEXT
);
CREATE TABLE IF NOT EXISTS score_hit (
id INTEGER PRIMARY KEY AUTOINCREMENT,
point_id INTEGER NOT NULL,
asset_id INTEGER, vuln_id INTEGER, step_id INTEGER, target TEXT,
evidence TEXT, note TEXT,
self_created INTEGER DEFAULT 0,
port INTEGER,
recorded_by TEXT, recorded_at TEXT,
/* 本次命中的实际分值(NULL = 用得分点的默认 points)。
《合并版》把同一项的多个档位合并成一条(如服务器主机权限"普通 10 / 管理员 50"、
域名控制"一级 50 / 二级 20"),**档位差异只能落在每一条命中上**,
否则"权限取高只计一次"无从表达。 */
points INTEGER,
/* 倍率:G5 数据规模翻倍(×2)/ G6 IPv6 成果 ×3。**作用在权限分上**,
与 points 相乘后再参与上限累计。存下来是为了让面板与报告能解释"这条为什么是 200 分",
而不是让读者以为分值算错了。 */
multiplier REAL DEFAULT 1
);
/* 凭据:secret_value 存明文口令/密钥(面板直接显示,便于随时复用),secret_ref 指向 runs/ 下的证据文件。
注意:本库只在本机,禁止把库文件或导出内容提交到任何仓库。 */
CREATE TABLE IF NOT EXISTS credential (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER, host TEXT, username TEXT, secret_type TEXT,
secret_value TEXT, secret_ref TEXT,
privilege TEXT, source TEXT, tool TEXT, note TEXT,
found_by_agent TEXT, found_at TEXT, agent TEXT,
UNIQUE(host, username, secret_type)
);
/* 访问会话:拿到入口后的一次可控访问记录(横向移动的起点) */
CREATE TABLE IF NOT EXISTS access_session (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER, host TEXT, username TEXT, method TEXT, privilege TEXT,
session_ref TEXT, note TEXT, found_by_agent TEXT, obtained_at TEXT
);
/* WebShell:已经上线的可控入口。智能体随时可以复用,避免"打到最后忘了还有 webshell" */
CREATE TABLE IF NOT EXISTS webshell (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER, url TEXT NOT NULL, shell_type TEXT, pass_key TEXT,
secret_ref TEXT, privilege TEXT,
status TEXT DEFAULT 'unknown', last_check TEXT, check_note TEXT, latency_ms INTEGER,
note TEXT, found_by_agent TEXT, created_at TEXT, updated_at TEXT, agent TEXT,
UNIQUE(url, pass_key)
);
/* 内网隧道:suo5 / socks5 / ssh -R / frp 等。记录入口、监听地址与可达网段 */
CREATE TABLE IF NOT EXISTS tunnel (
id INTEGER PRIMARY KEY AUTOINCREMENT,
asset_id INTEGER, webshell_id INTEGER, kind TEXT, listen TEXT,
entry TEXT, reach TEXT,
entry_kind TEXT,
status TEXT DEFAULT 'unknown', last_check TEXT, check_note TEXT, latency_ms INTEGER,
pid TEXT, command TEXT, note TEXT, found_by_agent TEXT, created_at TEXT, updated_at TEXT, agent TEXT
);
/* HTTP 证据:原始请求/响应,可直接粘贴进 Burp Suite / Yakit 复现 */
CREATE TABLE IF NOT EXISTS http_evidence (
id INTEGER PRIMARY KEY AUTOINCREMENT,
vuln_id INTEGER, asset_id INTEGER, label TEXT,
method TEXT, url TEXT, status INTEGER,
request TEXT, response TEXT, note TEXT,
captured_by TEXT, captured_at TEXT
);
/* 攻击文件:针对某个目标实际生效的脚本/POC/EXP(只收录验证有效的) */
CREATE TABLE IF NOT EXISTS attack_file (
id INTEGER PRIMARY KEY AUTOINCREMENT,
target TEXT NOT NULL, target_kind TEXT, name TEXT NOT NULL, kind TEXT,
path TEXT NOT NULL, description TEXT, evidence TEXT,
asset_id INTEGER, vuln_id INTEGER, created_by TEXT, created_at TEXT,
UNIQUE(target, name)
);
/* 攻击链步骤:人工/智能体记录的链路节点,用于攻击链页面与报告。
tool/agent/result 三列是"这一步怎么做的"的凭证:报告要写清账号密码怎么来的、
隧道怎么搭的,靠的就是步骤上的工具与命令原文。 */
CREATE TABLE IF NOT EXISTS attack_step (
id INTEGER PRIMARY KEY AUTOINCREMENT,
seq INTEGER, stage TEXT, title TEXT, detail TEXT,
asset_id INTEGER, vuln_id INTEGER, access_id INTEGER, point_id INTEGER,
evidence_ref TEXT, tool TEXT, agent TEXT, result TEXT,
recorded_by TEXT, recorded_at TEXT
);
/* 证据截图:得分成果的"看得见"的那一份材料。
落盘位置:<靶标目录>/shots/,库里只存文件名与元数据 —— 图片不进 SQLite。
kind:screenshot 现场截图;card 由记录生成的证据摘录卡,报告里要分开标注。 */
CREATE TABLE IF NOT EXISTS shot (
id INTEGER PRIMARY KEY AUTOINCREMENT,
point_id INTEGER, hit_id INTEGER, asset_id INTEGER, vuln_id INTEGER,
target TEXT, label TEXT, note TEXT,
file TEXT NOT NULL,
kind TEXT DEFAULT 'screenshot',
mime TEXT, bytes INTEGER, width INTEGER, height INTEGER, sha256 TEXT,
source_ref TEXT, captured_at TEXT, found_by_agent TEXT, agent TEXT, created_at TEXT,
UNIQUE(file)
);
CREATE INDEX IF NOT EXISTS ix_asset_segment ON asset(segment_cidr);
CREATE INDEX IF NOT EXISTS ix_asset_ip_int ON asset(ip_int);
CREATE INDEX IF NOT EXISTS ix_port_asset ON port(asset_id);
CREATE INDEX IF NOT EXISTS ix_port_port ON port(port);
CREATE INDEX IF NOT EXISTS ix_service_port ON service(port_id);
CREATE INDEX IF NOT EXISTS ix_service_name ON service(name, product, version);
CREATE INDEX IF NOT EXISTS ix_fp_asset ON fingerprint(asset_id);
CREATE INDEX IF NOT EXISTS ix_fp_product ON fingerprint(product, version);
CREATE INDEX IF NOT EXISTS ix_edge_src ON edge(src_kind, src_id);
CREATE INDEX IF NOT EXISTS ix_edge_dst ON edge(dst_kind, dst_id);
CREATE INDEX IF NOT EXISTS ix_obs_entity ON observation(entity_kind, entity_id);
CREATE INDEX IF NOT EXISTS ix_vuln_asset ON vuln(asset_id);
CREATE INDEX IF NOT EXISTS ix_vuln_sev ON vuln(severity, status);
CREATE INDEX IF NOT EXISTS ix_vuln_cve ON vuln(cve);
CREATE INDEX IF NOT EXISTS ix_cred_host ON credential(host);
CREATE INDEX IF NOT EXISTS ix_access_host ON access_session(host);
CREATE INDEX IF NOT EXISTS ix_webshell_status ON webshell(status);
CREATE INDEX IF NOT EXISTS ix_tunnel_status ON tunnel(status);
CREATE INDEX IF NOT EXISTS ix_shot_point ON shot(point_id);
CREATE INDEX IF NOT EXISTS ix_shot_hit ON shot(hit_id);
CREATE INDEX IF NOT EXISTS ix_shot_asset ON shot(asset_id);
CREATE INDEX IF NOT EXISTS ix_http_vuln ON http_evidence(vuln_id);
CREATE INDEX IF NOT EXISTS ix_http_asset ON http_evidence(asset_id);
CREATE INDEX IF NOT EXISTS ix_step_seq ON attack_step(seq, id);
CREATE INDEX IF NOT EXISTS ix_attack_target ON attack_file(target);
CREATE INDEX IF NOT EXISTS ix_score_hit_point ON score_hit(point_id);
/* 报告/攻击链按时间排序取命中(scoreReport 的 ORDER BY h.recorded_at, h.id) */
CREATE INDEX IF NOT EXISTS ix_score_hit_time ON score_hit(recorded_at, id);
/* 报告的"这一步关联了哪些攻击步骤"按 asset_id / vuln_id / step_id 反查 */
CREATE INDEX IF NOT EXISTS ix_score_hit_vuln ON score_hit(vuln_id);
CREATE INDEX IF NOT EXISTS ix_score_hit_step ON score_hit(step_id);
/* 攻击步骤按资产/漏洞反查(报告溯源与 #hitTrace 的兜底归因都走这里) */
CREATE INDEX IF NOT EXISTS ix_step_asset ON attack_step(asset_id);
CREATE INDEX IF NOT EXISTS ix_step_vuln ON attack_step(vuln_id);
CREATE INDEX IF NOT EXISTS ix_step_recorded ON attack_step(recorded_at);
/* 资产按 C 段 + 状态筛(资产测绘左侧点某个 C 段就是这条) */
CREATE INDEX IF NOT EXISTS ix_asset_segment_state ON asset(segment_cidr, state);
/* http 证据按目标 URL 做 LIKE 兜底匹配(scoreReport 找不到显式关联时用) */
CREATE INDEX IF NOT EXISTS ix_http_url ON http_evidence(url);
/* 隧道/马按资产与状态查(会话页与攻击链都要) */
CREATE INDEX IF NOT EXISTS ix_tunnel_asset ON tunnel(asset_id);
CREATE INDEX IF NOT EXISTS ix_webshell_asset ON webshell(asset_id);
CREATE INDEX IF NOT EXISTS ix_credential_asset ON credential(asset_id);
CREATE INDEX IF NOT EXISTS ix_access_asset ON access_session(asset_id);
CREATE INDEX IF NOT EXISTS ix_score_hit_asset ON score_hit(asset_id);
CREATE VIEW IF NOT EXISTS v_asset_summary AS
SELECT a.id, a.ip, a.segment_cidr, a.state, a.primary_name, a.first_seen, a.last_seen,
(SELECT COUNT(*) FROM port p WHERE p.asset_id = a.id AND p.state = 'open') AS open_ports,
(SELECT COUNT(*) FROM observation o WHERE o.entity_kind = 'asset' AND o.entity_id = a.id AND o.provenance = 'passive') AS passive_signals,
(SELECT COUNT(*) FROM observation o WHERE o.entity_kind = 'asset' AND o.entity_id = a.id AND o.provenance = 'active') AS active_signals
FROM asset a;
CREATE VIEW IF NOT EXISTS v_asset_service AS
SELECT p.asset_id, p.port, p.proto, p.provenance AS port_provenance,
s.name AS service, s.product, s.version, s.provenance AS service_provenance
FROM port p LEFT JOIN service s ON s.port_id = p.id;
`
/* ------------------------------------------------------------------ 知识库 schema */
export const KNOWLEDGE_DDL = `
CREATE TABLE IF NOT EXISTS poc (
id INTEGER PRIMARY KEY AUTOINCREMENT,
code TEXT NOT NULL, -- 稳定标识(slug),智能体可直接引用
title TEXT NOT NULL,
kind TEXT, -- poc | exp | script | template | payload
category TEXT, -- 归类:rce / deserialization / file-upload / sqli / unauthorized / auth-bypass / weak-password / ssrf / xxe / path-traversal / file-read / info-leak / privesc / tunnel / other
cve TEXT, -- CVE / CNVD / 厂商编号
component TEXT, -- 组件/产品(Weblogic、Shiro、泛微 OA…)
versions TEXT, -- 影响版本
severity TEXT,
language TEXT, -- python | go | java | bash | http | nuclei | js | php
source TEXT, -- web | self | manual | nuclei-template | kb
source_url TEXT,
description TEXT,
usage TEXT, -- 用法/命令行示例
content TEXT, -- 正文(脚本 / POC / 原始请求)
path TEXT, -- 落盘位置(pocs/<code>/<file>),便于智能体直接 cat
verified INTEGER DEFAULT 0, -- 是否实测验证过
verified_note TEXT, -- 验证证据(哪台目标、什么回显)
hit_count INTEGER DEFAULT 0, -- 被复用次数
used_on TEXT, -- 最近一次使用在哪个靶标/目标
-- 来源溯源:这条知识是在哪个靶标、哪台资产上发现/验证出来的(建立时间看 created_at)
engagement_id TEXT,
engagement_name TEXT,
asset_target TEXT,
found_by_agent TEXT,
tags TEXT,
created_by TEXT, created_at TEXT, updated_at TEXT,
UNIQUE(code)
);
CREATE INDEX IF NOT EXISTS ix_poc_cve ON poc(cve);
CREATE INDEX IF NOT EXISTS ix_poc_component ON poc(component);
CREATE INDEX IF NOT EXISTS ix_poc_kind ON poc(kind, verified);
/* 注意:归类 / 来源靶标两个索引**不能写在这里** —— 老 knowledge.db 的 poc 表还没有
这两列,CREATE INDEX 会在 exec(DDL) 阶段直接抛
"no such column: category",连补列的迁移都跑不到。它们在 migrateKnowledge() 补完列之后再建。 */
`
/* ------------------------------------------------------------------ 知识库归类 */
/**
* 知识库归类(与得分点/攻击面口径对齐):智能体回填时必须选一个,
* 面板按它分组,用户才能"一类一类看"而不是几百条平铺。
*/
const POC_CATEGORIES = [
{ code: 'rce', name: "Remote command execution", hint: "Framework/middleware/component RCE, expression injection, template injection" },
{ code: 'deserialization', name: "Deserialization", hint: "Java/PHP/.NET deserialization chains, fastjson/jackson, etc." },
{ code: 'file-upload', name: "File upload getshell", hint: "Upload bypass, parsing flaws, second-render, race conditions" },
{ code: 'sqli', name: "SQL injection", hint: "Injection-point validation, data dumping, file writes, privilege escalation" },
{ code: 'unauthorized', name: "Unauthorized access", hint: "Unauthenticated interfaces/services (Redis, Docker, Actuator, Swagger calls)" },
{ code: 'auth-bypass', name: "Auth bypass / broken access control", hint: "Login bypass, JWT flaws, unauthorized read/write, logic flaws" },
{ code: 'weak-password', name: "Weak passwords / password brute force", hint: "Weak admin passwords, weak database passwords, default passwords" },
{ code: 'ssrf', name: 'SSRF', hint: "Server-side request forgery, cloud metadata, internal-network probing pivot" },
{ code: 'xxe', name: 'XXE', hint: "XML external entity reads and SSRF" },
{ code: 'path-traversal', name: "Path traversal / arbitrary file read", hint: "Path traversal, arbitrary file read, source/config file read" },
{ code: 'info-leak', name: "Information disclosure", hint: "Config/credential/source/backup leaks (the kind that can be upgraded to a score)" },
{ code: 'privesc', name: "Privilege escalation / lateral movement", hint: "Local privilege escalation, credential reuse, Pass-the-Hash, lateral tools" },
{ code: 'tunnel', name: "Tunnel / proxy", hint: "suo5, frp, chisel, Neo-ReGeorg, internal proxies" },
{ code: 'other', name: "Other", hint: "Does not fit any category above (describe the purpose)" },
]
export { POC_CATEGORIES }
/** 归类 code → 中文名(未知值原样返回,允许用户自定义)。 */
export function pocCategoryName(code) {
const hit = POC_CATEGORIES.find((c) => c.code === String(code || ''))
return hit ? hit.name : (code ? String(code) : "Uncategorized")
}
/**
* 老条目的归类推测(迁移时给 category 为空的条目打标)。
* 依据是 code/title/component 里的关键词 —— 命中就归那一类,都不中才落 `other`。
* 顺序即优先级:越具体的越靠前(例如"任意文件上传"要压过泛化的"上传")。
* 新写入的条目由 `redteam_poc_add` 的 `category` 参数决定,不走这里。
*/
export function guessPocCategory(text) {
const t = String(text || '').toLowerCase()
const has = (...words) => words.some((w) => t.includes(w))
if (has('反序列化', 'deserial', 'shiro', 'fastjson', 'weblogic', 'log4j', 'jackson')) return 'deserialization'
if (has('文件上传', 'file-upload', 'fileupload', 'upload', 'getshell', 'webshell', '写马')) return 'file-upload'
if (has('sql 注入', 'sqli', 'sql注入', '注入拖库', 'union select')) return 'sqli'
if (has('弱口令', '爆破', 'brute', '默认口令', '默认凭据', 'hydra')) return 'weak-password'
if (has('隧道', 'socks', 'suo5', 'frp', 'chisel', 'regeorg', '代理')) return 'tunnel'
if (has('未授权', 'unauth', '免认证', '免鉴权', '未鉴权', '无鉴权')) return 'unauthorized'
if (has('越权', '认证绕过', '鉴权绕过', 'jwt', '逻辑漏洞', '验证码绕过', 'auth-bypass')) return 'auth-bypass'
if (has('rce', '命令执行', '代码执行', '表达式注入', '模板注入', 'ssti', '命令注入', '远程执行')) return 'rce'
if (has('ssrf', '服务端请求伪造')) return 'ssrf'
if (has('xxe', '外部实体')) return 'xxe'
if (has('任意文件读', '文件读取', '目录穿越', '路径穿越', 'path traversal', 'lfi', '任意文件下载')) return 'path-traversal'
if (has('提权', '横向', 'pass-the-hash', 'mimikatz', 'impacket', '凭据复用')) return 'privesc'
if (has('信息泄露', '配置泄露', '敏感信息', '源码泄露', '泄露', 'leak')) return 'info-leak'
return 'other'
}
/* ------------------------------------------------------------------ 靶标库迁移 */
/**
* 轻量迁移:给既有库补列。先查 PRAGMA 再 ADD COLUMN,重复执行安全。
* 只在新增列时执行,因此老靶标库不需要重建。
*/
export function migrate(db) {
const has = (table, column) => {
try {
return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column)
} catch {
/* 读不到表结构必须返回 false(= "没有这一列"),让 ensure 去尝试 ALTER。
返回 true 会让迁移被静默跳过,代码随后按新列写 SQL,故障表现为远端 SQL 报错
而不是迁移失败。 */
return false
}
}
const ensure = (table, column, ddl) => {
if (has(table, column)) return false
try { db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`) } catch { /* 并发迁移时忽略 */ }
return true
}
ensure('vuln', 'target', 'TEXT')
ensure('vuln', 'found_by_agent', 'TEXT')
ensure('vuln', 'found_at', 'TEXT')
ensure('port', 'url', 'TEXT')
ensure('port', 'title', 'TEXT')
ensure('asset', 'test_status', "TEXT DEFAULT 'untested'")
ensure('asset', 'test_notes', 'TEXT')
ensure('asset', 'test_surface', 'TEXT')
ensure('asset', 'test_updated_at', 'TEXT')
ensure('asset', 'test_updated_by', 'TEXT')
ensure('asset', 'blocked_count', 'INTEGER DEFAULT 0')
ensure('asset', 'priority', 'TEXT')
ensure('asset', 'potential', 'TEXT')
ensure('asset', 'assess_reason', 'TEXT')
ensure('asset', 'assessed_at', 'TEXT')
ensure('asset', 'assessed_by', 'TEXT')
/* 发现时间:本条资产**第一次进入本库**的时刻(不随重复采集刷新,便于"这条什么时候发现的")。
与 first_seen(数据源/工具给出的首次出现时间)不是一回事,两个都留。 */
ensure('asset', 'discovered_at', 'TEXT')
/* 产出这条记录的智能体角色(recon/assess/vuln-scan/exploit/internal),
报告要写清"谁发现的、怎么拿到的" */
ensure('vuln', 'agent', 'TEXT')
ensure('credential', 'agent', 'TEXT')
ensure('webshell', 'agent', 'TEXT')
ensure('tunnel', 'agent', 'TEXT')
/* 攻击步骤:用了什么工具/命令、由谁记录。报告里"隧道怎么搭的、马怎么上的"靠这三列说清 */
ensure('attack_step', 'tool', 'TEXT')
ensure('attack_step', 'agent', 'TEXT')
ensure('attack_step', 'result', 'TEXT')
/* 内外网维度:internal(内网/私网地址)| external(互联网可达)。手工指定优先于自动推导 */
ensure('asset', 'scope', 'TEXT')
/* 通过这个漏洞拿到了什么:账号权限 / 服务器权限 / 内网隧道 / 得分点等 */
ensure('vuln', 'gained', 'TEXT')
/* 凭据明文:面板要直接显示口令,不再只存引用(库在本机,禁止导出/提交) */
ensure('credential', 'secret_value', 'TEXT')
/* 得分点按《突破入侵类得分规则》重构(v0.11.0):
rule/tier/cap/dedup_scope 承载"规则号 + 档位 + 该规则上限 + 计分口径"。
老库补列后由 seedScorePoints() 做一次性迁移(旧默认点转 legacy 停用,新增 25 条规则的得分点),
用户自建的得分点与全部历史命中一律保留。 */
ensure('score_point', 'rule', 'INTEGER')
ensure('score_point', 'tier', 'TEXT')
ensure('score_point', 'cap', 'INTEGER DEFAULT 0')
ensure('score_point', 'dedup_scope', "TEXT DEFAULT 'service'")
ensure('score_point', 'legacy', 'INTEGER DEFAULT 0')
/* builtin:区分内置点与用户自建点(见 schema 注释)。
老库先按 0 建列,再由 seedScorePoints 用 DEFAULT_SCORE_POINTS 的 code 名单回填。 */
ensure('score_point', 'builtin', 'INTEGER DEFAULT 0')
ensure('score_point', 'src', 'INTEGER')
/* G5 / G6 倍率(老库补列,默认 1 = 不放大) */
ensure('score_hit', 'multiplier', 'REAL DEFAULT 1')
/* 每条命中自带分值(合并版把档位并进一条后必需,见 score_hit 建表注释) */
ensure('score_hit', 'points', 'INTEGER')
/* 得分类别不设数量上限(max_hits 列保留只为兼容老库结构,计分不再使用) */
/* 得分 ↔ 漏洞/步骤 关联:报告取原始请求、流程图连线用 */
ensure('score_hit', 'vuln_id', 'INTEGER')
ensure('score_hit', 'step_id', 'INTEGER')
ensure('attack_step', 'point_id', 'INTEGER')
/* 攻击链已推倒重来:老的五阶段行整体作废,attck 列移除 */
try {
/* 注意:'target' 在新老两版里同名,必须按名称区分,否则第二次打开会把新版阶段删掉 */
db.prepare("DELETE FROM stage WHERE code IN ('external','foothold','tunnel','privilege')").run()
db.prepare("DELETE FROM stage WHERE code = 'target' AND name = '靶标系统权限'").run()
db.prepare("DELETE FROM stage WHERE code NOT IN ('recon','internet','boundary','internal','target')").run()
} catch { /* 表还不存在,忽略 */ }
if (has('stage', 'attck')) {
try { db.exec('ALTER TABLE stage DROP COLUMN attck') } catch { /* 老 SQLite 不支持则保留 */ }
}
/* 攻击步骤上的阶段:老值是上一版的阶段 code,清掉以便按 legacy stage 重新映射。
注意:'target' 在新版里仍是合法阶段(⑤ 靶标权限),不能一起清——否则每次打开
靶标都会把「显式指定 ⑤」的步骤与得分打回自动推导。 */
try {
db.prepare("UPDATE attack_step SET stage_code = NULL WHERE stage_code IN ('external','foothold','tunnel','privilege')").run()
db.prepare("UPDATE score_hit SET stage_code = NULL WHERE stage_code IN ('external','foothold','tunnel','privilege')").run()
} catch { /* 忽略 */ }
/* 阶段归属改为按每条得分自动推导,得分点上的 stage_code 已废弃 */
if (has('score_point', 'stage_code')) {
try { db.exec('ALTER TABLE score_point DROP COLUMN stage_code') } catch { /* 忽略 */ }
}
/* 蓝队视角已从作战阶段中移除:老库把这一列删掉(失败则忽略,不影响使用) */
if (has('stage', 'blue_team')) {
try { db.exec('ALTER TABLE stage DROP COLUMN blue_team') } catch { /* 老 SQLite 不支持则保留 */ }
}
/* 阶段归属:得分命中可显式覆盖(默认自动推导);攻击步骤记录所属阶段 */
ensure('score_hit', 'stage_code', 'TEXT')
/* 自建账号标记:自己注册/自己创建的账号不算得分权限,只作过程记录(老数据默认 0) */
ensure('score_hit', 'self_created', 'INTEGER DEFAULT 0')
/* 得分落在哪个「服务」上:账号类得分按 (资产, 端口) 封顶,同一服务只算一次最高权限。
端口在写入时解析(工具传的 port → target 里的端口 → 该资产唯一登记的端口);老数据打开靶标时按 target 回填一次。 */
ensure('score_hit', 'port', 'INTEGER')
try {
const p = db.prepare("SELECT COUNT(*) AS n FROM score_hit WHERE port IS NULL AND target IS NOT NULL AND target <> ''").get().n
if (p > 0) {
const upd = db.prepare('UPDATE score_hit SET port = ? WHERE id = ?')
for (const row of db.prepare("SELECT id, target FROM score_hit WHERE port IS NULL AND target IS NOT NULL AND target <> ''").all()) {
const port = parseTargetPort(row.target)
if (port !== null) upd.run(port, row.id)
}
}
} catch { /* 表还不存在,忽略 */ }
/* 隧道入口归属:判断这条通道有没有真的跨越靶标边界(self-only 不算突破) */
ensure('tunnel', 'entry_kind', 'TEXT')
if (ensure('attack_step', 'stage_code', 'TEXT')) {
try {
const stmt = db.prepare('UPDATE attack_step SET stage_code = ? WHERE stage = ?')
for (const [legacy, code] of Object.entries(LEGACY_STAGE_MAP)) stmt.run(code, legacy)
} catch { /* 忽略 */ }
}
/* 老库回填:按 IP 归属自动区分内外网 */
try {
db.exec(`UPDATE asset SET scope = (${SCOPE_SQL}) WHERE scope IS NULL OR scope = ''`)
} catch { /* 首次建库时表为空,忽略 */ }
/* 老库回填发现时间:没有 discovered_at 的用 first_seen 顶上(总比空白好) */
try {
db.exec("UPDATE asset SET discovered_at = COALESCE(first_seen, last_seen) WHERE discovered_at IS NULL OR discovered_at = ''")
} catch { /* 忽略 */ }
}
/* ------------------------------------------------------------------ 知识库迁移 */
/**
* 知识库轻量迁移:给既有 knowledge.db 补列(归类 / 来源溯源)。
* 与靶标库迁移同样先查 PRAGMA 再 ADD COLUMN,重复执行安全、老库不用重建。
*/
export function migrateKnowledge(db) {
const has = (column) => {
try {
return db.prepare('PRAGMA table_info(poc)').all().some((row) => row.name === column)
} catch { return true }
}
const ensure = (column, ddl) => {
if (has(column)) return
try { db.exec(`ALTER TABLE poc ADD COLUMN ${column} ${ddl}`) } catch { /* 并发迁移时忽略 */ }
}
ensure('category', 'TEXT')
ensure('engagement_id', 'TEXT')
ensure('engagement_name', 'TEXT')
ensure('asset_target', 'TEXT')
ensure('found_by_agent', 'TEXT')
try { db.exec('CREATE INDEX IF NOT EXISTS ix_poc_category ON poc(category)') } catch { /* 忽略 */ }
try { db.exec('CREATE INDEX IF NOT EXISTS ix_poc_engagement ON poc(engagement_id)') } catch { /* 忽略 */ }
/* 老条目没有归类:按 code/标题/组件的关键词推一个(推测逻辑只有一份,见 guessPocCategory) */
try {
const rows = db.prepare("SELECT id, code, title, component FROM poc WHERE COALESCE(category, '') = ''").all()
const upd = db.prepare('UPDATE poc SET category = ? WHERE id = ?')
for (const row of rows) {
upd.run(guessPocCategory([row.code, row.title, row.component].filter(Boolean).join(' ')), row.id)
}
} catch { /* 忽略 */ }
}