基于AST的Python代码混淆技术详解<\/h1>

1. 概述<\/h2>
本文档详细介绍了基于抽象语法树（AST）的Python代码混淆技术，涵盖变量名混淆、属性名混淆和控制流混淆三个主要方面。通过操作AST节点实现代码保护，提高逆向工程难度。<\/p>

2. 变量名混淆<\/h2>

2.1 变量分类与识别<\/h3>

Python变量分为以下几类：<\/p>

内置变量（__builtins__<\/code>包含的）<\/li>
全局变量<\/li>
局部变量<\/li>

导入模块、方法<\/li>
<\/ul>
AST节点表示：<\/p>

读取变量：Name(id=xx, ctx=Load())<\/code><\/li>
设置变量：Name(id=xx, ctx=Store())<\/code><\/li>
<\/ul>
2.2 内置变量混淆方法<\/h3>
内置变量可通过xx in dir(__builtins__)<\/code>判断，混淆方式：<\/p>
# 方法1：直接重命名<\/span>
<\/span><\/span>obfname =<\/span> xx
<\/span><\/span>
<\/span><\/span># 方法2：使用getattr<\/span>
<\/span><\/span>obfname =<\/span> getattr(__builtins__, xx)
<\/span><\/span>
<\/span><\/span># 方法3：使用__dict__<\/span>
<\/span><\/span>__builtins__.<\/span>__dict__[obfname] =<\/span> __builtins__.<\/span>__dict__[xx]
<\/span><\/span><\/code><\/pre>后两种方法将变量以字符串形式表示，便于后续字符串混淆。<\/p>
2.3 导入变量混淆<\/h3>
导入变量有两种AST节点：Import<\/code>和ImportFrom<\/code><\/p>
ImportFrom节点处理（from xx import yy, zz, ...）<\/h4>

记录xx模块的所有导入项<\/li>
对之后出现的变量（不在内置、全局、局部变量中），如果在xx中，使用：
yy =<\/span> getattr(xx, yy)  # 进行导入<\/span>
<\/span><\/span><\/code><\/pre><\/li>
<\/ol>
2.4 全局变量与局部变量处理<\/h3>
通过是否进入FunctionDef<\/code>节点判断是否处于函数定义中：<\/p>


设置变量时<\/strong>：<\/p>

如果不在导入变量、内置变量之列，考虑全局或局部变量<\/li>
处于函数定义中：设置局部变量，否则为全局变量<\/li>
<\/ul>
<\/li>

读取变量时<\/strong>：<\/p>

依次检查是否为：导入变量 → 局部变量 → 全局变量 → 内置变量 → ImportFrom导入项<\/li>
<\/ul>
<\/li>
<\/ul>
2.5 特殊变量处理<\/h3>
For循环中的临时变量（i, k, v等）需要特殊处理，使用处理函数中局部变量的思路处理以下节点：<\/p>

ListComp<\/code><\/li>
DictComp<\/code><\/li>
SetComp<\/code><\/li>
For<\/code><\/li>
<\/ul>
3. 属性名混淆<\/h2>
3.1 基本混淆方法<\/h3>
对于属性名，可通过以下方式混淆：<\/p>
obfname =<\/span> xx.<\/span>yy
<\/span><\/span># 或<\/span>
<\/span><\/span>xx.<\/span>obfname =<\/span> xx.<\/span>yy
<\/span><\/span><\/code><\/pre>需要区分模块属性和类属性：<\/p>


模块属性混淆<\/strong>：<\/p>
xx.<\/span>__dict__[obfname] =<\/span> xx.<\/span>__dict__[yy]
<\/span><\/span><\/code><\/pre><\/li>

类属性混淆<\/strong>：<\/p>
gc.<\/span>get_referents(xx.<\/span>__dict__)[0<\/span>][obfname] =<\/span> gc.<\/span>get_referents(xx.<\/span>__dict__)[0<\/span>][yy]
<\/span><\/span><\/code><\/pre><\/li>
<\/ul>
3.2 Attribute节点处理<\/h3>
属性名混淆出现在访问Attribute<\/code>的AST节点，混淆定义需要出现在该节点之前。设置三个存储新AST节点的列表：<\/p>

builtin_attribute_nodes<\/code>：存储__builtins__<\/code>属性混淆的新节点<\/li>
class_attribute_nodes<\/code>：存储类属性混淆的新节点<\/li>
module_attribute_nodes<\/code>：存储模块属性混淆的新节点<\/li>
<\/ul>
3.3 不同value类型的处理<\/h3>
根据Attribute<\/code>节点的value类型采取不同策略：<\/p>


Name节点<\/strong>：<\/p>

模块是__builtins__<\/code>：以getattr<\/code>形式混淆<\/li>
属性是__dict__<\/code>：以getattr<\/code>形式混淆<\/li>
模块是导入变量：以__dict__<\/code>形式混淆<\/li>
类是内置变量：以get_referents<\/code>形式混淆<\/li>
其他情况：无法确定属性所属类（未做变量类型确定）<\/li>
<\/ul>
<\/li>

Constant\/List\/Dict节点<\/strong>：<\/p>

对应Python常见变量类型，可直接确定属性对应类<\/li>
以get_referents<\/code>形式混淆<\/li>
<\/ul>
<\/li>

Call节点<\/strong>：<\/p>

如果调用的函数未做返回值类型定义，无法确定属性所属类<\/li>
<\/ul>
<\/li>
<\/ol>
4. 控制流混淆<\/h2>
4.1 基本思路<\/h3>
基于OLLVM控制流混淆思路，在py2cfg和AST基础上实现：<\/p>

混淆单位为函数<\/li>
通过py2cfg获取每个函数的控制流图<\/li>
修改控制流结构，增加分析难度<\/li>
<\/ul>
4.2 基本块处理<\/h3>
对每个基本块进行以下操作：<\/p>

为每个块生成唯一ID（自定义随机数生成器），作为OLLVM中的switchVar<\/code><\/li>
对循环节点的基本块进行特殊处理<\/li>
<\/ol>
4.3 循环节点处理<\/h3>
4.3.1 循环头节点分析<\/h4>
判断循环头（While或For）的后继节点数量：<\/p>

一个后继节点：循环结束后无其他语句，生成含Return None<\/code>的后继基本块<\/li>
两个后继节点：第一个为循环体中第一个节点，第二个为循环结束的下一个节点<\/li>
<\/ul>
4.3.2 循环体分析<\/h4>
使用BFS搜索循环体中所有基本块：<\/p>

加入队列条件：非循环头节点、非循环结束的下一个节点、非遍历过的节点<\/li>
对于遍历到的节点：

循环体后仍有节点：后继节点为循环结束的下一个节点，则为break节点<\/li>
循环体后无节点：后继节点数为0且含Break语句，则为break节点<\/li>
<\/ul>
<\/li>
<\/ul>
4.3.3 break节点处理<\/h4>

含多条语句：删去break语句<\/li>
只有一条语句：删去该节点，将前驱节点连接到后续节点（保留条件跳转关系）<\/li>
<\/ul>
4.3.4 continue节点处理<\/h4>

识别：所有不在循环体中且为循环头节点的前驱节点<\/li>
处理方法与break节点相同<\/li>
<\/ul>
4.4 While循环处理<\/h3>
4.4.1 有条件While循环（判断为Compare节点）<\/h4>

生成If节点，条件与While节点相同<\/li>
复制While节点的跳转关系<\/li>
增加跳转：If节点 → 循环结束的下一个节点<\/li>
<\/ol>
4.4.2 无条件While循环（判断为永真式）<\/h4>


分析前驱节点：<\/p>

在循环体中：循环体中的最后一个节点<\/li>
不在循环体中：执行循环体前的节点<\/li>
<\/ul>
<\/li>

更新节点连接：<\/p>

删除：执行循环体前的节点 → While节点<\/li>
增加：执行循环体前的节点 → 循环体中第一个节点<\/li>
删除：While节点 → 循环体中第一个节点<\/li>
删除：循环体中的最后一个节点 → While节点<\/li>
增加：循环体中的最后一个节点 → 循环体中的第一个基本块<\/li>
<\/ul>
<\/li>
<\/ol>
4.5 For循环处理<\/h3>
将for循环改为iter + next + if + break<\/code>的形式：<\/p>


分析前驱节点：<\/p>

在循环体中：循环体中的最后一个节点<\/li>
不在循环体中：执行循环体前的节点<\/li>
<\/ul>
<\/li>

生成新节点：<\/p>

iter<\/code>节点：iter_var = iter(for_iter)<\/code><\/li>
next<\/code>节点：step_var = next(iter_var, None)<\/code><\/li>
if<\/code>节点：if step_var is not None<\/code><\/li>
assign<\/code>节点：for_target = step_var<\/code><\/li>
<\/ul>
<\/li>

更新节点连接：<\/p>

删除：循环体中的最后一个节点 → 循环头节点<\/li>
增加：循环体中的最后一个节点 → iter节点<\/li>
增加：iter节点 → next节点<\/li>
增加：next节点 → if节点<\/li>
增加：if节点 → assign节点（跳转条件为if节点自身）<\/li>
增加：if节点 → 循环结束的下一个节点（跳转条件与if节点自身相反）<\/li>
增加：assign节点 → 循环体中第一个节点<\/li>
删除：循环体中的最后一个节点 → 循环头节点<\/li>
增加：循环体中的最后一个节点 → next节点<\/li>
<\/ul>
<\/li>
<\/ol>
4.6 控制流混淆实现<\/h3>


生成Assign语句，为switchVar赋初始值<\/p>
<\/li>

生成结束循环的if-break语句，作为逻辑结束点<\/p>
<\/li>

构建无限循环体：<\/p>

遍历函数的每一个基本块<\/li>
根据后继节点数处理不同情况：

后继节点数为0：...<\/li>
后继节点数为1：...<\/li>
后继节点数为2：if的两个分支跳转条件与节点条件跳转关系相同<\/li>
<\/ul>
<\/li>
<\/ul>
<\/li>

将新的If节点加入到循环体中<\/p>
<\/li>

Assign语句和无限循环体构成函数的新逻辑<\/p>
<\/li>

直接在FunctionDef的AST节点中替换新逻辑<\/p>
<\/li>
<\/ol>
5. 总结<\/h2>
本文详细介绍了基于AST的Python代码混淆技术，包括：<\/p>

变量名混淆<\/strong>：通过识别不同类型变量并采用相应混淆策略<\/li>
属性名混淆<\/strong>：区分模块属性和类属性，根据value类型采取不同混淆方法<\/li>
控制流混淆<\/strong>：基于OLLVM思路，重构函数控制流，增加分析复杂度<\/li>
<\/ol>
这些技术通过操作AST节点实现，能有效提高代码的逆向工程难度，保护知识产权。实际应用中需根据具体需求选择合适的混淆策略和强度。<\/p>

基于AST的Python代码混淆技术详解<\/h1>

1. 概述<\/h2> 本文档详细介绍了基于抽象语法树（AST）的Python代码混淆技术，涵盖变量名混淆、属性名混淆和控制流混淆三个主要方面。通过操作AST节点实现代码保护，提高逆向工程难度。<\/p>

2. 变量名混淆<\/h2>

2.3 导入变量混淆<\/h3> 导入变量有两种AST节点：Import<\/code>和ImportFrom<\/code><\/p>

3. 属性名混淆<\/h2>

4. 控制流混淆<\/h2>

4.3 循环节点处理<\/h3>

4.4 While循环处理<\/h3>

1. 概述<\/h2>
本文档详细介绍了基于抽象语法树（AST）的Python代码混淆技术，涵盖变量名混淆、属性名混淆和控制流混淆三个主要方面。通过操作AST节点实现代码保护，提高逆向工程难度。<\/p>

2.3 导入变量混淆<\/h3>
导入变量有两种AST节点：`Import<\/code>和ImportFrom<\/code><\/p>`