From a2b26f541639a138121a4ad1dc3d1ae2cbf524aa Mon Sep 17 00:00:00 2001 From: Coff0xc <184964491+Coff0xc@users.noreply.github.com> Date: Tue, 17 Nov 2026 18:08:49 +0000 Subject: [PATCH] fix(db): skip RSI lesson extract on multi-company tasks NULL company_id leaked those lessons to every later task. --- db/lessons.go | 14 ++- db/lessons_test.go | 244 ++++++++++++++++++++++++++++++++++++++++++-- db/task_context.go | 8 +- docs/rsi-lessons.md | 8 +- 4 files changed, 261 insertions(+), 13 deletions(-) diff --git a/db/lessons.go b/db/lessons.go index b13ba0e..a4639f3 100644 --- a/db/lessons.go +++ b/db/lessons.go @@ -72,7 +72,7 @@ func taskLessonScope(ctx context.Context, d *DB, taskID int64) (categoryID int64 if cat.Valid { categoryID = cat.Int64 } - companyIDs, err = d.TaskCompanyIDs(taskID) + companyIDs, err = d.TaskCompanyIDsContext(ctx, taskID) if err != nil { return 0, nil, err } @@ -83,9 +83,8 @@ func taskLessonScope(ctx context.Context, d *DB, taskID int64) (categoryID int64 } // lessonExtractCompanyID is the company written onto a new lesson. The row has -// one company_id; a task can have several. Scope only when the task has exactly -// one company. Zero or several → generic (NULL), which is the remaining product -// call for multi-company tasks. +// one company_id. Scope only when the task has exactly one company. Zero +// companies → generic (NULL). ExtractLessonsForTask skips when there are several. func lessonExtractCompanyID(companyIDs []int64) int64 { if len(companyIDs) == 1 { return companyIDs[0] @@ -95,12 +94,17 @@ func lessonExtractCompanyID(companyIDs []int64) int64 { // ExtractLessonsForTask derives candidate lessons from one task's findings and // retests. It is idempotent: the evidence primary key means a second run adds -// no support. Returns the number of distinct lessons touched. +// no support. A task with more than one company is skipped so a generic +// (NULL company_id) lesson cannot leak across companies. Returns the number of +// distinct lessons touched. func (d *DB) ExtractLessonsForTask(ctx context.Context, taskID int64) (int, error) { categoryID, companyIDs, err := taskLessonScope(ctx, d, taskID) if err != nil { return 0, err } + if len(companyIDs) > 1 { + return 0, nil + } companyID := lessonExtractCompanyID(companyIDs) rows, err := d.QueryContext(ctx, ` SELECT f.id, f.vulnclass, f.name, f.summary, f.severity, f.status, diff --git a/db/lessons_test.go b/db/lessons_test.go index c311d59..2fc87b1 100644 --- a/db/lessons_test.go +++ b/db/lessons_test.go @@ -112,12 +112,6 @@ func TestTaskLessonsUsesTaskScopeAndRanksCompanyFirst(t *testing.T) { aKey := fmt.Sprintf("lesson-a-%d", stamp) bKey := fmt.Sprintf("lesson-b-%d", stamp) var genericID, aID, bID int64 - if err := d.QueryRow(` - INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id) - VALUES ($1,'positive','xss','generic prior',NULL) RETURNING id`, genericKey).Scan(&genericID); err != nil { - t.Fatal(err) - } - t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) }) if err := d.QueryRow(` INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id) VALUES ($1,'positive','xss','company A prior',$2) RETURNING id`, aKey, companyA).Scan(&aID); err != nil { @@ -130,6 +124,13 @@ func TestTaskLessonsUsesTaskScopeAndRanksCompanyFirst(t *testing.T) { t.Fatal(err) } t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, bID) }) + // Generic last: without the company rank term, id DESC would put this first. + if err := d.QueryRow(` + INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id) + VALUES ($1,'positive','xss','generic prior',NULL) RETURNING id`, genericKey).Scan(&genericID); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) }) got, err := d.TaskLessons(t.Context(), taskA.ID, 8) if err != nil { @@ -221,3 +222,234 @@ func TestExtractLessonsScopesSingleCompanyFromTaskScope(t *testing.T) { } t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, scoped.ID) }) } + +func TestExtractLessonsSkipsMultiCompanyTask(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v) — skipping", err) + } + t.Cleanup(func() { d.Close() }) + + stamp := time.Now().UnixNano() + cs := d.Companies() + companyA, _, err := cs.UpsertCompany(fmt.Sprintf("LessonMultiA %d", stamp), "") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupCompany(d, companyA) }) + companyB, _, err := cs.UpsertCompany(fmt.Sprintf("LessonMultiB %d", stamp), "") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupCompany(d, companyB) }) + + task, err := d.CreateTaskWithOptions("extract multi company", "goal", TaskCreateOptions{ + Name: fmt.Sprintf("lesson-multi-%d", stamp), CompanyIDs: []int64{companyA, companyB}, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupErr(t, "multi-company task", d.DeleteTask(task.ID)) }) + findingID := insertLessonFinding(t, d, task.ID, "confirmed") + + n, err := d.ExtractLessonsForTask(t.Context(), task.ID) + if err != nil { + t.Fatal(err) + } + if n != 0 { + t.Fatalf("extracted=%d, want 0 for a multi-company task", n) + } + var evidence int + if err := d.QueryRow(` + SELECT COUNT(*) FROM rsi_lesson_evidence + WHERE source_kind='finding' AND source_id=$1`, findingID).Scan(&evidence); err != nil { + t.Fatal(err) + } + if evidence != 0 { + t.Fatalf("multi-company extract wrote %d evidence rows", evidence) + } +} + +func TestExtractLessonsGenericWhenTaskHasNoCompany(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v) — skipping", err) + } + t.Cleanup(func() { d.Close() }) + + stamp := time.Now().UnixNano() + task, err := d.CreateTaskWithOptions("extract no company", "goal", TaskCreateOptions{ + Name: fmt.Sprintf("lesson-nocompany-%d", stamp), + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupErr(t, "no-company task", d.DeleteTask(task.ID)) }) + findingID := insertLessonFinding(t, d, task.ID, "confirmed") + + n, err := d.ExtractLessonsForTask(t.Context(), task.ID) + if err != nil { + t.Fatal(err) + } + if n != 1 { + t.Fatalf("extracted=%d, want 1", n) + } + var lessonID, companyID int64 + if err := d.QueryRow(` + SELECT l.id, COALESCE(l.company_id,0) + FROM rsi_lessons l + JOIN rsi_lesson_evidence e ON e.lesson_id=l.id + WHERE e.source_kind='finding' AND e.source_id=$1`, findingID).Scan(&lessonID, &companyID); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, lessonID) }) + if companyID != 0 { + t.Fatalf("no-company extract scoped lesson to company %d", companyID) + } +} + +func TestTaskLessonsRanksCategoryBeforeGeneric(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v) — skipping", err) + } + t.Cleanup(func() { d.Close() }) + + stamp := time.Now().UnixNano() + category, err := d.CreateTaskCategory(fmt.Sprintf("LessonCat %d", stamp)) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + _, err := d.DeleteTaskCategory(category.ID) + cleanupErr(t, "category", err) + }) + task, err := d.CreateTaskWithOptions("lesson category rank", "goal", TaskCreateOptions{ + Name: fmt.Sprintf("lesson-cat-%d", stamp), CategoryID: &category.ID, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupErr(t, "category task", d.DeleteTask(task.ID)) }) + + var catID, genericID int64 + if err := d.QueryRow(` + INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,category_id) + VALUES ($1,'positive','xss','category prior',$2) RETURNING id`, + fmt.Sprintf("lesson-cat-%d", stamp), category.ID).Scan(&catID); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, catID) }) + // Generic last: without the category rank term, id DESC would put this first. + if err := d.QueryRow(` + INSERT INTO rsi_lessons(dedupe_key,kind,cue,action) + VALUES ($1,'positive','xss','generic prior') RETURNING id`, + fmt.Sprintf("lesson-cat-generic-%d", stamp)).Scan(&genericID); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) }) + + got, err := d.TaskLessons(t.Context(), task.ID, 8) + if err != nil { + t.Fatal(err) + } + if len(got) == 0 { + t.Fatal("categorized task saw no lessons") + } + if got[0].ID != catID { + t.Fatalf("category-scoped lesson should rank first, got id=%d category=%d (want %d)", + got[0].ID, got[0].CategoryID, catID) + } + var sawCat, sawGeneric bool + for _, l := range got { + switch l.ID { + case catID: + sawCat = true + case genericID: + sawGeneric = true + } + } + if !sawCat || !sawGeneric { + t.Fatalf("want category and generic lessons, sawCat=%v sawGeneric=%v", sawCat, sawGeneric) + } +} + +func TestLogLessonUsageRecordsOnlyRendered(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v) — skipping", err) + } + t.Cleanup(func() { d.Close() }) + + stamp := time.Now().UnixNano() + task, err := d.CreateTaskWithOptions("lesson usage", "goal", TaskCreateOptions{ + Name: fmt.Sprintf("lesson-usage-%d", stamp), + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupErr(t, "usage task", d.DeleteTask(task.ID)) }) + + var firstID, secondID int64 + if err := d.QueryRow(` + INSERT INTO rsi_lessons(dedupe_key,kind,cue,action) + VALUES ($1,'positive','xss',$2) RETURNING id`, + fmt.Sprintf("lesson-usage-a-%d", stamp), + "Confirmed xss: "+strings.Repeat("a", 80)).Scan(&firstID); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, firstID) }) + if err := d.QueryRow(` + INSERT INTO rsi_lessons(dedupe_key,kind,cue,action) + VALUES ($1,'negative','ssrf',$2) RETURNING id`, + fmt.Sprintf("lesson-usage-b-%d", stamp), + "Do not re-report: "+strings.Repeat("b", 80)).Scan(&secondID); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, secondID) }) + + lessons := []Lesson{ + {ID: firstID, Kind: "positive", Cue: "xss", Action: "Confirmed xss: " + strings.Repeat("a", 80), Support: 1}, + {ID: secondID, Kind: "negative", Cue: "ssrf", Action: "Do not re-report: " + strings.Repeat("b", 80), Support: 1}, + } + _, ids := RenderLessons(lessons, 250) + if len(ids) != 1 || ids[0] != firstID { + t.Fatalf("rendered IDs=%v, want only %d", ids, firstID) + } + if err := d.LogLessonUsage(t.Context(), task.ID, ids, "shadow"); err != nil { + t.Fatal(err) + } + + rows, err := d.Query(`SELECT lesson_id FROM rsi_lesson_usage WHERE task_id=$1 ORDER BY lesson_id`, task.ID) + if err != nil { + t.Fatal(err) + } + defer rows.Close() + var logged []int64 + for rows.Next() { + var id int64 + if err := rows.Scan(&id); err != nil { + t.Fatal(err) + } + logged = append(logged, id) + } + if err := rows.Err(); err != nil { + t.Fatal(err) + } + if len(logged) != 1 || logged[0] != firstID { + t.Fatalf("usage log=%v, want only rendered lesson %d (dropped %d)", logged, firstID, secondID) + } +} + +func insertLessonFinding(t *testing.T, d *DB, taskID int64, status string) int64 { + t.Helper() + var id int64 + if err := d.QueryRow(` + INSERT INTO findings(task_id,vulnclass,name,summary,severity,status) + VALUES ($1,'xss','Reflected XSS','reflected in search','high',$2) + RETURNING id`, taskID, status).Scan(&id); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, id) }) + return id +} diff --git a/db/task_context.go b/db/task_context.go index 751baaa..0dc2b27 100644 --- a/db/task_context.go +++ b/db/task_context.go @@ -1,6 +1,7 @@ package db import ( + "context" "database/sql" "fmt" "strings" @@ -344,7 +345,12 @@ func (d *DB) TaskSourceIDs(taskID int64) ([]int64, error) { // TaskCompanyIDs returns the companies whose asset scopes are available to the // task. The task_scope rows remain the single source of truth. func (d *DB) TaskCompanyIDs(taskID int64) ([]int64, error) { - rows, err := d.Query(` + return d.TaskCompanyIDsContext(context.Background(), taskID) +} + +// TaskCompanyIDsContext is the context-aware form of TaskCompanyIDs. +func (d *DB) TaskCompanyIDsContext(ctx context.Context, taskID int64) ([]int64, error) { + rows, err := d.QueryContext(ctx, ` SELECT company_id FROM task_scope WHERE task_id=$1 AND kind='company' AND company_id IS NOT NULL ORDER BY id`, taskID) diff --git a/docs/rsi-lessons.md b/docs/rsi-lessons.md index 9af9711..b17bf59 100644 --- a/docs/rsi-lessons.md +++ b/docs/rsi-lessons.md @@ -48,6 +48,11 @@ Rules: Pending and in-progress findings produce nothing: there is no outcome yet. Empty cue, action, or source is refused by the gate. +A task with more than one company in `task_scope` is skipped. A generic +(`company_id` NULL) lesson would be visible to every later task, including +those of the other companies on this one. Per-finding company attribution is +a later change. + ## Selection `GET /api/tasks/{id}/lessons` returns the lessons visible to a task plus the @@ -55,7 +60,8 @@ rendered block. Selection is scoped: - generic lessons (no company, no category) are visible to every task; - company scope comes from `task_scope`, not `tasks.company_id`; a lesson is - company-scoped only when the source task had exactly one company; + company-scoped only when the source task had exactly one company, and a + task with several companies is not extracted; - lessons from the same company or the same task category rank first (company/category matches sort ahead of generic rows); - within a scope: positive before negative before caution, then support, then