One gRPC service per domain in state.v1 (tasks, executions, accounts, identities, packages, captures, bindings, access, orgs, alerts and so on), each with its own server type in staterpc. RPC and message names and numbers are unchanged.
176 lines
6.1 KiB
Go
176 lines
6.1 KiB
Go
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/encoding/protowire"
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
)
|
|
|
|
type harnessCapture struct{ got harnesssecret.Secret }
|
|
|
|
func (h *harnessCapture) GetHarnessSecret(_ context.Context, org, service string) (harnesssecret.Secret, error) {
|
|
h.got = harnesssecret.Secret{Org: org, Service: service}
|
|
return h.got, nil
|
|
}
|
|
|
|
func (h *harnessCapture) PutHarnessSecret(_ context.Context, value harnesssecret.Secret) error {
|
|
h.got = value
|
|
return nil
|
|
}
|
|
|
|
func TestHarnessSecretsUseCallerOrg(t *testing.T) {
|
|
for _, caller := range []org.OrgID{"acme", org.DefaultOrgID, ""} {
|
|
t.Run(string(caller), func(t *testing.T) {
|
|
capture := &harnessCapture{}
|
|
s := &harnessSecretServer{server: &server{deps: Deps{HarnessSecrets: capture}}}
|
|
ctx := org.WithOrg(context.Background(), caller)
|
|
// A stale or malicious client still sending field 1 cannot choose the org.
|
|
wire := protowire.AppendString(protowire.AppendTag(nil, 1, protowire.BytesType), "victim")
|
|
req := &pb.GetHarnessSecretRequest{}
|
|
if err := proto.Unmarshal(wire, req); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
req.Service = "provider"
|
|
if _, err := s.GetHarnessSecret(ctx, req); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if capture.got.Org != string(org.OrgFromContext(ctx)) {
|
|
t.Fatalf("read org = %q, want caller org %q", capture.got.Org, org.OrgFromContext(ctx))
|
|
}
|
|
secret := &pb.HarnessSecret{}
|
|
if err := proto.Unmarshal(wire, secret); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
secret.Service = "provider"
|
|
if _, err := s.PutHarnessSecret(ctx, &pb.PutHarnessSecretRequest{Secret: secret}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if capture.got.Org != string(org.OrgFromContext(ctx)) {
|
|
t.Fatalf("write org = %q, want caller org %q", capture.got.Org, org.OrgFromContext(ctx))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type harnessTasks struct {
|
|
storecontract.TaskStore
|
|
err error
|
|
}
|
|
|
|
func (h harnessTasks) TaskByID(context.Context, int64) (*task.Task, error) {
|
|
return &task.Task{ID: 7, Org: "acme"}, h.err
|
|
}
|
|
|
|
func TestHarnessSecretsUseTaskGrant(t *testing.T) {
|
|
for _, tt := range []struct {
|
|
name, token string
|
|
scope org.OrgID
|
|
taskErr error
|
|
want codes.Code
|
|
}{
|
|
{name: "live grant", token: strings.Repeat("ab", 32)},
|
|
{name: "unknown grant", token: strings.Repeat("cd", 32), want: codes.Unauthenticated},
|
|
{name: "another org", token: strings.Repeat("ab", 32), scope: "other", want: codes.PermissionDenied},
|
|
{name: "system principal cannot cross org", token: strings.Repeat("ab", 32), scope: org.DefaultOrgID, want: codes.PermissionDenied},
|
|
{name: "task lookup failure", token: strings.Repeat("ab", 32), taskErr: errors.New("store unavailable"), want: codes.Internal},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
grants := &TaskGrants{Store: credentials{}}
|
|
if err := grants.register(t.Context(), 7, strings.Repeat("ab", 32), time.Hour); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
capture := &harnessCapture{}
|
|
s := &harnessSecretServer{server: &server{deps: Deps{Grants: grants, Tasks: harnessTasks{err: tt.taskErr}, HarnessSecrets: capture}}}
|
|
ctx := org.WithScope(t.Context(), tt.scope)
|
|
for _, write := range []bool{false, true} {
|
|
capture.got = harnesssecret.Secret{}
|
|
var err error
|
|
if write {
|
|
_, err = s.PutHarnessSecret(ctx, &pb.PutHarnessSecretRequest{RunCredential: tt.token, Secret: &pb.HarnessSecret{Service: "provider"}})
|
|
} else {
|
|
_, err = s.GetHarnessSecret(ctx, &pb.GetHarnessSecretRequest{RunCredential: tt.token, Service: "provider"})
|
|
}
|
|
if status.Code(err) != tt.want {
|
|
t.Fatalf("write %v: error %v, want %v", write, err, tt.want)
|
|
}
|
|
if tt.want == codes.OK && capture.got.Org != "acme" {
|
|
t.Fatalf("write %v: org %q, want acme", write, capture.got.Org)
|
|
}
|
|
if tt.want != codes.OK && capture.got.Org != "" {
|
|
t.Fatalf("unauthorized access reached store: %+v", capture.got)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type harnessRPC struct {
|
|
pb.HarnessSecretServiceClient
|
|
server *harnessSecretServer
|
|
}
|
|
|
|
func (h harnessRPC) GetHarnessSecret(ctx context.Context, r *pb.GetHarnessSecretRequest, _ ...grpc.CallOption) (*pb.GetHarnessSecretResponse, error) {
|
|
return h.server.GetHarnessSecret(ctx, r)
|
|
}
|
|
|
|
func (h harnessRPC) PutHarnessSecret(ctx context.Context, r *pb.PutHarnessSecretRequest, _ ...grpc.CallOption) (*pb.PutHarnessSecretResponse, error) {
|
|
return h.server.PutHarnessSecret(ctx, r)
|
|
}
|
|
|
|
func TestHarnessSecretClientGrant(t *testing.T) {
|
|
grants := &TaskGrants{Store: credentials{}}
|
|
token := strings.Repeat("ab", 32)
|
|
if err := grants.register(t.Context(), 7, token, time.Hour); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
capture := &harnessCapture{}
|
|
c := &Client{harnessSecret: harnessRPC{server: &harnessSecretServer{server: &server{deps: Deps{Grants: grants, Tasks: harnessTasks{}, HarnessSecrets: capture}}}}}
|
|
ctx := harnesssecret.WithRunCredential(t.Context(), token)
|
|
for _, tt := range []struct {
|
|
name, org string
|
|
revoke bool
|
|
want codes.Code
|
|
}{
|
|
{name: "task org", org: "acme"},
|
|
{name: "another org", org: "victim", want: codes.PermissionDenied},
|
|
{name: "revoked grant", org: "acme", revoke: true, want: codes.Unauthenticated},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.revoke {
|
|
if err := grants.revoke(ctx, token); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
secret, err := c.GetHarnessSecret(ctx, tt.org, "provider")
|
|
if status.Code(err) != tt.want {
|
|
t.Fatalf("error %v, want %v", err, tt.want)
|
|
}
|
|
if tt.want == codes.OK {
|
|
if secret.Org != "acme" {
|
|
t.Fatalf("secret org %q, want acme", secret.Org)
|
|
}
|
|
if err := c.PutHarnessSecret(ctx, secret); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if capture.got.Org != "acme" {
|
|
t.Fatalf("stored org %q, want acme", capture.got.Org)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|