From 83921350fd92cbc2e0161c1096471b690e38c38b Mon Sep 17 00:00:00 2001 From: Zeusina Date: Wed, 14 Oct 2026 15:13:32 +0300 Subject: [PATCH] fix: diagnose opaque qualification predicates Add fixed attestation, factory guard and restoration reasons without changing fail-closed predicates or cleanup order. Retain nested reasons under joined ownership vetoes and distinguish prior cleanup veto from a new restoration failure. Co-authored-by: GPT-6 --- .../qualification_diagnostic.go | 34 ++- .../qualification_diagnostic_test.go | 34 ++- .../qualification_predicate_test.go | 195 ++++++++++++++++++ cmd/zapret-autotune/resource_qualify.go | 77 ++++--- .../resource_qualify_completion.go | 2 +- 5 files changed, 310 insertions(+), 32 deletions(-) create mode 100644 cmd/zapret-autotune/qualification_predicate_test.go diff --git a/cmd/zapret-autotune/qualification_diagnostic.go b/cmd/zapret-autotune/qualification_diagnostic.go index b8e130e..eb3df92 100644 --- a/cmd/zapret-autotune/qualification_diagnostic.go +++ b/cmd/zapret-autotune/qualification_diagnostic.go @@ -1,6 +1,7 @@ package main import ( + "errors" "fmt" "io" ) @@ -43,6 +44,23 @@ const ( reasonDefinition reasonRuntime reasonCollector + reasonGuard + reasonWorkerScan + reasonEngine + reasonArgv + reasonParent + reasonStarttime + reasonQueue + reasonVersion + reasonRulesRead + reasonMode + reasonPlanStore + reasonContext + reasonQueuePresentOrUnreadable + reasonNFTRead + reasonNFTPresent + reasonBaseline + reasonPriorCleanupVeto ) func (s qualificationStage) String() string { @@ -54,7 +72,7 @@ func (s qualificationStage) String() string { } func (r qualificationReason) String() string { - names := [...]string{"unknown", "execution", "output_bound", "metrics", "origin", "tls_evidence", "framing", "body", "mime", "worker_identity", "rules", "files", "definition", "runtime", "collector"} + names := [...]string{"unknown", "execution", "output_bound", "metrics", "origin", "tls_evidence", "framing", "body", "mime", "worker_identity", "rules", "files", "definition", "runtime", "collector", "guard", "worker_scan", "engine", "argv", "parent", "starttime", "queue", "version", "rules_read", "mode", "plan_store", "context", "queue_present_or_unreadable", "nft_read", "nft_present", "baseline", "prior_cleanup_veto"} if int(r) >= len(names) { return names[0] } @@ -76,7 +94,19 @@ func qualificationOperation(err error, stage qualificationStage) error { if err == nil { return nil } - return &qualificationDiagnostic{Err: err, Stage: stage} + return &qualificationDiagnostic{Err: err, Stage: stage, Reason: qualificationErrorReason(err, reasonUnknown)} +} + +func qualificationPredicate(err error, reason qualificationReason) error { + return &qualificationDiagnostic{Err: err, Reason: reason} +} + +func qualificationErrorReason(err error, fallback qualificationReason) qualificationReason { + var diagnostic *qualificationDiagnostic + if errors.As(err, &diagnostic) && diagnostic.Reason != reasonUnknown { + return diagnostic.Reason + } + return fallback } func attestationMismatch(a, b qualificationAttestation) qualificationReason { diff --git a/cmd/zapret-autotune/qualification_diagnostic_test.go b/cmd/zapret-autotune/qualification_diagnostic_test.go index 4700d01..f5a02d1 100644 --- a/cmd/zapret-autotune/qualification_diagnostic_test.go +++ b/cmd/zapret-autotune/qualification_diagnostic_test.go @@ -140,12 +140,15 @@ func TestQualificationDiagnosticVetoAndFinalStages(t *testing.T) { func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) { secret := errors.New("PRIVATE sentinel") - for _, mode := range []string{"cleanup", "restore", "guard", "ack", "success"} { + for _, mode := range []string{"cleanup", "owned_cleanup", "restore", "guard", "ack", "success"} { t.Run(mode, func(t *testing.T) { var primary error if mode == "cleanup" { primary = &qualificationCleanupFailure{Err: secret} } + if mode == "owned_cleanup" { + primary = errors.Join(context.Canceled, &managedRecoveryFatal{Err: &managedAssetCleanupFailure{Err: secret}}) + } restores, guards, acks := 0, 0, 0 err := qualificationFinalize(primary, func(context.Context) error { restores++ @@ -187,13 +190,38 @@ func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) { if mode != "ack" && acks != 0 { t.Fatal("ACK passed failed gate") } - if mode == "cleanup" && (restores != 0 || guards != 0) { - t.Fatal("cleanup failure retried") + if mode == "cleanup" || mode == "owned_cleanup" { + if restores != 0 || guards != 0 || acks != 0 || !strings.Contains(out.String(), "reason=prior_cleanup_veto") { + t.Fatal("cleanup failure retried or misdiagnosed", out.String()) + } } }) } } +func TestQualificationOpaqueAttestationReasonUnderPostDNSGuard(t *testing.T) { + secret := errors.New("PRIVATE attestation path env argv") + q, s, registry, _, transfers := qualifierFixture(t) + attest, calls := q.attest, 0 + q.attest = func(ctx context.Context, pid int, args []string, d strategyDefinition) (qualificationAttestation, error) { + calls++ + if calls == 3 { // Initial attestation, pre-DNS, then post-DNS. + return qualificationAttestation{}, qualificationPredicate(secret, reasonWorkerScan) + } + return attest(ctx, pid, args, d) + } + proof, err := q.complete(context.Background(), s, registry) + if !errors.Is(err, errResourcePlan) || !errors.Is(err, secret) || proof.seal != "" || *transfers != 0 { + t.Fatal("ownership veto or execution order changed", err, *transfers) + } + var out bytes.Buffer + writeQualificationDiagnostics(&out, err) + if strings.Contains(out.String(), "PRIVATE") || strings.Contains(out.String(), "reason=unknown") || + strings.Count(out.String(), "stage=post_dns_guard reason=worker_scan candidate=1 resource=1 attempt=1 tls=tls12") != 2 { + t.Fatal(out.String()) + } +} + func TestQualificationAttestationErrorRetainsOwnershipVeto(t *testing.T) { q, s, registry, _, _ := qualifierFixture(t) attest, calls := q.attest, 0 diff --git a/cmd/zapret-autotune/qualification_predicate_test.go b/cmd/zapret-autotune/qualification_predicate_test.go new file mode 100644 index 0000000..5df10f9 --- /dev/null +++ b/cmd/zapret-autotune/qualification_predicate_test.go @@ -0,0 +1,195 @@ +package main + +import ( + "bytes" + "context" + "errors" + "go/ast" + "go/format" + "go/parser" + "go/token" + "reflect" + "strings" + "testing" +) + +func TestQualificationRestorePredicatesAndOrder(t *testing.T) { + secret := errors.New("PRIVATE nft process baseline sentinel") + for _, reason := range []qualificationReason{reasonContext, reasonGuard, reasonMode, reasonPlanStore, reasonRuntime, reasonWorkerScan, reasonQueuePresentOrUnreadable, reasonNFTRead, reasonNFTPresent, reasonBaseline, reasonUnknown} { + t.Run(reason.String(), func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + if reason == reasonContext { + cancel() + } + var order []string + q := resourceQualifier{guard: func() error { + order = append(order, "guard") + if reason == reasonGuard { + return secret + } + if reason == reasonMode || reason == reasonPlanStore || reason == reasonRuntime { + return qualificationPredicate(secret, reason) + } + return nil + }} + q.runtime.nft = func(_ context.Context, input string) (string, error) { + order = append(order, "nft") + if input != "list tables\n" { + t.Fatal(input) + } + if reason == reasonNFTRead { + return "", secret + } + if reason == reasonNFTPresent { + return "table inet " + managedAssetTable, nil + } + return "", nil + } + err := q.restoreBaseline(ctx, func() error { + order = append(order, "worker_queue") + if reason == reasonWorkerScan || reason == reasonQueuePresentOrUnreadable { + return qualificationPredicate(secret, reason) + } + return nil + }, func() error { + order = append(order, "baseline") + if reason == reasonBaseline { + return errResourcePlan + } + return nil + }) + want := []string{"guard", "worker_queue", "nft", "baseline"} + switch reason { + case reasonContext: + want = nil + case reasonGuard, reasonMode, reasonPlanStore, reasonRuntime: + want = want[:1] + case reasonWorkerScan, reasonQueuePresentOrUnreadable: + want = want[:2] + case reasonNFTRead, reasonNFTPresent: + want = want[:3] + } + if !reflect.DeepEqual(order, want) { + t.Fatal(order, want) + } + if reason == reasonUnknown { + if err != nil { + t.Fatal(err) + } + return + } + if !errors.Is(err, errResourcePlan) || errors.Is(err, secret) { + t.Fatal("original restore classification changed", err) + } + var out bytes.Buffer + writeQualificationDiagnostics(&out, qualificationOperation(err, stageRestore)) + if !strings.Contains(out.String(), "role=cleanup stage=restore reason="+reason.String()) || strings.Contains(out.String(), "PRIVATE") { + t.Fatal(out.String()) + } + }) + } +} + +// Check the actual production factory, not just injected diagnostic errors. This +// pins opaque predicate order/strictness without starting workers or changing nft. +func TestQualificationProductionPredicateMap(t *testing.T) { + fset := token.NewFileSet() + f, err := parser.ParseFile(fset, "resource_qualify.go", nil, 0) + if err != nil { + t.Fatal(err) + } + text := func(n ast.Node) string { + var b bytes.Buffer + if err := format.Node(&b, fset, n); err != nil { + t.Fatal(err) + } + return b.String() + } + var attest *ast.FuncLit + var restore, guard, noWorker, onlyWorker string + ast.Inspect(f, func(n ast.Node) bool { + if fn, ok := n.(*ast.FuncDecl); ok { + switch fn.Name.Name { + case "qualificationNoWorker": + noWorker = text(fn.Body) + case "qualificationOnlyWorker": + onlyWorker = text(fn.Body) + } + } + a, ok := n.(*ast.AssignStmt) + if !ok || len(a.Lhs) != 1 || len(a.Rhs) != 1 { + return true + } + if text(a.Lhs[0]) == "q.attest" { + attest, _ = a.Rhs[0].(*ast.FuncLit) + } + if text(a.Lhs[0]) == "q.restore" { + restore = text(a.Rhs[0]) + } + if text(a.Lhs[0]) == "q.guard" && guard == "" { + guard = text(a.Rhs[0]) + } + return true + }) + if attest == nil || !strings.Contains(restore, "q.restoreBaseline(ctx, qualificationNoWorker, func() error { return qualificationBaseline(d.directory) })") { + t.Fatal("production restore wiring changed", restore) + } + for _, check := range []string{ + "if e := qualificationMode(config, strategies, d); e != nil {\n\t\treturn qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonMode))", + "if e := s.guard(); e != nil {\n\t\treturn qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonPlanStore))", + "if e := r.guard(); e != nil {\n\t\treturn qualificationPredicate(e, qualificationErrorReason(e, reasonRuntime))", + } { + if !strings.Contains(guard, check) { + t.Fatal("production guard predicate changed", guard) + } + } + if !strings.Contains(noWorker, "qualificationOnlyWorker(0)") || !strings.Contains(noWorker, "qualificationPredicate(e, reasonWorkerScan)") || + !strings.Contains(noWorker, "managedAssetQueueReady(0)") || !strings.Contains(noWorker, "e != nil || occupied") || !strings.Contains(noWorker, "qualificationPredicate(errResourcePlan, reasonQueuePresentOrUnreadable)") { + t.Fatal("production worker/queue predicate changed", noWorker) + } + if !strings.Contains(onlyWorker, "if errors.Is(e, os.ErrNotExist) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\treturn errResourcePlan") { + t.Fatal("unexpected procfs readlink errors must remain fail-closed", onlyWorker) + } + var got []string + for _, stmt := range attest.Body.List { + branch, ok := stmt.(*ast.IfStmt) + if !ok { + continue + } + predicate := text(branch.Cond) + if branch.Init != nil { + predicate = text(branch.Init) + "; " + predicate + } + ret, ok := branch.Body.List[0].(*ast.ReturnStmt) + if !ok || len(ret.Results) != 2 { + t.Fatal("unexpected attestation branch", text(branch)) + } + got = append(got, predicate+" => "+text(ret.Results[1])) + } + want := []string{ + "e := q.guard(); e != nil => qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonGuard))", + "qualificationOnlyWorker(pid) != nil => qualificationPredicate(errResourcePlan, reasonWorkerScan)", + `engine == nil || engine.validate() != nil || engine.running(fmt.Sprintf("/proc/%d/exe", pid)) != nil => qualificationPredicate(errResourcePlan, reasonEngine)`, + `e != nil || string(cmd) != strings.Join(append([]string{qualificationEngine}, args...), "\x00")+"\x00" => qualificationPredicate(errResourcePlan, reasonArgv)`, + "e != nil => qualificationPredicate(e, reasonParent)", + "end < 0 => qualificationPredicate(errResourcePlan, reasonParent)", + "len(tail) < 2 || tail[1] != strconv.Itoa(os.Getpid()) => qualificationPredicate(errResourcePlan, reasonParent)", + "e != nil => qualificationPredicate(e, reasonStarttime)", + "e != nil || !ready => qualificationPredicate(errResourcePlan, reasonQueue)", + "e != nil => qualificationPredicate(e, reasonFiles)", + "version.Run() != nil => qualificationPredicate(errResourcePlan, reasonVersion)", + "!valid => qualificationPredicate(errResourcePlan, reasonVersion)", + `e != nil || strings.TrimSpace(rules) == "" => qualificationPredicate(errResourcePlan, reasonRulesRead)`, + } + if !reflect.DeepEqual(got, want) { + t.Fatalf("production attestation predicates:\n%v\nwant:\n%v", got, want) + } + // The factory's strict mode check must precede any store, worker or nft access. + q := newResourceQualifier("", "", managedDeps{lookup: func(string) (string, bool) { return "", false }}, nil) + defer q.close() + _, err = q.attest(context.Background(), 0, nil, strategyDefinition{}) + if !errors.Is(err, errResourcePlan) || qualificationErrorReason(err, reasonUnknown) != reasonMode { + t.Fatal(err) + } +} diff --git a/cmd/zapret-autotune/resource_qualify.go b/cmd/zapret-autotune/resource_qualify.go index 08f1d32..b89e627 100644 --- a/cmd/zapret-autotune/resource_qualify.go +++ b/cmd/zapret-autotune/resource_qualify.go @@ -151,11 +151,34 @@ func (s *resourcePlanStore) protectBaseline() error { } func qualificationNoWorker() error { if e := qualificationOnlyWorker(0); e != nil { - return e + return qualificationPredicate(e, reasonWorkerScan) } occupied, e := managedAssetQueueReady(0) if e != nil || occupied { - return errResourcePlan + return qualificationPredicate(errResourcePlan, reasonQueuePresentOrUnreadable) + } + return nil +} + +func (q resourceQualifier) restoreBaseline(ctx context.Context, noWorker, baseline func() error) error { + if ctx.Err() != nil { + return qualificationPredicate(errResourcePlan, reasonContext) + } + if e := q.guard(); e != nil { + return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonGuard)) + } + if e := noWorker(); e != nil { + return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonUnknown)) + } + tables, e := q.runtime.nft(ctx, "list tables\n") + if e != nil { + return qualificationPredicate(errResourcePlan, reasonNFTRead) + } + if strings.Contains(tables, "table inet "+managedAssetTable) { + return qualificationPredicate(errResourcePlan, reasonNFTPresent) + } + if e := baseline(); e != nil { + return qualificationPredicate(e, reasonBaseline) } return nil } @@ -242,55 +265,57 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP q.runtime = r q.source = func() (resourceMonitorSource, error) { return readResourceMonitorSource(config, d.lookup, s.files.key) } q.guard = func() error { - if qualificationMode(config, strategies, d) != nil || s.guard() != nil { - return errResourcePlan + if e := qualificationMode(config, strategies, d); e != nil { + return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonMode)) } - return r.guard() + if e := s.guard(); e != nil { + return qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonPlanStore)) + } + if e := r.guard(); e != nil { + return qualificationPredicate(e, qualificationErrorReason(e, reasonRuntime)) + } + return nil } q.restore = func(ctx context.Context) error { - if ctx.Err() != nil || q.guard() != nil || qualificationNoWorker() != nil { - return errResourcePlan - } - tables, e := r.nft(ctx, "list tables\n") - if e != nil || strings.Contains(tables, "table inet "+managedAssetTable) { - return errResourcePlan - } - return qualificationBaseline(d.directory) + return q.restoreBaseline(ctx, qualificationNoWorker, func() error { return qualificationBaseline(d.directory) }) } q.attest = func(ctx context.Context, pid int, args []string, definition strategyDefinition) (qualificationAttestation, error) { - if q.guard() != nil || qualificationOnlyWorker(pid) != nil { - return qualificationAttestation{}, errResourcePlan + if e := q.guard(); e != nil { + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, qualificationErrorReason(e, reasonGuard)) + } + if qualificationOnlyWorker(pid) != nil { + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonWorkerScan) } if engine == nil || engine.validate() != nil || engine.running(fmt.Sprintf("/proc/%d/exe", pid)) != nil { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonEngine) } cmd, e := os.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid)) if e != nil || string(cmd) != strings.Join(append([]string{qualificationEngine}, args...), "\x00")+"\x00" { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonArgv) } stat, e := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid)) if e != nil { - return qualificationAttestation{}, e + return qualificationAttestation{}, qualificationPredicate(e, reasonParent) } end := strings.LastIndex(string(stat), ") ") if end < 0 { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonParent) } tail := strings.Fields(string(stat)[end+2:]) if len(tail) < 2 || tail[1] != strconv.Itoa(os.Getpid()) { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonParent) } start, e := readMonitorProcessStarttime(pid) if e != nil { - return qualificationAttestation{}, e + return qualificationAttestation{}, qualificationPredicate(e, reasonStarttime) } ready, e := r.queue(pid) if e != nil || !ready { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonQueue) } hash, e := q.filesHash() if e != nil { - return qualificationAttestation{}, e + return qualificationAttestation{}, qualificationPredicate(e, reasonFiles) } versionCtx, cancel := context.WithTimeout(ctx, 5*time.Second) defer cancel() @@ -299,7 +324,7 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP version.Stdout = &playerBoundedWriter{dst: &output, limit: 4096} version.Stderr = io.Discard if version.Run() != nil { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonVersion) } fields := strings.Fields(output.String()) valid := false @@ -309,11 +334,11 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP } } if !valid { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonVersion) } rules, e := r.nft(ctx, "list table inet "+managedAssetTable+"\n") if e != nil || strings.TrimSpace(rules) == "" { - return qualificationAttestation{}, errResourcePlan + return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonRulesRead) } return qualificationAttestation{Collector: "owned-resource-nfq-v1", Runtime: "nfqws2-1.0.2", Definition: planDigest(definition), LuaHash: hash, RulesHash: planDigest(rules), WorkerArgsHash: planDigest(args), Queue: managedAssetQueue, PID: pid, StartTime: start}, nil } diff --git a/cmd/zapret-autotune/resource_qualify_completion.go b/cmd/zapret-autotune/resource_qualify_completion.go index 3ba45d0..22e4864 100644 --- a/cmd/zapret-autotune/resource_qualify_completion.go +++ b/cmd/zapret-autotune/resource_qualify_completion.go @@ -93,7 +93,7 @@ func qualificationFinalize(err error, restore func(context.Context) error, guard return restoreErr }) { if restoreErr == nil { - restoreErr = errResourcePlan + return qualificationOperation(qualificationPredicate(errResourcePlan, reasonPriorCleanupVeto), stageRestore) } return qualificationOperation(restoreErr, stageRestore) }