CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-53998

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 18, 2026·9 min read·0 visits

Executive Summary (TL;DR)

An unrestricted Python format string evaluation in Arize Phoenix's applyChatTemplate GraphQL endpoint allows unauthenticated attackers to traverse object attributes and extract sensitive environment variables, such as PHOENIX_SECRET, enabling administrative session forgery and credential decryption.

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.

Vulnerability Overview

Arize Phoenix (arize-phoenix) is an open-source observability and evaluation platform designed for monitoring large language model (LLM) applications. As part of its prompt engineering and evaluation capabilities, Phoenix provides a template rendering engine accessible via its GraphQL API (applyChatTemplate). This feature allows users to test prompt structures and substitute dynamic variables using either Mustache syntax or Python f-string formatting conventions.

In versions 13.0.0 through 15.6.0, the f-string template processor (FStringTemplateFormatter) fails to sanitize or restrict attribute traversal within user-supplied format strings. This weakness is classified under CWE-134 (Use of Externally-Controlled Format String) and CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor). When the server processes a template string via the applyChatTemplate query, it delegates string interpolation directly to Python's built-in str.format() method.

Because Python's standard formatting engine resolves dot-notation attributes and dictionary keys using getattr() and __getitem__(), an attacker can craft format directives that traverse Python's internal object hierarchy. By stepping through special double-underscore (dunder) attributes such as __init__ and __globals__, an attacker can access imported modules like os and dump the server's runtime environment variables (os.environ).

By default, Arize Phoenix deploys without authentication enabled, exposing the /graphql endpoint to any network client capable of reaching the service port (typically TCP port 6006). Even when authentication is explicitly configured via PHOENIX_ENABLE_AUTH=True, the applyChatTemplate query remains accessible to any authenticated user regardless of privilege level. Consequently, both unauthenticated remote attackers and low-privileged authenticated users can extract the PHOENIX_SECRET signing key, forge administrative session tokens, and decrypt stored platform credentials.

Root Cause Analysis

The root cause of CVE-2026-53998 lies in how FStringTemplateFormatter._format in src/phoenix/utilities/template_formatters.py handles variable substitution on untrusted template inputs. To allow users to reference nested dictionary fields using dot notation (for example, {user.name}) inside prompt templates, Phoenix wraps input dictionaries and lists in a helper class named DotDict via the _wrap_value() function before invoking template.format(**wrapped_variables).

Python's str.format() implementation parses replacement fields enclosed in curly braces {} and evaluates attribute access (.attr) and element indexing ([key]) sequentially. Unlike full Python eval() expressions or actual f-string literals, str.format() does not permit arbitrary function calls with arguments. However, it imposes zero access controls on which object attributes or dictionary keys can be inspected during resolution.

In the Python data model, every object and method maintains references to its class definition, base classes, and defining module scope through internal dunder attributes. Specifically, a function or method object exposes a __globals__ dictionary containing all global variables and imported modules present in the namespace where that function was defined. Because DotDict is a custom Python class defined within src/phoenix/utilities/template_formatters.py, its __init__ constructor method carries a __globals__ reference pointing directly to the global namespace of that module.

When an attacker supplies a dictionary variable u in the GraphQL variables map, _wrap_value() converts u into a DotDict instance. The attacker's template {u.__init__.__globals__[os].environ} then instructs str.format() to look up the __init__ method on DotDict, access the __globals__ dictionary of template_formatters.py, index into the imported os module, and retrieve the environ mapping. The formatting engine converts the resulting os._Environ object into its string representation and returns it directly in the GraphQL HTTP response.

Code Analysis

Prior to version 15.7.0, FStringTemplateFormatter relied entirely on Python's built-in str.format() method without overriding field resolution behavior. The vulnerable implementation in src/phoenix/utilities/template_formatters.py processed input variables as follows:

class FStringTemplateFormatter(TemplateFormatter):
    """
    Regular f-string template formatter.
 
    Examples:
 
    >>> formatter = FStringTemplateFormatter()
    >>> formatter.format("{hello}", hello="world")
    'world'
    """
 
    def parse(self, template: str) -> set[str]:
        return set(field_name for _, field_name, _, _ in Formatter().parse(template) if field_name)
 
    def _format(self, template: str, variable_names: Iterable[str], **variables: Any) -> str:
        # Wrap dict and list variables to support attribute access (e.g., {user.name})
        wrapped_variables = {key: _wrap_value(value) for key, value in variables.items()}
        # VULNERABLE: Raw str.format() allows unrestricted traversal of __class__, __init__, and __globals__
        return template.format(**wrapped_variables)

In commit e7224a685589f2ffae1fefcc68ff210bd6ad28b8, Arize AI remediated the flaw by introducing _SafeFieldFormatter, a custom subclass of string.Formatter. Instead of allowing Python's C-level formatting implementation to resolve attributes unchecked, _SafeFieldFormatter overrides the get_field() method to manually parse each attribute and index step using the regular expression _FIELD_NAME_PART_RE = re.compile(r"\.([^.\[\]]+)|\[([^\[\]]+)\]").

_FIELD_NAME_PART_RE = re.compile(r"\.([^.\[\]]+)|\[([^\[\]]+)\]")
 
 
class _SafeFieldFormatter(Formatter):
    """
    A :class:`string.Formatter` that forbids access to "private" attributes.
    """
 
    def get_field(self, field_name: str, args: Any, kwargs: Any) -> Any:
        # Extract the root variable identifier before any dot or bracket
        first = re.match(r"^[^.\[\]]*", field_name).group(0)  # type: ignore[union-attr]
        rest = field_name[len(first) :]
        key: Any = int(first) if first.isdigit() else first
        obj = self.get_value(key, args, kwargs)
        
        # Iterate through each subsequent .attr or [index] operation
        for attr, index in _FIELD_NAME_PART_RE.findall(rest):
            if attr:
                # FIX: Block access to any attribute starting with an underscore
                if attr.startswith("_"):
                    raise TemplateFormatterError(
                        f"Access to attribute '{attr}' is not permitted in templates"
                    )
                obj = getattr(obj, attr)
            else:
                # Index access (e.g., [0] or [key]) does not traverse object attributes
                obj = obj[int(index) if index.lstrip("-").isdigit() else index]
        return obj, first

FStringTemplateFormatter was updated to instantiate _SafeFieldFormatter() and invoke self._formatter.vformat(template, (), wrapped_variables) inside _format(). By rejecting any attribute name where attr.startswith("_") evaluates to True, the patch prevents access to all dunder attributes (__class__, __init__, __globals__, __builtins__, __subclasses__) as well as single-underscore private attributes.

> [!NOTE] > Assessment of Fix Completeness: Blocking attribute traversal on leading underscores effectively breaks reflection chains in string.Formatter because transitioning from a data instance (DotDict, dict, list, str, int) to its underlying type or function namespace in Python requires accessing a dunder attribute. While bracket indexing (obj[index]) is not filtered for leading underscores, indexing only invokes __getitem__ on the target container (looking up dictionary keys or list indices) and cannot access object attributes unless an attacker already possesses a reference to __globals__ or __dict__. The regression suite in tests/unit/utilities/test_template_formatters.py also verified that the alternative MustacheTemplateFormatter (backed by pystache) safely resolves dunder attribute lookups on primitives and dictionaries to empty strings.

Exploitation

Exploiting CVE-2026-53998 requires only network access to the Phoenix HTTP server (default port 6006) and the ability to issue a GraphQL query to /graphql. When Phoenix runs in its default configuration (PHOENIX_ENABLE_AUTH unset or False), no authentication headers, cookies, or API tokens are required. If authentication is enabled, any user with a valid session or API key can execute the query.

To trigger the vulnerability, the attacker sends an HTTP POST request containing the applyChatTemplate GraphQL operation. The attacker defines a variable in the variables JSON object (such as {"u": {"x": 1}}) so that Phoenix wraps it in a DotDict instance. When DotDict is instantiated, its __init__ method is bound to the src/phoenix/utilities/template_formatters.py module scope.

POST /graphql HTTP/1.1
Host: target-phoenix:6006
Content-Type: application/json
 
{
  "query": "query ApplyChatTemplate($template: String!, $variables: JSON!) { applyChatTemplate(template: $template, variables: $variables) }",
  "variables": {
    "template": "LEAKED_ENV: {u.__init__.__globals__[os].environ}",
    "variables": {
      "u": { "x": 1 }
    }
  }
}

The regression test suite introduced in commit e7224a685589f2ffae1fefcc68ff210bd6ad28b8 demonstrates four distinct traversal vectors that were exploitable prior to the patch:

  • {u.__class__}: Leaks the internal class definition (phoenix.utilities.template_formatters.DotDict).
  • {u.__class__.__bases__[0].__init__.__globals__}: Walks up the class inheritance hierarchy (dict / object) to access base constructor globals.
  • {u.__init__.__globals__[os].environ}: Directly accesses the os module imported within the formatter utility namespace and dumps all process environment variables.
  • {u[x].__class__}: Demonstrates that nested dictionary values (u[x]) can also serve as the starting point for attribute traversal.

If a primitive variable (such as a string or integer) is passed instead of a dictionary, its __init__ method is a C-level wrapper_descriptor that does not expose a __globals__ attribute directly. However, because DotDict is a pure-Python class defined in Phoenix's application code, passing any JSON object ({"u": {}}) guarantees that u.__init__ is a pure-Python method possessing a populated __globals__ dictionary.

Impact Assessment

CVE-2026-53998 carries a CVSS v3.1 base score of 10.0 (Critical) with the vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L. The Scope is marked as Changed (S:C) because the format string vulnerability resides within the template rendering component, but successful exploitation compromises the broader host environment, external LLM integrations, and cryptographic authentication boundaries of the entire Phoenix platform.

The immediate impact is a complete breach of confidentiality (C:H) regarding the Phoenix process environment and memory space. Because AI observability platforms routinely integrate with external model providers and storage backends, the leaked os.environ output frequently contains high-value credentials:

  • PHOENIX_SECRET: The master cryptographic secret used by Phoenix when authentication is enabled.
  • OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY: Third-party LLM API keys used for running evaluations and prompt playground queries.
  • AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY: Cloud infrastructure credentials.
  • PHOENIX_SQL_DATABASE_URL: PostgreSQL or SQLite connection strings containing plaintext database usernames and passwords.

The secondary impact is a high-severity integrity compromise (I:H). In deployments where authentication is enabled, PHOENIX_SECRET is used to sign JWT session tokens and derive encryption keys for sensitive configuration data stored at rest in the Phoenix database. Once an attacker extracts PHOENIX_SECRET via the format string injection, they can forge valid administrative session tokens offline and decrypt any credentials stored within the platform's database.

Remediation

Arize AI addressed this vulnerability in arize-phoenix version 15.7.0. Operators running any version of arize-phoenix from 13.0.0 up to 15.6.0 must upgrade to 15.7.0 or later to enforce _SafeFieldFormatter checks on all f-string template evaluations.

pip install --upgrade "arize-phoenix>=15.7.0"

Because exploitation leaves minimal forensic indicators beyond standard HTTP access logs to /graphql, any Phoenix instance that was exposed to untrusted networks while running an affected version should be treated as potentially compromised. Administrators should immediately rotate PHOENIX_SECRET to invalidate existing session tokens and re-encrypt stored secrets, as well as rotate all LLM API keys, database passwords, and cloud provider credentials present in the runtime environment.

If an immediate software upgrade is not feasible, administrators should implement defense-in-depth mitigations at the network and proxy layers:

  1. Network Access Control: Restrict access to the Phoenix service port (default 6006) using firewall rules, VPC security groups, or a VPN so that untrusted hosts cannot reach the /graphql endpoint.
  2. Enable Platform Authentication: Set PHOENIX_ENABLE_AUTH=True to block unauthenticated network exploitation. Note that this is only a partial workaround, as authenticated users can still trigger the vulnerability.
  3. WAF / Reverse Proxy Filtering: Deploy a Web Application Firewall (WAF) or reverse proxy in front of /graphql configured to inspect JSON request bodies and block payloads containing Python dunder strings such as __class__, __init__, __globals__, __builtins__, or __subclasses__.

Official Patches

Arize AIGitHub Security Advisory GHSA-gfv3-m769-5xm3
Arize AIPull Request #13197: fix: prevent format-string injection in f-string template formatter
Arize AIArize Phoenix v15.7.0 Release Notes

Fix Analysis (1)

Technical Appendix

CVSS Score
10.0/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L
EPSS Probability
0.36%
Top 70% most exploited

Affected Systems

arize-phoenixarize-phoenix-evalsarize-phoenix-otelarize-phoenix-client

Affected Versions Detail

Product
Affected Versions
Fixed Version
arize-phoenix
Arize AI
>= 13.0.0, < 15.7.015.7.0
AttributeDetail
Vulnerability TypeFormat String Injection / Information Disclosure (CWE-134, CWE-200)
Affected ComponentFStringTemplateFormatter._format via applyChatTemplate GraphQL endpoint
Attack VectorNetwork (Unauthenticated HTTP POST to /graphql by default)
CVSS v3.1 Score10.0 Critical (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L)
EPSS Score0.36% (29.86th Percentile)
ImpactDisclosure of os.environ (PHOENIX_SECRET, API keys), session forgery, credential decryption
Exploit StatusProof-of-Concept (Regression tests public in patch commit)
Fixed Versionarize-phoenix 15.7.0

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1005Data from Local System
Collection
T1552Unsecured Credentials
Credential Access
CWE-134
Use of Externally-Controlled Format String

The software uses a function that accepts a format string as an argument, but the format string originates from an external source or is influenced by untrusted input.

Known Exploits & Detection

GitHubOfficial patch commit containing regression test payloads demonstrating dunder attribute traversal and os.environ extraction.

Vulnerability Timeline

Vulnerability identified and Pull Request #13197 authored by Mikyo King.
2026-05-12
Patch commit e7224a685589f2ffae1fefcc68ff210bd6ad28b8 merged and arize-phoenix v15.7.0 released.
2026-05-13
CVE-2026-53998 and GHSA-gfv3-m769-5xm3 officially published.
2026-11-16
NVD record updated with CVSS v3.1 Base Score of 10.0.
2026-11-17

References & Sources

  • [1]GitHub Security Advisory: GHSA-gfv3-m769-5xm3
  • [2]Fix Pull Request: Arize-ai/phoenix#13197
  • [3]Fix Commit: e7224a685589f2ffae1fefcc68ff210bd6ad28b8
  • [4]Arize Phoenix Release v15.7.0
  • [5]Official CVE Record: CVE-2026-53998
  • [6]NVD Vulnerability Detail: CVE-2026-53998
  • [7]CVEListV5 Record: CVE-2026-53998

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•CVE-2026-63634
6.9

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

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.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 2 hours ago•CVE-2026-14265
7.5

CVE-2026-14265: Remote Code Execution via Unsafe Deserialization in AWS Advanced JDBC Wrapper

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.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 3 hours ago•CVE-2026-63672
6.1

CVE-2026-63672: User-Controlled Identity Provider Selection in EGroupware SAML Authentication

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.

Amit Schendel
Amit Schendel
5 views•9 min read
•about 4 hours ago•CVE-2026-62336
8.5

CVE-2026-62336: Local Privilege Escalation via Symlink Following in qbee-agent

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.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 5 hours ago•CVE-2026-110782
8.7

CVE-2026-110782: Cryptographic Signature Verification Bypass and Cross-IdP Impersonation in SimpleSAMLphp SAML2

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.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 6 hours ago•CVE-2026-110789
7.5

CVE-2026-110789: Pre-Authentication Denial of Service via ASN.1 DER Length Parsing in js-libp2p (@libp2p/crypto)

CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.

Amit Schendel
Amit Schendel
6 views•11 min read