From 0c346a7c0ae7ab37b36046598fece15f71a1811a Mon Sep 17 00:00:00 2001 From: RuoJi6 Date: Sat, 24 Oct 2026 20:48:35 +0800 Subject: [PATCH] =?UTF-8?q?fix(findings):=20address=20Grok=20review=20?= =?UTF-8?q?=E2=80=94=20keep=20folders=20mergeable=20after=20group=20reject?= =?UTF-8?q?,=20re-anchor=20groups=20on=20finding=20delete,=20guard=20stale?= =?UTF-8?q?=20suggestion=20list=20writes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- agent/finding_cases.go | 4 +- db/finding_cases.go | 31 +++++++++--- db/finding_cases_test.go | 60 ++++++++++++++++++++++++ db/schema.sql | 23 +++++++++ server/finding_cases.go | 2 +- web/src/components/finding-case-list.tsx | 30 ++++++++---- 6 files changed, 132 insertions(+), 18 deletions(-) diff --git a/agent/finding_cases.go b/agent/finding_cases.go index 370e760..25548dd 100644 --- a/agent/finding_cases.go +++ b/agent/finding_cases.go @@ -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,并提供总结。根因证据应说明具体相同/不同的检查及证据来源;疑似建议明确待补证据。服务端验收通过后才可宣布完成。工具不可用或验收失败时如实报告,不能只用自然语言声称完成。` diff --git a/db/finding_cases.go b/db/finding_cases.go index 5878535..4b05b25 100644 --- a/db/finding_cases.go +++ b/db/finding_cases.go @@ -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 } } diff --git a/db/finding_cases_test.go b/db/finding_cases_test.go index a50cab4..0592bf3 100644 --- a/db/finding_cases_test.go +++ b/db/finding_cases_test.go @@ -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) + } +} diff --git a/db/schema.sql b/db/schema.sql index 44d7c4f..8e92122 100644 --- a/db/schema.sql +++ b/db/schema.sql @@ -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, diff --git a/server/finding_cases.go b/server/finding_cases.go index bc08b0f..3f0b7d8 100644 --- a/server/finding_cases.go +++ b/server/finding_cases.go @@ -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"}}, } diff --git a/web/src/components/finding-case-list.tsx b/web/src/components/finding-case-list.tsx index ff5508c..b4deab1 100644 --- a/web/src/components/finding-case-list.tsx +++ b/web/src/components/finding-case-list.tsx @@ -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([]); 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([]); const [runs, setRuns] = React.useState([]); 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; 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 {