Description

Keycloak provides a Dynamic Client Registration feature that allows users with specific tokens to register their own applications. A flaw in how Keycloak validates these registration requests allows an attacker to create a malicious application that forges identity information. By mapping their own user profile details to protected fields like the user ID (sub) or intended audience (aud), an attacker can generate signed security tokens that make them appear to be a different user. This could allow an attacker to impersonate other users or gain unauthorized access to services that rely on these tokens for identity verification.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.1",
  "pubDate": "2026-11-05T18:17:10.887Z",
  "pubdate": "2026-11-05T18:17:10.887Z",
  "executiveSummary": "This vulnerability involves an improper validation flaw within the Dynamic Client Registration feature of Keycloak. An attacker capable of interacting with the registration endpoint can manipulate client metadata during the registration process to inject unauthorized claims into resulting security tokens.\nThe vulnerability allows for identity impersonation, where an attacker crafts a malicious client registration request that maps their user-controlled attributes to sensitive fields such as the 'sub' (subject) or 'aud' (audience) claims. By successfully forcing the Keycloak token issuance engine to incorporate these forged claims into signed JSON Web Tokens (JWTs), an attacker can effectively masquerade as any arbitrary user or elevate their privileges within downstream services that trust Keycloak as the Identity Provider (IdP).\nThe impact is critical, as it bypasses standard authorization controls and compromises the integrity of identity verification across the ecosystem. Exploitation requires the attacker to possess the capability to perform dynamic client registration, typically necessitating specific registration access tokens or configurations that permit public registration. The consequence is unauthorized access to protected resources and the potential for full account takeover in systems relying on Keycloak-issued tokens.",
  "technicalDetails": "The root cause of this vulnerability lies in the insufficient server-side sanitization and validation of client metadata parameters submitted during the Dynamic Client Registration process. Keycloak fails to enforce strict schema adherence for user-supplied fields that dictate the structure and content of issued identity and access tokens.\nWhen a dynamic registration request is initiated, the application processes a JSON body containing configuration details for the new client. The vulnerability allows an attacker to inject specific OIDC (OpenID Connect) claims into the client metadata configuration. Specifically, the system does not adequately constrain the mapping of claims, permitting the registration of a client that is explicitly configured to override critical token attributes.\nThe attack flow proceeds as follows: First, the attacker invokes the Keycloak Dynamic Client Registration endpoint (typically /auth/realms/{realm-name}/clients-registrations/openid-connect). Second, the attacker includes a malicious payload in the request body that specifies custom token mapping configurations. By targeting the 'sub' or 'aud' fields, the attacker instructs the Keycloak authorization server to sign tokens that contain identifier values controlled by the attacker rather than those derived from the authentic user context.\nOnce the client is registered, the attacker proceeds to initiate an authorization flow using the newly created, malicious client ID. Keycloak, operating under the assumption that the registered client's configuration is trustworthy, generates a signed JWT. Because the claim-mapping logic is flawed, the resulting token contains the injected 'sub' or 'aud' values. The token remains cryptographically valid because it is signed by Keycloak’s legitimate private key, which is inaccessible to the attacker but utilized by the server during issuance.\nDownstream services receiving this forged token perceive it as a legitimate assertion of identity from the Keycloak server. Consequently, the services validate the signature and the claims, inadvertently granting the attacker the identity or permissions associated with the forged 'sub' claim. This bypasses the need for the attacker to compromise actual user credentials, as they are essentially exploiting the trust relationship between the IdP and the Service Provider (SP). The post-exploitation state results in unauthorized access, data exfiltration, or administrative actions performed under the guise of an impersonated identity."
}