# 一、CFG的构建

## 1. `createGraphNode` - 图节点创建核心
```javascript
function createGraphNode(nodeGraph, astNode, fromPc, type) {
  const node = {
    astNode: astNode,            // 关联的AST语法节点
    fromPc,                     // 对应的程序计数器位置
    postNodes: [],              // 后继节点索引数组
    index: nodeGraph.length,    // 当前节点在nodeGraph中的索引
    type                        // 节点类型("direct"顺序/"jump"跳转等)
  };
  nodeGraph.push(node);
  return node;
}
```
**目的**：为每条语句或表达式创建图节点，承载控制流信息

## 2. `getBlockAst` - 构建入口及整体流程
```javascript
function getBlockAst(startPc, noProxystack, blockEndPc, stackTop) {
  const nodeGraph = [];          // 存储语句节点
  const pcNodeMap = new Map();   // 记录PC对应的图节点
  const enterNode = createGraphNode(nodeGraph, t.emptyStatement(), startPc);
  
  // 递归构建控制流图
  traverseLinkNode(startPc, noProxystack, enterNode, stackTop);
  //后续进行代码结构的还原
  const blockAst = convertBlockAst(nodeGraph, enterNode);
  return blockAst;
}
```
**参数说明**：
- `startPc`：字节码起始地址
- `noProxystack`：操作栈
- `blockEndPc`：代码块结束地址
- `stackTop`：当前栈顶指针位置

## 3. `traverseLinkNode` - 递归构建
代码:
```javascript
  function traverseLinkNode(pc, noProxystack, preNode, stackTop) {
    //每个pc的访问都需要创建一个空节点,用做节点的连接。
    const firstNode = createGraphNode(nodeGraph, t.emptyStatement(), pc);
    //把空语句节点连接前节点的后驱,并让前节点引用指向当前节点
    preNode.postNodes.push(firstNode.index);
    preNode = firstNode;
    if (pc >= blockEndPc) {
      return;
    }
    var startPc = pc;
    var breakFlag = false;
    function handlerForAstList() {
    }
    function createProxyStack(noProxystack) {
      return new Proxy(noProxystack, handlerForStack());
    }
    function handlerForStack() {
    }
    const proxyStack = createProxyStack(noProxystack);
    var astList = [];
    const proxyAstList = new Proxy(astList, handlerForAstList());
    const visNode = pcNodeMap.get(pc);
    if (visNode) {
      preNode.postNodes.push(visNode.index);
      return;
    }
    pc = excuteInstruction(pc, proxyStack, proxyAstList);
    pcNodeMap.set(startPc, firstNode);
    if (breakFlag || pc >= blockEndPc) {
      return;
    }
    traverseLinkNode(pc, noProxystack, preNode, blockEndPc, stackTop);
    function excuteInstruction(pc, valueStack, astList) {
    }

    const blockAst = convertBlockAst(nodeGraph, enterNode, fucCount);//后续进行控制流还原
    return blockAst;
  }
```
### 3.1 创建空节点并连边
```javascript
const firstNode = createGraphNode(nodeGraph, t.emptyStatement(), pc);
preNode.postNodes.push(firstNode.index);
preNode = firstNode;
```
**作用**：每次递归入口创建空节点
### 3.2 结束条件
```javascript
if (pc >= blockEndPc) {
  return;
}
```
**作用**：超过块范围时停止递归

### 3.3 代理astList自动建图节点
```javascript
const proxyAstList = new Proxy(astList, {
  get(target, prop, receiver) {
    if (prop === 'push') {
      return (astNode, type) => {
        const cloneAstNode = t.cloneNode(astNode);
        const node = createGraphNode(nodeGraph, cloneAstNode, startPc, type || "direct");
        preNode.postNodes.push(node.index);
        preNode = node;
        if (t.isReturnStatement(astNode) || t.isThrowStatement(astNode)) {
          breakFlag = true;  // 遇到终止语句停止递归
        }
        return node;
      };
    }
    return Reflect.get(target, prop, receiver);
  }
});
```
**功能**：
- 所有推入astList的AST节点自动生成图节点
- 遇到return/throw语句设置breakFlag停止后续递归遍历

### 3.4 代理执行栈自动生成变量声明
```javascript
const proxyStack = new Proxy(noProxystack, {
  set(target, prop, value, receiver) {
    if (!isNaN(prop)) {
      if (t.isNode(value)) {
        const id = t.identifier(`temp${prop}`);
        const assignStmt = t.variableDeclaration("let", [
          t.variableDeclarator(id, value)
        ]);
        const node = proxyAstList.push(assignStmt);
        value = id;
      }
      return Reflect.set(target, prop, value, receiver);
    }
  }
});
```
**功能**：执行栈写入AST节点时自动生成临时变量声明语句

### 3.5 避免重复递归
```javascript
const visNode = pcNodeMap.get(pc);
if (visNode) {
  preNode.postNodes.push(visNode.index);
  return;
}
```
**作用**：访问已处理节点时直接连接，防止重复生成和死循环

## 4. `excuteInstruction` - 指令执行模拟，每个网站的vmp不同的部分
```javascript
function excuteInstruction(pc, valueStack, astList) {
  const instructionCode = instruction[pc++];
  switch (instructionCode) {
    // 算术指令示例
    case 0: 
      // 原:
      // valueStack[stackTop] = valueStack[stackTop] + valueStack[stackTop - 1];

      // 实际AST构造
      valueStack[stackTop] = t.binaryExpression(
        "+", 
        valueStack[stackTop], 
        valueStack[stackTop - 1]
      );
      break;
    
    // 条件跳转指令示例
    case 1:
      //原:
      // const gotoValue = instruction[pc++];
      // valueStack[stackTop] && pc + gotoValue;
      // break;

      //实际处理:
      const gotoValue = instruction[pc++];
      const test = valueStack[stackTop];
      proxyAstList.push(test);  // 自动创建条件节点
      
      // 克隆当前栈状态
      const ifTrueStack = shallowCloneArray(noProxystack);
      const ifFalseStack = shallowCloneArray(noProxystack);
      
      // 递归处理两个分支
      traverseLinkNode(pc + gotoValue, ifTrueStack, preNode, stackTop);
      traverseLinkNode(pc, ifFalseStack, preNode, stackTop);
      breakFlag = true;
      break;
  }
  return pc;
}
```
**功能**：
- 普通指令：构建一个ast表达式模拟指令的操作
- 跳转指令：递归遍历分支路径构建完整语句图节点

## 5. 构建结构化代码块
```javascript
const blockAst = convertBlockAst(nodeGraph, enterNode);
```
**作用**：将语句图交给后续的还原模块,生成结构化代码块。

## 6. 结果图实例

![image.png](/static/img/ded45738fa0c7cbb8be177e86e161c74.image.webp)

**可以看到每一个代码语句或表达式都是图中的一个节点，并且正确构建了连接关系**
# 二、SSA的转化与代码结构还原
详细见http://dtt666.com/post/3




jsVmp还原框架(通用思路+可复用代码)

## 🧱 控制流图节点结构转化

首先将原始的控制流图节点结构进行转换，方便后续进行分析：

原始节点格式如下：

```js
const node = {
    astNode: astNode,  // AST 语法节点
    postNodes: [],     // 后继节点在 nodeGraph 中的索引列表
    index: nodeGraph.length, // 当前节点在 nodeGraph 中的位置
};
```

转换后的目标块结构如下：

```js
{
    index: 0,                         // 当前块编号（唯一）
    type: "direct" | "condBranch",   // 块类型：顺序执行 or 条件分支
    astNodes: [],                    // 所包含的 AST 节点（通常是一组语句）
    entryCond: null,                 // 如果是条件块，记录条件表达式（Babel AST 节点）

    directNext: null,                // 顺序块的下一跳 index
    trueBranch: null,                // 条件为 true 跳转的块 index（条件块专用）
    falseBranch: null,               // 条件为 false 跳转的块 index（条件块专用）

    predecessors: [],                // 所有前驱块 index 列表
    successors: [],                  // 所有后继块 index 列表
}
```

---

使用如下步骤完成转化：

```js
updatePreNodes(nodeGraph, enterNode.index);      // 更新每个节点的前驱信息
processEmptyStatement(nodeGraph);                // 去除无效或空语句节点
const { blocks, enterIndex } = buildControlFlowBlocks(nodeGraph, enterNode.index);
```

- `buildControlFlowBlocks` 的核心作用是将一组顺序执行的语句合并到一个逻辑块（基本块），便于后续分析。

---

## 🔁 SSA 构建完整流程

主函数如下：

```js
/**
 * 构建并拆解 SSA 的主函数
 * @param {Array} blocks - 控制流图块列表（基本块）
 * @param {number} entry - 入口块索引（默认 0）
 */
function buildAndDestructSSA(blocks, entry = 0) {
    // Step 1: 计算支配关系
    const Dom = computeDominators(blocks, entry);          // 所有块的支配集合
    const idoms = computeImmediateDoms(Dom, blocks);       // 每个块的最近支配者（iDom）
    const domChildren = buildDomChildren(idoms);           // 支配树子节点映射

    // Step 2: 计算支配前沿（dominance frontier）
    const DF = computeDomFrontier(blocks, Dom);

    // Step 3: 收集变量的定义位置
    const defSites = collectDefSites(blocks);              // defSites: 变量 -> 块索引数组

    // Step 4: 活跃性分析
    computeFullLiveness(blocks);                           // 分析每个块中变量的 live-in/live-out

    // Step 5: 插入 φ 函数
    insertPhi(blocks, DF, defSites);                       // 在 DF 上插入 φ 节点

    // Step 6: 进行 SSA 重命名（核心：唯一化变量版本）
    renameSSA(blocks, entry, domChildren);

    // Step 7: 拆解 φ 函数为真实赋值
    const idomsForDestruct = idoms;
    destructPhiAndInsertBlocks({ blocks }, idomsForDestruct);
}
```

## 代码控制流结构还原
```js
/**
 * 从 CFG 结构化生成 AST，支持 while + break/continue
 */
function decompileCFGWithLoops(blocks, enter, loops) {
    const postDom = computePostDominators(blocks);
    function findNearestCommonPostDominator(n, m) {
        const sN = postDom[n], sM = postDom[m];
        const common = [...sN].filter(x => sM.has(x));
        if (!common.length) return null;
        common.sort((a, b) => postDom[b].size - postDom[a].size);
        return common[0];
    }

    const loopsByHead = new Map(loops.map(l => [l.head, l]));

    function region(cur, stop, currentLoop) {
        const stmts = [];

        while (cur != null && cur !== stop) {
            const blk = blocks[cur];
            // 循环头
            if (loopsByHead.has(cur) && (!currentLoop || currentLoop.head !== cur)) {
                const loop = loopsByHead.get(cur);
                const bodyStmts = region(loop.head, loop.exit, loop);
                stmts.push(t.whileStatement(t.booleanLiteral(true), wrapNodesInBlockStatement(bodyStmts)));
                cur = loop.exit;
                continue;
            }
            // 条件分支
            if (blk.type === 'condBranch') {
                const [t0, f0] = blk.successors;
                const merge = findNearestCommonPostDominator(t0, f0);
                const thenStmts = [];
                const elseStmts = [];
                // 处理 then 分支
                if (currentLoop) {
                    if (t0 === currentLoop.exit) {
                        thenStmts.push(t.breakStatement());
                    } else if (t0 === currentLoop.head) {
                        thenStmts.push(t.continueStatement());
                    } else {
                        thenStmts.push(...region(t0, merge, currentLoop));
                    }
                } else {
                    thenStmts.push(...region(t0, merge, currentLoop));
                }
                // 处理 else 分支
                if (currentLoop) {
                    if (f0 === currentLoop.exit) {
                        elseStmts.push(t.breakStatement());
                    } else if (f0 === currentLoop.head) {
                        elseStmts.push(t.continueStatement());
                    } else {
                        elseStmts.push(...region(f0, merge, currentLoop));
                    }
                } else {
                    elseStmts.push(...region(f0, merge, currentLoop));
                }
                // 生成 if
                stmts.push(...blk.astNodes);
                stmts.push(
                    t.ifStatement(
                        blk.entryCond,
                        wrapNodesInBlockStatement(thenStmts),
                        elseStmts.length ? wrapNodesInBlockStatement(elseStmts) : null
                    )
                );
                cur = merge;
                continue;
            }
            // 直接跳转
            stmts.push(...blk.astNodes);
            const nxt = blk.directNext;
            if (currentLoop) {
                if (nxt === currentLoop.exit) { stmts.push(t.breakStatement()); return stmts; }
                if (nxt === currentLoop.head) { stmts.push(t.continueStatement()); return stmts; }
            }
            cur = nxt;
            continue;
        }
        return stmts;
    }

    return region(enter, null, null);
}

```


:::info{title="可以看到反编译的代码都变成了静态单赋值形式，接下来要进行中间变量的合并，以消除代码行数，以及可以对代码进行的各种优化"}

:::
![image.png](/static/img/4acc5a520e2bb8a2c7563bb6fa0c7670.image.webp)

后续更新啦



SSA的转化与代码结构还原

# 一. 构建ast节点
:::note{title="思路"}
**hook栈，如果对栈数组某个位置进行赋值，就生成一个用临时变量接收这个值的赋值语句，并生成一个GraphNode节点，并正确连接后驱节点关系，以便后续建立CFG结构还原控制流**
:::
![image.png](/static/img/ea1f6209937c379464bcfce29599d4b0.image.webp)

![image.png](/static/img/18ec0b705eac921dbb7eabfd6f42c39f.image.webp)

![image.png](/static/img/a651f570489f05d09693d16b6d8ae59e.image.webp)

## 1. 闭包函数的创建
第一步找到vmp模拟函数闭包的创建的逻辑。因为我们还原最大的单位是方法，然后是语句，控制流。
腾讯的vmp非常清晰，E变量为pc指针，C指令集，w为栈和堆，也就是每次执行指令的中间值和变量储存的位置都是w。我们需要区分变量和中间值。腾讯用于存储变量的值，是以一个长度为1的数组进行包裹，变量的储存空间为这个数组的0索引，这样就可以把变量存储空间的引用传给新建的闭包函数，以便在闭包函数访问和修改。
![db75e493aaf11626fbac8f300d9d0c2.png](/static/img/a2b83ea89e5a3de8ba6741ece5e1bc2f.image.webp)
图中1处解析：首先闭包函数需要一个栈和堆空间，为图中的A变量。然后把父函数，也就是创建闭包函数的函数中的变量传递给闭包函数。


图中2处解析：初始化闭包函数的变量，K[0]为函数创建上下文this，K[1]为调用闭包函数的参数列表,[2]为闭包函数本身。

图中3处解析: 初始化调用闭包函数的每一个参数，相当于把每一个参数作为闭包函数里的var变量。
所以我们可以改写这个case函数。

![image.png](/static/img/90983f9eb32165da780bbaedfee52099.image.webp)
push创建的闭包函数的ast到栈里。
![image.png](/static/img/072e22882fd071bbe0c8c263945a3406.image.webp)
genarateFucAst方法调用getBlockAst方法dump出方法的所有语句。
![](http://dtt666.com:8080/static/img/4a5f4131d8d9f3e9af38336cad238b2b.image.webp)
## 2. try-tatch的处理
try-catch的处理：需要注意的是try和catch的汇合点的寻找。
![image.png](/static/img/ba59c2c18a3ee2e11aecb0f23e060a38.image.webp)
## 3. 跳转指令的处理
![image.png](/static/img/7a31d6aa1bace4ac2cecca7b9b6fea38.image.webp)
## 4. 最后得到nodeGrapth
nodeGrapth保存每一个语句节点，和语句节点之间的后驱关系。
![image.png](/static/img/c9698772e1d470c5307bac5884c39110.image.webp)
# 二.SSA转化和还原代码结构
详细见http://dtt666.com/post/3
# 三.反编译的代码正确性验证
1.直接把还原的代码替换掉原网站原本的vmp，可以正确运行并生成加密参数

2.浏览器直接调用vmp中的加密方法，结果与原vmp一致

原vmp结果：

![34e5d132ae97b7f773d82ea2a7e71b9.png](/static/img/ab746e43dea862ef105498ca040cd10e.34e5d132ae97b7f773d82ea2a7e71b9.webp)

![image.png](/static/img/4b30f881821cd326aaf82eddcd9cf7a5.image.webp)

反编译的vmp结果：

![d5ed7feab9147d77d9b924bb3e00102.png](/static/img/6a2703f44b4caafd88609c90a36ac775.d5ed7feab9147d77d9b924bb3e00102.webp)

![image.png](/static/img/5e00214d8ce877699edf01a68a029764.image.webp)



一、CFG的构建

1. createGraphNode - 图节点创建核心

🧱 控制流图节点结构转化

一. 构建ast节点

1. `createGraphNode` - 图节点创建核心