May 11, 2026·6 min read·62 visits
A flaw in Unity Catalog's JWT validation allows complete authentication bypass. By supplying a malicious 'iss' claim, attackers force the server to fetch a public key from an attacker-controlled server to validate a forged token.
Unity Catalog version 0.4.0 and prior contains a critical authentication bypass vulnerability in the token exchange endpoint. The server dynamically fetches JSON Web Key Sets (JWKS) based on unverified 'iss' (issuer) claims within incoming JSON Web Tokens (JWTs), allowing unauthenticated attackers to forge tokens and impersonate arbitrary users.
Unity Catalog implements an OAuth 2.0 Token Exchange protocol (RFC 8693) to exchange external OIDC identity tokens for internal access tokens. This functionality is exposed via the /api/1.0/unity-control/auth/tokens endpoint. The server accepts a subject_token in the form of a JSON Web Token (JWT) and validates it before issuing internal credentials.
The vulnerability, identified as CVE-2026-27478, stems from a failure to validate the origin of the incoming token prior to performing cryptographic operations. The system exhibits weaknesses categorized under CWE-290 (Authentication Bypass by Spoofing) and CWE-346 (Origin Validation Error). The core issue is the implicit trust placed in the token's unverified payload.
An unauthenticated remote attacker can exploit this flaw to bypass authentication controls entirely. By forging a JWT with a specific payload, the attacker can spoof the identity of any registered user. This grants the attacker unauthorized access to the Unity Catalog environment under the context of the impersonated identity.
The exploit relies on manipulating the dynamic discovery mechanism used by the OpenID Connect (OIDC) protocol. The server trusts the attacker-controlled input to dictate the location of the cryptographic keys used for verification, creating a circular trust dependency that compromises the entire authentication flow.
The root cause of CVE-2026-27478 is a fundamentally insecure implementation of the OIDC discovery process. When the server receives an incoming subject_token, it parses the unverified token payload to extract the iss (issuer) claim. This extraction occurs before any cryptographic signature validation takes place.
Once the iss claim is extracted, the server uses it to dynamically construct an OIDC discovery URL. It appends /.well-known/openid-configuration to the issuer value and makes an outbound HTTP request. The server parses the resulting JSON document to locate the jwks_uri field, which specifies the location of the JSON Web Key Set (JWKS).
The server subsequently fetches the JWKS from the specified URI to retrieve the public keys. Finally, it uses these public keys to verify the signature of the incoming JWT. The vulnerability exists because the server fails to cross-reference the extracted iss claim against a definitive whitelist of trusted identity providers.
This implementation creates a critical logic flaw. Because the server trusts the unverified claim to locate the verification keys, an attacker can supply an issuer URL pointing to their own infrastructure. The server will fetch the attacker's public keys and use them to successfully verify a token signed with the attacker's corresponding private key.
In the vulnerable implementation, the token exchange endpoint blindly accepted the parsed issuer string to drive the network retrieval of cryptographic material. The code lacked any boundary checks to verify that the issuer belonged to a recognized entity such as Okta, Azure AD, or Google Workspace.
The fix was implemented in commit 89b91863e4ec0ead5865a602a4203ed254c151da and introduces strict validation logic. The patch requires administrators to define a server.allowed-issuers configuration property. The server now loads this comma-separated list into memory during initialization and uses it as a mandatory validation gate.
// Conceptual representation of the patched validation logic
String issuer = extractIssuerFromUnverifiedToken(token);
if (!allowedIssuers.contains(issuer)) {
throw new AuthenticationException("Untrusted issuer: " + issuer);
}
// Discovery request only proceeds if the issuer is whitelisted
JWKSet jwkSet = fetchJwksFromIssuer(issuer);Additionally, the patch addresses cross-application token replay by introducing audience validation. The server now requires a server.audiences configuration property. During token validation, the code verifies that the aud (audience) claim within the JWT matches the configured client identifier for the Unity Catalog instance.
Exploitation of CVE-2026-27478 requires no specialized tools beyond a standard HTTP client and a publicly accessible web server. The attacker first establishes a lightweight rogue OIDC provider. This infrastructure must serve a valid OIDC discovery document at /.well-known/openid-configuration and host a JWKS file containing an RSA public key generated by the attacker.
With the rogue infrastructure in place, the attacker crafts a malicious JWT. The payload is configured to target a specific identity within the Unity Catalog system, typically an administrator, by setting the sub or email claim. Crucially, the attacker sets the iss claim to the URL of their rogue web server.
The attacker signs the forged JWT using the private RSA key corresponding to the public key hosted on their rogue server. They then submit this token to the Unity Catalog /api/1.0/unity-control/auth/tokens endpoint via an HTTP POST request.
Successful exploitation of this vulnerability yields complete authentication bypass. The attacker receives a valid internal access token corresponding to the impersonated identity. This token grants the attacker all permissions and privileges associated with that user within the Unity Catalog environment.
If the impersonated account holds administrative privileges, the attacker gains full control over the metadata catalog. They can read sensitive schema definitions, alter data access policies, and modify or delete registered data assets. The attacker can perform these actions without triggering standard authentication failure alerts.
The CVSS v3.1 vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N, resulting in a Base Score of 9.1 (Critical). The score reflects the network-based attack vector, the low complexity of the exploit, and the total lack of required privileges or user interaction.
Exploit Prediction Scoring System (EPSS) data indicates a score of 0.00023, placing it in the 6.59th percentile. This low score reflects a lack of observed exploitation in the wild at the time of assessment. However, the trivial nature of the exploit methodology dictates that organizations prioritize remediation immediately.
The primary remediation for CVE-2026-27478 is upgrading the Unity Catalog server to version 0.4.1 or later. The patch completely resolves the circular trust dependency by enforcing explicit issuer whitelisting. Administrators must download the updated release and deploy it according to standard operational procedures.
Following the upgrade, administrators must update the etc/conf/server.properties file to define the required security parameters. The server.allowed-issuers property must contain a comma-separated list of legitimate OIDC provider URLs. The server.audiences property must specify the expected client identifier to prevent token replay attacks.
For environments where immediate patching is impossible, security teams must implement strict network egress filtering. Firewalls should block the Unity Catalog server from initiating outbound HTTP connections to unauthorized external domains. This prevents the server from retrieving the attacker's rogue JWKS file.
Additionally, security operations centers should monitor application logs and network traffic. Analysts should create alerts for outbound requests originating from the Unity Catalog server that target /.well-known/openid-configuration on unrecognized domains. Reviewing the /api/1.0/unity-control/auth/tokens endpoint logs for anomalous iss claims provides retrospective detection of exploitation attempts.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
unitycatalog unitycatalog | <= 0.4.0 | 0.4.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-290, CWE-346, CWE-1390 |
| Attack Vector | Network |
| CVSS v3.1 | 9.1 (Critical) |
| EPSS Score | 0.00023 (6.59%) |
| Impact | Complete Authentication Bypass / User Impersonation |
| Exploit Status | Proof of Concept Available |
| KEV Status | Not Listed |
Authentication Bypass by Spoofing and Origin Validation Error
CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.
CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.
CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.
CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.
CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.
CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.