fix(findings): address Grok review — keep folders mergeable after group reject, re-anchor groups on finding delete, guard stale suggestion list writes

This commit is contained in:
RuoJi6 committed 2026-10-24 20:48:35 +08:00
1 parent 00ec84d14e
commit 0c346a7c0a
6 files changed
+132 -18

No files matched your search

+2 -2
View File
@@ -46,12 +46,12 @@ func findingCaseWorkflow(key string, tools []actool.CoreTool) ([]actool.CoreTool
return tools, `
【同一漏洞的多次上报整理】保留本次独立报告,不覆盖其他原报告。默认报告完成即停止的旧指引在此扩展:先保存本次报告,然后 search_finding_duplicates(finding_id=独立记录ID) 分页读取同任务候选摘要(按 score 排序;strong=同漏洞类型且资产重叠,优先核对;weak=单一条件命中,仅作参考),按需 get_finding_record 查看证据。仅凭漏洞类型/标题相似或高中低等级不能归并;须核对目标、接口、参数、权限边界、根因及实际验证证据。
【判断准则】有证据表明端点/路由、处理器或后端组件、易受影响参数、缺失检查属于不同代码路径时,可以判定 independent;但仅凭路径、接口、登录入口、令牌、标题或漏洞类型相同/不同都不能证明根因。比较实际缺失的鉴权检查、对象权限边界、会话门或共同组件,并引用每条记录中的具体证据。只有根因明确相同才用 merge_finding_records;只有存在具体共同点(同端点/参数/组件/缺失检查)但缺关键证据确认时才用 suggest_finding_merge,并一次提交覆盖2..N条记录的分组,禁止仅因类型或资产相同而建议。没有具体共同点就保持 independent,不要因不确定而建议。不重复上报、不删除记录、不重新探测目标。人工选择整理时只能判断所选记录,不能加入未选记录(既有组成员可作为报告上下文)。
【判断准则】有证据表明端点/路由、处理器或后端组件、易受影响参数、缺失检查属于不同代码路径时,可以判定 independent;但仅凭路径、接口、登录入口、令牌、标题或漏洞类型相同/不同都不能证明根因。比较实际缺失的鉴权检查、对象权限边界、会话门或共同组件,并引用每条记录中的具体证据。只有根因明确相同才用 merge_finding_records;只有存在具体共同点(同端点/参数/组件/缺失检查)但缺关键证据确认时才用 suggest_finding_merge,并一次提交覆盖2..20条记录的分组,禁止仅因类型或资产相同而建议。没有具体共同点就保持 independent,不要因不确定而建议。不重复上报、不删除记录、不重新探测目标。人工选择整理时只能判断所选记录,不能加入未选记录(既有组成员可作为报告上下文)。
归并不以统一报告为前提:根因明确就先归并,统一报告可随后补齐(未完成时文件夹显示“统一报告待更新”)。归并成功或已有case_id时,get_finding_case 记录实际version,分页读取全部成员,按需get_finding_record、get_finding_traffic读取原报告、PoC及已保存流量。update_finding_case_report保存完整统一报告(包含有内容的概述、影响、前置条件、复现步骤、证据、PoC、根因分析、修复建议章节,不得半篇截断)和基于已验证影响的severity及severity_reason;不能直接取成员最高等级。集中给出前置条件、完整执行顺序、输入输出如何衔接、可运行的完整脚本及命令,不把必要步骤分散到原报告;缺失条件、未验证步骤如实标明。版本冲突重新读取材料并生成,不能仅换version重试。各成员仍有独立报告、评级和证据。没有明确重复则保留独立记录。工具被关闭时不绕过配置。`
}
const historicalFindingReviewGuidance = `
【历史整理模式,优先于旧报告撰写及自动绑流量指引】本次只整理已经存在的上报。原始报告即使为空或待更新,也只记录缺失情况,绝不调用 update_finding_report、report_finding、bind_finding_traffic,不修改原始标题、评级、状态、证据或报告,不执行 Bash、写文件或重新探测目标。
先逐条 get_finding_record 读取所选记录,已有原报告直接作为判断材料复用,不重复撰写。只在所选范围内检查同一实际缺陷,可按需读取已存在的证据。按上述根因准则形成明确归并/独立/疑似建议;无法确认时保存建议供人工确认。
先逐条 get_finding_record 读取所选记录,已有原报告直接作为判断材料复用,不重复撰写。只在所选范围内检查同一实际缺陷,可按需读取已存在的证据。按上述根因准则形成明确归并/独立/疑似建议;仅当存在具体共同点(同端点/参数/组件/缺失检查)但缺关键证据时才保存疑似建议供人工确认,没有具体共同点的不确定情况保持 independent。
已有或新建文件夹应读取全部成员并尽力用 update_finding_case_report 写入完整、最新的统一报告;归并不因报告暂缺而阻塞,未完成时文件夹会显示“统一报告待更新”,可由后续运行或人工补齐。统一报告是单独的材料,不覆盖原报告。最后必须调用 complete_finding_case_review,为每条所选 finding_id 提交 verdict(independent/merged/suggested)、reason 和 root_cause_evidence,并提供总结。根因证据应说明具体相同/不同的检查及证据来源;疑似建议明确待补证据。服务端验收通过后才可宣布完成。工具不可用或验收失败时如实报告,不能只用自然语言声称完成。`
+25 -6
View File
@@ -530,6 +530,7 @@ func (d *DB) SuggestFindingCase(ctx context.Context, taskID int64, findingIDs []
want[fid] = true
}
superseded := []int64{}
var exact, covering int64
for _, g := range groups {
inNew := 0
for fid := range g.members {
@@ -539,22 +540,35 @@ func (d *DB) SuggestFindingCase(ctx context.Context, taskID int64, findingIDs []
}
switch {
case inNew == len(ids) && len(g.members) == len(ids):
id = g.id
_, err := tx.Exec(`UPDATE finding_case_suggestions SET title=$2,reason=$3 WHERE id=$1`, g.id, title, reason)
return err
if exact == 0 {
exact = g.id
} else {
superseded = append(superseded, g.id)
}
case inNew == len(ids):
// An existing pending group already covers every requested record.
id = g.id
return nil
if covering == 0 {
covering = g.id
}
case inNew == len(g.members):
superseded = append(superseded, g.id)
}
}
// Strict subsets are superseded on every path, including refresh/reuse.
for _, sid := range superseded {
if _, err := tx.Exec(`UPDATE finding_case_suggestions SET state='superseded' WHERE id=$1 AND state='pending'`, sid); err != nil {
return err
}
}
if exact > 0 {
id = exact
_, err := tx.Exec(`UPDATE finding_case_suggestions SET title=$2,reason=$3 WHERE id=$1`, exact, title, reason)
return err
}
if covering > 0 {
id = covering
return nil
}
if err := tx.QueryRow(`INSERT INTO finding_case_suggestions(task_id,left_id,right_id,title,reason) VALUES($1,$2,$3,$4,$5) RETURNING id`, taskID, ids[0], ids[1], title, reason).Scan(&id); err != nil {
return err
}
@@ -653,9 +667,14 @@ func (d *DB) ResolveFindingCaseSuggestion(ctx context.Context, id int64, accept
if err != nil {
return err
}
// Pairs already sharing a folder are not vetoed: the folder is the newer human
// decision, and a block inside it would make every later merge into it fail.
// Splitting a folder goes through RemoveFindingCaseMember instead.
for i := range current {
for j := i + 1; j < len(current); j++ {
if _, err := tx.Exec(`INSERT INTO finding_case_blocks(left_id,right_id,reason) VALUES($1,$2,'人工否决') ON CONFLICT DO NOTHING`, current[i], current[j]); err != nil {
if _, err := tx.Exec(`INSERT INTO finding_case_blocks(left_id,right_id,reason) SELECT $1::bigint,$2::bigint,'人工否决'
WHERE NOT EXISTS(SELECT 1 FROM finding_case_members a JOIN finding_case_members b ON a.case_id=b.case_id WHERE a.finding_id=$1 AND b.finding_id=$2)
ON CONFLICT DO NOTHING`, current[i], current[j]); err != nil {
return err
}
}
+60
View File
@@ -502,3 +502,63 @@ func TestFindingCaseClusterExclusionCannotBePulledInByFolder(t *testing.T) {
t.Fatal("failed exclusion was not rolled back")
}
}
func TestFindingCaseClusterRejectKeepsExistingFolderMergeable(t *testing.T) {
d, task, ids := caseTestDB(t)
ctx := context.Background()
cid, err := d.MergeFindingCase(ctx, task.ID, ids[:2], "orders", "proof", "reporter")
if err != nil {
t.Fatal(err)
}
sid, err := d.SuggestFindingCase(ctx, task.ID, ids[:3], "orders", "shared handler")
if err != nil {
t.Fatal(err)
}
if _, err := d.ResolveFindingCaseSuggestion(ctx, sid, false, nil); err != nil {
t.Fatal(err)
}
var inFolder int
if err := d.QueryRow(`SELECT count(*) FROM finding_case_blocks WHERE left_id=$1 AND right_id=$2`, ids[0], ids[1]).Scan(&inFolder); err != nil || inFolder != 0 {
t.Fatalf("co-membered pair vetoed: %d %v", inFolder, err)
}
if _, err := d.MergeFindingCase(ctx, task.ID, []int64{ids[0], ids[2]}, "x", "x", "reporter"); err == nil {
t.Fatal("rejected pair merged")
}
if got, err := d.MergeFindingCase(ctx, task.ID, []int64{ids[1], ids[3]}, "orders", "proof", "reporter"); err != nil || got != cid {
t.Fatalf("folder poisoned by reject: %d %v", got, err)
}
}
func TestFindingCaseClusterSurvivesAnchorDeletion(t *testing.T) {
d, task, ids := caseTestDB(t)
ctx := context.Background()
sid, err := d.SuggestFindingCase(ctx, task.ID, ids[:3], "orders", "shared handler")
if err != nil {
t.Fatal(err)
}
if n, err := d.DeleteFinding(ids[0]); err != nil || n != 1 {
t.Fatal(n, err)
}
list, err := d.FindingCaseSuggestions(task.ID)
if err != nil || len(list) != 1 || list[0].ID != sid || !reflect.DeepEqual(list[0].FindingIDs, []string{fmt.Sprint(ids[1]), fmt.Sprint(ids[2])}) {
t.Fatalf("group lost with its anchor: %+v %v", list, err)
}
if list[0].LeftID != ids[1] || list[0].RightID != ids[2] {
t.Fatalf("anchors not moved: %+v", list[0])
}
if cid, err := d.ResolveFindingCaseSuggestion(ctx, sid, true, nil); err != nil || cid == 0 {
t.Fatal(cid, err)
}
// Deleting below two members still drops the pair through the cascade.
pair, err := d.SuggestFindingCase(ctx, task.ID, []int64{ids[2], ids[3]}, "orders", "x")
if err != nil {
t.Fatal(err)
}
if _, err := d.DeleteFinding(ids[3]); err != nil {
t.Fatal(err)
}
var n int
if err := d.QueryRow(`SELECT count(*) FROM finding_case_suggestions WHERE id=$1`, pair).Scan(&n); err != nil || n != 0 {
t.Fatalf("two-member group kept after anchor deletion: %d %v", n, err)
}
}
+23
View File
@@ -1499,6 +1499,29 @@ INSERT INTO finding_case_suggestion_members(suggestion_id,finding_id)
SELECT id,left_id FROM finding_case_suggestions ON CONFLICT DO NOTHING;
INSERT INTO finding_case_suggestion_members(suggestion_id,finding_id)
SELECT id,right_id FROM finding_case_suggestions ON CONFLICT DO NOTHING;
-- left_id/right_id only anchor a group (ON DELETE CASCADE). Before one anchor
-- finding is deleted, move the anchors to the two smallest surviving members so
-- the rest of a 3+ member group is not cascade-deleted with it.
CREATE OR REPLACE FUNCTION finding_case_suggestion_reanchor() RETURNS trigger AS $$
DECLARE
sid BIGINT;
l BIGINT;
r BIGINT;
BEGIN
FOR sid IN SELECT id FROM finding_case_suggestions WHERE left_id=OLD.id OR right_id=OLD.id LOOP
SELECT min(sm.finding_id) INTO l FROM finding_case_suggestion_members sm
WHERE sm.suggestion_id=sid AND sm.finding_id<>OLD.id AND EXISTS(SELECT 1 FROM findings f WHERE f.id=sm.finding_id);
SELECT min(sm.finding_id) INTO r FROM finding_case_suggestion_members sm
WHERE sm.suggestion_id=sid AND sm.finding_id>l AND sm.finding_id<>OLD.id AND EXISTS(SELECT 1 FROM findings f WHERE f.id=sm.finding_id);
IF r IS NOT NULL THEN
UPDATE finding_case_suggestions SET left_id=l,right_id=r WHERE id=sid;
END IF;
END LOOP;
RETURN OLD;
END $$ LANGUAGE plpgsql;
DROP TRIGGER IF EXISTS trg_finding_case_suggestion_reanchor ON findings;
CREATE TRIGGER trg_finding_case_suggestion_reanchor BEFORE DELETE ON findings
FOR EACH ROW EXECUTE FUNCTION finding_case_suggestion_reanchor();
-- Rejected/detached pairs are a durable human veto, also checked on group unions.
CREATE TABLE IF NOT EXISTS finding_case_blocks (
left_id BIGINT NOT NULL REFERENCES findings(id) ON DELETE CASCADE,
+1 -1
View File
@@ -267,7 +267,7 @@ func (s *Server) findingCaseTools() []actool.CoreTool {
{"search_finding_duplicates", "只读检索同任务候选摘要与资产,按分数排序并返回 score、tier、hit_reasons:strong=同漏洞类型且资产重叠,weak=单一条件命中仅作参考。等级不同也可能重复。支持分页,按需读取详情。", []string{"finding_id"}},
{"get_finding_record", "读取独立漏洞完整原始证据和报告,返回探索节点编号以便追溯执行记录。", []string{"finding_id"}},
{"merge_finding_records", "证据明确证明同一缺陷时归并;保留所有原始记录。不跨任务、不改变原评级,不可绕过人工否决。", []string{"task_id", "finding_ids", "title", "reason"}},
{"suggest_finding_merge", "证据存在具体共同点但缺少关键证据时,提交一个疑似重复分组(2..N 条同任务记录,一次覆盖全部疑似成员,不要拆成两两建议),待人工确认;不是自动合并。仅类型/资产相同不应提交。", []string{"task_id", "finding_ids", "title", "reason"}},
{"suggest_finding_merge", "证据存在具体共同点但缺少关键证据时,提交一个疑似重复分组(2..20 条同任务记录,一次覆盖全部疑似成员,不要拆成两两建议),待人工确认;不是自动合并。仅类型/资产相同不应提交。", []string{"task_id", "finding_ids", "title", "reason"}},
{"get_finding_case", "读取归并组和成员分页。先记录version,再读取成员的原报告、证据及流量;版本变化必须重新读取。", []string{"case_id"}},
{"update_finding_case_report", "保存统一报告及评级理由,version必须来自实际读取。保留各条原报告,不新建漏洞。", []string{"case_id", "version", "title", "report", "severity", "severity_reason"}},
}
+21 -9
View File
@@ -196,7 +196,7 @@ function FindingMergeSuggestionCard({
}) {
const [expanded, setExpanded] = React.useState(false);
const [busy, setBusy] = React.useState(false);
const ids = s.finding_ids?.length ? s.finding_ids : [s.left_id, s.right_id];
const ids = s.finding_ids.length ? s.finding_ids : [s.left_id, s.right_id];
const [excluded, setExcluded] = React.useState<string[]>([]);
const included = ids.filter((id) => !excluded.includes(id));
async function resolve(accept: boolean) {
@@ -224,7 +224,7 @@ function FindingMergeSuggestionCard({
disabled={busy}
onCheckedChange={(v) =>
setExcluded((old) =>
v === true ? old.filter((x) => x !== id) : old.includes(id) ? old : [...old, id],
v === true ? old.filter((x) => x !== id) : [...old.filter((x) => x !== id), id],
)
}
aria-label={`归并时包含上报 #${id}`}
@@ -295,14 +295,20 @@ export function FindingCaseReviewPanel({ taskId, onChange }: { taskId?: string;
const [suggestions, setSuggestions] = React.useState<FindingCaseSuggestion[]>([]);
const [runs, setRuns] = React.useState<FindingCaseReviewRun[]>([]);
const [error, setError] = React.useState("");
// Only the newest suggestions request (poll or post-resolve refresh) may write the list,
// so an older response cannot bring back a resolved group or another task's list.
const listSeq = React.useRef(0);
const currentTask = React.useRef(taskId);
currentTask.current = taskId;
React.useEffect(() => {
let active = true;
let timer: ReturnType<typeof setTimeout>;
async function load() {
const seq = ++listSeq.current;
try {
const [s, r] = await Promise.all([api.findingCaseSuggestions(taskId), api.findingCaseReviewRuns()]);
if (active) {
setSuggestions(s);
if (seq === listSeq.current) setSuggestions(s);
setRuns(r.filter((x) => !taskId || x.task_id === taskId));
setError("");
}
@@ -321,12 +327,18 @@ export function FindingCaseReviewPanel({ taskId, onChange }: { taskId?: string;
async function resolve(s: FindingCaseSuggestion, accept: boolean, excludeIds: string[] = []) {
try {
const result = await api.resolveFindingCaseSuggestion(s.id, accept, excludeIds);
setSuggestions((v) => v.filter((x) => x.id !== s.id));
// Server-side resolution may also clear related groups; refresh instead of waiting for the poll.
api
.findingCaseSuggestions(taskId)
.then(setSuggestions)
.catch(() => undefined);
// A resolve that finishes after switching tasks must not touch the new task's list.
if (currentTask.current === taskId) {
const seq = ++listSeq.current;
setSuggestions((v) => v.filter((x) => x.id !== s.id));
// Server-side resolution may also clear related groups; refresh instead of waiting for the poll.
api
.findingCaseSuggestions(taskId)
.then((v) => {
if (seq === listSeq.current && currentTask.current === taskId) setSuggestions(v);
})
.catch(() => undefined);
}
if (accept && result.case_id !== "0") {
toast.success("已归并,请进入文件夹生成统一报告");
} else {