Une faille de chaîne de format dans Arize Phoenix expose des secrets (CVE-2026-53998)
Une faille de chaîne de format dans Arize Phoenix 13.0.0 à 15.6.x expose PHOENIX_SECRET et les identifiants IA stockés ; corrigée en 15.7.0.
En bref
- Une injection de chaîne de format dans la requête GraphQL
applyChatTemplatede Phoenix permet à un attaquant de lireos.environ, y comprisPHOENIX_SECRET. GitHub lui a attribué un score CVSS v3.1 de 10,0 (Critique) et a publié une charge utile fonctionnelle le 2026-11-17. - Elle touche
arize-phoenix13.0.0 à 15.6.x. Le correctif est disponible dans la 15.7.0, publiée le 2026-05-13. - Aucune exploitation dans la nature n'est connue. Le CISA ADP enregistre Exploitation : aucune, et la CVE ne figure pas dans le catalogue KEV au 2026-11-18.
- Passez à 15.7.0 ou une version ultérieure, renouvelez
PHOENIX_SECRETet chaque identifiant stocké dans Phoenix, et limitez l'accès réseau à l'API.
Suis-je concerné ?
Toutes ces conditions doivent être réunies :
arize-phoenix13.0.0 ou une version ultérieure, mais antérieure à 15.7.0, est en cours d'exécution.- L'API GraphQL est joignable par l'attaquant. Sur les installations par défaut, l'authentification est désactivée.
Le format F_STRING est choisi dans la requête elle-même ; aucun réglage côté serveur ne conditionne la faille.
L'enregistrement de la CVE a été publié le 2026-11-16 et l'avis GitHub le 2026-11-17. Le commit du correctif date du 2026-05-13, donc une installation maintenue à jour depuis mai n'est pas exposée. La dernière version publiée sur PyPI est la 21.0.0.
Selon pypistats, le paquet a enregistré 135 422 téléchargements dans la semaine précédant le 2026-11-18 et 616 502 le mois précédent. Le projet compte 12 341 étoiles GitHub. Ces chiffres décrivent le projet, pas le nombre de déploiements exposés.
Phoenix est distribué sous forme de paquet Python et d'image de conteneur, et les deux exécutent le même serveur GraphQL. La vérification de version couvre les deux formes. Un déploiement géré dépend du calendrier de correctifs du fournisseur ; demandez-lui donc quelle version de Phoenix il exécute et quand il passera à la 15.7.0.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| 13.x à 15.6.x | 13.0.0 à 15.6.x | 15.7.0 |
| 15.7.0 et ultérieures | Aucune | Déjà corrigée |
Vérifiez ce qui est installé :
# 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
Comment corriger ?
Passez à 15.7.0 ou une version ultérieure, puis renouvelez les secrets que l'ancien processus pouvait lire. Le correctif se trouve dans le formateur : un proxy inverse seul n'élimine donc pas la faille.
- Mettez à jour le paquet et redémarrez le serveur :
python -m pip install --upgrade 'arize-phoenix>=15.7.0'
-
Reconstruisez et recréez chaque conteneur qui exécute Phoenix. Récupérer une nouvelle image ne modifie pas un conteneur créé à partir de l'ancienne.
-
Renouvelez
PHOENIX_SECRET. Phoenix l’utilise pour signer les JWT et dériver la clé Fernet des identifiants stockés. Le changement invalide les jetons de session existants et rend illisibles les identifiants chiffrés avec l’ancienne clé ; prévoyez de remplacer ces identifiants stockés. -
Renouvelez les clés d'API LLM, les jetons OAuth et les identifiants de base de données que Phoenix stockait ou pouvait lire. Rechiffrez les identifiants stockés une fois le nouveau secret en place.
-
Si vous ne pouvez pas encore mettre à jour, placez l'API GraphQL derrière un proxy authentifiant et coupez l'accès réseau aux clients non fiables. Cela réduit l'exposition, mais un utilisateur authentifié peut toujours envoyer la charge utile : ce n'est donc pas un correctif.
-
Si un fournisseur géré exploite Phoenix pour vous, demandez-lui de confirmer la version déployée et la date à laquelle il atteindra la 15.7.0. Vous ne pouvez pas corriger une instance hébergée de votre côté : la confirmation est donc le seul contrôle dont vous disposez.
Quelle est la cause racine ?
Le formateur f-string transmet à str.format de Python un modèle contrôlé par l'attaquant, et l'enveloppe censée bloquer l'accès aux attributs privés ne s'exécute pas pour les attributs dunder. Le parcours atteint donc les globales de la classe Namespace et lit os.environ.
La méthode vulnérable est FStringTemplateFormatter._format dans 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 transforme un dictionnaire en DotDict, et DotDict hérite de argparse.Namespace. Sa méthode __getattr__ bloque les noms qui commencent par un souligné :
def __getattr__(self, name: str) -> Any:
if name.startswith("_"):
raise AttributeError(name)
raise AttributeError(f"No attribute '{name}'")
Cette protection est inefficace pour __class__. Python résout __class__ par la recherche d'attribut normale sur le type de l'objet avant d'appeler __getattr__, si bien que la méthode ne voit jamais le nom. Depuis __class__, le modèle remonte à __bases__[0], qui est argparse.Namespace, puis à Namespace.__init__.__globals__. Le module argparse importe os sous le nom _os, donc __globals__['_os'].environ renvoie l'environnement du processus.
Le résolveur applyChatTemplate accepte une valeur PromptChatTemplateInput et une valeur PromptTemplateOptions. Les options choisissent le formateur et fournissent les variables. Rien dans le résolveur ne restreint la syntaxe du modèle ni le chemin d'attributs.
Le point de terminaison n'est pas une surface réservée au débogage. Phoenix utilise le même formateur lorsqu'un utilisateur prévisualise un prompt dans l'interface ou appelle l'API pour afficher un prompt avec des variables. Un déploiement qui laisse les utilisateurs modifier les modèles de prompt expose donc ce chemin à chaque utilisateur qui peut atteindre cette fonctionnalité, et pas seulement à un administrateur.
Comment la faille est-elle exploitée ?
L'attaquant interroge applyChatTemplate avec une seule requête GraphQL, au moyen d'un modèle qui remonte d'une variable fournie jusqu'aux globales du formateur.
- L'attaquant atteint le point de terminaison GraphQL. Sur une installation par défaut, aucun identifiant n'est nécessaire.
- La requête fournit un message de modèle dont le texte est
{u.__class__.__bases__[0].__init__.__globals__[_os].environ}et une variableuavec n'importe quelle valeur de type dictionnaire. - Le résolveur sélectionne
FStringTemplateFormatterparce que les options définissentformatsurF_STRING. _formatenveloppeudansDotDictet appelletemplate.format. Python résout la chaîne d'attributs et renvoie l'environnement sous forme de texte dans la réponse.- L'attaquant lit
PHOENIX_SECRETdans ce texte, puis forge un jeton de session administrateur ou dérive la clé Fernet qui protège les identifiants stockés.
L'avis publie cette charge utile :
{
"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 réponse renvoie l'environnement dans une seule partie texte. L'attaquant n'a pas besoin de connaître la syntaxe du modèle à l'avance : la charge utile de l'avis est un document GraphQL normal, et la seule partie inhabituelle est la chaîne d'attributs. Un filtre qui bloque les chaînes exactes __class__ ou __globals__ intercepterait cette charge utile, mais un parcours différent échapperait à une correspondance de chaîne fixe.
Comment se déroule l'attaque ?
Une seule requête GraphQL non authentifiée remonte d'une variable de modèle jusqu'à l'environnement du serveur et renvoie le secret qui protège chaque identifiant stocké.
sur le modèle de l'attaquant"] C --> D["La protection de DotDict ne couvre pas __class__"] D --> E["Les globales de Namespace exposent _os.environ"] E --> F["La réponse contient PHOENIX_SECRET"] F --> G["L'attaquant forge un JWT d'administrateur
et déchiffre les identifiants stockés"]
Que peut faire un attaquant ?
L'attaquant peut lire l'environnement du processus et utiliser les valeurs qu'il contient pour prendre le contrôle de l'installation Phoenix et des identifiants qu'elle protège.
PHOENIX_SECRETpermet à l'attaquant de signer un JWT pour un administrateur et de dériver la clé Fernet utilisée pour les identifiants stockés.- Les clés d'API LLM, les jetons OAuth et les autres identifiants de fournisseurs stockés dans Phoenix peuvent être déchiffrés et utilisés aux frais de la victime.
- Les chemins de fichiers, les noms de modules chargés et les constantes internes aident l'attaquant à préparer une seconde étape.
L'avis ne démontre pas d'exécution de code. L'impact qu'il documente est la divulgation de l'environnement et des secrets qu'il contient, suivie d'une falsification de jeton et d'un déchiffrement avec la clé divulguée.
PHOENIX_SECRET est la clé maîtresse de deux opérations. Phoenix signe les JWT de session avec elle : une valeur divulguée permet donc à l'attaquant de fabriquer un jeton pour n'importe quel utilisateur, y compris un administrateur. Phoenix en dérive aussi la clé Fernet qui chiffre les identifiants stockés, si bien que la même valeur déchiffre les clés d'API LLM et les jetons OAuth présents dans la base de données. Renouveler l'une sans l'autre laisse une fenêtre pendant laquelle un ancien jeton ou un ancien texte chiffré fonctionne encore.
Les conditions sont les mêmes que dans « Suis-je concerné ? » : une version vulnérable, une API GraphQL joignable et le format F_STRING. Une installation où l'authentification est activée expose tout de même les données à tout compte authentifié, quels que soient ses privilèges.
Lire l'environnement n'est que la première étape. L'attaquant doit encore utiliser le secret pour signer un jeton ou déchiffrer une valeur stockée. Une fois le secret connu, ces deux opérations se font localement chez l'attaquant, et aucune ne laisse de requête dans le journal de Phoenix.
Pourquoi le correctif fonctionne-t-il ?
Le correctif remplace str.format par une sous-classe de Formatter qui rejette tout attribut dont le nom commence par un souligné. Cela brise l'étape __class__, si bien que le modèle ne peut plus atteindre __globals__ ni 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)
La modification bloque le vecteur de parcours d'attributs pour l'accès par point comme par crochets. Elle n'ajoute pas d'authentification au résolveur. L'avis recommandait cela comme mesure d'atténuation distincte : une installation par défaut expose donc toujours le point de terminaison à quiconque peut l'atteindre. Le placement réseau et l'authentification restent des éléments de l'exposition.
Comment vérifier si j'ai été compromis ?
Aucun indicateur de compromission n'a été publié. La requête est un POST GraphQL normal, et une lecture réussie renvoie l'environnement dans une réponse normale. Un journal d'accès par défaut n'enregistre que la ligne de requête, donc le corps du POST constitue la principale trace lorsque le proxy ou un WAF le conserve.
# 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
Une occurrence de applyChatTemplate est une piste, pas une preuve : le point de terminaison est aussi utilisé par des outils de prompt légitimes. Une occurrence qui contient également __class__, __globals__ ou environ est bien plus solide. Si vous en trouvez une, renouvelez PHOENIX_SECRET et chaque identifiant de fournisseur stocké, puis examinez les sessions administrateur créées après la requête.
Chronologie
- 2026-02-13 :
arize-phoenix13.0.0 est publié avec le formateur vulnérable. - 2026-05-13 : le commit
e7224a68ajoute le formateur sûr et la version 15.7.0 est publiée. - 2026-11-16 : l'enregistrement de la CVE-2026-53998 est publié.
- 2026-11-17 : la base d'avis GitHub publie GHSA-gfv3-m769-5xm3 avec une charge utile fonctionnelle.
- 2026-11-18 : le CISA ADP enregistre Exploitation : aucune ; la CVE ne figure pas dans le catalogue KEV.
FAQ
La faille peut-elle être exploitée sans authentification ?
Oui, sur une installation par défaut où l'authentification est désactivée. Si l'authentification est activée, tout compte peut envoyer la requête, quel que soit son rôle.
Une interaction de l'utilisateur est-elle nécessaire ?
Non. L'attaquant envoie une seule requête GraphQL et lit la réponse. Aucune victime n'a à ouvrir un lien ni à approuver quoi que ce soit.
Existe-t-il une preuve de concept publique ?
Oui. L'avis GitHub contient une charge utile de requête complète qui renvoie l'environnement. L'avis crédite OmarXtream comme rapporteur.
La 15.7.0 est-elle la seule version corrigée ?
Non. La 15.7.0 est la première version à embarquer le formateur sûr, et la dernière version publiée est la 21.0.0. Toute version à partir de la 15.7.0 contient le correctif.
Le correctif ajoute-t-il une authentification ?
Non. Le correctif bloque le parcours d'attributs dans le formateur. Le résolveur n'impose toujours aucune authentification : une installation par défaut reste donc joignable par quiconque peut atteindre l'API.
A-t-elle été exploitée dans la nature ?
Aucune exploitation n'est connue. Le CISA ADP enregistre Exploitation : aucune, et la CVE ne figure pas dans le catalogue KEV au 2026-11-18.
Le point de terminaison est-il censé être public ?
Sur une installation par défaut, Phoenix désactive l'authentification pour qu'un utilisateur local ou d'un réseau de confiance puisse ouvrir l'interface. C'est ce réglage par défaut qui fait qualifier la faille de non authentifiée dans l'avis. Un déploiement de production qui expose l'API au-delà d'un réseau de confiance doit placer une authentification devant elle, même après la mise à jour.
Un service Phoenix géré utilise-t-il le même code ?
Un service géré exécute le même code serveur, mais le fournisseur contrôle la version et l'exposition réseau. Demandez au fournisseur la version déployée et la date du correctif. Votre propre mise à jour du paquet ne modifie pas une instance hébergée.
Détectez les API Phoenix exposées avec Ostorlab
Le Web Agentic Deep Scan d'Ostorlab recense et teste les applications web et les API que vous exposez. Pour un déploiement Phoenix, il cartographie la surface GraphQL joignable et les paramètres d'authentification placés devant elle, afin que vous puissiez voir quelles installations acceptent des requêtes non authentifiées avant de mettre à jour.
Références
- GitHub Advisory Database, GHSA-gfv3-m769-5xm3, « Phoenix: Format String Injection in applyChatTemplate » : https://github.com/advisories/GHSA-gfv3-m769-5xm3 (vérifié le 18 novembre 2026)
- Enregistrement CVE, CVE-2026-53998 : https://www.cve.org/CVERecord?id=CVE-2026-53998 (vérifié le 18 novembre 2026)
- Commit de correctif d'Arize Phoenix
e7224a68, « fix: prevent format-string injection in f-string template formatter » : https://github.com/Arize-ai/phoenix/commit/e7224a685589f2ffae1fefcc68ff210bd6ad28b8 (vérifié le 18 novembre 2026) - Version 15.7.0 d'Arize Phoenix : https://github.com/Arize-ai/phoenix/releases/tag/arize-phoenix-v15.7.0 (vérifié le 18 novembre 2026)
- Code source d'Arize Phoenix en 15.6.0,
template_formatters.py: https://github.com/Arize-ai/phoenix/blob/arize-phoenix-v15.6.0/src/phoenix/utilities/template_formatters.py (vérifié le 18 novembre 2026) - Code source d'Arize Phoenix en 15.6.0,
queries.py: https://github.com/Arize-ai/phoenix/blob/arize-phoenix-v15.6.0/src/phoenix/server/api/queries.py (vérifié le 18 novembre 2026) - Page du projet PyPI pour
arize-phoenix: https://pypi.org/project/arize-phoenix/ (vérifié le 18 novembre 2026) - pypistats, statistiques de téléchargement de
arize-phoenix: https://pypistats.org/packages/arize-phoenix (vérifié le 18 novembre 2026) - Flux du catalogue Known Exploited Vulnerabilities de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 18 novembre 2026)