Skip to content

Agent Mesh

controlplane: bans survive keypair regeneration and gate both enrollment paths

Antonio Ojeaaa84f0baeb80
diff --git a/internal/controlplane/server.go b/internal/controlplane/server.go
index 5e86afed..ead125fa 100644
--- a/internal/controlplane/server.go
+++ b/internal/controlplane/server.go
@@ -470,6 +470,29 @@ func (s *Server) HandleRegister(w http.ResponseWriter, r *http.Request) {
return
}
+ // A ban names the device key and the identity behind it; check both, or
+ // a banned node re-enrolls from a freshly generated keypair.
+ if banned, err := s.store.IsNodeBanned(ctx, req.PeerId); err != nil {
+ logger.Errorf("Failed to check node ban for %s: %v", req.PeerId, err)
+ http.Error(w, "Internal server error", http.StatusInternalServerError)
+ return
+ } else if banned {
+ logger.Warnw("Banned node attempted enrollment", "peer_id", req.PeerId)
+ http.Error(w, "Node is banned", http.StatusForbidden)
+ return
+ }
+ if key := oidcIdentityKey(claims); key != "" {
+ if banned, err := s.store.IsIdentityBanned(ctx, key); err != nil {
+ logger.Errorf("Failed to check identity ban for %s: %v", req.PeerId, err)
+ http.Error(w, "Internal server error", http.StatusInternalServerError)
+ return
+ } else if banned {
+ logger.Warnw("Banned identity attempted enrollment", "peer_id", req.PeerId, "identity", key)
+ http.Error(w, "Identity is banned", http.StatusForbidden)
+ return
+ }
+ }
+
// Mesh policy is distributed dynamically to the target nodes, no need to inject into token.
// Fetch current signing private key
@@ -1229,6 +1252,19 @@ func (s *Server) HandleEnroll(w http.ResponseWriter, r *http.Request) {
return
}
+ // Bootstrap enrollments carry no OIDC identity, but the device-key ban
+ // still applies, and before the existing-request lookup: a banned node
+ // must not replay its old approved enrollment either.
+ if banned, err := s.store.IsNodeBanned(ctx, req.PeerId); err != nil {
+ logger.Errorf("Failed to check node ban for %s: %v", req.PeerId, err)
+ http.Error(w, "Internal server error", http.StatusInternalServerError)
+ return
+ } else if banned {
+ logger.Warnw("Banned node attempted bootstrap enrollment", "peer_id", req.PeerId)
+ s.writeEnrollError(w, api.EnrollmentStatus_ENROLLMENT_STATUS_REJECTED, "Node is banned")
+ return
+ }
+
// 2. Check for existing enrollment request
existingReq, err := s.store.GetEnrollmentRequest(ctx, req.PeerId)
if err == nil {
@@ -1798,7 +1834,7 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {
}
// Retrieve the node from storage to verify it exists
- _, err = s.store.GetNode(ctx, req.PeerId)
+ node, err := s.store.GetNode(ctx, req.PeerId)
if err == storage.ErrNotFound {
http.Error(w, "Node not found", http.StatusNotFound)
return
@@ -1808,8 +1844,7 @@ func (s *Server) HandleAdminRevoke(w http.ResponseWriter, r *http.Request) {
return
}
- // Set node as banned (revoked)
- if err := s.store.SetNodeBanned(ctx, req.PeerId, true); err != nil {
+ if err := s.banNode(ctx, node); err != nil {
logger.Errorf("Failed to ban/revoke node %s: %v", req.PeerId, err)
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
@@ -2086,7 +2121,7 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {
return
}
- if err := s.store.SetNodeBanned(ctx, peerID, true); err != nil {
+ if err := s.banNode(ctx, node); err != nil {
logger.Errorf("Failed to revoke node: %v", err)
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
@@ -2100,6 +2135,40 @@ func (s *Server) HandleUserRevoke(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte("Node revoked successfully"))
}
+// oidcIdentityKey names an enrolled OIDC identity independently of any
+// keypair: issuer and subject, the pair the issuer promises stable. Empty
+// when there is no subject (e.g. bootstrap enrollments).
+func oidcIdentityKey(claims jwt.MapClaims) string {
+ if claims == nil {
+ return ""
+ }
+ sub, _ := claims["sub"].(string)
+ if sub == "" {
+ return ""
+ }
+ iss, _ := claims["iss"].(string)
+ return iss + "|" + sub
+}
+
+// banNode bans the device key and, when the record carries OIDC claims, the
+// enrolled identity behind it, so the ban survives keypair regeneration.
+func (s *Server) banNode(ctx context.Context, node *storage.EnrolledNode) error {
+ if err := s.store.SetNodeBanned(ctx, node.PeerID, true); err != nil {
+ return err
+ }
+ if node.ClaimsJSON == "" {
+ return nil
+ }
+ var claims jwt.MapClaims
+ if err := json.Unmarshal([]byte(node.ClaimsJSON), &claims); err != nil {
+ return fmt.Errorf("stored claims for %s are unreadable: %w", node.PeerID, err)
+ }
+ if key := oidcIdentityKey(claims); key != "" {
+ return s.store.SetIdentityBanned(ctx, key, true)
+ }
+ return nil
+}
+
// allowedLabelPatterns collects the label grants of every role an identity
// resolves to. A role that names none contributes none, so an identity with no
// grant anywhere may declare no labels at all.
diff --git a/internal/controlplane/server_test.go b/internal/controlplane/server_test.go
index b56293ff..9bea6ce2 100644
--- a/internal/controlplane/server_test.go
+++ b/internal/controlplane/server_test.go
@@ -2207,6 +2207,91 @@ func TestAuthDenialPaths(t *testing.T) {
})
}
+// TestBanSurvivesKeypairRegeneration pins the fix for the GHSA-cgmg-9xf6-rrgw
+// ban-bypass claim: bans were keyed only on peer_id, which the node itself
+// mints, so a banned operator regenerated a keypair and re-enrolled. Revoking
+// now also bans the OIDC identity (issuer|subject) and /register checks both.
+func TestBanSurvivesKeypairRegeneration(t *testing.T) {
+ issuer, mintToken := startCustomMockOIDC(t)
+ srv, store, baseURL := setupTestServer(t, issuer)
+ defer func() {
+ _ = srv.Close()
+ _ = store.Close()
+ }()
+ srv.config.AdminToken = "super-secret-admin-token"
+
+ ctx := context.Background()
+ client := &http.Client{Timeout: 5 * time.Second}
+
+ if err := store.SaveMeshPolicy(ctx, nil, []*api.PolicyBinding{
+ {Role: api.RoleNode, Members: []string{api.SystemAuthenticated}},
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ enrollKey := func(t *testing.T, priv crypto.PrivKey, sub string) int {
+ t.Helper()
+ pID, err := peer.IDFromPrivateKey(priv)
+ if err != nil {
+ t.Fatal(err)
+ }
+ pubBytes, err := crypto.MarshalPublicKey(priv.GetPublic())
+ if err != nil {
+ t.Fatal(err)
+ }
+ reqData, _ := proto.Marshal(&api.EnrollRequest{
+ Jwt: mintToken(map[string]interface{}{"sub": sub}),
+ PeerId: pID.String(),
+ PublicKey: pubBytes,
+ RequestedRole: api.RoleNode,
+ })
+ resp, err := client.Post(baseURL+"/register", "application/x-protobuf", bytes.NewReader(reqData))
+ if err != nil {
+ t.Fatalf("/register failed: %v", err)
+ }
+ defer func() { _ = resp.Body.Close() }()
+ return resp.StatusCode
+ }
+ newKey := func(t *testing.T) crypto.PrivKey {
+ t.Helper()
+ priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return priv
+ }
+
+ bannedKey := newKey(t)
+ if status := enrollKey(t, bannedKey, "ban-me"); status != http.StatusOK {
+ t.Fatalf("initial enrollment: got %d, want 200", status)
+ }
+
+ bannedPeer, _ := peer.IDFromPrivateKey(bannedKey)
+ revokeData, _ := proto.Marshal(&api.TokenRevokeRequest{PeerId: bannedPeer.String()})
+ req, _ := http.NewRequest("POST", baseURL+"/admin/revoke", bytes.NewReader(revokeData))
+ req.Header.Set("Authorization", "Bearer super-secret-admin-token")
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("/admin/revoke failed: %v", err)
+ }
+ _ = resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ t.Fatalf("/admin/revoke: got %d, want 200", resp.StatusCode)
+ }
+
+ if status := enrollKey(t, bannedKey, "ban-me"); status != http.StatusForbidden {
+ t.Errorf("re-enrollment with the banned keypair: got %d, want 403", status)
+ }
+ // Same identity behind a fresh keypair: the bypass this test exists for.
+ if status := enrollKey(t, newKey(t), "ban-me"); status != http.StatusForbidden {
+ t.Errorf("re-enrollment with a fresh keypair: got %d, want 403", status)
+ }
+ // An unrelated identity keeps working.
+ if status := enrollKey(t, newKey(t), "somebody-else"); status != http.StatusOK {
+ t.Errorf("unrelated identity: got %d, want 200", status)
+ }
+}
+
// TestBootstrapTokenOwnerPropagatesToNode ensures a node enrolled with a user-owned
// bootstrap token is attributed to that user, which is what makes the console's
// per-user node listing work.
diff --git a/internal/storage/sql_store.go b/internal/storage/sql_store.go
index ed12b367..86abd092 100644
--- a/internal/storage/sql_store.go
+++ b/internal/storage/sql_store.go
@@ -351,6 +351,24 @@ var migrations = []migration{
`ALTER TABLE enrollment_requests ADD COLUMN labels_json TEXT DEFAULT '' NOT NULL`,
},
},
+ {
+ // A ban must outlive the keypair that carried it: banning a node also
+ // bans the enrolled OIDC identity (issuer|subject), which a fresh
+ // peer id cannot shed.
+ version: 8,
+ postgres: []string{
+ `CREATE TABLE IF NOT EXISTS banned_identities (
+ identity VARCHAR(512) PRIMARY KEY,
+ banned_at BIGINT NOT NULL
+ )`,
+ },
+ sqlite: []string{
+ `CREATE TABLE IF NOT EXISTS banned_identities (
+ identity TEXT PRIMARY KEY,
+ banned_at BIGINT NOT NULL
+ )`,
+ },
+ },
}
func (s *SQLStore) initSchema() error {
@@ -693,6 +711,35 @@ func (s *SQLStore) IsNodeBanned(ctx context.Context, peerID string) (bool, error
return banned, nil
}
+// SetIdentityBanned implements Store.
+func (s *SQLStore) SetIdentityBanned(ctx context.Context, identity string, banned bool) error {
+ if identity == "" {
+ return fmt.Errorf("identity cannot be empty")
+ }
+ if banned {
+ query := s.rebind(`INSERT INTO banned_identities (identity, banned_at) VALUES (?, ?) ON CONFLICT (identity) DO NOTHING`)
+ _, err := s.db.ExecContext(ctx, query, identity, time.Now().Unix())
+ return err
+ }
+ query := s.rebind(`DELETE FROM banned_identities WHERE identity = ?`)
+ _, err := s.db.ExecContext(ctx, query, identity)
+ return err
+}
+
+// IsIdentityBanned implements Store.
+func (s *SQLStore) IsIdentityBanned(ctx context.Context, identity string) (bool, error) {
+ query := s.rebind(`SELECT 1 FROM banned_identities WHERE identity = ?`)
+ var one int
+ err := s.db.QueryRowContext(ctx, query, identity).Scan(&one)
+ if err == sql.ErrNoRows {
+ return false, nil
+ }
+ if err != nil {
+ return false, err
+ }
+ return true, nil
+}
+
// UpsertRouterLease implements Store.
func (s *SQLStore) UpsertRouterLease(ctx context.Context, lease *RouterLease) error {
addrsBytes, err := json.Marshal(lease.Addresses)
diff --git a/internal/storage/sql_store_test.go b/internal/storage/sql_store_test.go
index 077a82a2..baf0f9d1 100644
--- a/internal/storage/sql_store_test.go
+++ b/internal/storage/sql_store_test.go
@@ -326,6 +326,53 @@ func TestNodeEnrollmentOps(t *testing.T) {
}
}
+func TestIdentityBanOps(t *testing.T) {
+ store := newTestStore(t)
+ defer func() { _ = store.Close() }()
+
+ ctx := context.Background()
+ identity := "http://issuer.example|banned-sub"
+
+ banned, err := store.IsIdentityBanned(ctx, identity)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if banned {
+ t.Fatalf("expected identity not banned by default")
+ }
+
+ if err := store.SetIdentityBanned(ctx, identity, true); err != nil {
+ t.Fatalf("failed to ban identity: %v", err)
+ }
+ // Banning twice must not error: two revoked nodes can share one identity.
+ if err := store.SetIdentityBanned(ctx, identity, true); err != nil {
+ t.Fatalf("re-banning identity: %v", err)
+ }
+
+ banned, err = store.IsIdentityBanned(ctx, identity)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if !banned {
+ t.Fatalf("expected identity to be banned")
+ }
+
+ if err := store.SetIdentityBanned(ctx, identity, false); err != nil {
+ t.Fatalf("failed to unban identity: %v", err)
+ }
+ banned, err = store.IsIdentityBanned(ctx, identity)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if banned {
+ t.Fatalf("expected identity to be unbanned")
+ }
+
+ if err := store.SetIdentityBanned(ctx, "", true); err == nil {
+ t.Fatalf("expected an error banning the empty identity")
+ }
+}
+
func TestRouterLeaseOps(t *testing.T) {
store := newTestStore(t)
defer func() { _ = store.Close() }()
diff --git a/internal/storage/storage.go b/internal/storage/storage.go
index f1ee555d..bae522db 100644
--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@@ -169,6 +169,14 @@ type Store interface {
// IsNodeBanned checks if a node is currently banned.
IsNodeBanned(ctx context.Context, peerID string) (bool, error)
+ // SetIdentityBanned bans or unbans an enrolled OIDC identity, keyed as
+ // "issuer|subject". A node ban is keyed on a self-generated peer id, so
+ // this is what makes a ban survive keypair regeneration.
+ SetIdentityBanned(ctx context.Context, identity string, banned bool) error
+
+ // IsIdentityBanned checks if an identity is currently banned.
+ IsIdentityBanned(ctx context.Context, identity string) (bool, error)
+
// UpsertRouterLease updates or creates a lease for a sam-router.
UpsertRouterLease(ctx context.Context, lease *RouterLease) error