首页
社区
课程
招聘
问答 CTF 排行榜 知识库 工具下载 看雪峰会 看雪商城 证书查询
  1. 看雪社区
  2. 软件逆向
    3. 发新帖
[原创]基于llvm的变量轮转混淆pass实现
2022-3-14 11:28 14889

[原创]基于llvm的变量轮转混淆pass实现

R1mao 活跃值
2
2022-3-14 11:28
14889

前言

之前有了解过一点点VMP的虚拟机，其中存在一种混淆机制，就是在执行之后将虚拟机的寄存器轮转，这样每个指令的寄存器就不一样了，极大的增加了数据流分析的难度。可能理解有点问题，但是这种思想也可以应用于源码级混淆。所以我就基于LLVM实现了一种变量轮转的混淆方式，发现能够能够阻碍数据流分析，迷惑看代码的人。

设计

在LLVM中，函数内部的变量都是通过allocainst进行分配的，其分配的结果是一个指针类型，在IDA中对应的就是栈空间。

在这里，由于LLVM的分配类型并不相同，不能像虚拟寄存器那样方便轮转。所以先想个办法将这些分配的allocainst统一一下。

  • 由于allocainst返回的是一个指针，代表的该变量存储的位置。所以我们可以一开始就将所有的allocainst收集起来。
  • 统一用一个allocainst分配一个巨大的uchar类型的buffer空间，用于这些allocainst分配。然后计算每一个alloca指令相对于这个buffer空间的偏移地址。
  • 将引用这些原来allocainst的指令的操作数替换成，分配buffer+偏倚地址的指针。到这里实现将所有的allocainst统一起来。
  • 然后就是构造变量轮转函数了，这个直接用llvm的irbuilder即可。
  • 接下来就是变量轮转，由于空间本身不是环形空间，轮转的位数也有限制，必须一整个一整个变量的轮转。且要保证每个基本块进入时相对于原来没有发生移位。

具体代码实现

构造轮转函数

具体算法实现很简单，给一个数组指针，数组长度，移位位数，然后移位就可以了。

c代码实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
Function *VariableRotation::createRotateFunc(Module *m,PointerType *ptrType,Twine &name)
{
    std::vector<Type*> params;
    params.push_back(ptrType);
    params.push_back(Type::getInt32Ty(m->getContext()));
    params.push_back(Type::getInt32Ty(m->getContext()));
    Type *rawType=ptrType->getPointerElementType();
    FunctionType *funcType=FunctionType::get(Type::getVoidTy(m->getContext()),params,false);
    Function *func=Function::Create(funcType,GlobalValue::PrivateLinkage,name,m);
    BasicBlock *entry1=BasicBlock::Create(m->getContext(),"entry1",func);
    BasicBlock *cmp1=BasicBlock::Create(m->getContext(),"cmp1",func);
    BasicBlock *entry2=BasicBlock::Create(m->getContext(),"entry2",func);
    BasicBlock *cmp2=BasicBlock::Create(m->getContext(),"cmp2",func);
    BasicBlock *shift=BasicBlock::Create(m->getContext(),"shift",func);
    BasicBlock *end2=BasicBlock::Create(m->getContext(),"end2",func);
    BasicBlock *end1=BasicBlock::Create(m->getContext(),"end1",func);
    Function::arg_iterator iter=func->arg_begin();
    Value *ptr=iter;
    Value *len=++iter;
    Value *times=++iter;
    IRBuilder<> irb(entry1);
    Value *zero=ConstantInt::get(irb.getInt32Ty(),0);
    Value *one=ConstantInt::get(irb.getInt32Ty(),1);
    AllocaInst *i=irb.CreateAlloca(irb.getInt32Ty());
    AllocaInst *j=irb.CreateAlloca(irb.getInt32Ty());
    AllocaInst *tmp=irb.CreateAlloca(rawType);
    AllocaInst *array=irb.CreateAlloca(ptrType);
    irb.CreateStore(zero,j);
    irb.CreateStore(ptr,array);
    irb.CreateBr(cmp1);
 
    irb.SetInsertPoint(cmp1);
    irb.CreateCondBr(irb.CreateICmpSLT(irb.CreateLoad(j),times),entry2,end1);
 
    irb.SetInsertPoint(entry2);
    irb.CreateStore(zero,i);
    irb.CreateStore(irb.CreateLoad(irb.CreateInBoundsGEP(irb.CreateLoad(array),{zero})),tmp);
    irb.CreateBr(cmp2);
 
    irb.SetInsertPoint(cmp2);
    irb.CreateCondBr(irb.CreateICmpSLT(irb.CreateLoad(i),irb.CreateSub(len,one)),shift,end2);
 
    irb.SetInsertPoint(shift);
    Value *ival=irb.CreateLoad(i);
    Value *arr=irb.CreateLoad(array);
    irb.CreateStore(irb.CreateLoad(irb.CreateInBoundsGEP(arr,{irb.CreateAdd(ival,one)})),irb.CreateInBoundsGEP(rawType,arr,{ival}));
    irb.CreateStore(irb.CreateAdd(ival,one),i);
    irb.CreateBr(cmp2);
 
    irb.SetInsertPoint(end2);
    irb.CreateStore(irb.CreateAdd(irb.CreateLoad(j),one),j);
    irb.CreateStore(irb.CreateLoad(tmp),irb.CreateInBoundsGEP(irb.CreateLoad(array),{irb.CreateSub(len,one)}));
    irb.CreateBr(cmp1);
 
    irb.SetInsertPoint(end1);
    irb.CreateRetVoid();
    return func;
}

这里并不是重点，熟悉llvm的ir的很快就能写出来。

处理函数的AllocaInst

  • 函数第一个参数代表着要处理的llvm函数，第二个代表着统计出的函数的allocainst集合，第三个代表之前生成的移位函数。
  • 然后开始处理，先遍历AllocaInst，然后使用getTypeAllocSize分别获取该指令分配的空间的大小，用于计算value_map，其实就是表示这AllocaInst到buffer的偏移地址的一个映射。
  • 计算完成各个变量的偏移地址后，同时也得到了buffer应该有的大小，保存下来，并且使用AllocaInst分配空间。
  • 开始遍历每个基本块。
  • 对于每个基本块，开始进行处理每个引用了原来变量的指令，替换成GEP buffer生成的指针，并将指针类型转换成原allocainst的指针类型。然后在基本块内部维护一个int，保存到当前指令的时候，已经轮转了多少位了，然后通过随机数进行插入轮转函数，更新int。
  • 处理完基本块之后，查看轮转了多少位，如果不是0的话则需要修正一下，让轮转的位数为0(在取模意义下)

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#include "llvm/Pass.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/CFG.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
#include "assert.h"
#include<vector>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#include<cstdio>
using namespace llvm;
namespace
{
    struct VariableRotation : public ModulePass
    {
        static char ID;
 
           VariableRotation() : ModulePass(ID) {}
        Function *createRotateFunc(Module *m,PointerType *ptrType,Twine &name);
        void processFunction(Function &f,SetVector<Function*> &shift);
        bool processVars(Function &f,SetVector<AllocaInst*> &vars,Function *rotateFunc);
        bool isUsedByInst(Instruction *inst,Value *var)
        {
            for(Value *ops:inst->operands())
                if(ops==var)
                    return true;
            return false;
        }
 
        bool runOnModule(Module &m) override
        {
            Twine fname1=Twine("shiftFuncitonI8");
            Function *shiftFunc=createRotateFunc(&m,Type::getInt8PtrTy(m.getContext()),fname1);
            SetVector<Function*> shifts;
            shifts.insert(shiftFunc);
            for(Function &f:m)
            {
                if(&f==shiftFunc)
                    continue;
                if(f.hasExactDefinition())
                    processFunction(f,shifts);
            }
            return true;
        }
      };
}
 
char VariableRotation::ID=0;
static RegisterPass<VariableRotation> X("varobfu", "varobfu");
bool VariableRotation::processVars(Function &f,SetVector<AllocaInst*> &vars,Function *rotateFunc)
{
    if(vars.size()<2)
        return false;
    IRBuilder<> irb(&*f.getEntryBlock().getFirstInsertionPt());
    Value *zero=ConstantInt::get(irb.getInt32Ty(),0);
    DataLayout data=f.getParent()->getDataLayout();
    int space=0;
    SetVector<int> value_map;
    printf("function: %s\n",f.getName());
    for(int i=0;i<vars.size();i++)
    {
        AllocaInst *a=vars[i];
        value_map.insert(space);
        printf("address:  %d\n",space);
        space+=data.getTypeAllocSize(a->getAllocatedType());
    }
    ArrayType *arrayType=ArrayType::get(irb.getInt8Ty(),space);
    AllocaInst *array=irb.CreateAlloca(arrayType);
    int prob=30;
    for(BasicBlock &bb:f)
    {
        int offset=0;
        BasicBlock::iterator iter=bb.getFirstInsertionPt();
        if(&bb==&f.getEntryBlock())
            iter++;
        while(iter!=bb.end())
        {
            Instruction *inst=&*iter;
            irb.SetInsertPoint(inst);
            for(int i=0;i<vars.size();i++)
                if(isUsedByInst(inst,vars[i]))
                {
                    if(rand()%100<prob)
                    {
                        int times=rand()%(vars.size()-1)+1;
                        int delta=(space+value_map[(offset+times)%vars.size()]-value_map[offset])%space;
                        irb.CreateCall(FunctionCallee(rotateFunc),{irb.CreateGEP(array,{zero,zero}),ConstantInt::get(irb.getInt32Ty(),space),ConstantInt::get(irb.getInt32Ty(),delta)});
                        offset=(offset+times)%vars.size();
                    }
                    int index=(space+value_map[i]-value_map[offset])%space;
                    Value *gep=irb.CreateGEP(array,{zero,ConstantInt::get(irb.getInt32Ty(),index)});
                    Value *cast=irb.CreateBitOrPointerCast(gep,vars[i]->getType());
                    int c=0;
                    for(Value *ops:inst->operands())
                    {
                        if(ops==vars[i])
                            inst->setOperand(c,cast);
                        c++;
                    }
                    break;
                }
            iter++;
        }
        if(offset!=0)
        {
            irb.SetInsertPoint(bb.getTerminator());
            irb.CreateCall(FunctionCallee(rotateFunc),{irb.CreateGEP(array,{zero,zero}),ConstantInt::get(irb.getInt32Ty(),space),ConstantInt::get(irb.getInt32Ty(),(space-value_map[offset])%space)});
        }
 
    }
    return true;
}
void VariableRotation::processFunction(Function &f,SetVector<Function*> &shift)
{
    SetVector<AllocaInst*> list;
    for(BasicBlock &bb:f)
        for(Instruction &instr:bb)
            if(isa<AllocaInst>(instr))
            {
                AllocaInst *a=(AllocaInst*)&instr;
                list.insert(a);
            }
    if(processVars(f,list,shift[0]))
    {
        for(AllocaInst *a:list)
            a->eraseFromParent();
    }
}
Function *VariableRotation::createRotateFunc(Module *m,PointerType *ptrType,Twine &name)
{
    std::vector<Type*> params;
    params.push_back(ptrType);
    params.push_back(Type::getInt32Ty(m->getContext()));
    params.push_back(Type::getInt32Ty(m->getContext()));
    Type *rawType=ptrType->getPointerElementType();
    FunctionType *funcType=FunctionType::get(Type::getVoidTy(m->getContext()),params,false);
    Function *func=Function::Create(funcType,GlobalValue::PrivateLinkage,name,m);
    BasicBlock *entry1=BasicBlock::Create(m->getContext(),"entry1",func);
    BasicBlock *cmp1=BasicBlock::Create(m->getContext(),"cmp1",func);
    BasicBlock *entry2=BasicBlock::Create(m->getContext(),"entry2",func);
    BasicBlock *cmp2=BasicBlock::Create(m->getContext(),"cmp2",func);
    BasicBlock *shift=BasicBlock::Create(m->getContext(),"shift",func);
    BasicBlock *end2=BasicBlock::Create(m->getContext(),"end2",func);
    BasicBlock *end1=BasicBlock::Create(m->getContext(),"end1",func);
    Function::arg_iterator iter=func->arg_begin();
    Value *ptr=iter;
    Value *len=++iter;
    Value *times=++iter;
    IRBuilder<> irb(entry1);
    Value *zero=ConstantInt::get(irb.getInt32Ty(),0);
    Value *one=ConstantInt::get(irb.getInt32Ty(),1);
    AllocaInst *i=irb.CreateAlloca(irb.getInt32Ty());
    AllocaInst *j=irb.CreateAlloca(irb.getInt32Ty());
    AllocaInst *tmp=irb.CreateAlloca(rawType);
    AllocaInst *array=irb.CreateAlloca(ptrType);
    irb.CreateStore(zero,j);
    irb.CreateStore(ptr,array);
    irb.CreateBr(cmp1);
 
    irb.SetInsertPoint(cmp1);
    irb.CreateCondBr(irb.CreateICmpSLT(irb.CreateLoad(j),times),entry2,end1);
 
    irb.SetInsertPoint(entry2);
    irb.CreateStore(zero,i);
    irb.CreateStore(irb.CreateLoad(irb.CreateInBoundsGEP(irb.CreateLoad(array),{zero})),tmp);
    irb.CreateBr(cmp2);
 
    irb.SetInsertPoint(cmp2);
    irb.CreateCondBr(irb.CreateICmpSLT(irb.CreateLoad(i),irb.CreateSub(len,one)),shift,end2);
 
    irb.SetInsertPoint(shift);
    Value *ival=irb.CreateLoad(i);
    Value *arr=irb.CreateLoad(array);
    irb.CreateStore(irb.CreateLoad(irb.CreateInBoundsGEP(arr,{irb.CreateAdd(ival,one)})),irb.CreateInBoundsGEP(rawType,arr,{ival}));
    irb.CreateStore(irb.CreateAdd(ival,one),i);
    irb.CreateBr(cmp2);
 
    irb.SetInsertPoint(end2);
    irb.CreateStore(irb.CreateAdd(irb.CreateLoad(j),one),j);
    irb.CreateStore(irb.CreateLoad(tmp),irb.CreateInBoundsGEP(irb.CreateLoad(array),{irb.CreateSub(len,one)}));
    irb.CreateBr(cmp1);
 
    irb.SetInsertPoint(end1);
    irb.CreateRetVoid();
    return func;
}
static RegisterStandardPasses Y(PassManagerBuilder::EP_EarlyAsPossible,
  [](const PassManagerBuilder &Builder, legacy::PassManagerBase &PM) {
    PM.add(new VariableRotation());
  });

效果

编译成so，并应用于ll文件。

1
2
3
4
5
clang `llvm-config --cxxflags` -Wl,-znodelete -fno-rtti -fPIC -shared VarObfu.cpp -o Var.so `llvm-config --ldflags`
clang -S -emit-llvm test.cpp -o test.ll
opt -load Var.so -var test.ll -S -o test_out.ll
llvm-as test_out.ll
clang test_out.ll -o test

IDA打开，可以看到f5代码中的变量的意义已经完全不一样了，如果忽略轮转函数，则代码完全没有意义，而想要恢复，则需要脑子一点点去演算变量地址才行。


[培训]二进制漏洞攻防（第3期）；满10人开班；模糊测试与工具使用二次开发；网络协议漏洞挖掘；Linux内核漏洞挖掘与利用；AOSP漏洞挖掘与利用；代码审计。

最后于 2022-3-14 11:30 被R1mao编辑 ，原因：
收藏
点赞・9
打赏
分享
最新回复 (10)
34r7hm4n
雪    币： 14301
活跃值： (10654)
能力值： ( LV12，RANK：360 )
在线值：
发帖
回帖
粉丝
私信
34r7hm4n 7 2022-3-14 11:39
2 楼
0
666
会飞的鱼油
雪    币： 20792
活跃值： (5274)
能力值： ( LV12，RANK：529 )
在线值：
发帖
回帖
粉丝
私信
会飞的鱼油 8 2022-3-14 12:03
3 楼
0
编译器优化: 复制传播+死代码删除
R1mao
雪    币： 3119
活跃值： (3216)
能力值： ( LV9，RANK：150 )
在线值：
发帖
回帖
粉丝
私信
R1mao 2 2022-3-14 12:14
4 楼
0
会飞的鱼油 编译器优化: 复制传播+死代码删除
怎么编译优化呢
R1mao
雪    币： 3119
活跃值： (3216)
能力值： ( LV9，RANK：150 )
在线值：
发帖
回帖
粉丝
私信
R1mao 2 2022-3-14 12:23
5 楼
0
会飞的鱼油 编译器优化: 复制传播+死代码删除
是用o2重新编译一遍吗
会飞的鱼油
雪    币： 20792
活跃值： (5274)
能力值： ( LV12，RANK：529 )
在线值：
发帖
回帖
粉丝
私信
会飞的鱼油 8 2022-3-14 12:41
6 楼
0
R1mao 是用o2重新编译一遍吗
你用retdec反编译测试下，设置好优化选项，你这个混淆应该是可以被它优化掉的
R1mao
雪    币： 3119
活跃值： (3216)
能力值： ( LV9，RANK：150 )
在线值：
发帖
回帖
粉丝
私信
R1mao 2 2022-3-14 12:46
7 楼
0
大佬有什么参考文献吗，我想看看具体的优化选项。之前试了把ida的f5拿出来用o2编译好像是去不掉的。
R1mao
雪    币： 3119
活跃值： (3216)
能力值： ( LV9，RANK：150 )
在线值：
发帖
回帖
粉丝
私信
R1mao 2 2022-3-14 12:57
8 楼
0
python retdec-decompiler.py ---backend-aggressive-opts test 大佬我这样写可以吗
会飞的鱼油
雪    币： 20792
活跃值： (5274)
能力值： ( LV12，RANK：529 )
在线值：
发帖
回帖
粉丝
私信
会飞的鱼油 8 2022-3-14 13:11
9 楼
0
R1mao 大佬有什么参考文献吗，我想看看具体的优化选项。之前试了把ida的f5拿出来用o2编译好像是去不掉的。
优化算法原理可以看看编译原理相关书籍的优化算法部分，retdec我很久没用了，你看看官方文档吧
ahguoahgj
雪    币： 201
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
ahguoahgj 2022-8-4 15:14
10 楼
0
大佬，您的这篇文章还有一些疑问的地方希望向您请教一下，QQ3144880835
naville
雪    币： 136
活跃值： (549)
能力值： ( LV4，RANK：50 )
在线值：
发帖
回帖
粉丝
私信
naville 1 2023-10-28 13:57
11 楼
0

挖坟找到这贴, 理论上抛开安全性不谈这个算法没考虑到AA和Escape?

最后于 2023-10-28 13:58 被naville编辑 ，原因：
游客
登录 | 注册 方可回帖
　回帖　 表情 雪币赚取及消费
高级回复
返回