JavaScript框架库漏洞的底层执行过程是怎样的

JavaScript 运行时的底层脆弱点：动态查找与对象继承

要理解框架库漏洞的底层执行过程，首先必须看清 JavaScript 运行环境（如 Chrome 的 V8 引擎或 Node.js 运行时）是如何在内存中解析和执行代码的。与其他静态编译语言不同，JavaScript 具备极高自由度的动态特性，其中两个关键机制成为了各类漏洞最常利用的物理通道：

1. 原型链回溯机制（Prototype Chain Traversal）： 在 JavaScript 中，几乎每个常规对象都有一个内部隐式引用 [[Prototype]]（通常通过 __proto__ 暴露）。当代码尝试访问对象 obj.foo 时，V8 引擎首先在 obj 本身的自身属性（Own Properties）中查找。如果找不到，引擎指针会立即沿着 obj.__proto__ 向上回溯到 Object.prototype，直到检索到 null 为止。如果在原型上命中了属性 foo，引擎就会直接读取该值。
2. 无类型的属性动态扩展： JavaScript 对象的键值结构是开放式的。默认情况下，不仅普通对象可以随意挂载新属性，顶层原型 Object.prototype 同样是可写的。一旦某个操作修改了 Object.prototype，该修改会直接辐射到当前进程、当前执行上下文中的所有对象实例。

许多框架和实用工具库（如用于处理数据结构的 Lodash、Underscore，或处理参数绑定的中间件）封装了大量的通用逻辑，例如深拷贝（Deep Clone）、对象递归合并（Deep Merge）、路径取值赋值（set/get）。当这些库对外部传入的对象结构缺乏严格的键名过滤时，攻击者便能借助这套底层查找规则完成隐蔽的内存注入。

典型底层执行链路一：原型链污染（Prototype Pollution）的内存篡改全过程

原型链污染是 JavaScript 库中最经典的内存状态破坏型漏洞。为了更清晰地观察其在 V8 引擎中的物理执行轨迹，我们通过一个存在缺陷的通用对象合并函数（类似于历史版本 Lodash merge 或 jQuery extend 的基础模型）来复盘：

// 常见于库文件中的递归深度合并实现（存在漏洞）
function deepMerge(target, source) {
  for (let key in source) {
    if (source.hasOwnProperty(key)) {
      // 缺陷点：未过滤 "__proto__"、"constructor"、"prototype"
      if (typeof source[key] === 'object' && source[key] !== null) {
        if (!target[key]) {
          target[key] = {};
        }
        deepMerge(target[key], source[key]); // 递归调用
      } else {
        target[key] = source[key]; // 赋值执行
      }
    }
  }
  return target;
}

当攻击者通过 Web API 发送如下恶意的 JSON 负载（Payload）时：

// 攻击者发送的 JSON 字符串
'{"__proto__": {"isAdmin": true}}'

底层引擎执行调用栈的具体推进过程如下：

1. JSON 解析阶段（JSON.parse）： V8 引擎内置的快速 JSON 解析器在解析字符串时，会将 "__proto__" 仅仅当作一个普通的字符串键名保存在解析后的对象实例中，生成一个具有普通 Own Property "__proto__" 的字典对象。此时全局原型链尚未受到破坏。
2. 进入 deepMerge 第一次调用： 循环遍历 source 的键名，获取到 key = "__proto__"。函数执行属性访问：target["__proto__"]。
3. 关键底层跃迁（指针重定向）： 因为 target 本身并没有名为 "__proto__" 的 Own Property，所以引擎沿着原型链查找并触发了 Object.prototype 上的 __proto__ getter 访问器属性。getter 返回了 target 的原型引用——即真正的全局 Object.prototype。
4. 递归深入到第二层栈帧： 函数发起 deepMerge(Object.prototype, {"isAdmin": true})。此时目标指针 target 已经悄然从一个普通业务对象跃迁成了整个执行环境共用的 Object.prototype。
5. 赋值写入（Mutation）： 在第二层循环中，key = "isAdmin"。函数执行 target["isAdmin"] = true。由于此时 target 是 Object.prototype，引擎在全局顶层对象上创建了一个可枚举的自身属性 isAdmin: true。

至此，运行时的全局堆内存已被破坏。随后，代码中任何位置执行的新对象创建 const user = {}，一旦执行 if (user.isAdmin)，因 user 无自身属性，V8 会直接回溯到全局原型命中 true，导致原本需要超级管理员权限的操作被直接越权通行。

典型底层执行链路二：模板编译与虚拟 DOM 的执行流逃逸

在现代前端与服务端渲染（SSR）框架（如 Vue、React、Angular 以及通用模板库 Handlebars、EJS）中，另一类关键漏洞存在于编译期到执行期的转化管道中。框架为了追求极致性能，通常不会在运行时直接做纯文本的字符串正则替换，而是引入了编译流水线：

1. 词法分析与语法解析（Lexer & Parser）：将模板字符串切词并构建为抽象语法树（AST）；
2. 优化与静态标记（Optimizer）：标记静态节点与动态节点；
3. 代码生成（Codegen）：将 AST 编译为高执行效率的渲染函数（Render Function）；
4. 运行时求值与 VNode 挂载：通过 new Function() 或直接调用 Render 生成虚拟 DOM 并挂载至页面。

在这个执行过程中，漏洞的触发通常源于上下文混淆（Context Confusion）：框架将外部可控的“数据内容”错误地当成了“模板语法结构”进行解析。

1. AST 结构提升导致代码生成逃逸

以历史上的客户端模板注入（CSTI）或服务端模板注入（SSTI）为例，如果开发者将用户可控的字符串直接拼接进入框架的模板源文本中（例如在服务端直接用字符串拼接构建 Vue/Angular 模板）：

// 危险场景：未经过 AST 绑定的原始拼接
const rawTemplate = `<div>欢迎你，${userInput}</div>`;
const render = Vue.compile(rawTemplate);

当 userInput 传入普通文本 "张三" 时，解析器生成一个类型为 TextNode 的叶子节点。但如果传入包含模板闭合符的 Payload：

'{{_c.constructor("alert(document.domain)")()}}'

在底层的词法切词阶段，词法分析器（Lexer）扫描到双大括号标记 {{，立即将状态机从“纯文本字符状态”切换到“表达式状态”。原本应该作为纯文本子节点的 Payload，在 AST 阶段被提升成了一个具备求值语义的 ExpressionNode。

2. 代码生成阶段生成恶意执行闭包

在随后的 Codegen 阶段，编译器为 ExpressionNode 生成渲染代码。为了让表达式能访问组件的实例上下文，框架通常使用类似 with(this){ return ... } 或通过 new Function() 构造可执行闭包。表达式内部借助原型链上的 constructor 访问全局顶层构造函数 Function，从而彻底跳出框架预设的只读数据作用域，直接在全局 Window 或 Node.js 全局上下文中执行任意代码。

典型底层执行链路三：Node.js 服务端反序列化与动态求值执行

在 Node.js 服务端生态中，部分框架或中间件库（如早期的 node-serialize、serialize-javascript 等数据序列化库）为了还原复杂的 JavaScript 原生对象结构（例如支持反序列化 RegExp、Date 乃至函数闭包），在反序列化模块的底层直接引入了动态代码构建。

立即执行函数表达式（IIFE）的底层激发机制

当反序列化库扫描到一个带有特殊前缀（如 _$$ND_FUNC$$_）的序列化键值时，其内部的执行逻辑并非像处理纯数据那样填充字典，而是直接调用了底层解析：

// 序列化库的内部解构逻辑（存在致命缺陷）
if (value.startsWith('_$$ND_FUNC$$_')) {
  const funcBody = value.slice(12);
  // 致命点：直接使用 eval 执行动态拼接
  obj[key] = eval('(' + funcBody + ')');
}

如果攻击者精心构造一个末尾带有调用括号 () 的自执行函数（IIFE）：

'{"run": "_$$ND_FUNC$$_function(){ require('child_process').execSync('id'); }()"}'

在 V8 引擎解析这段传入 eval 的字符串时，立即将其解析为函数表达式的即时调用。无需等待下游业务代码调用 obj.run()，在 eval() 执行返回的这一毫秒内，Node.js 主事件循环上下文已经同步调用了 child_process.execSync，并在操作系统底层通过 fork/execve 系统调用唤起了一个独立的 Shell 进程。

总结：漏洞触发的核心条件与底层防范策略

梳理 JavaScript 框架与通用库漏洞的底层执行全过程，可以发现所有能够演变成高危利用的漏洞，都严格遵循一个“输入源（Source） → 危险转换器（Vulnerable Sink） → 运行时利用链（Gadget Chain）”的闭环模型：

针对底层的体系化防御手段

要彻底终结这些底层执行风险，单纯依靠黑名单过滤（如屏蔽 "__proto__"）通常容易被 "constructor.prototype" 绕过。最有效的方式是从语言底层切断漏洞赖以生存的物理环境：

• 消除原型继承依赖： 在需要存储外部键值映射的场景下，创建无原型对象 const cleanMap = Object.create(null)，或者直接使用 ES6 原生 Map 集合，从根源上消除 [[Prototype]] 回溯链条。
• 运行时顶层不可变冻结： 在系统启动初期执行 Object.freeze(Object.prototype)。一旦全局原型被冻结，任何试图写入新属性或修改现有属性的深拷贝操作都会在 V8 底层直接抛出 TypeError 异常或静默忽略，彻底封死原型污染路径。
• 严禁动态模板拼接与求值： 强制模板引擎在编译前执行严格的 AST 节点白名单校验，将模板与数据在语法分析阶段做物理隔离，严禁将未经验证的用户输入传入 new Function() 或 eval()。