> ## Content Index
> Fetch the complete content index at: https://stackurity.ai/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# Phoenix CVE-2026-53998: CVSS 10 secrets leak, upgrade to 15.7.0
- URL: https://stackurity.ai/blog/arize-phoenix-cve-2026-53998-format-string-secrets-leak/
- Published: 2026-11-18T01:35:03.000Z
- Updated: 2026-11-18T01:35:03.000Z
- Description: A critical Phoenix flaw lets one GraphQL query read server secrets, no login on default installs. See affected versions, the fix and what to rotate.
- Author: Stackurity Research Team
- Tags: Open Source Libraries, #deep-dive

## TL;DR

- CVE-2026-53998 is a critical flaw in Phoenix, the AI observability and evaluation platform: one GraphQL query lets an attacker read the server's environment variables and secrets.
- The advisory lists a CVSS v3.1 base score of 10, with the weaknesses CWE-134 (format string) and CWE-200 (information exposure).
- Releases from 13.0.0 up to 15.7.0 (excluding 15.7.0) are affected, and the endpoint needs no login on a default installation.
- The advisory does not say the flaw is exploited in the wild, and we know of no CISA catalogue entry, but a public proof of concept exists in the advisory.
- Upgrade to 15.7.0, then rotate the secrets and stored keys the server held.

## What the flaw is, in plain English

Phoenix is an open source platform that teams run to trace, inspect and evaluate their AI applications. It is installed as the Python package arize-phoenix, and it keeps credentials for the model providers it talks to, such as API keys and OAuth tokens, in its own database.

The flaw sits in a GraphQL query called applyChatTemplate. The query lets a user preview a chat prompt template, and one of the supported template formats is the Python f-string. The server passed the template text supplied in the request to the formatter without limiting what the template may reach. Python lets a template walk from an ordinary object to its internals through special attributes, and the wrapper meant to stop that did not prevent it. A crafted template could therefore reach the interpreter's globals and read the process environment variables and internal module state, then return them in the API response.

That is a format string injection (CWE-134), and what it exposes is sensitive information (CWE-200). The [GitHub advisory GHSA-gfv3-m769-5xm3](https://github.com/advisories/GHSA-gfv3-m769-5xm3) reports that the exposed values include PHOENIX\_SECRET, the master key Phoenix uses to sign session tokens and to derive the key that protects stored credentials. With that key an attacker can forge administrator session tokens and decrypt the credentials held in the database, such as the LLM API keys of every team that uses the instance.

## Why it matters now

- **Severity.** The advisory rates it critical with a CVSS v3.1 base score of 10\. The vector says it is reachable over the network, needs no privileges, needs no user interaction and affects other components than the one attacked.
- **No login by default.** On a default installation, authentication is off and the endpoint answers anyone who can reach it. When authentication is on, any account is enough, whatever its privileges.
- **The advisory was published on November 17, 2026** and includes a working request and the exact source locations. Once a mechanism is public and this simple, attempts tend to follow.
- **The loot is more valuable than the host.** A leaked master key and decrypted model provider keys let an attacker spend your AI budget, read your prompts and traces, or reach other systems, even after you patch the server.

Observability tools are often set up quickly by a data or machine learning team, on a laptop, a shared server or a container, and the team that runs vulnerability management may not know they exist. If an instance was reachable beyond one machine, assume it is in scope. Our post on [AI agents hunting API keys in exposed LiteLLM and Dify apps](https://stackurity.ai/blog/ai-agents-hunt-api-keys-in-litellm-dify-and-one-api/) shows the same pattern, and [how to respond to a leaked API key or token](https://stackurity.ai/blog/leaked-api-key-or-token-in-a-repository-how-to-respond/) covers rotation in detail.

## Am I affected?

You are affected if you run the arize-phoenix package from 13.0.0 up to 15.7.0 (excluding 15.7.0). The advisory names 13.0.0 as the first vulnerable release and 14.8.0 as the latest release it confirmed vulnerable. Releases from 15.7.0 on contain the fix.

To check one machine by hand, activate the environment Phoenix runs in and ask pip for the installed version:

```
pip show arize-phoenix
```

```
pip list
```

If Phoenix runs in a container, run the same command inside it, because the version in the image is what counts. In a repository, look for arize-phoenix in `requirements.txt`, `pyproject.toml` or the lock file and note the pinned version.

Then find out who can reach it. An instance open to the internet is the worst case, but an instance on a private network is still exposed to every colleague, contractor and compromised workstation that can reach it, so do not treat internal as safe. If authentication is off, turning it on is not a fix: the advisory says any account is enough, so only the upgrade closes the flaw.

## How to fix Phoenix CVE-2026-53998

1. List every Phoenix installation you own: servers, virtual environments, container images, notebooks that start a local server and repositories. Write down the version of each.
2. Upgrade each one to 15.7.0 or later. For a pip install, run `pip install --upgrade arize-phoenix`, or pin the version in your requirements file and reinstall. Rebuild and redeploy any container image that bundles Phoenix, then restart the service so the new code runs.
3. Run `pip show arize-phoenix` again in each place and confirm the version is 15.7.0 or later.
4. Until you can upgrade, take the instance off any network that untrusted people can reach, or put it behind a gateway that blocks requests to the applyChatTemplate query.
5. Treat every secret the instance held as exposed if it was reachable before the upgrade: replace PHOENIX\_SECRET (which signs sessions and protects stored credentials), then rotate the model provider keys and any OAuth tokens stored in Phoenix, and end existing sessions.
6. Review access logs from before the upgrade for requests to the applyChatTemplate query from addresses you do not recognise, and check the model provider's usage for spending you cannot explain.

Rotation matters as much as the upgrade. Patching stops new reads, but anything already read stays valid until you replace it.

## How to check with Stackurity

Stackurity keeps one inventory of the Python libraries in your repositories and the libraries your deployed applications load, matches it against new advisories every hour, and shows the upgrades that clear the most issues first. A Phoenix dependency in a requirements file, a lock file or a running application can be flagged, with the version to move to, and the finding names every place that needs it. After you upgrade, a check again records whether the fix is really in place. The [remediation guide](https://stackurity.ai/docs/remediation) shows how fixes are grouped and tracked.

There are limits. Stackurity does not cover libraries copied into an application outside a package manager or lockfile, so a vendored copy of Phoenix needs a manual check. Finding leaked keys is a separate job: the agent and the scan read files for keys, tokens and passwords, and each leak gets a rotate-by date, which helps with the rotation step above. [Start a free trial](https://app.stackurity.dev/signup?utm%5Fsource=blog&utm%5Fmedium=referral&utm%5Fcampaign=open-source-libraries&utm%5Fcontent=arize-phoenix-cve-2026-53998-format-string-secrets-leak) to see it on your own repositories.

## FAQ

### What is CVE-2026-53998?

It is a critical format string injection flaw in Phoenix, the AI observability and evaluation platform. A crafted template sent to the applyChatTemplate GraphQL query can read the server's environment variables and secrets.

### Which Phoenix versions are affected?

Releases from 13.0.0 up to 15.7.0 are affected, excluding 15.7.0\. The first vulnerable release is 13.0.0, and 15.7.0 is the first patched one.

### Does it need a login?

Not on a default installation, where authentication is off. When authentication is on, any account can use it, whatever its privileges.

### Is CVE-2026-53998 being exploited?

The advisory does not say so, and we know of no entry for it in the CISA catalogue. The advisory does publish a working request, so treat it as urgent.

### What should I rotate after upgrading?

Replace PHOENIX\_SECRET, then rotate the model provider keys and OAuth tokens stored in the instance, and end existing sessions. Anything the attacker read stays valid until you replace it.

### Does Stackurity find Phoenix?

Stackurity matches advisories against the Python libraries in your repositories and the libraries your deployed applications load, so a Phoenix dependency in either place can be flagged. It does not cover libraries copied into an application outside a package manager.

Sources: [NIST National Vulnerability Database](https://nvd.nist.gov/vuln/detail/CVE-2026-53998) and [GitHub Advisory Database](https://github.com/advisories/GHSA-gfv3-m769-5xm3).