Skip to content

Agent Mesh

security: resolve PR comments on nil token dereference, claims type conversions, and policy parsing loop optimization

Antonio Ojeab033fb7c3aeb
diff --git a/cmd/sam-hub/biscuit.go b/cmd/sam-hub/biscuit.go
index 49463bfc..34334be4 100644
--- a/cmd/sam-hub/biscuit.go
+++ b/cmd/sam-hub/biscuit.go
@@ -29,24 +29,12 @@ import (
)
func (h *Hub) mintBiscuitToken(claims jwt.MapClaims, token *oidc.IDToken, remotePeer peer.ID) ([]byte, error) {
- var oidcRoles []string
- if rolesAny, ok := claims["roles"].([]any); ok {
- for _, r := range rolesAny {
- if str, ok := r.(string); ok && str != "" {
- oidcRoles = append(oidcRoles, str)
- }
- }
- }
-
- var oidcGroups []string
- if groupsAny, ok := claims["groups"].([]any); ok {
- for _, g := range groupsAny {
- if str, ok := g.(string); ok && str != "" {
- oidcGroups = append(oidcGroups, str)
- }
- }
+ if token == nil {
+ return nil, fmt.Errorf("token cannot be nil")
}
+ oidcRoles := toStringSlice(claims["roles"])
+ oidcGroups := toStringSlice(claims["groups"])
oidcSub, _ := claims["sub"].(string)
// Resolve roles based on configured bindings and explicit OIDC roles
@@ -180,6 +168,16 @@ func (h *Hub) verifyBiscuit(biscuitData []byte, remotePeer peer.ID) (*biscuit.Bi
authOpts = append(authOpts, biscuit.WithWorldOptions(datalog.WithMaxDuration(h.BiscuitTimeout)))
}
+ timeCheck, err := parser.FromStringCheck(`check if time($time), expiration($exp), $time <= $exp`)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse time check: %w", err)
+ }
+
+ rule, err := parser.FromStringPolicy("allow if true")
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse allow policy: %w", err)
+ }
+
keys := h.KeyRing.GetAllValidPublicKeys()
var lastErr error
for _, pubKey := range keys {
@@ -196,18 +194,7 @@ func (h *Hub) verifyBiscuit(biscuitData []byte, remotePeer peer.ID) (*biscuit.Bi
},
})
- timeCheck, err := parser.FromStringCheck(`check if time($time), expiration($exp), $time <= $exp`)
- if err != nil {
- lastErr = err
- continue
- }
authorizer.AddCheck(timeCheck)
-
- rule, err := parser.FromStringPolicy("allow if true")
- if err != nil {
- lastErr = err
- continue
- }
authorizer.AddPolicy(rule)
if err := authorizer.Authorize(); err == nil {
@@ -237,24 +224,44 @@ func translateClaimsToFacts(builder biscuit.Builder, claims map[string]any) erro
}
}
case api.FactGroup:
- if sliceVal, ok := val.([]any); ok {
- seen := make(map[string]bool)
- for _, item := range sliceVal {
- if strItem, ok := item.(string); ok && strItem != "" {
- if seen[strItem] {
- continue
- }
- seen[strItem] = true
- if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
- Name: factName,
- IDs: []biscuit.Term{biscuit.String(strItem)},
- }}); err != nil {
- return fmt.Errorf("failed to add %s fact: %w", factName, err)
- }
- }
+ groups := toStringSlice(val)
+ seen := make(map[string]bool)
+ for _, g := range groups {
+ if seen[g] {
+ continue
+ }
+ seen[g] = true
+ if err := builder.AddAuthorityFact(biscuit.Fact{Predicate: biscuit.Predicate{
+ Name: factName,
+ IDs: []biscuit.Term{biscuit.String(g)},
+ }}); err != nil {
+ return fmt.Errorf("failed to add %s fact: %w", factName, err)
}
}
}
}
return nil
}
+
+func toStringSlice(val any) []string {
+ if val == nil {
+ return nil
+ }
+ switch v := val.(type) {
+ case string:
+ if v != "" {
+ return []string{v}
+ }
+ case []string:
+ return v
+ case []any:
+ var res []string
+ for _, item := range v {
+ if str, ok := item.(string); ok && str != "" {
+ res = append(res, str)
+ }
+ }
+ return res
+ }
+ return nil
+}
diff --git a/cmd/sam-hub/biscuit_test.go b/cmd/sam-hub/biscuit_test.go
index 10a4eb99..9c694338 100644
--- a/cmd/sam-hub/biscuit_test.go
+++ b/cmd/sam-hub/biscuit_test.go
@@ -392,3 +392,167 @@ func TestMintBiscuitToken_ClaimsTranslation(t *testing.T) {
t.Errorf("Authorization/Checks failed: %v\nWorld:\n%s", err, authorizer.PrintWorld())
}
}
+
+func TestMintBiscuitToken_NilToken(t *testing.T) {
+ dir := t.TempDir()
+ dbPath := filepath.Join(dir, "test.db")
+
+ kr, err := NewKeyRing(dbPath, 24*time.Hour, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = kr.Close() }()
+
+ hub := &Hub{KeyRing: kr}
+
+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ dummyPeer, err := peer.IDFromPrivateKey(priv)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ claims := jwt.MapClaims{"sub": "user-123"}
+ _, err = hub.mintBiscuitToken(claims, nil, dummyPeer)
+ if err == nil {
+ t.Error("Expected mintBiscuitToken to fail with nil token, got nil error")
+ }
+}
+
+func TestMintBiscuitToken_VariousClaimsTypes(t *testing.T) {
+ dir := t.TempDir()
+ dbPath := filepath.Join(dir, "test.db")
+
+ kr, err := NewKeyRing(dbPath, 24*time.Hour, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() { _ = kr.Close() }()
+
+ hub := &Hub{
+ KeyRing: kr,
+ Policy: &api.PolicyConfig{
+ Bindings: []api.Binding{
+ {
+ Group: "eng-group",
+ Role: "eng-role",
+ },
+ },
+ Roles: map[string]api.RolePolicy{
+ "admin": {},
+ "eng-role": {},
+ },
+ },
+ }
+
+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ dummyPeer, err := peer.IDFromPrivateKey(priv)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ token := &oidc.IDToken{
+ Expiry: time.Now().Add(1 * time.Hour),
+ }
+
+ tests := []struct {
+ name string
+ rolesClaim any
+ groupsClaim any
+ expectedRoles []string
+ expectedGroups []string
+ }{
+ {
+ name: "String slice (standard go code paths)",
+ rolesClaim: []string{"admin"},
+ groupsClaim: []string{"eng-group", "beta"},
+ expectedRoles: []string{"admin", "eng-role"}, // eng-role comes from eng-group mapping
+ expectedGroups: []string{"eng-group", "beta"},
+ },
+ {
+ name: "Interface slice (standard JSON unmarshalled jwt paths)",
+ rolesClaim: []any{"admin"},
+ groupsClaim: []any{"eng-group", "beta"},
+ expectedRoles: []string{"admin", "eng-role"},
+ expectedGroups: []string{"eng-group", "beta"},
+ },
+ {
+ name: "Single string claims",
+ rolesClaim: "admin",
+ groupsClaim: "eng-group",
+ expectedRoles: []string{"admin", "eng-role"},
+ expectedGroups: []string{"eng-group"},
+ },
+ {
+ name: "Missing or nil claims",
+ rolesClaim: nil,
+ groupsClaim: nil,
+ expectedRoles: nil,
+ expectedGroups: nil,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ claims := jwt.MapClaims{}
+ if tt.rolesClaim != nil {
+ claims["roles"] = tt.rolesClaim
+ }
+ if tt.groupsClaim != nil {
+ claims["groups"] = tt.groupsClaim
+ }
+
+ biscuitData, err := hub.mintBiscuitToken(claims, token, dummyPeer)
+ if err != nil {
+ t.Fatalf("mintBiscuitToken failed: %v", err)
+ }
+
+ b, err := biscuit.Unmarshal(biscuitData)
+ if err != nil {
+ t.Fatalf("Unmarshal biscuit failed: %v", err)
+ }
+
+ authorizer, err := b.Authorizer(kr.GetCurrentPublicKey())
+ if err != nil {
+ t.Fatalf("Authorizer failed: %v", err)
+ }
+
+ // Add checks to verify the output facts
+ for _, r := range tt.expectedRoles {
+ authorizer.AddCheck(biscuit.Check{Queries: []biscuit.Rule{
+ {
+ Body: []biscuit.Predicate{
+ {Name: "role", IDs: []biscuit.Term{biscuit.String(r)}},
+ },
+ },
+ }})
+ }
+
+ for _, g := range tt.expectedGroups {
+ authorizer.AddCheck(biscuit.Check{Queries: []biscuit.Rule{
+ {
+ Body: []biscuit.Predicate{
+ {Name: "group", IDs: []biscuit.Term{biscuit.String(g)}},
+ },
+ },
+ }})
+ }
+
+ authorizer.AddPolicy(biscuit.Policy{Queries: []biscuit.Rule{
+ {
+ Head: biscuit.Predicate{Name: "allow", IDs: []biscuit.Term{}},
+ Body: []biscuit.Predicate{},
+ },
+ }, Kind: biscuit.PolicyKindAllow})
+
+ if err := authorizer.Authorize(); err != nil {
+ t.Errorf("Verification failed for case: %v\nWorld:\n%s", err, authorizer.PrintWorld())
+ }
+ })
+ }
+}