79% frente al 51%: los neobancos independientes quedan atrás en seguridad de aplicaciones. Leer el informe

Análisis a fondo

Análisis a fondo

Un fallo de formato de cadena en Arize Phoenix filtra secretos (CVE-2026-53998)

Un fallo de formato de cadena en Arize Phoenix 13.0.0 a 15.6.x expone PHOENIX_SECRET y credenciales de IA almacenadas; corregido en 15.7.0.

Resumen

  • Una inyección de formato de cadena en la consulta GraphQL applyChatTemplate de Phoenix permite a un atacante leer os.environ, incluido PHOENIX_SECRET. GitHub le asignó una puntuación CVSS v3.1 de 10.0 (Crítica) y publicó una carga útil funcional el 17 de noviembre de 2026.
  • Afecta a arize-phoenix 13.0.0 a 15.6.x. La corrección está en la 15.7.0, publicada el 13 de mayo de 2026.
  • No se conoce explotación en entornos reales. CISA ADP registra Explotación: ninguna, y el CVE no está en KEV a 18 de noviembre de 2026.
  • Actualice a la 15.7.0 o posterior, rote PHOENIX_SECRET y todas las credenciales almacenadas en Phoenix, y restrinja el acceso de red a la API.

¿Estoy afectado?

Deben cumplirse todas estas condiciones:

  • Se ejecuta arize-phoenix 13.0.0 o posterior, pero anterior a la 15.7.0.
  • La API GraphQL es accesible para el atacante. En las instalaciones por defecto, la autenticación está deshabilitada.

El formato F_STRING se selecciona en la propia solicitud; no hay una opción del servidor que condicione el fallo.

El registro del CVE se publicó el 16 de noviembre de 2026 y el aviso de GitHub el 17 de noviembre de 2026. El commit de corrección es del 13 de mayo de 2026, así que una instalación que se haya mantenido al día desde mayo no está expuesta. La última versión en PyPI es la 21.0.0.

El paquete tuvo 135,422 descargas en la semana que terminó el 18 de noviembre de 2026 y 616,502 en el mes anterior, según pypistats. El proyecto tiene 12,341 estrellas en GitHub. Esas cifras describen el proyecto, no el número de despliegues expuestos.

Phoenix se distribuye como paquete de Python y como imagen de contenedor, y ambos ejecutan el mismo servidor GraphQL. La comprobación de versión cubre cualquiera de las dos formas. Un despliegue gestionado depende del calendario de parches del proveedor, así que pregunte al proveedor qué versión de Phoenix ejecuta y cuándo incorporará la 15.7.0.

Rama Versiones afectadas Versión corregida
13.x a 15.6.x 13.0.0 a 15.6.x 15.7.0
15.7.0 y posterior Ninguna Ya corregida

Compruebe qué está instalado:

# The version in the current environment
python -m pip show arize-phoenix

# The version inside a running container
docker exec <container> python -m pip show arize-phoenix

# A container image that has not been started
docker run --rm <image> python -m pip show arize-phoenix

¿Cómo lo corrijo?

Actualice a la 15.7.0 o posterior y después rote los secretos que el proceso antiguo podía leer. La corrección está en el formateador, así que un proxy inverso por sí solo no elimina el fallo.

  1. Actualice el paquete y reinicie el servidor:
python -m pip install --upgrade 'arize-phoenix>=15.7.0'
  1. Reconstruya y vuelva a crear todos los contenedores que ejecutan Phoenix. Descargar una imagen nueva no cambia un contenedor creado a partir de la anterior.

  2. Rote PHOENIX_SECRET. Phoenix lo usa para firmar JWT y derivar la clave Fernet que cifra las credenciales almacenadas. Cambiarlo invalida los tokens de sesión existentes e impide descifrar las credenciales con la clave anterior; planifique sustituir esas credenciales almacenadas.

  3. Rote las claves de API de LLM, los tokens OAuth y las credenciales de base de datos que Phoenix almacenaba o podía leer. Vuelva a cifrar las credenciales almacenadas una vez que el nuevo secreto esté en su lugar.

  4. Si aún no puede actualizar, coloque la API GraphQL detrás de un proxy que autentique y retire el acceso de red a los clientes no confiables. Eso reduce la exposición, pero un usuario autenticado todavía puede enviar la carga útil, así que no es una corrección.

  5. Si un proveedor gestionado ejecuta Phoenix por usted, pídale que confirme la versión desplegada y la fecha en que llegará a la 15.7.0. No puede parchear una instancia alojada desde su lado, así que la confirmación es el único control del que dispone.

¿Cuál es la causa raíz?

El formateador de f-strings pasa una plantilla controlada por el atacante a str.format de Python, y el envoltorio que debía bloquear el acceso a atributos privados no se ejecuta para los atributos dunder. El recorrido llega así a los globales de la clase Namespace y lee os.environ.

El método vulnerable es FStringTemplateFormatter._format en src/phoenix/utilities/template_formatters.py:

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()}
    return template.format(**wrapped_variables)

_wrap_value convierte un diccionario en DotDict, y DotDict extiende argparse.Namespace. Su __getattr__ bloquea los nombres que empiezan con guion bajo:

def __getattr__(self, name: str) -> Any:
    if name.startswith("_"):
        raise AttributeError(name)
    raise AttributeError(f"No attribute '{name}'")

Esa protección es ineficaz para __class__. Python resuelve __class__ mediante la búsqueda normal de atributos en el tipo del objeto antes de llamar a __getattr__, así que el método nunca ve el nombre. Desde __class__, la plantilla avanza hasta __bases__[0], que es argparse.Namespace, y luego hasta Namespace.__init__.__globals__. El módulo argparse importa os como _os, así que __globals__['_os'].environ devuelve el entorno del proceso.

El resolutor applyChatTemplate acepta un PromptChatTemplateInput y un valor PromptTemplateOptions. Las opciones eligen el formateador y aportan las variables. Nada en el resolutor restringe la sintaxis de la plantilla ni la ruta de atributos.

El endpoint no es una superficie exclusiva de depuración. Phoenix usa el mismo formateador cuando un usuario previsualiza un prompt en la interfaz o llama a la API para renderizar un prompt con variables. Un despliegue que permite a los usuarios editar plantillas de prompt expone por tanto la ruta a todos los usuarios que puedan llegar a esa función, no solo a un administrador.

¿Cómo se explota?

El atacante envía una sola solicitud GraphQL a la consulta applyChatTemplate con una plantilla que avanza desde una variable proporcionada hasta los globales del formateador.

  1. El atacante llega al endpoint GraphQL. En una instalación por defecto, no se necesitan credenciales.
  2. La solicitud aporta un mensaje de plantilla cuyo texto es {u.__class__.__bases__[0].__init__.__globals__[_os].environ} y una variable u con cualquier valor de diccionario.
  3. El resolutor selecciona FStringTemplateFormatter porque las opciones fijan format en F_STRING.
  4. _format envuelve u en DotDict y llama a template.format. Python resuelve la cadena de atributos y devuelve el entorno como texto en la respuesta.
  5. El atacante lee PHOENIX_SECRET en ese texto y después forja un token de sesión de administrador o deriva la clave Fernet que protege las credenciales almacenadas.

El aviso publica esta carga útil:

{
  "query": "query($t: PromptChatTemplateInput!, $o: PromptTemplateOptions!) { applyChatTemplate(template: $t, templateOptions: $o) { messages { content { ... on TextContentPart { text { text } } } } } }",
  "variables": {
    "t": { "messages": [{ "role": "USER", "content": [{ "text": { "text": "{u.__class__.__bases__[0].__init__.__globals__[_os].environ}" } }] }] },
    "o": { "format": "F_STRING", "variables": { "u": { "x": 1 } } }
  }
}

La respuesta devuelve el entorno como una parte de texto. El atacante no necesita conocer la sintaxis de la plantilla de antemano: la carga útil del aviso es un documento GraphQL normal, y la única parte inusual es la cadena de atributos. Un filtro que bloquee las cadenas exactas __class__ o __globals__ detectaría esta carga útil, pero un recorrido distinto evadiría una coincidencia de cadena fija.

¿Cómo se desarrolla el ataque?

Una sola solicitud GraphQL sin autenticar avanza desde una variable de plantilla hasta el entorno del servidor y devuelve el secreto que protege todas las credenciales almacenadas.

flowchart LR A["El atacante envía applyChatTemplate"] --> B["El resolutor selecciona F_STRING"] B --> C["_format llama a str.format
con la plantilla del atacante"] C --> D["La protección de DotDict no cubre __class__"] D --> E["Los globales de Namespace exponen _os.environ"] E --> F["La respuesta contiene PHOENIX_SECRET"] F --> G["El atacante forja un JWT de administrador
y descifra credenciales almacenadas"]

¿Qué puede hacer un atacante?

El atacante puede leer el entorno del proceso y usar sus valores para tomar el control de la instalación de Phoenix y de las credenciales que protege.

  • PHOENIX_SECRET permite al atacante firmar un JWT de administrador y derivar la clave Fernet que se usa para las credenciales almacenadas.
  • Las claves de API de LLM, los tokens OAuth y otras credenciales de proveedores almacenadas en Phoenix se pueden descifrar y usar a costa de la víctima.
  • Las rutas del sistema de archivos, los nombres de módulos cargados y las constantes internas ayudan al atacante a planear un segundo paso.

El aviso no demuestra ejecución de código. El impacto que documenta es la revelación del entorno y de los secretos que contiene, seguida de la falsificación de tokens y el descifrado con la clave filtrada.

PHOENIX_SECRET es la clave maestra para dos operaciones. Phoenix firma con él los JWT de sesión, así que un valor filtrado permite al atacante acuñar un token para cualquier usuario, incluido un administrador. Phoenix también deriva de él la clave Fernet que cifra las credenciales almacenadas, así que el mismo valor descifra las claves de API de LLM y los tokens OAuth de la base de datos. Rotar uno sin el otro deja una ventana en la que un token antiguo o un texto cifrado antiguo todavía funcionan.

Las condiciones son las mismas que en «¿Estoy afectado?»: una versión vulnerable, una API GraphQL accesible y el formato F_STRING. Una instalación con autenticación habilitada sigue exponiendo los datos a cualquier cuenta autenticada, independientemente de sus privilegios.

Leer el entorno es el primer paso, no el final. El atacante todavía tiene que usar el secreto para firmar un token o descifrar un valor almacenado. Ambas operaciones son locales para el atacante una vez conocido el secreto, y ninguna deja una solicitud en el registro de Phoenix.

¿Por qué funciona la corrección?

La corrección sustituye str.format por una subclase de Formatter que rechaza cualquier atributo cuyo nombre empiece con guion bajo. Eso rompe el paso por __class__, así que la plantilla no puede llegar a __globals__ ni a os.environ.

@@ -235,6 +235,39 @@ def _format(self, template: str, *args: Any, **variables: Any) -> str:
         return template


+_FIELD_NAME_PART_RE = re.compile(r"\.([^.\[\]]+)|\[([^\[\]]+)\]")
+
+
+class _SafeFieldFormatter(Formatter):
+    """
+    A :class:`string.Formatter` that forbids access to "private" attributes.
+
+    Python's ``str.format`` resolves ``{x.attr}`` and ``{x[key]}`` expressions.
+    Without restrictions, a malicious template can walk from a user-supplied
+    value to ``__class__`` / ``__globals__`` / ``__builtins__`` and read process
+    state (environment variables, secrets, etc.). This subclass blocks any
+    attribute access whose name starts with an underscore, which is sufficient
+    to break the traversal chain while preserving normal usage like
+    ``{user.name}`` and ``{items[0].value}``.
+    """
+
+    def get_field(self, field_name: str, args: Any, kwargs: Any) -> Any:
+        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)
+        for attr, index in _FIELD_NAME_PART_RE.findall(rest):
+            if attr:
+                if attr.startswith("_"):
+                    raise TemplateFormatterError(
+                        f"Access to attribute '{attr}' is not permitted in templates"
+                    )
+                obj = getattr(obj, attr)
+            else:
+                obj = obj[int(index) if index.lstrip("-").isdigit() else index]
+        return obj, first
+
+
 class FStringTemplateFormatter(TemplateFormatter):
@@ -266,10 +299,14 @@ class FStringTemplateFormatter(TemplateFormatter):
     def parse(self, template: str) -> set[str]:
         return set(field_name for _, field_name, _, _ in Formatter().parse(template) if field_name)

+    # Shared formatter that blocks traversal into "private"/dunder attributes,
+    # preventing format-string injection (e.g. {x.__class__.__init__.__globals__}).
+    _formatter = _SafeFieldFormatter()
+
     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()}
-        return template.format(**wrapped_variables)
+        return self._formatter.vformat(template, (), wrapped_variables)

El cambio bloquea el vector de recorrido de atributos tanto para el acceso con punto como con corchetes. No añade autenticación al resolutor. El aviso lo recomendaba como mitigación aparte, así que una instalación por defecto sigue exponiendo el endpoint a cualquiera que pueda llegar a él. La ubicación en la red y la autenticación siguen formando parte de la exposición.

¿Cómo compruebo si estuve comprometido?

No hay indicadores de compromiso publicados. La solicitud es un POST GraphQL normal, y una lectura correcta devuelve el entorno dentro de una respuesta normal. Un registro de acceso predeterminado solo guarda la línea de la solicitud, así que el cuerpo del POST es el rastro principal cuando el proxy o un WAF lo conservan.

# Access logs record only the request line by default; these greps match only
# when the reverse proxy or a WAF logs the POST body (for example nginx $request_body).
grep -i "applyChatTemplate" /var/log/nginx/access.log /var/log/apache2/access.log 2>/dev/null
grep -i "__class__\|__globals__\|__bases__\|environ" /var/log/nginx/access.log /var/log/apache2/access.log 2>/dev/null

# Phoenix application logs, if request bodies are retained
grep -i "applyChatTemplate\|__class__\|__globals__\|__bases__\|environ" /var/log/phoenix/*.log 2>/dev/null

Una coincidencia en applyChatTemplate es una pista, no una prueba: el endpoint también lo usan herramientas legítimas de prompt. Una coincidencia que además contenga __class__, __globals__ o environ es mucho más sólida. Si encuentra una, rote PHOENIX_SECRET y todas las credenciales de proveedor almacenadas, y luego revise las sesiones de administrador creadas después de la solicitud.

Cronología

  • 13 de febrero de 2026: se publica arize-phoenix 13.0.0 con el formateador vulnerable.
  • 13 de mayo de 2026: el commit e7224a68 añade el formateador seguro y se publica la 15.7.0.
  • 16 de noviembre de 2026: se publica el registro del CVE-2026-53998.
  • 17 de noviembre de 2026: la base de datos de avisos de GitHub publica GHSA-gfv3-m769-5xm3 con una carga útil funcional.
  • 18 de noviembre de 2026: CISA ADP registra Explotación: ninguna; el CVE no está en KEV.

Cronología del CVE-2026-53998: el formateador vulnerable se publicó en febrero de 2026, la corrección llegó en mayo y el aviso publicó la carga útil en noviembre
Figura 1: La corrección se publicó seis meses antes del aviso, así que las instalaciones actuales ya están protegidas. Fuente: el aviso de GitHub y la versión de Arize Phoenix, comprobados el 18 de noviembre de 2026.

Preguntas frecuentes

¿Se puede explotar sin autenticación?

Sí, en una instalación por defecto donde la autenticación está deshabilitada. Si la autenticación está habilitada, cualquier cuenta puede enviar la solicitud, independientemente de su rol.

¿Necesita interacción del usuario?

No. El atacante envía una solicitud GraphQL y lee la respuesta. Ninguna víctima tiene que abrir un enlace ni aprobar nada.

¿Existe una prueba de concepto pública?

Sí. El aviso de GitHub incluye una carga útil de solicitud completa que devuelve el entorno. El aviso acredita a OmarXtream como el reportero.

¿Es la 15.7.0 la única versión corregida?

No. La 15.7.0 es la primera versión con el formateador seguro, y la última versión es la 21.0.0. Cualquier versión desde la 15.7.0 en adelante incluye la corrección.

¿La corrección añade autenticación?

No. La corrección bloquea el recorrido de atributos en el formateador. El resolutor sigue sin exigir autenticación, así que una instalación por defecto sigue siendo accesible para cualquiera que pueda llegar a la API.

¿Se explotó en entornos reales?

No se conoce explotación. CISA ADP registra Explotación: ninguna, y el CVE no está en KEV a 18 de noviembre de 2026.

¿Se supone que el endpoint es público?

En una instalación por defecto, Phoenix deshabilita la autenticación para que un usuario local o de una red de confianza pueda abrir la interfaz. Ese valor por defecto es la razón por la que el aviso califica el fallo como no autenticado. Un despliegue de producción que exponga la API más allá de una red de confianza debería poner la autenticación delante, incluso después de la actualización.

¿Un servicio gestionado de Phoenix usa el mismo código?

Un servicio gestionado ejecuta el mismo código de servidor, pero el proveedor controla la versión y la exposición de red. Pregunte al proveedor por la versión desplegada y la fecha de corrección. La actualización de su propio paquete no cambia una instancia alojada.

Encuentre APIs de Phoenix expuestas con Ostorlab

El Web Agentic Deep Scan de Ostorlab inventaría y prueba las aplicaciones web y las APIs que usted expone. Para un despliegue de Phoenix, traza un mapa de la superficie GraphQL accesible y la configuración de autenticación que tiene delante, para que pueda ver qué instalaciones aceptan consultas sin autenticar antes de actualizar.

Referencias

  • Base de datos de avisos de GitHub, GHSA-gfv3-m769-5xm3, «Phoenix: inyección de formato de cadena en applyChatTemplate»: https://github.com/advisories/GHSA-gfv3-m769-5xm3 (comprobado el 18 de noviembre de 2026)
  • Registro del CVE, CVE-2026-53998: https://www.cve.org/CVERecord?id=CVE-2026-53998 (comprobado el 18 de noviembre de 2026)
  • Commit de corrección de Arize Phoenix e7224a68, «corregir: evitar la inyección de formato de cadena en el formateador de plantillas f-string»: https://github.com/Arize-ai/phoenix/commit/e7224a685589f2ffae1fefcc68ff210bd6ad28b8 (comprobado el 18 de noviembre de 2026)
  • Versión 15.7.0 de Arize Phoenix: https://github.com/Arize-ai/phoenix/releases/tag/arize-phoenix-v15.7.0 (comprobado el 18 de noviembre de 2026)
  • Código fuente de Arize Phoenix en la 15.6.0, template_formatters.py: https://github.com/Arize-ai/phoenix/blob/arize-phoenix-v15.6.0/src/phoenix/utilities/template_formatters.py (comprobado el 18 de noviembre de 2026)
  • Código fuente de Arize Phoenix en la 15.6.0, queries.py: https://github.com/Arize-ai/phoenix/blob/arize-phoenix-v15.6.0/src/phoenix/server/api/queries.py (comprobado el 18 de noviembre de 2026)
  • Página del proyecto arize-phoenix en PyPI: https://pypi.org/project/arize-phoenix/ (comprobado el 18 de noviembre de 2026)
  • pypistats, estadísticas de descargas de arize-phoenix: https://pypistats.org/packages/arize-phoenix (comprobado el 18 de noviembre de 2026)
  • Feed del catálogo de vulnerabilidades explotadas conocidas de CISA: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (comprobado el 18 de noviembre de 2026)