Arize Phoenix CVE-2026-53998 (CVSS 10.0): Format String Injection in applyChatTemplate Leaks AI Server Secrets and Lets Attackers Forge Admin Sessions — Fixed in 15.7.0 Six Months Before the CVE

A crafted prompt template sent to Arize Phoenix's applyChatTemplate GraphQL query can walk into Python internals to read environment variables, LLM API keys and the PHOENIX_SECRET that signs admin sessions, with no login needed on default installs; upgrade to 15.7.0 or later and rotate secrets.
A critical flaw in Arize Phoenix, an open-source tool that many AI teams run to trace, debug and evaluate their LLM applications, can let an unauthenticated attacker read the server's environment variables, including the signing secret behind every login session. Tracked as CVE-2026-53998 with a CVSS 3.1 score of 10.0, the bug sits in the prompt playground's applyChatTemplate GraphQL query. It was published as a CVE on 16 November 2026, but the fix has existed since Phoenix 15.7.0, released on 13 May 2026. Teams that pinned an older version, or that run a forgotten Phoenix container on a GPU box or in a notebook environment, have been exposed for the whole time.
What Happened
The project's security advisory, GHSA-gfv3-m769-5xm3, describes a "Format String Injection in applyChatTemplate". Phoenix lets users write prompt templates in several formats, one of which is Python f-string style ({variable}). The applyChatTemplate query takes a template from the request and renders it on the server so the playground can show the filled-in prompt.
The problem is that Python's str.format does more than replace simple names. It also resolves attribute paths ({x.attr}) and index lookups ({x[0]}). Phoenix wraps template variables in a helper class called DotDict so that {user.name} works on dictionaries. That wrapper tried to block "private" attributes, but the security researcher who reported the issue found that the check was ineffective. A crafted field could walk from an ordinary variable into Python internals such as __class__, __init__ and __globals__, and from there to the process environment and loaded module state. The text came back in the API response like any other rendered prompt.
The advisory credits the researcher OmarXtream with the report. It lists affected versions as 13.0.0 and later, up to the fix in 15.7.0. The reporter tested up to 14.8.0, which was the newest release when they filed it.
Technical Details
The CVSS vector is AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L: network reachable, low complexity, no privileges, no user interaction, and a scope change, because a leak from one GraphQL query exposes the rest of the deployment. The weaknesses listed are CWE-134 (externally controlled format string) and CWE-200 (exposure of sensitive information).
According to the advisory, what can be read includes:
- Server filesystem paths, the names of loaded Python modules and internal configuration constants.
- The full process environment, which in many deployments holds database URLs, cloud credentials and LLM provider API keys passed in as variables.
PHOENIX_SECRET, the key Phoenix uses to sign its JWT session tokens. The reporter says it also derives the key that encrypts credentials Phoenix stores, such as LLM API keys and OAuth tokens.
That last item turns a data leak into a takeover. With the signing secret, an attacker can forge an administrator session and, according to the reporter, decrypt the secrets saved in the Phoenix database. Phoenix is often connected to OpenAI, Anthropic, Azure or self-hosted model endpoints so that the playground and evaluators can call them, so the keys stored there can be costly to lose.
Authentication matters here, but less than you might hope:
- Default installs: Phoenix ships with authentication turned off. The vendor's documentation describes that mode as suitable for trying Phoenix or running it inside a private network. In this mode, anyone who can reach the server can send the query.
- Auth-enabled installs (
PHOENIX_ENABLE_AUTH=True): the advisory says any account, whatever its role, is enough to exploit the flaw. A low-privilege viewer account, or a leaked one, can therefore steal the secret that makes them an admin.
How It Was Fixed
The fix landed in pull request #13197, merged on 13 May 2026 with the message "prevent format-string injection in f-string template formatter". It adds a stricter formatter that checks every step of a field path and refuses any attribute name that starts with an underscore. Breaking that one link stops the walk from a template variable to __globals__. Normal paths such as {user.name} and {items[0].value} still work.
The reporter also recommended requiring authentication on the applyChatTemplate resolver and limiting f-string templates to trusted, system-defined ones. The advisory does not say whether those extra hardening steps were adopted.
There is no public report of exploitation so far, and the CVE is not in CISA's Known Exploited Vulnerabilities catalogue. Still, the bug is easy to understand and the fix is public. Researchers have repeatedly shown that attackers now use AI tools to turn published patches into working exploits within hours, so the six-month gap between the fix and the CVE should not be taken as a margin of safety.
Who Is Affected
Anyone running a self-hosted arize-phoenix server from version 13.0.0 up to (but not including) 15.7.0. Common places to look:
- Docker or Kubernetes deployments pinned to an older image tag.
- Phoenix started from a notebook with
px.launch_app()on a shared GPU server or in a cloud workbench, then left running. - Internal "LLM observability" stacks set up early in 2026 and not updated since. The project ships releases often (21.x is current), so a pin from February or March is very likely vulnerable.
The advisory covers the open-source server package. It does not say whether Arize's hosted service was ever affected.
What To Do Now
- Upgrade. Move to 15.7.0 or, better, a current release. Check what is actually running, not what your requirements file says:
pip show arize-phoenix | grep -i '^version'
docker ps --format '{{.Image}}' | grep -i phoenix
- Rotate secrets on any server that ran a vulnerable version where untrusted users could reach it. Set a new
PHOENIX_SECRET, which invalidates existing sessions. Then rotate every LLM provider key, database password and cloud credential that was in the process environment or stored in Phoenix. - Turn on authentication and replace the default administrator password (the documented default is
admin). Remember that this does not, by itself, fix vulnerable versions. - Keep Phoenix off the internet. Put it behind a VPN, an identity-aware proxy or at least an IP allow-list. Trace data often contains customer prompts and model outputs, which is a privacy risk in its own right.
- Hunt for abuse. Search reverse-proxy or GraphQL logs for
applyChatTemplaterequests whose templates contain__(double underscore),__globals__or__class__. Also check for unexpected admin sessions or new API keys. - Watch provider bills. A sudden jump in LLM API spend is often the first sign that a key has been stolen and resold.
Why It Matters
AI teams have added a new layer of tools very quickly: tracing servers, evaluation dashboards, prompt playgrounds and agent consoles. Many of them were built for convenience on a laptop, ship with authentication switched off, and gather the most valuable secrets in the company, namely model API keys, data connections and customer conversations. CVE-2026-53998 shows the risk. A feature meant to preview a prompt became a way to read the server's memory. It also shows a disclosure gap: a fix released in May, an advisory in early November and a CVE in mid-November means vulnerability scanners that rely on CVE feeds would not have flagged old Phoenix installs for six months. If you run AI observability tools, treat them as production systems that hold secrets, and patch them on the same schedule as your other internet-facing servers.
