深入解析LLVM代码混淆技术:从基本块分割到控制流混淆的实现原理
先知防再学攻。本篇文章针对OLLVM进行详细解析,旨在让读者在逆向过程中遇到此类情形不会迷茫。后续会针对此类问题提出相应的解决方案。
基本块分割
什么是基本块分割?
基本块分割即将一个基本块分割为等价的若干个基本块,在分割后的基本块之间加上无条件跳转。(通俗理解为,本来一句话解释清的事情,非要添油加醋废话连篇。类比营销号。)
注意:基本块分割不能算是混淆,但是可以提高某些代码混淆的混淆效果。
为何要使用基本块分割?
在许多基于基本块的代码混淆中,基本块数量越多,代码混淆后的复杂度越大。通过增加基本块的数量,可以到达提高混淆效果的目的。
未经过基本块分割的虚假控制流:
经过基本块分割的虚假控制流:
如何实现基本块分割?
遍历每个函数中的每个基本块,对每个基本块进行分割。注意,有 PHI 指令的基本块我们选择暂时跳过。如之前LLVM文章所说,PHI指令计算结果是根据PHI指令所在代码块的前驱块所决定的。如下两图所示,代码块经过分割后phi指令将无法识别前驱块。
当然,如何操作PHI指令的代码块分割,将在后续慢慢讲解。
基本块分割API
额外参数指定
在 LLVM 中,可以通过 cl::opt 模板类获取指令中的参数,这里的 cl是clang的意思,opt 是选项 option 的缩写,不是优化器的意思。
#include "llvm/Support/CommandLine.h"
// 可选的参数,指定一个基本块会被分裂成几个基本块,默认值为 2
static cl::opt<int> splitNum("split_num", cl::init(2), cl::desc("Split <split_num> time(s) each BB"));splitBasicBlock 函数
splitBasicBlock 函数是 BasicBlock 类的一个成员函数。在BasicBlock.h 头文件里可以看到这个函数的两种用法。
isa<> 函数
isa<> 是一个模板函数,用于判断一个指针指向的数据的类型是不是给定的类型,类似于 Java 中的 instanceof。可以用来判断是否属于PHI类型的指令。
理论成立,实践开始
沿用上一章的vscode文件夹,在src目录下新建SplitBasicBlock.cpp,并且为了雅观,在Test目录下新建IR和BIN两个文件夹。代码如下,我都添加了注释,方便理解:
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/IR/Instructions.h"
#include <vector>
#include "SplitBasicBlock.h"
using std::vector;
using namespace llvm;
// 可选的参数,指定一个基本块会被分裂成几个基本块,默认值为 2,使用前需要引用 #include "llvm/Support/CommandLine.h"
static cl::opt<int> splitNum("split_num", cl::init(2), cl::desc("Split <split_num> time(s) each BB"));
namespace{
class SplitBasicBlock : public FunctionPass{
public:
static char ID;
SplitBasicBlock() : FunctionPass(ID){};
bool runOnFunction(Function & F);
// 对单个基本块执行分裂操作
void split(BasicBlock *BB);
//判断一个基本块中是否包含 PHI指令(PHINode)
bool containsPHI(BasicBlock *BB);
};
}
//todo
bool SplitBasicBlock::runOnFunction(Function & F){
// 第一步:保存原先的所有基本块
//使用vector前需要引用
vector<BasicBlock*> origBB;//对函数中的基本块进行分割操作,会导致遍历的基本块数量增加,为防止出现报错,先缓存到vector容器中,再进行遍历。
for(BasicBlock &BB : F){
origBB.push_back(&BB);
}
// 第二步:对每个不包含 PHI 指令的基本块执行分裂操作
for(BasicBlock *BB : origBB){
if(!containsPHI(BB)){//判断是否含有PHI指令
split(BB);
}
}
return true;
}
bool SplitBasicBlock::containsPHI(BasicBlock *BB){
for(Instruction &I : *BB){
if(isa<PHINode>(&I)){//模板函数判断是否为PHI指令
return true;
}
}
return false;
}
void SplitBasicBlock::split(BasicBlock *BB){
// 计算分裂后每个基本块的大小
// 原基本块的大小 / 分裂数目(向上取整)
int splitSize = (BB->size() + splitNum - 1) / splitNum;//比如,7条指令,分裂3次,则每个分裂块长度为3
BasicBlock *curBB = BB;//存储当前操作的基本块位置
for(int i = 1;i < splitNum;i ++){
int cnt = 0;//计数变量
for(Instruction &I : *curBB){
if(cnt++ == splitSize){//cnt = 3
// 在 I 指令处对基本块进行分割
curBB = curBB->splitBasicBlock(&I);
break;
}
}
}
}
FunctionPass* llvm::createSplitBasicBlockPass(){
return new SplitBasicBlock();
}
//初始化ID并注册
char SplitBasicBlock::ID = 0;
static RegisterPass<SplitBasicBlock> X("split","Split Basic Blcok is OK.");解释一下SplitBasicBlock.h。
我们在 llvm 命名空间里添加一个函数 FunctionPass* createSplitBasicBlockPass(); 。
这个函数将在 SplitBasicBlock.cpp 里实现。
这样的话其他 LLVM Pass 就可以通过引入头文件 SplitBasicBlock.h ,调用。
createSplitBasicBlockPass 函数来创建一个 SplitBasicBlock Pass,完成基本块的分割。
//SplitBasicBlock.h
#ifndef _SPlit_Basic_Block_//防止头文件被重复使用
#define _SPlit_Basic_Block_//防止头文件被重复使用
#include "llvm/IR/Function.h"
#include "llvm/Pass.h"
namespace llvm{
FunctionPass* createSplitBasicBlockPass();
}
#endif//防止头文件被重复使用// SplitBasicBlock.cpp实现
FunctionPass* llvm::createSplitBasicBlockPass(){
return new SplitBasicBlock();
}之后在CMakeLists.txt声明Pass源代码src/SplitBasicBlock.cpp
最后在test.sh添加需要使用的命令,上一章详细讲过,这里便不再赘述:
cd ./Build
cmake ../Transforms
make
cd ../Test
clang -S -emit-llvm TestProgram.cpp -o IR/TestProgram.ll
opt -load ../Build/LLVMObfuscator.so -split -S IR/TestProgram.ll -o IR/TestProgram_split.ll
clang IR/TestProgram_split.ll -o BIN/TestProgram_split
./BIN/TestProgram_split效果如下:
值得一提的是,如果你单纯把基本块进行分割,IDA在识别的时候,会自动清理,这也是为什么说基本块分割只是用来辅助代码混淆的。
代码混淆
代码混淆是将计算机程序的代码,转换成一种功能上等价,但是难以阅读和理解的形式的行为。
混淆前
混淆后
代码混淆设计很多前置知识,我们先对于基本概念进行查缺补漏。
函数
函数是代码混淆的基本单位,一个函数由若干个基本块组成,有且仅有一个入口块,可能有多个出口块。
一个函数可以用一个控制流图(Control Flow Graph, CFG)表示。
基本块
基本块由一组线性指令组成,每一个基本块都有一个入口点(第一条执行的指令)和一个出口点(最后一条执行的指令,亦即终结指令)。
终结指令要么跳转到另一个基本块(br, switch),要么从函数返回(ret)。
控制流
控制流代表了一个程序在执行过程中可能遍历到的所有路径。 通常情况下,程序的控制流很清晰地反映了程序的逻辑,但经过混淆的控制流会使得人们难以分辨正常逻辑。
可以用小时候做过的数学题来辅助理解。
小明到学校的一条路线即为一条控制流,混淆前逻辑清楚,混淆后则不好分辨。
不透明谓词
不透明谓词指的是其值为混淆者明确知晓,而反混淆者却难以推断的变量。谓词简单来说就是在原程序中某个位置插入一个if分支。
分类:
永远为真或者永远为假
可以为真或假
例子:
#include <cstdio>
int x=0;
int main(){
if(x<0){
printf("yeah!yeah!yeah!\n");
}else{printf("NB666!\n");
}
}转换成二进制文件使用IDA进行反编译,则IDA无法识别出来x变量的值,那么x对于IDA来说便是个不透明谓词。
例如y > 10 || x * (x + 1) % 2 == 0这个不等式,大家都知道x * (x + 1) % 2 == 0这个式子是恒成立的,因此刚才这个不等式是恒成立的,当然这是我们知道,而IDA就不知道了,IDA不确定x,y的值,因此无法识别出来,因此就可以增加虚假控制流。
常见混淆思路
符号混淆
将函数的符号,如函数名、全局变量名去除或者混淆。对于 ELF 文件可以通过 strip 指令去除符号表完成。
混淆前
混淆后
控制流混淆
控制流混淆指的是混淆程序正常的控制流,使其在功能保持不变的情况下不能清晰地反映原程序的正常逻辑。
混淆前
混淆后
计算混淆
计算混淆指的是混淆程序的计算流程,或计算流程中使用的数据,使分析者难以分辨某一段代码所执行的具体计算。
混淆前
混淆后
虚拟机混淆
虚拟机混淆的思想是将一组指令集合(如一组 x86 指令),转化为一组攻击者未知的自定义指令集。并用与程序绑定的解释器解释执行。虚拟机混淆代表:VMProtect。 虚拟机混淆是目前最强力的混淆,但也有许多缺点:如性能损耗大、容易被杀毒软件报毒等。所以一般不会使用。
OLLVM 环境搭建
Obfuscator-LLVM(简称OLLVM)是2010年6月由瑞士西部应用科学大学(HEIG-VD)的信息安全小组发
起的一个项目。 这个项目的目的是提供一个 LLVM 编译套件的开源分支,能够通过代码混淆和防篡改提
供更高的软件安全性。
OLLVM 在国内移动安全的使用非常广泛,虽然 OLLVM 已于2017年停止更新,并且到目前为止,三种
代码混淆方式均已有成熟的反混淆手段 。但是 OLLVM 的各种变体仍然在被开发和使用(如王者荣耀的 某个so文件),OLLVM 至今仍有很大的学习价值。
前辈说过,在Ubuntu上直接配置OLLVM环境,你会报错到想上吊,于是乎前辈推荐使用Docker容器进行OLLVM源代码的编译。
gcc8 g++8 camke 安装
安装camke
sudo apt-get install cmake -y安装gcc-8 g++8
sudo apt-get install gcc-8 g++-8 -ygit LLVM源码
git clone -b llvm-4.0 https://github.com/obfuscator-llvm/obfuscator.gitollvm目录/include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h进行源码修改,把char修改为uint8_t,在此前请给该文件chmod 777权限
编译安装
//在源码同级目录中
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_INCLUDE_TESTS=OFF ../obfuscator/
make -j8
sudo make install检验
//检验llvm和clang是否安装成功
clang --version检验OLLVM使用
在桌面建立test文件夹,在文件夹中新建test.cpp,其中代码自定义即可,如下代码来自网络:
#include <stdio.h>
#include <stdlib.h>
int encryptFunc(int inputNum_1,int inputNum_2){
int tmpNum_1 = 666, tmpNum_2 = 888, tmpNum_3 = 777;
return tmpNum_1 ^ tmpNum_2 + tmpNum_3 * inputNum_1 - inputNum_2;
}
int main(int argc,char *argv[]){
int printNum = 55;
if (argc > 1)
{
printNum = encryptFunc(printNum, atoi(argv[1]));
}else{
printNum = encryptFunc(printNum, argc);
}
printf("Hello OLLVM %d\r\n", printNum);
return 0;
}OLLVM 基本用法
控制流平坦化(Control Flow Flattening)
clang -mllvm -fla -mllvm -split -mllvm -split_num=3 test.cpp -o test_fla-mllvm -fla : 激活控制流平坦化
-mllvm -split : 激活基本块分割
-mllvm -split_num=3 : 指定基本块分割的数目,这里一个基本款会被分割成3个基本块后再进行
控制流平坦化混淆
注意在编译时可能出现 stddef.h 和 stdarg.h 头文件不存在的错误,可以使用 locate stddef.h 和 locate stdarg.h 指令找到这两个头文件的位置,然后复制到 /usr/include
或 /usr/local/include 目录下。
虚假控制流(Bogus Control Flow)
clang -mllvm -bcf -mllvm -bcf_loop=3 -mllvm -bcf_prob=40 test.cpp -o test_bcf-mllvm -bcf : 激活虚假控制流
-mllvm -bcf_loop=3 : 混淆次数,这里一个函数会被混淆3次,默认为 1
-mllvm -bcf_prob=40 : 每个基本块被混淆的概率,这里每个基本块被混淆的概率为40%,默认为 30
指令替换(Instruction Substitution)
clang -mllvm -sub -mllvm -sub_loop=3 test.cpp -o test_sub-mllvm -sub : 激活指令替代
-mllvm -sub_loop=3 : 混淆次数,这里一个函数会被混淆3次,默认为 1
控制流平坦化
控制流平坦化指的是将正常控制流中基本块之间的跳转关系删除,用一个集中的分发块来调度基本块的执行顺序。
- 入口块:进入函数第一个执行的基本块。
- 主分发块与子分发块:负责跳转到下一个要执行的原基本块。
- 原基本块:混淆之前的基本块,真正完成程序工作的基本块。
- 返回块:返回到主分发块。
控制流平坦化混淆后的伪代码,while + switch 结构对应平坦化后的控制流结构。 如果是if...else也有可能。
控制流平坦化的代码实现思路
保存原基本块
将除入口块以外的以外的基本块保存到 vector 容器中,方便后续处理。
如果入口块的终结指令是条件分支指令,则将该指令单独分离出来作为一个基本块,加入到 vector 容器的最前面。
实现后效果
//将除入口块以外的基本块保存到 vector 容器中,方便后续处理
// 首先保存所有基本块
vector<BasicBlock*> origBB;
for(BasicBlock &BB : F){
origBB.push_back(&BB);
}
// 从 vector 中去除第一个基本块
// 因为第一个基本块一定是入口块
origBB.erase(origBB.begin());
BasicBlock &entryBB = F.getEntryBlock();
// 判断:如果第一个基本块的末尾是条件跳转 -> 单独分离
// dyn_cast:用来类型判断和类型转换,如果给定参数(entryBB.getTerminator())符合想要类型(BranchInst),进行转换,转换成(BranchInst *br),如果不符合类型,返回一个 nullptr 空指针
if(BranchInst *br = dyn_cast<BranchInst>(entryBB.getTerminator())){
if(br->isConditional()){//isConditional函数:判断是否是条件跳转指令。
// 分离跳转指令作为新基本快,插入到 vector 容器最前端
BasicBlock *newBB = entryBB.splitBasicBlock(br, "newBB");
origBB.insert(origBB.begin(), newBB);
}
}创建分发块和返回块
除了原基本块之外,我们还要续创建一个分发块来调度基本块的执行顺序。并建立入口块到分发块的绝对跳转。
再创建一个返回块,原基本块执行完后都需要跳转到这个返回块,返回块会直接跳转到分发块。
// 创建分发块和返回块
// BasicBlock::Create创建基本块函数,第一个参数是 LLVM Context(上下文) 类型,可用getContext方法获取;
//第二个参数是新建块的名称(dispatchBB);
//第三个参数是函数指针,即在哪个函数(F)里面创建基本块;
//第四个参数指定创建的基本块被移动到哪个基本块(entryBB)的前面。
BasicBlock *dispatchBB = BasicBlock::Create(F.getContext(), "dispatchBB", &F, &entryBB);
BasicBlock *returnBB = BasicBlock::Create(F.getContext(), "returnBB", &F, &entryBB);
// 此时的块顺序如下
/*-----------------------
分发块
返回块
入口块
-----------------------*/
// 建立分发块和返回块的链接
//BranchInst::Create(dispatchBB, returnBB)无条件函数:
//在基本块returnBB的末尾添加一条br指令(无条件跳转)。即直接从基本块returnBB跳转到另一个基本块dispatchBB。
BranchInst::Create(dispatchBB, returnBB);
// 把入口块移到最前面,分发块前面
//moveBefore方法:移动一个基本块(entryBB)到另一个基本块(dispatchBB)前面。
entryBB.moveBefore(dispatchBB);
// 此时的块顺序如下
/*-----------------------
入口块
分发块
返回块
-----------------------*/
// 去除入口块末尾的跳转
//getTerminator方法:获取基本块最后一条指令
//eraseFromParent方法:删除指令
entryBB.getTerminator()->eraseFromParent();
// 使入口块跳转到 dispatchBB,brDispatchBB 也就是入口块的终结指令
BranchInst *brDispatchBB = BranchInst::Create(dispatchBB, &entryBB);实现分发块调度
在入口块中创建并初始化 switch 变量,在调度块中插入switch 指令实现分发功能。
将原基本块移动到返回块之前,并分配随机的 case 值,并将其添加到 switch 指令的分支中。
// 在入口块插入 alloca 和 store 指令创建并初始化 switch 变量,初始值为随机值
int randNumCase = rand();
// 在入口块跳转分发块指令(brDispatchBB)之前插入一条申请分配内存的指令,使用 AllocaInst 的构造函数
AllocaInst *swVarPtr = new AllocaInst(TYPE_I32, 0, "swVar.ptr", brDispatchBB);
// 在入口块跳转分发块指令(brDispatchBB)之前插入一条内存存储的指令
new StoreInst(CONST_I32(randNumCase), swVarPtr, brDispatchBB);
// 在分发块插入 load 指令读取 switch 变量
LoadInst *swVar = new LoadInst(TYPE_I32, swVarPtr, "swVar", false, dispatchBB);
// 在返回块前创建 switch 默认跳转的基本块
BasicBlock *swDefault = BasicBlock::Create(F.getContext(), "seDefault", &F, returnBB);
// switch 默认跳转的基本块默认跳转到返回块
BranchInst::Create(returnBB, swDefault);
// 在分发块末尾的 switch 块中添加 switch 指令
SwitchInst *swInst = SwitchInst::Create(swVar, swDefault, 0, dispatchBB);
// 将原基本块插入到返回块之前,并分配 case 值
for(BasicBlock *BB : origBB){
BB->moveBefore(returnBB);
//addCase方法,在基本块中添加对应 switch 指令的 case 值。
swInst->addCase(CONST_I32(randNumCase), BB);
randNumCase = rand();
}实现调度变量自动调整
在每个原基本块最后添加修改 switch 变量值的指令,以便返回分发块之后,能够正确执行到下一个基本块。
删除原基本块末尾的跳转,使其结束执行后跳转到返回块。
// 在每个基本块最后添加修改 switch 变量的指令和跳转到返回块的指令
for(BasicBlock *BB : origBB){
// retn BB
//getNumSuccessors方法:获取后继块的数量。为 0 表示后续只有一条 return 指令;为 1 表示为非条件跳转,后续有一个后继块;为 2 表示为条件跳转,后续有两个后继块。
if(BB->getTerminator()->getNumSuccessors() == 0){
continue;
}
// 非条件跳转
else if(BB->getTerminator()->getNumSuccessors() == 1){
// 获取后继块
BasicBlock *sucBB = BB->getTerminator()->getSuccessor(0);
// 删除基本块最后一条跳转到后继块的指令
BB->getTerminator()->eraseFromParent();
// 获取后继块的 case 值,(常量类型)
//findCaseDest方法:寻找基本块中 switch case 值,返回值为 ConstantInt 类型。
ConstantInt *numCase = swInst->findCaseDest(sucBB);
// 把 switch 变量修改成它的后继块的 case 值,下一轮进入分发块就根据这个值跳转到后继块
new StoreInst(numCase, swVarPtr, BB);
// 基本块跳转到返回块
BranchInst::Create(returnBB, BB);
}
// 条件跳转
else if(BB->getTerminator()->getNumSuccessors() == 2){
ConstantInt *numCaseTrue = swInst->findCaseDest(BB->getTerminator()->getSuccessor(0));
ConstantInt *numCaseFalse = swInst->findCaseDest(BB->getTerminator()->getSuccessor(1));
BranchInst *br = cast<BranchInst>(BB->getTerminator());
// 创建 select 指令判断需要修改哪一个 case 值
//getCondition方法:获取跳转条件。
SelectInst *sel = SelectInst::Create(br->getCondition(), numCaseTrue, numCaseFalse, "", BB->getTerminator());
// 删除基本块最后一条跳转到后继块的指令
BB->getTerminator()->eraseFromParent();
// 把 switch 变量修改成它的后继块的 case 值,下一轮进入分发块就根据这个值跳转到后继块
new StoreInst(sel, swVarPtr, BB);
// 基本块跳转到返回块
BranchInst::Create(returnBB, BB);
}
}修复 PHI 指令和逃逸变量
PHI 指令的值由前驱块决定,平坦化后所有原基本块的前驱块都变成了分发块,因此 PHI 指令发生了损坏。
逃逸变量指在一个基本块中定义,并且在另一个基本块被引用的变量。在原程序中某些基本块可能引用之前某个基本块中的变量,平坦化后原基本块之间不存在确定的前后关系(由分发块决定),因此某些变量的引用可能会损坏,在编译时会出现分不清定义和引用顺序的问题。
修复的方法是,调用DemotePHIToStack、DemotePHIToStack这两个函数将 PHI 指令和逃逸变量都转化为内存存取指令(alloca、store、load)。Demote 是降级的意思,DemoteToStack就是用 alloca, store, load 三类内存访问指令来代替之前的 PHI 指令。 LLVM IR 中的 alloca 指令是在栈中进行分配的,这点不同于C语言中的 malloc 函数。将所有 PHI 指令用三类内存访问指令表示,并将所有 alloca 指令都放在入口块,PHI 指令的错误就被修复了。
void Flattening::fixStack(Function &F){
vector<PHINode*> origPHI;
vector<Instruction*> origReg;
BasicBlock &entryBB = F.getEntryBlock();
for(BasicBlock &BB : F){
for(Instruction &I : BB){
if(!PHINode *PN = dyn_cast<PHINode>(&I)){
origPHI.push_back(PN);
}else if(!(isa<AllocaInst>(&I) && I.getParent() == &entryBB) && I.isUsedOutsideOfBlock(&BB)){
origReg.push_back(&I);
}
}
}
for(PHINode *PN : origPHI){
DemotePHIToStack(PN, entryBB.getTerminator());
}
for(Instruction *I : origReg){
DemoteRegToStack(*I, entryBB.getTerminator());
}
}指令 I 判断为逃逸变量需要同时满足两个条件:
- 不能是内存申请指令且不在入口块内
- isUseOutsideOfBlock函数判断为真,这个函数用于判断指令 I 是否在其他基本块中被使用
虚假控制流
虚假控制流指,通过向正常控制流中插入若干不可达基本块(永远不会被执行的基本块)和由不透明谓词造成的虚假跳转,以产生大量垃圾代码干扰攻击者分析的混淆。
与控制流平坦化不同,经过虚假控制流混淆的控制流图呈长条状。
虚假控制流是以基本块为单位进行混淆的,每个基本块要经过分裂、克隆、构建虚假跳转等操作。
基本块拆分
将基本块拆分成头部、中部和尾部三个基本块。
通过 getFirstNonPHI 函数获取第一个不是 PHINode 的指令,以该指令为界限进行分割,得到 entryBB 和 bodyBB。 以 bodyBB 的终结指令为界限进行分割,最终得到头部、中部和尾部三个基本块,也就是 entryBB, bodyBB 和 endBB。
void BogusControlFlow::bogus(BasicBlock *entryBB){
// 第一步,拆分得到 entryBB,bodyBB,endBB
// 其中所有的 PHI 指令都在 entryBB(如果有的话)
// endBB 只包含一条终结指令
BasicBlock *bodyBB = entryBB->splitBasicBlock(entryBB--getFirstNonPHI(), "bodyBB");
BasicBlock *endBB = bodyBB->splitBasicBlock(bodyBB->getTerminator(), "endBB");基本块克隆
克隆中间的 bodyBB,得到克隆块 cloneBB。
LLVM 自带 CloneBasicBlock 函数,但该函数为不完全克隆,还需要做一些补充处理。 我们把基本块的克隆操作写到 createCloneBasicBlock 函数中:
BasicBlock *cloneBB = createCloneBasicBlock(bodyBB);在克隆的基本块中,仍然引用了原基本块中的 %a 变量,该引用是非法的,故需要将 %a 映射为 %a.clone:
orig:
%a = ...
%b = fadd %a, ...
clone:
%a.clone = ...
%b.clone = fadd %a, ... ; Note that this references the old %a and not %a.clone!根据 VMap 对克隆基本块中的变量进行修复:
BasicBlock* llvm::createCloneBasicBlock(BasicBlock *BB){//cloneBasicBlock函数:自带的克隆基本块函数,第一个参数为要克隆的基本块,第二个参数是映射表,第三个参数为克隆后基本块的名称,第四个为克隆基本块所属函数。
// 创建一个映射表类型变量
ValueToValueMapTy VMap;
BasicBlock *cloneBB = cloneBasicBlock(BB, VMap, BB->getName() + "cloneBB", BB->getParent());//getParent方法:返回基本块所属函数。
// 对克隆基本块的引用进行修复
for(Instruction &I : *cloneBB){
for(int i = 0;i < I.getNumOperands();i ++){//getNumOperands方法:获取给定下标的指令的操作数的数量。
value *V = MapValue(I.getOperand(i), VMap);//MapValue函数:映射变量。//getOperand方法:获取操作数。
// 如果映射出来不为空,(成功)
if(V){
I.setOperand(i, V);//setOperand方法:替换操作数。
}
}
}
return cloneBB;
}构造虚假跳转
将 entryBB 到 bodyBB 的绝对跳转改为条件跳转, 将 bodyBB 到 endBB 的绝对跳转改为条件跳转,
添加 cloneBB 到 bodyBB 的绝对跳转。
// 1. 将 entryBB, bodyBB, cloneBB 末尾的绝对跳转移除
entryBB->getTerminator()->eraseFromParent();
bodyBB->getTerminator()->eraseFromParent();
cloneBB->getTerminator()->eraseFromParent();
// 2. 在 entryBB 和 bodyBB 的末尾插入条件 恒为真 的虚假比较指令
Value *cond1 = createBogusCmp(entryBB);
Value *cond2 = createBogusCmp(bodyBB);
// 3. 将 entryBB 到 bodyBB 的绝对跳转改为条件跳转,条件为 cond1,为真跳转 bodyBB,为假跳转 cloneBB
BranchInst::Create(bodyBB, cloneBB, cond1, entryBB);
// 4. 将 bodyBB 到 endBB的绝对跳转改为条件跳转,条件为 cond2,为真跳转 endBB,为假跳转 cloneBB
BranchInst::Create(endBB, cloneBB, cond2, bodyBB);
// 5. 添加 bodyBB.clone 到 bodyBB 的绝对跳转
BranchInst::Create(bodyBB, cloneBB);该比较指令等价于 if(y < 10 || x * (x + 1) % 2 == 0):
//虚假跳转指令
Value* BogusControlFlow::createBogusCmp(BasicBlock *insertAfter){
// if((y < 10 || x * (x + 1) % 2 == 0))
// 等价于 if(true)
Module *M = insertAfter->getModule();
// 创建两个全局变量 x、y
//GlobalVariable:全局变量类型,其析构函数可以用于创建一个全局变量,第一个参数是模块,第二个参数是全局变量类型,第三个参数选择是否为常量,第四个参数选择链接方式(CommonLinkage),第五个参数是初始值(为0),第六个参数为创建出来的参数名字。
GlobalVariable *xptr = new GlobalVariable(*M, TYPE_I32, false, GlobalValue::CommonLinkage, CONST_I32(0), "x");
GlobalVariable *yptr = new GlobalVariable(*M, TYPE_I32, false, GlobalValue::CommonLinkage, CONST_I32(0), "y");
// 加载两个全局变量
//LoadInst:读取指令,其析构函数可以创建一条读取指令,第一个参数是全局变量类型,第二个参数是全局变量指针,第三个参数是名称,第四个参数指定插入到哪个基本块(insertAfter
LoadInst *x = new LoadInst(TYPE_I32, xptr, "", insertAfter);
LoadInst *y = new LoadInst(TYPE_I32, yptr, "", insertAfter);
// 创建 y < 10 和 x * (x + 1) % 2 两个式子
// 创建 y < 10
//ICmpInst:比较指令,其析构函数可以创建一条比较指令,第一个参数是指定插入到哪个基本块后面,第二个参数是谓词,指定为大于、小于、或等于(CmpInst::ICMP_SLT),第三个参数和第四个参数分别指定左边和右边的参数。
ICmpInst *cond1 = new ICmpInst(*insertAfter, CmpInst::ICMP_SLT, y, CONST_I32(10));
// 创建 x * (x + 1) % 2
BinaryOperator *op1 = BinaryOperator::CreateAdd(x, CONST_I32(1), "", insertAfter);
BinaryOperator *op2 = BinaryOperator::CreateMul(op1, x, "", insertAfter);
BinaryOperator *op3 = BinaryOperator::CreateURem(op2, CONST_I32(2), "", insertAfter);
ICmpInst *cond2 = new ICmpInst(*insertAfter, CmpInst::ICMP_EQ, op3, CONST_I32(0));
//BinaryOperator:二元运算指令,可以创建加减乘除和与或非等指令
return BinaryOperator::CreateOr(cond1, cond2, "", insertAfter);
}指令替代
指令替代指将正常的二元运算指令(如加法、减法、异或等等),替换为等效而更复杂的指令序列,以达到混淆计算过程的目的。
例如将 a+b 替换为 a - (-b) ,将 a ^ b 替换为 (~a & b) | (a & ~b) 等等。
仅支持整数运算的替换,因为替换浮点指令会造成舍入的错误和误差。
扫描所有指令,对目标指令(加法、减法、与或非、异或)进行替换:
bool Substitution::runOnFunction(Function &F){
for(int i = 0;i < ObfuTime;i ++){
for(BasicBlock &BB : F){
vector<Instruction*> origInst;
for(Instruction &I : BB){
origInst.push_back(&I);
}
for(Instruction *I : origInst){
if(isa<BinaryOperator>(I)){
BinaryOperator *BI = cast<BinaryOperator>(I);
substitute(BI);
}
}
}
}
}加法替换
减法替换
与替换
或替换
异或替换
随机控制流
随机控制流是虚假控制流的一种变体,随机控制流通过克隆基本块,以及添加随机跳转(随机跳转到两个功能相同的基本块中的一个)来混淆控制流。
与虚假控制流不同,随机控制流中不存在不可达基本块和不透明谓词,因此用于去除虚假控制流的手段(消除不透明谓词、符号执行获得不可达基本块后去除)失效。
随机控制流同样是以基本块为单位进行混淆的,每个基本块要经过分裂、克隆、构造随机跳转和构造虚假随机跳转四个操作。
基本块拆分
通过 getFirstNonPHI 函数获取第一个不是 PHINode 的指令,以该指令为界限进行分割,得到 entryBB 和 bodyBB。 以 bodyBB 的终结指令为界限进行分割,最终得到头部、中部和尾部三个基本块,也就是 entryBB, bodyBB 和 endBB。(去,跟控制流平坦化真像哈)
// 第一步,拆分得到 entryBB,bodyBB,endBB
// 其中所有的 PHI 指令都在 entryBB(如果有的话)
// endBB 只包含一条终结指令
BasicBlock *entryBB = BB;
BasicBlock *bodyBB = entryBB->splitBasicBlock(entryBB--getFirstNonPHIOrDbgOrLifetime(), "bodyBB");
BasicBlock *endBB = bodyBB->splitBasicBlock(bodyBB->getTerminator(), "endBB");基本块克隆
将中间的基本块进行克隆,这里可以选择对基本块进行变异,但不能改变基本块的功能。(不同点来了)
与虚假控制流不同,随机控制流在克隆时还需要修复逃逸变量
BasicBlock *cloneBB = createCloneBasicBlock(bodyBB);在一个基本块中定义的变量,如果在另一个基本块中被引用,那么该变量称为逃逸变量:
BasicBlock* llvm::createCloneBasicBlock(BasicBlock *BB){
// 克隆之前先修复所有逃逸变量
vector<Instruction*> origReg;
BasicBlock &entryBB = BB->getParent()->getEntryBlock();
for(Instruction &I : *BB){
if(!(isa<AllocaInst>(&I) && I.getParent() == &entryBB)
&& I.isUsedOutsideOfBlock(BB)){
origReg.push_back(&I);
}
}
for(Instruction *I : origReg){
DemoteRegToStack(*I, entryBB.getTerminator());
}
// 创建一个映射表类型变量
ValueToValueMapTy VMap;
BasicBlock *cloneBB = CloneBasicBlock(BB, VMap, "cloneBB", BB->getParent());
// 对克隆基本块的引用进行修复
for(Instruction &I : *cloneBB){
for(int i = 0;i < I.getNumOperands();i ++){
Value *V = MapValue(I.getOperand(i), VMap);
// 如果映射出来不为空,(成功)
if(V){
I.setOperand(i, V);
}
}
}
return cloneBB;
}构造随机跳转
将生成随机数的指令插入到 entryBB ,将生成的随机数命名为 randVar,并在 entryBB 后插入基于 randVar 的随机跳转指令。
插入生成随机数指令
向 entryBB 中插入生成随机数的指令和随机跳转,使其能够随机跳转到 bodyBB 或者 bodyBB 的克隆块。
其中随机数指令我们可以使用 LLVM 的内置函数 rdrand:
// 在 entryBB 后插入随机跳转,使其能够随机跳转到第 bodyBB 或其克隆基本块 cloneBB
entryBB->getTerminator()->eraseFromParent();
// 获取 rdrand 函数
Function *rdrand = Intrinsic::getDeclaration(entryBB->getModule(), Intrinsic::x86_rdrand_32);//Intrinsic::getDeclaration(id)方法:获取并且创建一个 LLVM 内置函数,这个 id 可以在 intrinsics.gen 中找到。这里调用 LLVM 内置的 rdrand 生成随机数的函数。
// 新建 call 指令调用 rdrand 函数,返回结果是一个结构体,第一个成员是生成的随机数,第二个参数表示该函数是否调用成功
CallInst *randVarStruct = CallInst::Create(rdrand->getFunctionType(), rdrand, "", entryBB);
// 通过 rdrand 内置函数获取随机数
Value *randVar = ExtractValueInst::Create(randVarStruct, 0, "", entryBB);
//插入随机跳转
insertRandomBranch(randVar, bodyBB, cloneBB, entryBB);//insertRandomBranch
void RandomControlFlow::insertRandomBranch(Value *randVar, BasicBlock *ifTrue, BasicBlock *ifFalse, BasicBlock *insertAfter){
// 对随机数进行等价变换
Value *alteredRandVar = alterVal(randVar, insertAfter);
// and 1 == % 2
Value *randMod2 = BinaryOperator::Create(Instruction::And, alteredRandVar, CONST_I32(1), "", insertAfter);
ICmpInst *condition = new ICmpInst(*insertAfter, ICmpInst::ICMP_EQ, randMod2, CONST_I32(1));
// 跳转到不同基本块
BranchInst::Create(ifTrue, ifFalse, condition, insertAfter);
}如果使用了内置函数rdrand,在生成了.ll文件后,需要用llc工具静态编译生成二进制文件,此时需要添加-mattr=rdrnd的属性:
llc -filetype=obj -mattr=+rdrnd IR/TestProgram_rcf.ll -o Bin/TestProgram_rcf.o对随机变量的恒等变换
Value* RandomControlFlow::alterVal(Value *startVar,BasicBlock *insertAfter){
uint32_t code = rand() % 3;
Value *result;
if(code == 0){
// x = x * (x + 1) - x^2
BinaryOperator *op1 = BinaryOperator::Create(Instruction::Add, startVar, CONST_I32(1), "", insertAfter);
BinaryOperator *op2 = BinaryOperator::Create(Instruction::Mul, startVar, op1, "", insertAfter);
BinaryOperator *op3 = BinaryOperator::Create(Instruction::Mul, startVar, startVar, "", insertAfter);
BinaryOperator *op4 = BinaryOperator::Create(Instruction::Sub, op2, op3, "", insertAfter);
result = op4;
}else if(code == 1){
// x = 3 * x * (x - 2) - 3 * x^2 + 7 * x
BinaryOperator *op1 = BinaryOperator::Create(Instruction::Mul, startVar, CONST_I32(3), "", insertAfter);
BinaryOperator *op2 = BinaryOperator::Create(Instruction::Sub, startVar, CONST_I32(2), "", insertAfter);
BinaryOperator *op3 = BinaryOperator::Create(Instruction::Mul, op1, op2, "", insertAfter);
BinaryOperator *op4 = BinaryOperator::Create(Instruction::Mul, startVar, startVar, "", insertAfter);
BinaryOperator *op5 = BinaryOperator::Create(Instruction::Mul, op4, CONST_I32(3), "", insertAfter);
BinaryOperator *op6 = BinaryOperator::Create(Instruction::Mul, startVar, CONST_I32(7), "", insertAfter);
BinaryOperator *op7 = BinaryOperator::Create(Instruction::Sub, op3, op5, "", insertAfter);
BinaryOperator *op8 = BinaryOperator::Create(Instruction::Add, op6, op7, "", insertAfter);
result = op8;
}else if(code == 2){
// x = (x - 1) * (x + 3) - (x + 4) * (x - 3) - 9
BinaryOperator *op1 = BinaryOperator::Create(Instruction::Sub, startVar, CONST_I32(1), "", insertAfter);
BinaryOperator *op2 = BinaryOperator::Create(Instruction::Add, startVar, CONST_I32(3), "", insertAfter);
BinaryOperator *op3 = BinaryOperator::Create(Instruction::Add, startVar, CONST_I32(4), "", insertAfter);
BinaryOperator *op4 = BinaryOperator::Create(Instruction::Sub, startVar, CONST_I32(3), "", insertAfter);
BinaryOperator *op5 = BinaryOperator::Create(Instruction::Mul, op1, op2, "", insertAfter);
BinaryOperator *op6 = BinaryOperator::Create(Instruction::Mul, op3, op4, "", insertAfter);
BinaryOperator *op7 = BinaryOperator::Create(Instruction::Sub, op5, op6, "", insertAfter);
BinaryOperator *op8 = BinaryOperator::Create(Instruction::Sub, op7, CONST_I32(9), "", insertAfter);
result = op8;
}
return result;
}构造虚假随机跳转
在 bodyBB 和 cloneBB 后插入虚假随机跳转指令(实际上仍会直接跳转到 endBB):
// 添加 bodyBB 到 bodyBB.clone 的虚假随机跳转
bodyBB->getTerminator()->eraseFromParent();
insertRandomBranch(randVar, endBB, cloneBB, bodyBB);
// 添加 bodyBB.clone 到 bodyBB 的虚假随机跳转
cloneBB->getTerminator()->eraseFromParent();
insertRandomBranch(randVar, bodyBB, endBB, cloneBB);常量替代
常量替代指将二元运算指令(如加法、减法、异或等等)中使用的常数,替换为等效而更复杂的表达式,以达到混淆计算过程或某些特殊常量的目的。
例如将 TEA 加密中使用的常量 0x9e3779b 替换为 12167*16715+18858*32146-643678438。
同指令替代,目前仅支持整数常量的替换,因为替换浮点数会造成舍入的错误和误差。且仅支持32位整数的替换。
常量替代可进一步拓展为常量数组的替代和字符串替代。
常量数组替代可以抹去 AES, DES 等加密算法中特征数组,字符串替代可以防止攻击者通过字符串定位关键代码。
扫描所有指令,对目标指令(操作数类型为32位整数)进行替换
for(Instruction *I : origInst){
// 只对二元运算指令中的常量进行替换
if(BinaryOperator *BI = dyn_cast<BinaryOperator>(I)){
// 仅对整数进行替换
if(BI->getType()->isIntegerTy(32)){
substitute(BI);
}
}
}
想问问作者LLVM有什么比较好的学习路线吗;对代码混淆这块比较感兴趣