Compare commits

...
Author SHA1 Message Date
BaaRai 84a623bf2d fix(db): parenthesise a top-level OR in asset DSL queries
QueryDSLInScope builds the DSL clause and then appends the task-scope clause with AND. An OR node joined its children without wrapping the whole group, so '(a) OR (b) AND id IN (scope)' let the first branch return assets outside the task scope. Wrap the whole disjunction; the children are already parenthesised.

Tests: the pure builder shape, and a PostgreSQL case where the bare-text branch matches both an in-scope and an out-of-scope asset (fails before the fix).
2026-11-20 01:34:28 +01:00
2 changed files with 91 additions and 1 deletions
+5 -1
View File
@@ -302,7 +302,11 @@ func (b *whereBuilder) build(node *astNode) (string, error) {
}
parts = append(parts, "("+clause+")")
}
return strings.Join(parts, " OR "), nil
// The whole disjunction must be parenthesised: callers append their own
// clauses with AND (the task scope in QueryDSLInScope, the type filter),
// and AND binds tighter than OR, so "(a) OR (b) AND scope" would let the
// first branch escape the scope.
return "(" + strings.Join(parts, " OR ") + ")", nil
case "leaf":
return b.buildLeaf(*node.expr)
}
+86
View File
@@ -0,0 +1,86 @@
package db
import (
"fmt"
"strings"
"testing"
"time"
)
// A top-level OR must be parenthesised as a whole. QueryDSLInScope appends the
// task-scope clause with AND, and AND binds tighter than OR, so an unparenthesised
// disjunction lets the first branch return rows from outside the task scope.
func TestBuildDSLWhereWrapsOr(t *testing.T) {
node, err := ParseDSL("domain=alpha OR domain=beta")
if err != nil {
t.Fatal(err)
}
where, _, err := buildDSLWhereBase(node, 0)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(where, "((") || !strings.HasSuffix(where, "))") {
t.Fatalf("compiled to %q: the whole OR group must be parenthesised", where)
}
}
// TestQueryDSLInScopeOrDoesNotEscape is the behavioural form: an OR query whose
// first branch matches every row must not return an asset outside the task scope.
func TestQueryDSLInScopeOrDoesNotEscape(t *testing.T) {
d, assets, _ := testSetup(t)
t.Cleanup(func() { d.Close() })
task, err := d.CreateTask("or scope", "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
stamp := time.Now().UnixNano()
root := fmt.Sprintf("in%d.invalid", stamp)
out := fmt.Sprintf("x%d.invalid", stamp)
marker := fmt.Sprintf("or%d", stamp)
if err := assets.upsertTaskScope(TaskScope{TaskID: task.ID, Kind: "root_domain", Domain: root}); err != nil {
t.Fatalf("seed scope: %v", err)
}
var inID, outID int64
for _, r := range []struct {
domain, root string
id *int64
}{
{"a." + root, root, &inID},
{out, out, &outID},
} {
if err := d.QueryRow(`INSERT INTO assets(type,domain,root_domain,page_title,last_seen)
VALUES ('subdomain',$1,$2,$3,now()) RETURNING id`, r.domain, r.root, marker).Scan(r.id); err != nil {
t.Fatalf("insert %s: %v", r.domain, err)
}
}
t.Cleanup(func() {
cleanupExec(t, d, `DELETE FROM assets WHERE id=ANY($1::bigint[])`, []int64{inID, outID})
})
// The bare marker matches both rows; the second branch names the out-of-scope
// host. Only the in-scope row may come back.
got, err := assets.QueryDSLInScope(marker+" OR domain="+out, "", task.ID, 50, 0)
if err != nil {
t.Fatal(err)
}
var sawIn, sawOut bool
for _, a := range got {
switch a.ID {
case inID:
sawIn = true
case outID:
sawOut = true
}
}
if !sawIn {
t.Fatalf("in-scope asset %d missing from %+v", inID, got)
}
if sawOut {
t.Fatalf("out-of-scope asset %d leaked through an OR query", outID)
}
}