From 116b03534ff307b979614ea180ba7efdfa5dd940 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sun, 11 Oct 2026 03:47:17 +1100 Subject: [PATCH] fix(staterpc): a task's own credential cannot replace its workflow pin The pinned definition carries the package a run's authority is read from. A task-scoped Update now reaches the store without a definition, and UpdateTask keeps the stored pin when none is sent; the workflow name still moves for handoffs and the daemon re-pins it. --- .../postgres/postgresdb/tasks.sql.go | 28 +++++---- .../infrastructure/postgres/queries/tasks.sql | 20 ++++--- .../infrastructure/staterpc/task_grants.go | 15 +++++ .../infrastructure/staterpc/task_pin_test.go | 57 +++++++++++++++++++ 4 files changed, 100 insertions(+), 20 deletions(-) create mode 100644 internal/infrastructure/staterpc/task_pin_test.go diff --git a/internal/infrastructure/postgres/postgresdb/tasks.sql.go b/internal/infrastructure/postgres/postgresdb/tasks.sql.go index d8508b7ea..64d48c313 100644 --- a/internal/infrastructure/postgres/postgresdb/tasks.sql.go +++ b/internal/infrastructure/postgres/postgresdb/tasks.sql.go @@ -1177,18 +1177,19 @@ func (q *Queries) TransitionTask(ctx context.Context, arg TransitionTaskParams) } const updateTask = `-- name: UpdateTask :exec -UPDATE tasks SET workflow = $2, branch = $3, plan = $4, notes = $5, - pr_number = $6, tokens_used = $7, iterations = $8, park_reason = $9, - watch_comment_id = $10, retry_count = $11, remediation_rounds = $12, - review_payload = $13, workflow_definition_version = $14, - workflow_definition_digest = $15, workflow_definition_yaml = $16, - outputs = $17, review_gate = $18, rereview_rounds = $19, - retry_mode = $20, updated_at = now() -WHERE id = $1 +UPDATE tasks SET workflow = $1, branch = $2, plan = $3, notes = $4, + pr_number = $5, tokens_used = $6, iterations = $7, park_reason = $8, + watch_comment_id = $9, retry_count = $10, remediation_rounds = $11, + review_payload = $12, + workflow_definition_version = CASE WHEN $13::text = '' THEN workflow_definition_version ELSE $14 END, + workflow_definition_digest = CASE WHEN $13::text = '' THEN workflow_definition_digest ELSE $15 END, + workflow_definition_yaml = CASE WHEN $13::text = '' THEN workflow_definition_yaml ELSE $13::text END, + outputs = $16, review_gate = $17, rereview_rounds = $18, + retry_mode = $19, updated_at = now() +WHERE id = $20 ` type UpdateTaskParams struct { - ID int64 Workflow string Branch string Plan string @@ -1201,18 +1202,20 @@ type UpdateTaskParams struct { RetryCount int64 RemediationRounds int64 ReviewPayload string + WorkflowDefinitionYaml string WorkflowDefinitionVersion int64 WorkflowDefinitionDigest string - WorkflowDefinitionYaml string Outputs string ReviewGate string RereviewRounds int64 RetryMode string + ID int64 } +// An update without a definition keeps the stored pin: a task's own +// credential sends none, so it cannot replace the definition it runs. func (q *Queries) UpdateTask(ctx context.Context, arg UpdateTaskParams) error { _, err := q.db.Exec(ctx, updateTask, - arg.ID, arg.Workflow, arg.Branch, arg.Plan, @@ -1225,13 +1228,14 @@ func (q *Queries) UpdateTask(ctx context.Context, arg UpdateTaskParams) error { arg.RetryCount, arg.RemediationRounds, arg.ReviewPayload, + arg.WorkflowDefinitionYaml, arg.WorkflowDefinitionVersion, arg.WorkflowDefinitionDigest, - arg.WorkflowDefinitionYaml, arg.Outputs, arg.ReviewGate, arg.RereviewRounds, arg.RetryMode, + arg.ID, ) return err } diff --git a/internal/infrastructure/postgres/queries/tasks.sql b/internal/infrastructure/postgres/queries/tasks.sql index e2e8c9bff..42be568e7 100644 --- a/internal/infrastructure/postgres/queries/tasks.sql +++ b/internal/infrastructure/postgres/queries/tasks.sql @@ -97,14 +97,18 @@ ORDER BY id; UPDATE tasks SET binding_id = $2, binding_version = $3 WHERE id = $1; -- name: UpdateTask :exec -UPDATE tasks SET workflow = $2, branch = $3, plan = $4, notes = $5, - pr_number = $6, tokens_used = $7, iterations = $8, park_reason = $9, - watch_comment_id = $10, retry_count = $11, remediation_rounds = $12, - review_payload = $13, workflow_definition_version = $14, - workflow_definition_digest = $15, workflow_definition_yaml = $16, - outputs = $17, review_gate = $18, rereview_rounds = $19, - retry_mode = $20, updated_at = now() -WHERE id = $1; +-- An update without a definition keeps the stored pin: a task's own +-- credential sends none, so it cannot replace the definition it runs. +UPDATE tasks SET workflow = @workflow, branch = @branch, plan = @plan, notes = @notes, + pr_number = @pr_number, tokens_used = @tokens_used, iterations = @iterations, park_reason = @park_reason, + watch_comment_id = @watch_comment_id, retry_count = @retry_count, remediation_rounds = @remediation_rounds, + review_payload = @review_payload, + workflow_definition_version = CASE WHEN @workflow_definition_yaml::text = '' THEN workflow_definition_version ELSE @workflow_definition_version END, + workflow_definition_digest = CASE WHEN @workflow_definition_yaml::text = '' THEN workflow_definition_digest ELSE @workflow_definition_digest END, + workflow_definition_yaml = CASE WHEN @workflow_definition_yaml::text = '' THEN workflow_definition_yaml ELSE @workflow_definition_yaml::text END, + outputs = @outputs, review_gate = @review_gate, rereview_rounds = @rereview_rounds, + retry_mode = @retry_mode, updated_at = now() +WHERE id = @id; -- name: RereviewRounds :one -- Read under the lock LockTaskStatus takes in the same transaction, so the diff --git a/internal/infrastructure/staterpc/task_grants.go b/internal/infrastructure/staterpc/task_grants.go index 36906e682..9a19464b3 100644 --- a/internal/infrastructure/staterpc/task_grants.go +++ b/internal/infrastructure/staterpc/task_grants.go @@ -183,10 +183,25 @@ func (g *TaskGrants) UnaryInterceptor(adminToken string) grpc.UnaryServerInterce // A container's metadata is its own claim: drop it so no later // interceptor attributes the call to a service or principal. ctx = metadata.NewIncomingContext(ctx, metadata.MD{}) + dropDefinitionPin(req) return handler(access.WithActor(ctx, fmt.Sprintf("task/%d", taskID)), req) } } +// dropDefinitionPin removes the workflow definition from a task-scoped +// Update, so the store keeps the stored pin. The pin is what the run's +// package authority is read from; only the daemon pins, from the active +// definitions. +func dropDefinitionPin(req any) { + r, ok := req.(*pb.UpdateRequest) + if !ok || r.Task == nil { + return + } + r.Task.WorkflowDefinitionVersion = 0 + r.Task.WorkflowDefinitionDigest = "" + r.Task.WorkflowDefinitionYaml = "" +} + // StreamInterceptor admits only administrators to store read streams. func (g *TaskGrants) StreamInterceptor(adminToken string) grpc.StreamServerInterceptor { return func(srv any, stream grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error { diff --git a/internal/infrastructure/staterpc/task_pin_test.go b/internal/infrastructure/staterpc/task_pin_test.go new file mode 100644 index 000000000..23102cf01 --- /dev/null +++ b/internal/infrastructure/staterpc/task_pin_test.go @@ -0,0 +1,57 @@ +package staterpc + +import ( + "context" + "crypto/sha256" + "strings" + "testing" + + "google.golang.org/grpc" + "google.golang.org/grpc/metadata" + + pb "github.com/samcharles93/archie-core/internal/contracts/state/v1" +) + +// TestTaskCredentialCannotReplaceItsPin pins that an Update made with a +// task's own credential reaches the store without a workflow definition, so +// the stored pin (where the run's package authority is read from) stays. The +// workflow name still moves for a handoff; the daemon's credential re-pins. +func TestTaskCredentialCannotReplaceItsPin(t *testing.T) { + taskToken := strings.Repeat("ab", 32) + grants := &TaskGrants{Store: credentials{sha256.Sum256([]byte(taskToken)): 7}} + intercept := grants.UnaryInterceptor("admin") + tests := []struct { + name, token, wantYAML string + }{ + {"task credential", taskToken, ""}, + {"daemon credential", "admin", "yaml-b"}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctx := metadata.NewIncomingContext(context.Background(), metadata.Pairs(tokenMetadataKey, tt.token)) + req := &pb.UpdateRequest{Task: &pb.Task{ + Id: 7, Workflow: "handoff-target", + WorkflowDefinitionVersion: 4, WorkflowDefinitionDigest: "digest-b", WorkflowDefinitionYaml: "yaml-b", + }} + var got *pb.Task + _, err := intercept(ctx, req, &grpc.UnaryServerInfo{FullMethod: pb.StateStoreService_Update_FullMethodName}, + func(_ context.Context, r any) (any, error) { + update, ok := r.(*pb.UpdateRequest) + if !ok { + t.Fatalf("handler got %T", r) + } + got = update.Task + return &pb.UpdateResponse{}, nil + }) + if err != nil { + t.Fatal(err) + } + if got.WorkflowDefinitionYaml != tt.wantYAML || (tt.wantYAML == "" && got.WorkflowDefinitionDigest != "") { + t.Fatalf("definition reaching the store = %q/%q, want %q", got.WorkflowDefinitionYaml, got.WorkflowDefinitionDigest, tt.wantYAML) + } + if got.Workflow != "handoff-target" { + t.Fatalf("workflow = %q, want handoff-target", got.Workflow) + } + }) + } +}