Completes the objective deletion gate for the UI Service (archie-core-8cda.5.6): go list -deps ./cmd/archie-ui now links zero banned packages -- no modernc.org/sqlite, no internal/store, gateway, channels, memory, secret, agentexec, tools, skill, yaegiutil, curator, or the workflow engine. The closure shrinks from 68 to 26 archie-core packages. Each cut is a producer-side move; no consumer-side defensive shims. - Store contracts (TaskStore family, value types, sentinels) moved from internal/store to internal/domain/storecontract -- the approved contract location per state-store-contract rev. 2d, and NOT internal/contracts: that tree is buf generate output and tools/proto.sh check deletes hand-written files there. internal/store keeps aliases; sentinel message strings are byte-identical and remain the wire contract. - Chat contracts (ChatContract, sessions, turns, streaming, commands) moved from internal/gateway to internal/domain/messaging; gateway keeps aliases. ToolCallEvent rendering helpers become gateway functions (methods cannot live on alias types). - Task vocabulary (Task, statuses, mid-run Store, Definition) split into internal/domain/workflow/task; the pipeline engine stays in package workflow with aliases, so daemon-side callers are unchanged. - overlay.DeniedKeys moved to internal/infrastructure/configuration: webui referenced the constant and that dragged the overlay SQLite store in. - webui.Server's concrete runtime handles become webui-owned view interfaces with daemon-side bootstrap adapters: channel lifecycle (internal/channels/status), MemoryStatus, CuratorStatus, and a SkillCatalog seam replacing the direct skill.DefaultRoots/CatalogRoots calls. Each degrades to an empty page when unwired. - config.SecretRef moved into internal/config (config vocabulary); internal/secret keeps an alias and Registry.Resolve absorbs the zero-value short-circuit. Docs: state-store-contract rev. 2d relocation record; ui-service-boundary deletion gate marked satisfied; ARCHITECTURE.md package map rows.
218 lines
7.4 KiB
Go
218 lines
7.4 KiB
Go
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"crypto/subtle"
|
|
"encoding/hex"
|
|
"sync"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/metadata"
|
|
"google.golang.org/grpc/status"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
)
|
|
|
|
// TaskGrants lives in the State Store process. Restart invalidates all worker
|
|
// grants; administrative credentials are never sent to workers.
|
|
type TaskGrants struct {
|
|
mu sync.Mutex
|
|
active map[int64]taskGrant
|
|
}
|
|
|
|
type taskGrant struct {
|
|
digest [32]byte
|
|
expires time.Time
|
|
}
|
|
|
|
func (g *TaskGrants) register(taskID int64, token string, lifetime time.Duration) error {
|
|
if taskID <= 0 || len(token) != 64 || lifetime <= 0 || lifetime > 7*24*time.Hour {
|
|
return status.Error(codes.InvalidArgument, "invalid task grant")
|
|
}
|
|
if _, err := hex.DecodeString(token); err != nil {
|
|
return status.Error(codes.InvalidArgument, "invalid task grant")
|
|
}
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
if g.active == nil {
|
|
g.active = make(map[int64]taskGrant)
|
|
}
|
|
now := time.Now()
|
|
for id, grant := range g.active {
|
|
if !now.Before(grant.expires) {
|
|
delete(g.active, id)
|
|
}
|
|
}
|
|
g.active[taskID] = taskGrant{digest: sha256.Sum256([]byte(token)), expires: now.Add(lifetime)}
|
|
return nil
|
|
}
|
|
|
|
func (g *TaskGrants) revoke(token string) {
|
|
digest := sha256.Sum256([]byte(token))
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
for id, grant := range g.active {
|
|
if grant.digest == digest {
|
|
delete(g.active, id)
|
|
}
|
|
}
|
|
}
|
|
|
|
// requestToken extracts the bearer token from ctx's metadata, if any.
|
|
func requestToken(ctx context.Context) string {
|
|
md, _ := metadata.FromIncomingContext(ctx)
|
|
if tokens := md.Get(tokenMetadataKey); len(tokens) > 0 {
|
|
return tokens[0]
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// taskFor resolves token to the task ID it was issued for, or 0 if the token
|
|
// is unknown, expired, or empty.
|
|
func (g *TaskGrants) taskFor(token string) int64 {
|
|
if token == "" {
|
|
return 0
|
|
}
|
|
digest := sha256.Sum256([]byte(token))
|
|
g.mu.Lock()
|
|
defer g.mu.Unlock()
|
|
now := time.Now()
|
|
for id, grant := range g.active {
|
|
if grant.digest == digest && now.Before(grant.expires) {
|
|
return id
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// authorizesTaskScopedCall reports whether req -- a call to one of the three
|
|
// task.Store RPCs a task grant may ever authorize -- targets taskID.
|
|
// Every other RPC (including RegisterTaskGrant/RevokeTaskGrant themselves)
|
|
// falls through to false: a task grant can only ever narrow, never expand.
|
|
func authorizesTaskScopedCall(fullMethod string, req any, taskID int64) bool {
|
|
switch fullMethod {
|
|
case pb.StateStoreService_Update_FullMethodName:
|
|
r, ok := req.(*pb.UpdateRequest)
|
|
return ok && r.Task != nil && r.Task.Id == taskID
|
|
case pb.StateStoreService_Transition_FullMethodName:
|
|
r, ok := req.(*pb.TransitionRequest)
|
|
return ok && r.TaskId == taskID
|
|
case pb.StateStoreService_InsertEvent_FullMethodName:
|
|
r, ok := req.(*pb.InsertEventRequest)
|
|
return ok && r.Event != nil && r.Event.TaskId == taskID
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// UnaryInterceptor separates administrator access from task-scoped worker
|
|
// access. A tokenless listener is permitted only on loopback by composition.
|
|
// Supplied worker tokens are still validated on loopback.
|
|
func (g *TaskGrants) UnaryInterceptor(adminToken string) grpc.UnaryServerInterceptor {
|
|
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
|
|
token := requestToken(ctx)
|
|
if (adminToken == "" && token == "") || (adminToken != "" && subtle.ConstantTimeCompare([]byte(token), []byte(adminToken)) == 1) {
|
|
return handler(ctx, req)
|
|
}
|
|
if token == "" {
|
|
return nil, status.Error(codes.Unauthenticated, "missing state store token")
|
|
}
|
|
taskID := g.taskFor(token)
|
|
if taskID == 0 {
|
|
return nil, status.Error(codes.Unauthenticated, "invalid state store token")
|
|
}
|
|
if !authorizesTaskScopedCall(info.FullMethod, req, taskID) {
|
|
return nil, status.Error(codes.PermissionDenied, "task grant does not authorize this operation")
|
|
}
|
|
return handler(ctx, req)
|
|
}
|
|
}
|
|
|
|
// 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 {
|
|
md, _ := metadata.FromIncomingContext(stream.Context())
|
|
tokens := md.Get(tokenMetadataKey)
|
|
if adminToken == "" && len(tokens) == 0 {
|
|
return handler(srv, stream)
|
|
}
|
|
if len(tokens) > 0 && adminToken != "" && subtle.ConstantTimeCompare([]byte(tokens[0]), []byte(adminToken)) == 1 {
|
|
return handler(srv, stream)
|
|
}
|
|
return status.Error(codes.PermissionDenied, "task grant does not authorize streaming reads")
|
|
}
|
|
}
|
|
|
|
func (s *server) RegisterTaskGrant(_ context.Context, r *pb.RegisterTaskGrantRequest) (*pb.RegisterTaskGrantResponse, error) {
|
|
if s.deps.Grants == nil {
|
|
return nil, status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
if r.LifetimeSeconds <= 0 || r.LifetimeSeconds > 7*24*60*60 {
|
|
return nil, status.Error(codes.InvalidArgument, "invalid task grant lifetime")
|
|
}
|
|
if err := s.deps.Grants.register(r.TaskId, r.Token, time.Duration(r.LifetimeSeconds)*time.Second); err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.RegisterTaskGrantResponse{}, nil
|
|
}
|
|
|
|
func (s *server) RevokeTaskGrant(_ context.Context, r *pb.RevokeTaskGrantRequest) (*pb.RevokeTaskGrantResponse, error) {
|
|
if s.deps.Grants == nil {
|
|
return nil, status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
s.deps.Grants.revoke(r.Token)
|
|
return &pb.RevokeTaskGrantResponse{}, nil
|
|
}
|
|
|
|
// RegisterTaskGrant creates fresh random material at the daemon and registers
|
|
// it at the remote authority before starting the container.
|
|
func (c *Client) RegisterTaskGrant(ctx context.Context, taskID int64, lifetime time.Duration) (string, error) {
|
|
var bytes [32]byte
|
|
if _, err := rand.Read(bytes[:]); err != nil {
|
|
return "", err
|
|
}
|
|
token := hex.EncodeToString(bytes[:])
|
|
_, err := c.client.RegisterTaskGrant(ctx, &pb.RegisterTaskGrantRequest{TaskId: taskID, Token: token, LifetimeSeconds: int64(lifetime / time.Second)})
|
|
if err != nil {
|
|
return "", unmapError(err)
|
|
}
|
|
return token, nil
|
|
}
|
|
|
|
func (c *Client) RevokeTaskGrant(ctx context.Context, token string) error {
|
|
_, err := c.client.RevokeTaskGrant(ctx, &pb.RevokeTaskGrantRequest{Token: token})
|
|
return unmapError(err)
|
|
}
|
|
|
|
// defaultGrantLifetime bounds how long an unrevoked grant stays valid if the
|
|
// daemon crashes before its deferred revoke runs. It is generous relative to
|
|
// any realistic task run, not a task timeout -- the server's own register
|
|
// additionally caps any requested lifetime at 7 days.
|
|
const defaultGrantLifetime = 24 * time.Hour
|
|
|
|
// GrantIssuer implements daemon.StateStoreGrantIssuer over a *Client,
|
|
// registering a fresh per-task credential at the remote State Store before a
|
|
// container starts and revoking it when the daemon releases the container.
|
|
type GrantIssuer struct {
|
|
Client *Client
|
|
}
|
|
|
|
func (g *GrantIssuer) Issue(task *task.Task) (string, func(), error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
token, err := g.Client.RegisterTaskGrant(ctx, task.ID, defaultGrantLifetime)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
return token, func() {
|
|
revokeCtx, revokeCancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer revokeCancel()
|
|
_ = g.Client.RevokeTaskGrant(revokeCtx, token)
|
|
}, nil
|
|
}
|