427 lines
14 KiB
Go
427 lines
14 KiB
Go
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"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/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/presence"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/rpctls"
|
|
)
|
|
|
|
// TaskGrants verifies run credentials: the one token a task's container
|
|
// presents to the State Store and, through ResolveTaskGrant, to archied's
|
|
// worktree push. Only digests are stored, in the State Store's database, so
|
|
// a credential survives a restart of either service until it is revoked or
|
|
// expires.
|
|
type TaskGrants struct {
|
|
Store storecontract.RunCredentialStore
|
|
}
|
|
|
|
// maxGrantLifetime caps any requested lifetime.
|
|
const maxGrantLifetime = 7 * 24 * time.Hour
|
|
|
|
func (g *TaskGrants) register(ctx context.Context, taskID int64, token string, lifetime time.Duration) error {
|
|
if taskID <= 0 || len(token) != 64 || lifetime <= 0 || lifetime > maxGrantLifetime {
|
|
return status.Error(codes.InvalidArgument, "invalid task grant")
|
|
}
|
|
if _, err := hex.DecodeString(token); err != nil {
|
|
return status.Error(codes.InvalidArgument, "invalid task grant")
|
|
}
|
|
return g.Store.PutRunCredential(ctx, sha256.Sum256([]byte(token)), taskID, time.Now().Add(lifetime))
|
|
}
|
|
|
|
func (g *TaskGrants) revoke(ctx context.Context, token string) error {
|
|
return g.Store.DeleteRunCredential(ctx, sha256.Sum256([]byte(token)))
|
|
}
|
|
|
|
// Sweep deletes every expired credential: the ones a crashed daemon never
|
|
// revoked.
|
|
func (g *TaskGrants) Sweep(ctx context.Context) error {
|
|
return g.Store.DeleteExpiredRunCredentials(ctx, time.Now())
|
|
}
|
|
|
|
// 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(ctx context.Context, token string) (int64, error) {
|
|
if token == "" {
|
|
return 0, nil
|
|
}
|
|
id, err := g.Store.RunCredentialTask(ctx, sha256.Sum256([]byte(token)), time.Now())
|
|
if errors.Is(err, storecontract.ErrRunCredentialUnknown) {
|
|
return 0, nil
|
|
}
|
|
return id, err
|
|
}
|
|
|
|
// authorizesTaskScopedCall reports whether a task-scoped token may make this
|
|
// call: only RPCs in taskScopedTargets that target taskID.
|
|
func authorizesTaskScopedCall(fullMethod string, req any, taskID int64) bool {
|
|
target := taskScopedTargets[fullMethod]
|
|
return target != nil && target(req) == taskID
|
|
}
|
|
|
|
// taskScopedTargets maps each RPC a task grant may call to the task ID its
|
|
// request targets.
|
|
var taskScopedTargets = map[string]func(any) int64{
|
|
pb.StatusService_PutPresence_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.PutPresenceRequest)
|
|
if !ok || r.Presence == nil || r.Presence.Service != presence.Agent {
|
|
return 0
|
|
}
|
|
id, err := strconv.ParseInt(r.Presence.InstanceId, 10, 64)
|
|
if err != nil || id <= 0 || strconv.FormatInt(id, 10) != r.Presence.InstanceId {
|
|
return 0
|
|
}
|
|
return id
|
|
},
|
|
pb.TaskService_Update_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.UpdateRequest)
|
|
if !ok || r.Task == nil {
|
|
return 0
|
|
}
|
|
return r.Task.Id
|
|
},
|
|
pb.TaskService_Transition_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.TransitionRequest)
|
|
if !ok {
|
|
return 0
|
|
}
|
|
return r.TaskId
|
|
},
|
|
pb.TaskEventService_InsertEvent_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.InsertEventRequest)
|
|
if !ok || r.Event == nil {
|
|
return 0
|
|
}
|
|
return r.Event.TaskId
|
|
},
|
|
pb.ExecutionService_StartStep_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.StartStepRequest)
|
|
if !ok {
|
|
return 0
|
|
}
|
|
return r.ExecutionId
|
|
},
|
|
pb.ExecutionService_RecordUsage_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.RecordUsageRequest)
|
|
if !ok || r.Record == nil {
|
|
return 0
|
|
}
|
|
return r.Record.TaskId
|
|
},
|
|
pb.ExecutionService_FinishStep_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.FinishStepRequest)
|
|
if !ok {
|
|
return 0
|
|
}
|
|
return r.ExecutionId
|
|
},
|
|
pb.TaskService_EnqueueCallTask_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.EnqueueCallTaskRequest)
|
|
if !ok {
|
|
return 0
|
|
}
|
|
return r.CallerTaskId
|
|
},
|
|
pb.TaskService_WorkflowCallStatus_FullMethodName: func(req any) int64 {
|
|
r, ok := req.(*pb.WorkflowCallStatusRequest)
|
|
if !ok {
|
|
return 0
|
|
}
|
|
return r.CallerTaskId
|
|
},
|
|
}
|
|
|
|
// UnaryInterceptor separates services from task-scoped workers. A trusted
|
|
// caller (a verified service certificate, or a plaintext peer, which only a
|
|
// loopback listener admits) has full access; any other call needs a task
|
|
// grant and is confined to its task.
|
|
func (g *TaskGrants) UnaryInterceptor() grpc.UnaryServerInterceptor {
|
|
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
|
|
if rpctls.Trusted(ctx) {
|
|
return handler(ctx, req)
|
|
}
|
|
token := requestToken(ctx)
|
|
if token == "" {
|
|
return nil, status.Error(codes.Unauthenticated, "missing client certificate or task grant")
|
|
}
|
|
taskID, err := g.taskFor(ctx, token)
|
|
if err != nil {
|
|
return nil, status.Error(codes.Unavailable, "run credentials unavailable")
|
|
}
|
|
if taskID == 0 {
|
|
return nil, status.Error(codes.Unauthenticated, "invalid task grant")
|
|
}
|
|
if !authorizesTaskScopedCall(info.FullMethod, req, taskID) {
|
|
return nil, status.Error(codes.PermissionDenied, "task grant does not authorize this operation")
|
|
}
|
|
// 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 services to store read streams.
|
|
func (g *TaskGrants) StreamInterceptor() grpc.StreamServerInterceptor {
|
|
return func(srv any, stream grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
|
|
if rpctls.Trusted(stream.Context()) {
|
|
return handler(srv, stream)
|
|
}
|
|
return status.Error(codes.PermissionDenied, "task grant does not authorize streaming reads")
|
|
}
|
|
}
|
|
|
|
func (s *taskGrantServer) RegisterTaskGrant(ctx context.Context, r *pb.RegisterTaskGrantRequest) (*pb.RegisterTaskGrantResponse, error) {
|
|
if s.deps.Grants == nil {
|
|
return nil, status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
if err := s.deps.Grants.register(ctx, r.TaskId, r.Token, time.Duration(r.LifetimeSeconds)*time.Second); err != nil {
|
|
if _, ok := status.FromError(err); ok {
|
|
return nil, err
|
|
}
|
|
return nil, status.Error(codes.Unavailable, "run credentials unavailable")
|
|
}
|
|
// No run starts unaudited: a start whose audit cannot be written is
|
|
// undone.
|
|
if err := s.auditIdentityStart(ctx, r.TaskId); err != nil {
|
|
_ = s.deps.Grants.revoke(context.WithoutCancel(ctx), r.Token)
|
|
return nil, status.Errorf(codes.Unavailable, "audit identity start: %v", err)
|
|
}
|
|
return &pb.RegisterTaskGrantResponse{}, nil
|
|
}
|
|
|
|
func (s *taskGrantServer) RevokeTaskGrant(ctx context.Context, r *pb.RevokeTaskGrantRequest) (*pb.RevokeTaskGrantResponse, error) {
|
|
if s.deps.Grants == nil {
|
|
return nil, status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
if err := s.deps.Grants.revoke(ctx, r.Token); err != nil {
|
|
return nil, status.Error(codes.Unavailable, "run credentials unavailable")
|
|
}
|
|
return &pb.RevokeTaskGrantResponse{}, nil
|
|
}
|
|
|
|
// ResolveTaskGrant answers which task a run credential belongs to, for the
|
|
// services that verify one (archied's worktree push). Task grants cannot call
|
|
// it: it is not in taskScopedTargets.
|
|
func (s *taskGrantServer) ResolveTaskGrant(ctx context.Context, r *pb.ResolveTaskGrantRequest) (*pb.ResolveTaskGrantResponse, error) {
|
|
if s.deps.Grants == nil {
|
|
return nil, status.Error(codes.Unavailable, "task grants unavailable")
|
|
}
|
|
id, err := s.deps.Grants.taskFor(ctx, r.GetToken())
|
|
if err != nil {
|
|
return nil, status.Error(codes.Unavailable, "run credentials unavailable")
|
|
}
|
|
if id == 0 {
|
|
return nil, status.Error(codes.NotFound, "run credential unknown or expired")
|
|
}
|
|
t, err := s.deps.Tasks.TaskByID(ctx, id)
|
|
if err != nil {
|
|
return nil, mapError(err)
|
|
}
|
|
principal, err := s.executionPrincipal(ctx, t)
|
|
if err != nil {
|
|
return nil, status.Error(codes.Unavailable, "execution identity unavailable")
|
|
}
|
|
route := string(principal)
|
|
if principal == s.deps.RootIdentity {
|
|
route = ""
|
|
}
|
|
return &pb.ResolveTaskGrantResponse{TaskId: id, ExecutionIdentity: route, PrincipalId: string(principal)}, 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.taskGrant.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.taskGrant.RevokeTaskGrant(ctx, &pb.RevokeTaskGrantRequest{Token: token})
|
|
return unmapError(err)
|
|
}
|
|
|
|
// ResolveTaskGrant returns the task a run credential was issued for.
|
|
func (c *Client) ResolveTaskGrant(ctx context.Context, token string) (int64, error) {
|
|
r, err := c.taskGrant.ResolveTaskGrant(ctx, &pb.ResolveTaskGrantRequest{Token: token})
|
|
if status.Code(err) == codes.NotFound {
|
|
return 0, storecontract.ErrRunCredentialUnknown
|
|
}
|
|
if err != nil {
|
|
return 0, unmapError(err)
|
|
}
|
|
return r.GetTaskId(), nil
|
|
}
|
|
|
|
// grantMargin outlives the task's own time limit, so a credential never
|
|
// expires under a run that is still inside its budget.
|
|
const grantMargin = time.Hour
|
|
|
|
// GrantIssuer implements daemon.StateStoreGrantIssuer over a *Client: one run
|
|
// credential per task, registered before the container starts and revoked
|
|
// when the daemon releases it. A crashed daemon's credential lapses at the
|
|
// task's time limit plus grantMargin.
|
|
type GrantIssuer struct {
|
|
Client *Client
|
|
}
|
|
|
|
func (g *GrantIssuer) Issue(parent context.Context, task *task.Task, limit time.Duration) (string, func(), error) {
|
|
ctx, cancel := context.WithTimeout(parent, 10*time.Second)
|
|
defer cancel()
|
|
lifetime := min(limit+grantMargin, maxGrantLifetime)
|
|
if limit <= 0 {
|
|
lifetime = maxGrantLifetime
|
|
}
|
|
token, err := g.Client.RegisterTaskGrant(ctx, task.ID, lifetime)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
return token, func() {
|
|
revokeCtx, revokeCancel := context.WithTimeout(context.WithoutCancel(parent), 10*time.Second)
|
|
defer revokeCancel()
|
|
_ = g.Client.RevokeTaskGrant(revokeCtx, token)
|
|
}, nil
|
|
}
|
|
|
|
// TaskForCredential returns the task a run credential was issued for.
|
|
func (c *Client) TaskForCredential(ctx context.Context, token string) (*task.Task, error) {
|
|
r, err := c.taskGrant.ResolveTaskGrant(ctx, &pb.ResolveTaskGrantRequest{Token: token})
|
|
if err != nil {
|
|
return nil, unmapError(err)
|
|
}
|
|
t, err := c.TaskByID(ctx, r.TaskId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
t.Identity = r.ExecutionIdentity
|
|
return t, nil
|
|
}
|
|
|
|
func executionReference(t *task.Task) (string, error) {
|
|
iface, err := task.ParseWorkflowInterface(t.WorkflowDefinitionYAML)
|
|
if err != nil {
|
|
return "", fmt.Errorf("execution identity: %w", err)
|
|
}
|
|
if iface.Identity == "" {
|
|
return "", fmt.Errorf("pinned workflow declares no execution identity")
|
|
}
|
|
return iface.Identity, nil
|
|
}
|
|
|
|
// auditIdentityStart records the run starting as its identity. Every field is
|
|
// the server's: the caller from the authenticated call, the identity from the
|
|
// task row, the org from the identity.
|
|
func (s *server) auditIdentityStart(ctx context.Context, taskID int64) error {
|
|
t, err := s.deps.Tasks.TaskByID(ctx, taskID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
principal, err := s.executionPrincipal(ctx, t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data := map[string]any{"requested_by": t.Identity}
|
|
if s.deps.Principals != nil {
|
|
p, err := s.deps.Principals.PrincipalFor(ctx, principal)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data["org"] = string(p.Org)
|
|
}
|
|
_, err = s.deps.Tasks.InsertEvent(ctx, events.Event{
|
|
At: time.Now(), Kind: events.KindIdentityStarted, TaskID: t.ID, Workflow: t.Workflow, Attempt: t.Attempt,
|
|
ActorID: access.ActorFromContext(ctx), PrincipalID: string(principal), Data: data,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (s *server) executionPrincipal(ctx context.Context, t *task.Task) (identity.IdentityID, error) {
|
|
ref, err := executionReference(t)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
id := identity.IdentityID(ref)
|
|
if ref == "" {
|
|
id = s.deps.RootIdentity
|
|
}
|
|
if s.deps.Identities == nil {
|
|
return "", fmt.Errorf("identity authority unavailable")
|
|
}
|
|
value, err := s.deps.Identities.Get(ctx, id)
|
|
if errors.Is(err, identity.ErrNotFound) {
|
|
value, err = s.deps.Identities.ResolveLegacyName(ctx, ref)
|
|
}
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if !value.Kind.Agent() || value.Lifecycle != identity.LifecycleActive {
|
|
return "", fmt.Errorf("execution identity may not act")
|
|
}
|
|
return value.ID, nil
|
|
}
|
|
|
|
// TaskPrincipalForCredential resolves the task and its canonical execution principal.
|
|
func (c *Client) TaskPrincipalForCredential(ctx context.Context, token string) (*task.Task, identity.IdentityID, error) {
|
|
r, err := c.taskGrant.ResolveTaskGrant(ctx, &pb.ResolveTaskGrantRequest{Token: token})
|
|
if err != nil {
|
|
return nil, "", unmapError(err)
|
|
}
|
|
t, err := c.TaskByID(ctx, r.TaskId)
|
|
return t, identity.IdentityID(r.PrincipalId), err
|
|
}
|
|
|
|
type taskGrantServer struct {
|
|
pb.UnimplementedTaskGrantServiceServer
|
|
*server
|
|
}
|