JS逆向-JavaScript AST反混淆完全指南

猿榜
0 阅读8分钟

JavaScript AST反混淆完全指南

目录

一、JavaScript混淆与反混淆基础

1.1 什么是JavaScript混淆？

JavaScript混淆（Obfuscation）是一种代码保护技术，通过将可读的源代码转换为难以理解的形式，以达到以下目的：

  • 保护知识产权
  • 防止代码被轻易复制
  • 增加逆向工程的难度
  • 减小代码体积

1.2 常见的混淆技术

  1. 变量/函数名混淆

    • 将有意义的名称替换为无意义的字符串
    • 使用Unicode字符
    • 使用数字和特殊字符组合

  2. 字符串加密

    • 使用编码（Base64、Hex等）
    • 使用自定义加密算法
    • 使用字符编码转换

  3. 控制流扁平化

    • 将顺序执行的代码转换为switch-case结构
    • 使用状态机
    • 插入跳转指令

  4. 死代码注入

    • 插入无用代码
    • 添加虚假分支
    • 插入调试陷阱

1.3 反混淆的目的

反混淆（Deobfuscation）是将混淆后的代码还原为可读形式的过程，主要用于：

  • 安全分析
  • 恶意代码检测
  • 代码审计
  • 学习研究

二、AST基础概念

2.1 什么是AST？

AST（Abstract Syntax Tree，抽象语法树）是源代码的树形结构表示。它将代码分解为节点，每个节点代表代码中的一个语法结构。

2.2 AST节点类型

常见的AST节点类型包括：

  • Program：程序入口
  • VariableDeclaration：变量声明
  • FunctionDeclaration：函数声明
  • ExpressionStatement：表达式语句
  • Identifier：标识符
  • Literal：字面量
  • BinaryExpression：二元表达式

2.3 AST示例

var a = 1 + 2;

对应的AST结构：

VariableDeclaration
 └─ VariableDeclarator
     ├─ Identifier (a)
     └─ BinaryExpression (+)
         ├─ Literal (1)
         └─ Literal (2)

三、AST在反混淆中的应用

3.1 主要应用场景

  1. 变量名还原

    • 批量重命名无意义变量
    • 恢复有意义的命名

  2. 字符串解密

    • 识别解密函数
    • 执行解密操作
    • 替换为明文

  3. 控制流还原

    • 简化switch-case结构
    • 还原顺序执行
    • 删除无用分支

  4. 死代码清理

    • 识别无用代码
    • 删除无效分支
    • 优化代码结构

3.2 反混淆流程

  1. 解析（Parse）

    const parser = require('@babel/parser');
const ast = parser.parse(code);

  2. 遍历（Traverse）

    const traverse = require('@babel/traverse').default;
traverse(ast, visitor);

  3. 修改（Transform）

    const visitor = {
  Identifier(path) {
    // 修改节点
  }
};

  4. 生成（Generate）

    const generator = require('@babel/generator').default;
const output = generator(ast).code;

四、AST反混淆工具链

4.1 核心工具

  1. 解析器

    • acorn：轻量级解析器
    • esprima：功能丰富的解析器
    • @babel/parser：支持最新语法的解析器

  2. 遍历工具

    • estraverse：通用遍历工具
    • @babel/traverse：Babel生态的遍历工具

  3. 代码生成器

    • escodegen：通用代码生成器
    • @babel/generator：Babel生态的代码生成器

4.2 辅助工具

  1. 类型工具

    • @babel/types：AST节点类型工具
    • estree-walker：轻量级遍历工具

  2. 转换工具

    • @babel/transform：代码转换工具
    • jscodeshift：代码重构工具

五、@babel/traverse详解

5.1 核心概念

  1. 遍历（Traverse）

    • 按顺序访问AST节点
    • 支持深度优先遍历
    • 可控制遍历过程
    • 支持异步遍历
    • 支持自定义遍历顺序
    • 支持节点过滤

  2. 访问者（Visitor）

    • 定义节点处理逻辑
    • 支持进入/离开节点
    • 可访问节点上下文
    • 支持多节点类型处理
    • 支持节点状态管理
    • 支持作用域追踪

5.2 基本用法

const parser = require('@babel/parser');
const traverse = require('@babel/traverse').default;
const t = require('@babel/types');
const generator = require('@babel/generator').default;

// 解析代码
const code = `
  function add(a, b) {
    return a + b;
  }
`;
const ast = parser.parse(code);

// 基本遍历
const visitor = {
  Identifier(path) {
    console.log('发现标识符:', path.node.name);
  }
};

traverse(ast, visitor);

5.3 节点操作详解

  1. 节点替换

    // 替换单个节点
path.replaceWith(newNode);

// 替换多个节点
path.replaceWithMultiple([node1, node2]);

// 替换为表达式
path.replaceWith(t.identifier('newName'));

// 替换为函数调用
path.replaceWith(
  t.callExpression(
    t.identifier('newFunc'),
    [t.identifier('arg')]
  )
);

// 替换为条件表达式
path.replaceWith(
  t.conditionalExpression(
    t.identifier('condition'),
    t.identifier('trueExpr'),
    t.identifier('falseExpr')
  )
);

  2. 节点删除

    // 删除当前节点
path.remove();

// 删除父节点
path.parentPath.remove();

// 删除兄弟节点
path.getSibling(1).remove();

// 删除所有子节点
path.get('body').forEach(child => child.remove());

// 条件删除
if (shouldRemove(path.node)) {
  path.remove();
}

  3. 节点插入

    // 在当前节点前插入
path.insertBefore(newNode);

// 在当前节点后插入
path.insertAfter(newNode);

// 在数组开始处插入
path.unshiftContainer('body', newNode);

// 在数组末尾插入
path.pushContainer('body', newNode);

// 在特定位置插入
path.insertAt(index, newNode);

  4. 节点判断

    // 判断节点类型
path.isIdentifier();
path.isFunctionDeclaration();

// 判断节点属性
path.isIdentifier({ name: 'specificName' });

// 判断节点结构
path.isCallExpression({
  callee: {
    type: 'Identifier',
    name: 'specificFunc'
  }
});

// 判断节点上下文
path.isInType('FunctionDeclaration');
path.isAncestor(path);

5.4 作用域操作

  1. 变量声明

    // 在作用域中声明变量
path.scope.declareVariable('newVar');

// 检查变量是否已声明
path.scope.hasBinding('varName');

// 获取变量绑定
const binding = path.scope.getBinding('varName');

// 获取所有变量绑定
const bindings = path.scope.getAllBindings();

// 获取变量引用
const references = path.scope.getBinding('varName').references;

  2. 变量重命名

    // 重命名变量
path.scope.rename('oldName', 'newName');

// 生成唯一变量名
const newName = path.scope.generateUid('prefix');

// 重命名所有引用
path.scope.rename('oldName', 'newName', true);

// 重命名并保持引用关系
path.scope.rename('oldName', 'newName', false);

  3. 作用域管理

    // 创建新作用域
const newScope = path.scope.createChild();

// 获取父作用域
const parentScope = path.scope.parent;

// 获取根作用域
const rootScope = path.scope.getProgramParent();

// 检查作用域关系
path.scope.isGlobal();
path.scope.isBlock();

5.5 高级遍历技巧

  1. 条件遍历

    const visitor = {
  Identifier(path) {
    // 只处理特定名称的标识符
    if (path.node.name.startsWith('_0x')) {
      // 处理逻辑
    }
  }
};

  2. 递归遍历

    const visitor = {
  FunctionDeclaration(path) {
    // 递归遍历函数体
    path.traverse({
      Identifier(innerPath) {
        // 处理内部标识符
      }
    });
  }
};

  3. 异步遍历

    const visitor = {
  async Identifier(path) {
    // 异步操作
    const result = await someAsyncOperation(path.node);
    path.node.name = result;
  }
};

  4. 自定义遍历顺序

    const visitor = {
  Program: {
    enter(path) {
      // 自定义遍历顺序
      const body = path.get('body');
      for (let i = body.length - 1; i >= 0; i--) {
        body[i].traverse(visitor);
      }
    }
  }
};

  5. 节点过滤

    const visitor = {
  Identifier(path) {
    // 过滤特定节点
    if (!shouldProcess(path.node)) {
      path.skip();
    }
  }
};

5.6 实用工具方法

  1. 节点构建

    // 创建标识符
const id = t.identifier('name');

// 创建函数声明
const func = t.functionDeclaration(
  t.identifier('name'),
  [t.identifier('param')],
  t.blockStatement([
    t.returnStatement(t.identifier('param'))
  ])
);

// 创建变量声明
const varDecl = t.variableDeclaration('var', [
  t.variableDeclarator(t.identifier('name'), t.numericLiteral(1))
]);

// 创建对象表达式
const obj = t.objectExpression([
  t.objectProperty(
    t.identifier('key'),
    t.stringLiteral('value')
  )
]);

// 创建数组表达式
const arr = t.arrayExpression([
  t.stringLiteral('item1'),
  t.numericLiteral(2)
]);

  2. 节点克隆

    // 克隆节点
const clonedNode = t.cloneNode(originalNode);

// 深度克隆
const deepClonedNode = t.cloneDeep(originalNode);

// 克隆并修改
const modifiedClone = t.cloneNode(originalNode, true, {
  name: 'newName'
});

  3. 节点验证

    // 验证节点类型
t.isIdentifier(node);
t.isFunctionDeclaration(node);

// 验证节点属性
t.isIdentifier(node, { name: 'specificName' });

// 验证节点结构
t.isCallExpression(node, {
  callee: {
    type: 'Identifier',
    name: 'specificFunc'
  }
});

5.7 错误处理

  1. 异常捕获

    try {
  traverse(ast, visitor);
} catch (error) {
  console.error('遍历错误:', error);
  // 错误处理逻辑
}

  2. 节点验证

    const visitor = {
  Identifier(path) {
    try {
      // 节点操作
      if (!path.node.name) {
        throw new Error('无效的标识符名称');
      }
    } catch (error) {
      console.error('节点处理错误:', error);
    }
  }
};

  3. 错误恢复

    const visitor = {
  Identifier(path) {
    try {
      // 节点操作
    } catch (error) {
      // 错误恢复逻辑
      path.skip();
      console.warn('跳过问题节点:', error);
    }
  }
};

5.8 性能优化

  1. 选择性遍历

    const visitor = {
  // 只处理特定类型的节点
  Identifier(path) {
    if (path.node.name.startsWith('_0x')) {
      // 处理逻辑
    } else {
      // 跳过其他节点
      path.skip();
    }
  }
};

  2. 缓存优化

    const cache = new Map();

const visitor = {
  Identifier(path) {
    const name = path.node.name;
    if (cache.has(name)) {
      path.node.name = cache.get(name);
    } else {
      const newName = generateNewName(name);
      cache.set(name, newName);
      path.node.name = newName;
    }
  }
};

  3. 批量处理

    const nodesToModify = [];

const visitor = {
  Identifier(path) {
    if (shouldModify(path.node)) {
      nodesToModify.push(path);
    }
  }
};

traverse(ast, visitor);

// 批量修改
nodesToModify.forEach(path => {
  // 修改逻辑
});

  4. 并行处理

    const visitor = {
  async Identifier(path) {
    // 并行处理多个节点
    const promises = path.get('references').map(ref => 
      processNode(ref.node)
    );
    await Promise.all(promises);
  }
};

  5. 内存优化

    // 使用流式处理
const stream = require('stream');
const { Transform } = stream;

class ASTTransform extends Transform {
  constructor() {
    super({ objectMode: true });
  }
  
  _transform(chunk, encoding, callback) {
    // 处理AST块
    traverse(chunk, visitor);
    this.push(chunk);
    callback();
  }
}

六、实战案例

6.1 变量名还原

const code = `
  var _0x1a2b3c = 123;
  function _0x4d5e6f(_0x7a8b9c) {
    return _0x7a8b9c + _0x1a2b3c;
  }
`;

const ast = parser.parse(code);

traverse(ast, {
  Identifier(path) {
    if (path.node.name === '_0x1a2b3c') path.node.name = 'myVar';
    if (path.node.name === '_0x4d5e6f') path.node.name = 'addFunc';
    if (path.node.name === '_0x7a8b9c') path.node.name = 'param';
  }
});

6.2 字符串解密

const code = `
  var _0xabc = function(x) { return String.fromCharCode(x); };
  var str = _0xabc(72) + _0xabc(105);
`;

const ast = parser.parse(code);

traverse(ast, {
  CallExpression(path) {
    if (path.get('callee').isIdentifier({ name: '_0xabc' })) {
      const arg = path.get('arguments.0').node.value;
      const result = String.fromCharCode(arg);
      path.replaceWith(t.stringLiteral(result));
    }
  }
});

6.3 控制流还原

const code = `
  switch(idx) {
    case 0: doA(); break;
    case 1: doB(); break;
  }
`;

const ast = parser.parse(code);

traverse(ast, {
  SwitchStatement(path) {
    const cases = path.get('cases');
    const statements = [];
    
    cases.forEach(casePath => {
      statements.push(...casePath.get('consequent').map(p => p.node));
    });
    
    path.replaceWithMultiple(statements);
  }
});

七、高级技巧与最佳实践

7.1 性能优化

  1. 选择性遍历

    • 只遍历需要的节点类型
    • 使用path.skip()跳过无关节点

  2. 缓存优化

    • 缓存重复使用的值
    • 避免重复计算

  3. 批量处理

    • 收集需要修改的节点
    • 一次性进行修改

7.2 代码质量

  1. 错误处理

    try {
  traverse(ast, visitor);
} catch (error) {
  console.error('遍历出错:', error);
}

  2. 日志记录

    const visitor = {
  Identifier(path) {
    console.log(`处理标识符: ${path.node.name}`);
  }
};

  3. 测试用例

    describe('反混淆测试', () => {
  it('应该正确还原变量名', () => {
    // 测试代码
  });
});

八、常见问题与解决方案

8.1 常见问题

  1. 内存溢出

    • 原因：AST过大
    • 解决：分批处理，使用流式处理

  2. 性能问题

    • 原因：遍历次数过多
    • 解决：优化访问者逻辑，减少遍历次数

  3. 还原不完整

    • 原因：混淆技术复杂
    • 解决：结合多种工具，人工介入

  4. 工具选择

    • 根据需求选择合适的工具
    • 考虑工具的性能和兼容性

搜索框传播样式-白色版.png

avatar
文章
阅读
粉丝