A vulnerability was found in keycloak 7.x, when keycloak is configured with LDAP user federation and StartTLS is used instead of SSL/TLS from the LDAP server (ldaps), in this case user authentication succeeds even if invalid password has entered.

A privilege escalation flaw was found in the token exchange feature of keycloak. Missing authorization allows a client application holding a valid access token to exchange tokens for any target client by passing the clientid of the target. This could allow a client to gain unauthorized access to additional services.

A flaw was found in keycloak in versions before 13.0.0. A Self Stored XSS attack vector escalating to a complete account takeover is possible due to user-supplied data fields not being properly encoded and Javascript code being used to process the data. The highest threat from this vulnerability is to data confidentiality and integrity as well as system availability.

A bug exists in Keycloak 7.x where the user federation LDAP bind type is "none" (LDAP anonymous bind), any password, invalid or valid will be accepted

Mitigation: If the LDAP service supports "simple" use that method instead

A flaw was found in the SAML metadata import functionality of the keycloak-services component, which is the core engine for identity brokering in Red Hat Build of Keycloak. When importing identity provider metadata that lacks specific usage attributes for keys, the system incorrectly disables signature validation for SAML responses even if a signing certificate is provided. This issue allows an unauthenticated attacker to forge a SAML response and gain unauthorized access to a user account by knowing their external identifier.

A flaw was found in the SAML HTTP-Redirect binding implementation of Keycloak. The issue occurs because the server processes percent-encoded parameter names (like %53AMLResponse) while the signature verification logic only checks literal parameter names. An attacker can use this discrepancy to provide a crafted, unsigned SAML message that the server processes instead of a legitimately signed one, leading to full account takeover of federated users.

A flaw was found in Keycloak where an authenticated attacker with delegated client management permissions (manage-clients) can achieve arbitrary code execution. When a client is created with authorization services enabled and an authorizationSettings payload is provided in the same request, Keycloak sets an internal session attribute to allow the creation of a default policy but fails to clear it. This mechanism can be abused to supply an inline JavaScript policy during client import, bypassing the security control that normally disables script uploads. When the policy is subsequently evaluated during a User-Managed Access (UMA) authorization request, the injected JavaScript executes within the Keycloak server JVM process. This allows an attacker to escape the delegated administrator's realm boundary and perform actions such as reading sensitive host data, modifying configurations for other realms, or causing a complete system shutdown.

A flaw was found in keycloack before version 8.0.0. The owner of 'placeholder.org' domain can setup mail server on this domain and knowing only name of a client can reset password and then log in. For example, for client name 'test' the email address will be 'service-account-test'

Upstream issue:

https://issues.jboss.org/browse/KEYCLOAK-10780

Upstream patch:

https://github.com/keycloak/keycloak/commit/9a7c1a91a59ab85e7f8889a505be04a71580777f

Critical: Red Hat build of Keycloak 26.6.6 Security Update

A flaw was discovered in Keycloak Core package. When a user registers itself through registration flow, the "password" and "password-confirm" field from the form will occur as regular attributes in the users attributes. The password is also created, but the user attributes must not be there. This way, any entities (all users and clients with proper rights/roles) are able to retrieve the users passwords in clear-text.

Impact Passwords for self-registered users are stored as cleartext attributes associated with the user.

Mitigation Disable self-registration for users in all realms until patched.

A flaw was found in org.keycloak.broker.saml. When a disabled Security Assertion Markup Language (SAML) client is configured as an Identity Provider (IdP)-initiated broker landing target, it can still complete the login process and establish a Single Sign-On (SSO) session. This allows a remote attacker to gain unauthorized access to other enabled clients without re-authentication, effectively bypassing security restrictions.

A vulnerability was found in keycloak. A CSRF attack can be performed in My Resources functionality in the Account Console. The attacker can trick the user to perform operations by using social engineering or any other mean that can result in a request to Keycloak from an untrusted domain.

References: https://issues.jboss.org/browse/KEYCLOAK-10775

A flaw was found in Keycloak before version 11.0.0, where the code base contains usages of ObjectInputStream without type checks. This flaw allows an attacker to inject arbitrarily serialized Java Objects, which would then get deserialized in a privileged context and potentially lead to remote code execution.

A flaw was found in the reset credential flow in all Keycloak versions before 8.0.0. This flaw allows an attacker to gain unauthorized access to the application.

It was discovered that the org.keycloak.services.resources.SocialResource.callback(String) method implementation lacked CSRF protection. A remote attacker could use this flaw to gain access to a KeyCloak managed accounts or perform other attacks.

A flaw was found in Keycloak. An attacker can exploit this vulnerability by modifying the organization ID and target email within a legitimate invitation token's JSON Web Token (JWT) payload. This lack of cryptographic signature verification allows the attacker to successfully self-register into an unauthorized organization, leading to unauthorized access.

A flaw was found in Keycloak. A remote attacker could bypass security controls by sending a valid SAML response from an external Identity Provider (IdP) to the Keycloak SAML endpoint for IdP-initiated broker logins. This allows the attacker to complete broker logins even when the SAML Identity Provider is disabled, leading to unauthorized authentication.

HCL Hive Telco Observability is affected by  a Required directives missing from the CSP issue is detected in keycloak component of the web application. Missing essential directives can leave a site vulnerable.

A flaw was found in Keycloak where the default Dynamic Client Registration (DCR) policy permits the use of User Property mappers without validating the target claim path. While the policy checks the mapper provider type, it does not restrict where the mapper can write data within the resulting token. An attacker with a standard user account and a limited Initial Access Token (IAT) can register a new client and configure User Property mappers (such as firstName or lastName) to target the resourceaccess.realm-management.roles claim path. By setting their user profile properties to administrative role names (e.g., manage-clients, realm-admin), the attacker can produce a forged access token containing these roles. Although recent mitigations (CVE-2026-4629) protect the Admin REST API from such forged tokens, the Client Registration API remains vulnerable because it reads the resourceaccess claim directly during authorization. An attacker can use this bypass to perform unauthorized DCR operations, including reading confidential client secrets, modifying redirect URIs, and impersonating service accounts to achieve full realm compromise.

A flaw was found in the Keycloak Organization identity-first login flow. The vulnerability is caused by a failure to clear the SSO re-authentication flag (SSOAUTH note) when a flow transition occurs, such as moving to the reset-credentials or registration path, even though the authenticated user is removed from the authentication session. An attacker with valid credentials in two or more organizations can exploit this by initiating an organization-scoped authorization request, triggering a flow transition, and then submitting a victim's username. The Organization authenticator incorrectly trusts the stale re-authentication flag as valid proof of identity for the new username. Successful exploitation allows a remote attacker with Low privileges to perform a full account takeover, obtaining the victim's authorization code, access tokens, and a valid SSO session usable against downstream applications.

A flaw was found in the UserManagedPermissionService of the Keycloak authorization server. The UMA Protection API, which manages user permissions, fails to validate the resourceType field when a user creates a new policy. This allows an attacker to create a policy that applies to resources owned by other users, potentially leading to unauthorized access or modification of sensitive data across the entire realm.

A flaw was found in Keycloak where the Dynamic Client Registration (DCR) policy Allowed Protocol Mapper Types fails to validate the configuration of protocol mappers, specifically the claim.name field. While the policy restricts the mapper types that can be used, it does not prevent an attacker from configuring allowed mappers (such as User Property or User Attribute mappers) to write to reserved identity claims. An attacker with a valid Initial Access Token (IAT) and a standard realm account can register a new client and configure mappers to map their own editable profile attributes to the sub and aud claims. When the attacker authenticates via this registered client, Keycloak issues access tokens, ID tokens, and UserInfo responses signed by the realm's active key where the sub claim contains an arbitrary user's UUID and the aud claim contains an arbitrary audience value. This allows the attacker to forge identity tokens that pass standard relying-party validation, leading to potential impersonation and unauthorized access to resource servers. This is a residual gap in the fix for CVE-2026-16102.

A flaw was found in Keycloak, where it would permit a user with a view-profile role to manage the resources in the new account console. This flaw allows a user with a view-profile role to access and modify data for which the user does not have adequate permission.

A flaw was found in Keycloak 4.2.1.Final, 4.3.0.Final. When TOPT enabled, an improper implementation of the Brute Force detection algorithm will not enforce its protection measures.

A flaw was found in JBOSS Keycloak. The SAML broker consumer endpoint ignores expiration conditions on SAML assertions. An attacker can exploit this vulnerability to perform a replay attack.

If an attacker modifies the SAML Response and removes the <Signature> Sections, the message is still accepted and the message can be modified, allowing the attacker to impersonate any user on the keycloak protected systems by modifying assertations.

Upstream Issue:

https://issues.jboss.org/browse/KEYCLOAK-10786

It was found that the keycloak before 2.3.0 did not implement authentication flow correctly. An attacker could use this flaw to construct a phishing URL, from which he could hijack the user's session. This could lead to information disclosure, or permit further possible attacks.

A flaw was found in Keycloak's SAML 1.1 XML parsing logic within the keycloak-saml-core component. When parsing the ds:KeyInfo element in SAML 1.1 assertions, the StAX-based parser loops over child elements but only contains logic to handle specific expected tags such as ds:EncryptedKey, ds:X509Data, and ds:KeyValue. The parser lacks a fallback branch to consume or reject other valid child elements like ds:KeyName. Consequently, the parser repeatedly peeks at the unhandled element without advancing, causing the processing thread to enter an infinite loop spinning at 100% CPU. An unauthenticated remote attacker can exploit this by sending crafted SAML requests to Keycloak's SAML endpoints (e.g., /realms/{realm}/protocol/saml). By sending multiple concurrent requests, an attacker can exhaust the worker thread pool, resulting in a permanent denial of service until the server is manually restarted.

A flaw was found in the theme resource endpoint of Keycloak, an open-source identity and access management solution. The issue occurs because the server fails to validate theme names before using them as keys for an on-disk gzip cache. An unauthenticated attacker can exploit this by sending many requests with unique, fabricated theme names, leading to persistent disk space exhaustion that survives server restarts and causes service disruptions.

A flaw was found in the authentication session handling of the keycloak-services component in Keycloak. The issue occurs because the system fails to verify if an authenticator is valid for the current authentication flow when switching between the standard authentication path and the reset credentials path. An authenticated attacker can exploit this by triggering a race condition during the credential reset process to associate their successful authentication state with another user's session. This can result in the attacker gaining full access to the victim's account and changing their password.