Two LLM gateway flaws where an ordinary account crossed the tenant line
A Red Hat AI gateway flaw let a model name pick another tenant's keys; a LiteLLM flaw let a stored secret become an admin login. The shared lesson.
An LLM gateway is where a company keeps the keys that pay for its AI usage, so its authorisation logic carries a lot of weight. Two recent advisories show the same mistake in different forms: the gateway trusted a value the caller could control to decide whose credentials or whose privileges applied. In both, the attacker needed only an ordinary account.
The first is CVE-2026-117574 in the ai-gateway-payload-processing component of Red Hat OpenShift AI, published at the end of October and still listed as affected with no fixed release when we checked on 9 November 2026. The second is LiteLLM's GHSA-7hp6-4w63-5g45, tracked as CVE-2026-114612, fixed at the end of September but the subject of new lab research published on 6 November that changes what operators should check.
The Red Hat flaw: the model name picks the keys
Red Hat describes a multi-tenant gateway in which an authenticated caller can name another tenant's model identifier in the request body or a header. The service then fetches credentials from a shared store without checking that the caller is entitled to them, and injects the other tenant's API keys into the request. The result is unauthorised requests that consume another tenant's model resources and quotas.
Red Hat's scoring note explains why the issue was re-rated on 27 October. The original path-based lookup had been removed, but credential selection now comes purely from the client-supplied model field in the body or the x-gateway-model-name header, through a flat cluster-wide map of model names, still with no identity check in the process. Meanwhile the access policy layer derives the model from the URL path. So a caller authorised for their own tenant's path can put a different tenant's model name in the body and, in Red Hat's words, "get that tenant credentials injected, deterministically".
Two details are worth reading carefully:
- Severity. Red Hat gives a CVSS 3.1 base score of 9.1 (network, low complexity, low privileges, scope changed, high confidentiality impact), which falls in the critical band, but its own impact rating is Important. The score is marked preliminary and subject to review. Both are on the same page; quote them together.
- Scope. The record lists the
odh-ai-gateway-payload-processing-rhel9package in Red Hat OpenShift AI as affected and an end-to-end test package as not affected. It lists no fixed release and no mitigation. The description does not say the keys are returned to the attacker; the impact is that they are used on the attacker's behalf.
The LiteLLM flaw: one key, two jobs
LiteLLM's advisory, rated critical with a CVSS score of 9.9, describes a different shape. The proxy used one encryption key both to seal secrets stored in its database and to mint session tokens. An internal user could create an API key with a crafted metadata field whose "secret" was a forged admin session, have the proxy encrypt it, read the ciphertext back, and present it as a bearer token. The proxy decrypted it, trusted the forged identity and granted proxy admin, including the ability to run commands on the host through the MCP stdio endpoint.
The advisory lists fixes in 1.100.4, 1.101.3, 1.102.2, 1.103.1 and 1.104.0rc2. FORTBRIDGE's write-up gives the last as 1.104.0. On affected versions, the advisory says versions "later than 1.91.0" are exploitable in the default configuration while its version table starts at 1.91.0, and FORTBRIDGE's lab reproduced the default-configuration attack on 1.100.3 and describes 1.91.0 as the release where session tokens became on by default. Versions 1.87.0 to 1.90.x are exploitable only with EXPERIMENTAL_UI_LOGIN=true. The advisory's workaround is EXPERIMENTAL_UI_LOGIN=false, which it says also breaks CLI single sign-on and Claude Code gateway login.
What the new research adds
FORTBRIDGE's analysis reproduced the chain on official images and tested the settings operators might assume protect them:
- A separate
LITELLM_SALT_KEYdoes not help. Both the stored-secret path and the session-token path use whichever key is configured, so the forged token was still accepted. - The fix separates by format, not by key. Patched releases give session tokens their own authenticated format with a prefix, so a stored secret no longer passes as a login. The two still derive from the same key.
- Evidence survives the upgrade. Forged records stay in the database after patching. FORTBRIDGE suggests decrypting stored logging-callback values and looking for ones that parse as a session object with an admin role, and reviewing stdio MCP servers registered by non-admin users, especially with inline code arguments.
FORTBRIDGE found no reports of exploitation in the wild and notes the flaw is not in the US known-exploited catalogue.
The shared lesson: authorisation from values the caller controls
The two flaws differ in mechanism but share a pattern.
- In the Red Hat case, the model name was routing data that also became an authorisation decision. One layer checked the path; another layer chose credentials from the body.
- In the LiteLLM case, a ciphertext produced for one purpose was accepted for another. Encryption proved only that the gateway had produced the value, not what it was for.
Both scores carry a "scope changed" rating for the same reason: in a shared gateway, one account's reach extends to other tenants' keys or to the whole proxy. Multi-tenant gateways concentrate provider credentials, so a small authorisation slip has a large blast radius.
What it means for engineering and security leaders
If you run a shared gateway, the useful questions are about where identity is bound, not which product you use:
- Is the upstream credential chosen from the authenticated identity, or from something in the request? Model names, headers and paths are inputs. The credential should follow from who the caller is.
- Do all layers agree on what was requested? If access policy reads the path and routing reads the body, an attacker will send different values to each.
- Does each key or token have one purpose? Reusing a key across stored secrets and session tokens invites confusion. Keys should be separated by purpose, or at least bound to it.
- What can an admin do on the host? In LiteLLM's case, admin could register an MCP server the proxy starts itself. Any escalation to admin inherits that.
Practical takeaways
- Red Hat OpenShift AI users: check Red Hat's CVE page for a fixed release. Until then, compare each tenant's usage with the models it owns, watch provider billing, and rotate keys for any tenant whose models show unexpected use.
- LiteLLM operators: upgrade to a fixed release for your line. If you can't yet, set
EXPERIMENTAL_UI_LOGIN=falseand plan for the login flows it disables. - Don't treat a separate salt key as a mitigation for CVE-2026-114612.
- If untrusted internal users had accounts during the exposure window, run the post-patch checks FORTBRIDGE describes, review users, teams and MCP servers created in that period, and rotate the master key and provider credentials.
- In any gateway, log both the authenticated tenant and the requested model for every call, and alert when they don't match.
- Give each tenant or team its own upstream provider key where you can, so a cross-tenant mistake is visible on a bill and limited to one key.
In SpanDock's model proxy, a service key can be limited to some models, by name, alias or pattern, and is refused any other model; a key can also have its own budget beside that of the person it spends as. Service keys are in the Premium plan and up. For a migration path off LiteLLM, see the migration guide.
For LiteLLM's separate Enterprise-proxy flaw from late October, see our earlier article. For the same pattern in MCP servers, see when the MCP tool skips the API's checks.