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 <gpt-6@openai.com>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-14 15:13:32 +03:00
1 parent 63cdc7d490
commit 83921350fd
5 files changed
+310 -32

No files matched your search

@@ -1,6 +1,7 @@
package main package main
import ( import (
"errors"
"fmt" "fmt"
"io" "io"
) )
@@ -43,6 +44,23 @@ const (
reasonDefinition reasonDefinition
reasonRuntime reasonRuntime
reasonCollector reasonCollector
reasonGuard
reasonWorkerScan
reasonEngine
reasonArgv
reasonParent
reasonStarttime
reasonQueue
reasonVersion
reasonRulesRead
reasonMode
reasonPlanStore
reasonContext
reasonQueuePresentOrUnreadable
reasonNFTRead
reasonNFTPresent
reasonBaseline
reasonPriorCleanupVeto
) )
func (s qualificationStage) String() string { func (s qualificationStage) String() string {
@@ -54,7 +72,7 @@ func (s qualificationStage) String() string {
} }
func (r qualificationReason) 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) { if int(r) >= len(names) {
return names[0] return names[0]
} }
@@ -76,7 +94,19 @@ func qualificationOperation(err error, stage qualificationStage) error {
if err == nil { if err == nil {
return 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 { func attestationMismatch(a, b qualificationAttestation) qualificationReason {
@@ -140,12 +140,15 @@ func TestQualificationDiagnosticVetoAndFinalStages(t *testing.T) {
func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) { func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) {
secret := errors.New("PRIVATE sentinel") 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) { t.Run(mode, func(t *testing.T) {
var primary error var primary error
if mode == "cleanup" { if mode == "cleanup" {
primary = &qualificationCleanupFailure{Err: secret} primary = &qualificationCleanupFailure{Err: secret}
} }
if mode == "owned_cleanup" {
primary = errors.Join(context.Canceled, &managedRecoveryFatal{Err: &managedAssetCleanupFailure{Err: secret}})
}
restores, guards, acks := 0, 0, 0 restores, guards, acks := 0, 0, 0
err := qualificationFinalize(primary, func(context.Context) error { err := qualificationFinalize(primary, func(context.Context) error {
restores++ restores++
@@ -187,13 +190,38 @@ func TestQualificationFinalizeDiagnosticsAndACKGate(t *testing.T) {
if mode != "ack" && acks != 0 { if mode != "ack" && acks != 0 {
t.Fatal("ACK passed failed gate") t.Fatal("ACK passed failed gate")
} }
if mode == "cleanup" && (restores != 0 || guards != 0) { if mode == "cleanup" || mode == "owned_cleanup" {
t.Fatal("cleanup failure retried") 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) { func TestQualificationAttestationErrorRetainsOwnershipVeto(t *testing.T) {
q, s, registry, _, _ := qualifierFixture(t) q, s, registry, _, _ := qualifierFixture(t)
attest, calls := q.attest, 0 attest, calls := q.attest, 0
@@ -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)
}
}
+51 -26
View File
@@ -151,11 +151,34 @@ func (s *resourcePlanStore) protectBaseline() error {
} }
func qualificationNoWorker() error { func qualificationNoWorker() error {
if e := qualificationOnlyWorker(0); e != nil { if e := qualificationOnlyWorker(0); e != nil {
return e return qualificationPredicate(e, reasonWorkerScan)
} }
occupied, e := managedAssetQueueReady(0) occupied, e := managedAssetQueueReady(0)
if e != nil || occupied { 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 return nil
} }
@@ -242,55 +265,57 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP
q.runtime = r q.runtime = r
q.source = func() (resourceMonitorSource, error) { return readResourceMonitorSource(config, d.lookup, s.files.key) } q.source = func() (resourceMonitorSource, error) { return readResourceMonitorSource(config, d.lookup, s.files.key) }
q.guard = func() error { q.guard = func() error {
if qualificationMode(config, strategies, d) != nil || s.guard() != nil { if e := qualificationMode(config, strategies, d); e != nil {
return errResourcePlan 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 { q.restore = func(ctx context.Context) error {
if ctx.Err() != nil || q.guard() != nil || qualificationNoWorker() != nil { return q.restoreBaseline(ctx, qualificationNoWorker, func() error { return qualificationBaseline(d.directory) })
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)
} }
q.attest = func(ctx context.Context, pid int, args []string, definition strategyDefinition) (qualificationAttestation, error) { q.attest = func(ctx context.Context, pid int, args []string, definition strategyDefinition) (qualificationAttestation, error) {
if q.guard() != nil || qualificationOnlyWorker(pid) != nil { if e := q.guard(); e != nil {
return qualificationAttestation{}, errResourcePlan 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 { 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)) cmd, e := os.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
if e != nil || string(cmd) != strings.Join(append([]string{qualificationEngine}, args...), "\x00")+"\x00" { 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)) stat, e := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid))
if e != nil { if e != nil {
return qualificationAttestation{}, e return qualificationAttestation{}, qualificationPredicate(e, reasonParent)
} }
end := strings.LastIndex(string(stat), ") ") end := strings.LastIndex(string(stat), ") ")
if end < 0 { if end < 0 {
return qualificationAttestation{}, errResourcePlan return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonParent)
} }
tail := strings.Fields(string(stat)[end+2:]) tail := strings.Fields(string(stat)[end+2:])
if len(tail) < 2 || tail[1] != strconv.Itoa(os.Getpid()) { if len(tail) < 2 || tail[1] != strconv.Itoa(os.Getpid()) {
return qualificationAttestation{}, errResourcePlan return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonParent)
} }
start, e := readMonitorProcessStarttime(pid) start, e := readMonitorProcessStarttime(pid)
if e != nil { if e != nil {
return qualificationAttestation{}, e return qualificationAttestation{}, qualificationPredicate(e, reasonStarttime)
} }
ready, e := r.queue(pid) ready, e := r.queue(pid)
if e != nil || !ready { if e != nil || !ready {
return qualificationAttestation{}, errResourcePlan return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonQueue)
} }
hash, e := q.filesHash() hash, e := q.filesHash()
if e != nil { if e != nil {
return qualificationAttestation{}, e return qualificationAttestation{}, qualificationPredicate(e, reasonFiles)
} }
versionCtx, cancel := context.WithTimeout(ctx, 5*time.Second) versionCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel() defer cancel()
@@ -299,7 +324,7 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP
version.Stdout = &playerBoundedWriter{dst: &output, limit: 4096} version.Stdout = &playerBoundedWriter{dst: &output, limit: 4096}
version.Stderr = io.Discard version.Stderr = io.Discard
if version.Run() != nil { if version.Run() != nil {
return qualificationAttestation{}, errResourcePlan return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonVersion)
} }
fields := strings.Fields(output.String()) fields := strings.Fields(output.String())
valid := false valid := false
@@ -309,11 +334,11 @@ func newResourceQualifier(config, strategies string, d managedDeps, s *resourceP
} }
} }
if !valid { if !valid {
return qualificationAttestation{}, errResourcePlan return qualificationAttestation{}, qualificationPredicate(errResourcePlan, reasonVersion)
} }
rules, e := r.nft(ctx, "list table inet "+managedAssetTable+"\n") rules, e := r.nft(ctx, "list table inet "+managedAssetTable+"\n")
if e != nil || strings.TrimSpace(rules) == "" { 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 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
} }
@@ -93,7 +93,7 @@ func qualificationFinalize(err error, restore func(context.Context) error, guard
return restoreErr return restoreErr
}) { }) {
if restoreErr == nil { if restoreErr == nil {
restoreErr = errResourcePlan return qualificationOperation(qualificationPredicate(errResourcePlan, reasonPriorCleanupVeto), stageRestore)
} }
return qualificationOperation(restoreErr, stageRestore) return qualificationOperation(restoreErr, stageRestore)
} }