Skip to content

Agent Mesh

fix(policy): resolve node e2e enrollment failures by passing resolved roles during minting

Antonio Ojeab1716b189c3f
diff --git a/internal/controlplane/server.go b/internal/controlplane/server.go
index f69025f0..c61bb12e 100644
--- a/internal/controlplane/server.go
+++ b/internal/controlplane/server.go
@@ -335,9 +335,44 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {
return
}
+ _, bindings, err := s.store.GetMeshPolicy(ctx)
+ if err != nil && err != storage.ErrNotFound {
+ logger.Errorf("Failed to load policy for role resolution: %v", err)
+ http.Error(w, "Internal server error", http.StatusInternalServerError)
+ return
+ }
+
+ resolvedRoles := resolveRoles(claims, bindings)
+ var hasCapabilityRoles bool
+ var customAccessRoles []string
+ resolvedMap := make(map[string]bool)
+ for _, r := range resolvedRoles {
+ resolvedMap[r] = true
+ if strings.HasPrefix(r, "sam:role:") {
+ hasCapabilityRoles = true
+ } else {
+ customAccessRoles = append(customAccessRoles, r)
+ }
+ }
+
+ isAuthorized := false
+ if resolvedMap[req.RequestedRole] {
+ isAuthorized = true
+ } else if req.RequestedRole == api.RoleNode && !hasCapabilityRoles {
+ isAuthorized = true
+ }
+
+ if !isAuthorized {
+ http.Error(w, fmt.Sprintf("requested role %q is not authorized for this identity", req.RequestedRole), http.StatusForbidden)
+ return
+ }
+
+ finalRoles := []string{req.RequestedRole}
+ finalRoles = append(finalRoles, customAccessRoles...)
+
// Mint token
biscuitExpiry := time.Now().Add(api.BiscuitTokenTTL)
- biscuitData, _, err := identity.MintBiscuitToken(privKey, claims, token, pID, biscuitExpiry)
+ biscuitData, _, err := identity.MintBiscuitToken(privKey, claims, token, pID, biscuitExpiry, finalRoles)
if err != nil {
logger.Errorw("Biscuit minting failed", "peer_id", req.PeerId, "error", err)
http.Error(w, "Failed to mint biscuit: "+err.Error(), http.StatusForbidden)
@@ -518,7 +553,41 @@ func (s *Server) HandleRefresh(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
}
- bBytes, _, err := identity.MintBiscuitToken(privKey, claims, nil, pID, biscuitExpiry)
+ _, bindings, err := s.store.GetMeshPolicy(ctx)
+ if err != nil && err != storage.ErrNotFound {
+ logger.Errorf("Failed to load policy for role resolution: %v", err)
+ http.Error(w, "Internal server error", http.StatusInternalServerError)
+ return
+ }
+ resolvedRoles := resolveRoles(claims, bindings)
+ var hasCapabilityRoles bool
+ var customAccessRoles []string
+ resolvedMap := make(map[string]bool)
+ for _, r := range resolvedRoles {
+ resolvedMap[r] = true
+ if strings.HasPrefix(r, "sam:role:") {
+ hasCapabilityRoles = true
+ } else {
+ customAccessRoles = append(customAccessRoles, r)
+ }
+ }
+
+ isAuthorized := false
+ if resolvedMap[nodeRecord.Role] {
+ isAuthorized = true
+ } else if nodeRecord.Role == api.RoleNode && !hasCapabilityRoles {
+ isAuthorized = true
+ }
+
+ if !isAuthorized {
+ http.Error(w, fmt.Sprintf("role %q is no longer authorized for this identity", nodeRecord.Role), http.StatusForbidden)
+ return
+ }
+
+ finalRoles := []string{nodeRecord.Role}
+ finalRoles = append(finalRoles, customAccessRoles...)
+
+ bBytes, _, err := identity.MintBiscuitToken(privKey, claims, nil, pID, biscuitExpiry, finalRoles)
if err != nil {
logger.Errorf("Failed to mint refreshed token for node %s: %v", nodeRecord.PeerID, err)
http.Error(w, "Internal server error", http.StatusInternalServerError)
@@ -1625,3 +1694,72 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte("Node revoked successfully"))
}
+
+func resolveRoles(claims jwt.MapClaims, bindings []*api.PolicyBinding) []string {
+ oidcRoles := toStringSlice(claims["roles"])
+ oidcGroups := toStringSlice(claims["groups"])
+ oidcSub, _ := claims["sub"].(string)
+ oidcEmail, _ := claims["email"].(string)
+
+ resolvedRoles := make(map[string]bool)
+ for _, b := range bindings {
+ if b == nil {
+ continue
+ }
+ for _, m := range b.Members {
+ if m == api.SystemAuthenticated {
+ resolvedRoles[b.Role] = true
+ continue
+ }
+ parts := strings.SplitN(m, ":", 2)
+ if len(parts) != 2 {
+ continue
+ }
+ prefix, value := parts[0], parts[1]
+ switch prefix {
+ case api.FactGroup:
+ for _, g := range oidcGroups {
+ if g == value {
+ resolvedRoles[b.Role] = true
+ }
+ }
+ case api.FactUser:
+ if oidcSub == value || oidcEmail == value {
+ resolvedRoles[b.Role] = true
+ }
+ }
+ }
+ }
+ for _, r := range oidcRoles {
+ resolvedRoles[r] = true
+ }
+
+ var res []string
+ for r := range resolvedRoles {
+ res = append(res, r)
+ }
+ return res
+}
+
+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/internal/identity/biscuit.go b/internal/identity/biscuit.go
index 1ce8fa8b..e5254e99 100644
--- a/internal/identity/biscuit.go
+++ b/internal/identity/biscuit.go
@@ -47,18 +47,16 @@ import (
// - Once authorized, the generated Biscuit is minted with:
// - The requested capability role (enforcing least privilege).
// - All other custom access roles mapped to the identity (so they preserve their resource permissions).
-func MintBiscuitToken(signingKey ed25519.PrivateKey, claims jwt.MapClaims, token *oidc.IDToken, remotePeer peer.ID, biscuitExpiry time.Time) ([]byte, []string, error) {
+func MintBiscuitToken(signingKey ed25519.PrivateKey, claims jwt.MapClaims, token *oidc.IDToken, remotePeer peer.ID, biscuitExpiry time.Time, roles []string) ([]byte, []string, error) {
if claims == nil {
return nil, nil, fmt.Errorf("claims cannot be nil")
}
- finalRoles := []string{}
-
- biscuitBytes, err := mintBiscuit(signingKey, remotePeer, finalRoles, biscuitExpiry, claims)
+ biscuitBytes, err := mintBiscuit(signingKey, remotePeer, roles, biscuitExpiry, claims)
if err != nil {
return nil, nil, err
}
- return biscuitBytes, finalRoles, nil
+ return biscuitBytes, roles, nil
}
func mintBiscuit(signingKey ed25519.PrivateKey, remotePeer peer.ID, roles []string, expiration time.Time, claims jwt.MapClaims) ([]byte, error) {
diff --git a/internal/identity/biscuit_test.go b/internal/identity/biscuit_test.go
index c316f731..c7917491 100644
--- a/internal/identity/biscuit_test.go
+++ b/internal/identity/biscuit_test.go
@@ -70,7 +70,7 @@ func TestVerifyBiscuit_Expiration(t *testing.T) {
"roles": []any{"admin"},
}
- biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry)
+ biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry, []string{"admin"})
if err != nil {
t.Fatalf("MintBiscuitToken failed: %v", err)
}
@@ -111,7 +111,7 @@ func TestMintBiscuitToken_ClaimsTranslation(t *testing.T) {
"groups": []any{"beta-testers", "engineering"},
}
- biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry)
+ biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry, nil)
if err != nil {
t.Fatalf("Failed to mint biscuit: %v", err)
}
@@ -201,7 +201,7 @@ func TestVerifyBiscuit_Concurrent(t *testing.T) {
"roles": []any{"admin"},
}
- biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry)
+ biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry, []string{"admin"})
if err != nil {
t.Fatalf("MintBiscuitToken failed: %v", err)
}
@@ -249,7 +249,7 @@ func TestMintBiscuitToken(t *testing.T) {
"groups": []any{"group1", "group2"},
"roles": []any{"admin", "user"},
}
- biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry)
+ biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry, []string{"admin", "user"})
if err != nil {
t.Fatal(err)
}
@@ -348,7 +348,7 @@ func TestMintBiscuitToken_VariousClaimsTypes(t *testing.T) {
claims["groups"] = tt.groupsClaim
}
- biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry)
+ biscuitData, _, err := MintBiscuitToken(priv, claims, token, dummyPeer, token.Expiry, tt.expectedRoles)
if err != nil {
t.Fatalf("MintBiscuitToken failed: %v", err)
}