浅谈IAT加密原理及过程

上一次做完代码段加密后,又接触到了新的加密方式:IAT加密

IAT加密是通过隐藏程序的导入表信息,以达到增加分析程序的难度。因为没有导入表,就无法单纯的从静态状态下分析调用了什么函数,动态调试时,也无法直接从调用处判断出调用的函数。从而增加了程序分析的难度。

 

思路如下:

1.把IAT信息全部删除掉,只留下DLL名和第一个调用函数的信息(目的是让程序在最开始运行时能正常调用那些初始化类型的函数)

2.根据导入表的信息,自己实现函数加载,通过调用LoadLibraryA和GetProcAddress函数把DLL中的所有函数加载进来,并在程序中保存加载后的函数地址。(但由于是用程序A给程序B加密,程序B未运行时,如何获得这2个函数的地址呢?而且IAT表也已经被删掉了。此时只能借助PEB和TEB来获取这2个函数的地址,并记录在程序B中,当程序B运行时,就可以通过对应的位置取得函数地址)

3.找到所有 “指令中包含了IAT加载地址” 的指令,并记录这些指令的位置(指令所在位置而不是指令中的地址位置)

4.构建一个shellcode表,里面写着每个3.里所找到的指令的处理代码,简单来说就是把3.所找到的地址,修改成跳到4的这个shellcode表对应的处理指令中,这段处理指令实现和3.的指令一样的效果。

5.把3.中的指令修改为一个jmp,jmp到4.中对应的处理代码。实现一样的效果。

6.把重定位表中,有关于IAT表的项删掉,因为IAT加密后,原调用位置的指令是跳转到自己写的shellcode中,里面的指令是在函数运行后修改的。无需重定位了。并在在4.的shellcode中,用到了基址,这里采用的获取基址方式是通过重定位,所以要被shellcode表中的所有对应位置也添加到重定位表中。

 

实现步骤:

1.先常规的检查该程序是否为PE文件(检查"MZ"和“PE”是否存在)

2.通过导入表,找到对应的IAT值,并构建一个向量vector用于存储。(注:这里为IAT的值,而不是IAT的值指向的地址中的值)

3.根据2.中所找到的IAT,找到在源文件中,又那些是使用了这个值的,分别是mov exx(每个寄存器对应的二进制数不同),push,call,jmp。记得这里记录的是调用指令的位置,而不是调用指令中IAT地址所在的位置

4.用向量vector+结构体的方式先将IAT表中的信息保存下来(DLL个数,每个DLL的名及名字的长度。这个DLL是通过什么方式导出函数(名称/序号);DLL有几个导出函数,他们分别的值是多少,如果他是以名称导出的话,该名称的长度和值分别又是多少)。

5.接着隐藏被加密文件的导入表,每个DLL下面的INT和IAT表只保留第一个值,其他的全部赋值为0,去除掉导入信息

6.更新重定位表数据,如果没有重定位表则跳过这项。看7.

  6.1先把重定位表的值保存下来,以便后续移动到程序末尾(这么做的目的是为了后续添加新的重定位项时,重定位块的范围能覆盖上) (例:当前程序最大内存偏移为0x15000,增加后的偏移为0x18000,如果不把重定位移到最后的话,新增加的这0x3000中就无法被重定位到)

  6.2把目标程序的重定位表数据清空

7.将每个节的保护属性修改为可写(本来只修改.text节的属性即可,但由于该节的位置不在data数组里面记录,单凭节名判断未必准确,所以将所以节都改为可写)

8.创建一个新的节,把4.中保存的导入表信息填充进去。由于已知这些信息的长度,写shellcode时把位置一一对应即可。

  8.1再在这个节当中,申请导入函数个数*4的空间,以便存放后续导入的函数地址

  8.2记录当前的内存地址,设为新的OEP;

  8.3整个加密最为重要的一点:编写shellcode

    8.3.1:由于LoadLibraryA和GetProcAddress都为Kernel32中的导出函数;所以先通过进程的fs:[0x30]获取到PEB结构,再在该结构的0x0C的位置获取到该进程的DLL列表指针,再通过这个列表的0x1C的位置获取初始化模块列表;通过这个初始化模块列表取得结构,对比结构成员中的长度和值,取到目标DLL(Kernel32.dll)在该程序的装载基址

    8.3.2获得Kernel32的装载基址后,把该地址当成一个PE文件处理,通过偏移取值,最后找到导出表位置,根据导出表中的数据一一比对,得到LoadLibraryA和GetProcAddress在该程序的位置。保存起来

    8.3.3根据8中保存的导入表数据,一一调用LoadLibraryA获得目标DLL的装载地址,再根据该装载地址,调用GetProcAddress把其中的函数地址全部获取出来,并按导入表的顺序,保存到8.1所预留出来的空间中

    8.3.4构造代替原导入表功能的shellcode块,每个shellcode块对应一个使用到IAT地址的位置(2.所保存的值)。

    8.3.5把原调用到IAT指令的位置,全部修改为jmp到8.3.4对应的shellcode块,注意指令长度,替换后的指令为jmp [目标shellcode块地址],占5字节,如原指令占6字节的话,填充一个nop对齐     流程为:找到调用IAT地址的指令位置(3.中保存了),将其替换成jmp [对应shellcode块地址],在对应shellcode块中,把自己在8.3.3所获得的函数地址,用混淆的方式,实现成原来的功能。(本来为mov eax [iat地址],修改成JMP 对应shellcode块,对应shellcode块里实现mov eax [自己所获得的函数地址])

9.如果没有重定位表跳过这一步,看10.  把重定位把重定位表中有关调用函数的指令位置删掉(注:这里的位置为指令当中的地址的位置,例:E9 0X0123 4567在0x8的位置,那么地址位置就为0x9)。这么做的目的是因为IAT表加密后,函数都是自己实现导入的,原导入表的这些项无需再进行重定位了,填充时地址就已经是当前程序的位置了。

10.由于8.3.4的shellcode块中需要用到基址,这里利用了重定位表的方式获得基址,所以要把每个shellcode块中,对应获得基址的指令地址也添加到重定位块中

11.将新增的节按文件对齐和内存对齐后,将重定位表恢复,恢复起始位置为新增节的起始位置+对齐后的大小   

12.IAT加密完成

 

下面附上代码:

代码长度1594 未精简,有备注     其中有涉及jit编译shellcode指令的代码,所以无法直接复制运行,这里仅提供编写思路。

要在此再增加分析者的难度的话,可以在8.填充导入表信息时,先做异或加密处理,等运行时,再异或解密出来,因为知道位置与长度,所以很容易做到

浅谈IAT加密原理及过程

   1 #include<iostream>
   2 #include<Windows.h>
   3 #include<map>
   4 #include<vector>
   5 #include "Asmjit\\asmjit.h"
   6 
   7 using namespace std;
   8 using namespace asmjit;
   9 using namespace asmjit::x86;
  10 
  11 int g_iFileSize = 0;        //文件大小
  12 UCHAR *g_pFileSrc = NULL;  //文件内容  (此处必须为无符号字符指针,因为char会将十六进制的最高位默认为符号位)
  13 int g_iSectionAlignment = 0;//内存对齐大小
  14 int g_iFileAlignment = 0;//文件对齐大小
  15 int g_iImageBase = 0;//程序基址
  16 int g_iNewOEP = 0;//新入口点
  17 int g_iOldOEP = 0;//旧入口点
  18 
  19 struct FuncTag
  20 {
  21     BYTE iFuncNameLenth;//函数名称长度
  22     char *szFuncName;
  23 };
  24 struct DLLFuncTag
  25 {
  26     byte bDllNameLenth;//DLL名长度
  27     char *szDllName;
  28     WORD wFuncNum;//当前DLL的函数数量
  29     byte bTab;//导入方式:0为序号导入 1为名称
  30     vector<FuncTag>vFuncNAMEorNo;//注意:此时的序号已经去掉最高位
  31 };
  32 vector<DLLFuncTag>g_tagDllFunc;//存放IAT信息的结构体,成员为DLL名长度,DLL名,函数数量,标志(最高位为1则是序号,否则为一个字符串的地址),函数名列表
  33 
  34 
  35 //先通过遍历获得下面结构体中各个成员的值  注:成员的位置皆为RVA
  36 /*
  37 1.将dwRelocAddr这4字节的地址放入重定位表中,使其在运行后该位置的值变为程序基址
  38 2.先去dwCallAddr的位置,将那行代码修改为jmp dwJmpAddr(如果是mov eax,则直接修改即可,其他的则要填充多一个nop(0x90),以便对齐指令长度)
  39 3.执行shellcode时,会将2的调用地址+5/+6作为返回地址压栈 (jmp指令除外)
  40 4.将NewLatAddr的值,加上基址后,在得到的地址上取值,该地址上的值与原IAT所指向的值相同
  41 5.执行完后,根据3得到的值,返回到调用指令的下一条指令上
  42 */
  43 struct IatAddrTab
  44 {
  45     DWORD dwCallAddr;//以便区分当前是什么类型下使用了这个IAT地址  注意,这里为整个调用代码的位置,而非调用的代码的函数地址的位置    
  46     BYTE bType;//该调用类型 0-7为mov eax、edx、esp、esi、ecx、ebx、ebp、edi  8为call 9为jmp (其中8和9可以归类成一个处理方式) 10为push  
  47     DWORD dwRelocAddr;//用于添加到重定位块中,该位置存放的为基址
  48     WORD wIndex;//当前IAT位于加载表的下标 每个地址占4字节
  49     DWORD dwOldIatAddr;//原IAT地址
  50     DWORD dwNewIatAddr;//将要替换成的新IAT地址
  51     DWORD dwJmpAddr;//shellcode所在的起始位置RVA     
  52 };  
  53 vector<IatAddrTab>g_tagIAT;//存放IAT替换地址的结构体,成员为IAT地址,以及一个调用地址位置,还有一个该IAT类型
  54 
  55 
  56 vector<DWORD>g_IATaddrList;
  57 
  58 struct tagRelocation
  59 {
  60     DWORD wR_Head;
  61     vector<WORD>wR_Offset;
  62 };
  63 vector<tagRelocation>vOldReloction;
  64 
  65 
  66 VOID GetKernel32Base(X86Assembler &a)
  67 {
  68     Label GetInfoBegin = a.newLabel();
  69     Label cmpDllName = a.newLabel();
  70     Label cmpChar = a.newLabel();
  71     Label GetNextModule = a.newLabel();
  72     Label GetBaseOver = a.newLabel();
  73 
  74     a.push(ebx);
  75     a.push(ecx);
  76     a.push(edx);
  77     a.push(esi);
  78     a.push(edi);
  79     a.mov(edx, esp);
  80     a.sub(esp, 0x18);
  81     
  82     a.mov(dword_ptr(esp, 0x00), 0x0065006B);
  83     a.mov(dword_ptr(esp, 0x04), 0x006E0072);
  84     a.mov(dword_ptr(esp, 0x08), 0x006C0065);
  85     a.mov(dword_ptr(esp, 0x0C), 0x00320033);
  86     a.mov(dword_ptr(esp, 0x10), 0x0064002E);
  87     a.mov(dword_ptr(esp, 0x14), 0x006C006C);
  88     a.xor_(eax, eax);
  89     a.mov(esi, dword_ptr_abs(0x30).setSegment(fs));//获得PEB 同理mov esi,fs:[30]
  90     a.mov(esi, dword_ptr(esi, 0x0C));            //取到dll的列表指针
  91     a.mov(esi, dword_ptr(esi, 0x1C));             //取到初始化序模块化
  92 
  93     a.bind(GetInfoBegin);//遍历模块信息
  94     a.mov(edi, dword_ptr(esi, 8));//取到当前模块基址
  95     a.lea(ebx, dword_ptr(esi, 0x1c));//取到UNICODE STRING结构
  96     a.movzx(ecx, word_ptr(ebx));//取出长度
  97     a.cmp (ecx, 24);//对比长度
  98     a.jne(GetNextModule);//不等则获取下一个模块
  99     a.mov(ebx, dword_ptr(ebx , 4));//取到字符串地址  此时ebx不再为结构地址
 100     a.mov(ecx, 0);//用于遍历
 101 
 102     a.bind(cmpDllName);//对比模块名字
 103     a.cmp(ecx, 24);
 104     //遍历到字符末尾 找到目标模块(先对的长度再对的字符,排除了前面同名后面A/W的情况)
 105     a.jnl(GetBaseOver);//获取基址结束
 106     a.xor_ (eax, eax);//清空容器
 107     a.movzx(eax, word_ptr(ebx, ecx));
 108     a.cmp(eax, 0x41);//如果是大写字符(41~5A)范围内,转成小写
 109     a.jna(cmpChar);
 110     a.cmp(eax, 0x5A);
 111     a.ja(cmpChar);
 112     a.add(eax, 0x20);//大写字符的值+0x20即转成小写字符
 113     
 114     a.bind(cmpChar);//对比每个字符
 115     a.cmp(ax, word_ptr(esp, ecx));//对比字符串内容
 116     a.jne(GetNextModule);//不等则获取下一个模块
 117     a.add(ecx, 2);
 118     a.jmp(cmpDllName);
 119 
 120     a.bind(GetNextModule);//获得下一个模块信息
 121     a.mov(esi, dword_ptr(esi));//取得下一个初始化模块
 122     a.test(esi, esi);
 123     a.jnz(GetInfoBegin);//不为空则继续遍历
 124 
 125     a.bind(GetBaseOver);
 126     a.mov(eax, edi);
 127     a.add(esp, 0x18);
 128     a.pop(edi);
 129     a.pop(esi);
 130     a.pop(edx);
 131     a.pop(ecx);
 132     a.pop(ebx);
 133 }
 134 
 135 VOID GetLoadLibraryAAddr(X86Assembler &a)
 136 {
 137     //跳转标记
 138     Label FindFuncAddr = a.newLabel();
 139     Label FindFuncAddrOver = a.newLabel();
 140 
 141     a.push(ebx);
 142     a.push(ecx);
 143     a.push(esi);
 144     a.push(ebp);
 145     //记得开始获取出来的都是RVA  要加上DLL的基址edi来取值
 146     a.mov(eax, dword_ptr(edi, 0x3c));
 147     a.mov(ebx, dword_ptr(edi, eax, 0, 0x78));//NT头+0x78 = 导出表RVA
 148     //上面等价于[edi + eax + 0x78],如果没有0的话,他会把第三个参数当成2的N次方变成了edi + eax * 2的0x78次方
 149     a.add(ebx, edi);//ebx=导出表RVA+基址
 150     a.mov(ecx, dword_ptr(ebx, 0x18));//ecx=按名称导出个数
 151     a.mov(esi, dword_ptr(ebx, 0x20));//esi=导出函数名称表rva
 152     a.add(esi, edi);
 153 
 154     a.bind(FindFuncAddr);
 155     a.sub(ecx, 1);//从后面往前遍历 能少占用一个寄存器,但要记得先-1再遍历
 156     a.jz(FindFuncAddrOver);//减到0即遍历完
 157     a.mov(ebp, dword_ptr(esi, ecx, 2));//取到函数名称比拗最后一个函数名的RVA 等价于[esi,ecx*(2的n次方)]
 158     a.add(ebp, edi);
 159     a.cmp(dword_ptr(ebp), 0x64616F4C);
 160     a.jne(FindFuncAddr);
 161     a.cmp(dword_ptr(ebp, 4), 0x7262694C);
 162     a.jne(FindFuncAddr);
 163     a.cmp(dword_ptr(ebp, 8), 0x41797261);
 164     a.jne(FindFuncAddr);
 165     a.cmp(byte_ptr(ebp, 12), 0);//结束符  防止类似LoadLibrary和LoadLibraryA扩展函数名偏差出现
 166     a.jne(FindFuncAddr);
 167     //此时ecx为遍历的下标 
 168     a.mov(esi, dword_ptr(ebx, 0x24));//esi=导出函数序号表RVA(上面名称对比完 回收esi)
 169     a.add(esi, edi);
 170     a.movzx(ebp, word_ptr(esi, ecx, 1));//ebp=函数序号 ebp=[esi+ecx*2一次方]
 171     //EBP:Get=2b0 Load=3c2
 172     a.mov(esi, dword_ptr(ebx, 0x1c));//esi=函数地址表RVA
 173     a.add(esi, edi);
 174     a.mov(eax, dword_ptr(esi, ebp, 2));//地址=地址表+序号*2的2次方
 175     a.add(eax, edi);
 176     //此时eax为loadlibraryA地址
 177     a.bind(FindFuncAddrOver);
 178     a.pop(ebp);
 179     a.pop(esi);
 180     a.pop(ecx);
 181     a.pop(ebx);
 182 }
 183 
 184 VOID GetGetProcAddressAddr(X86Assembler &a)
 185 {
 186     //跳转标记
 187     Label FindFuncAddr = a.newLabel();
 188     Label FindFuncAddrOver = a.newLabel();
 189 
 190     a.push(ebx);
 191     a.push(ecx);
 192     a.push(esi);
 193     a.push(ebp);
 194     //记得开始获取出来的都是RVA  要加上DLL的基址edi来取值
 195     a.mov(eax, dword_ptr(edi, 0x3c));
 196     a.mov(ebx, dword_ptr(edi, eax, 0, 0x78));//NT头+0x78 = 导出表RVA
 197     //上面等价于[edi + eax + 0x78],如果没有0的话,他会把第三个参数当成2的N次方变成了edi + eax * 2的0x78次方
 198     a.add(ebx, edi);//ebx=导出表
 199     a.mov(ecx, dword_ptr(ebx, 0x18));//ecx=按名称导出个数
 200     a.mov(esi, dword_ptr(ebx, 0x20));//esi=导出函数名称表rva
 201     a.add(esi, edi);
 202 
 203     a.bind(FindFuncAddr);
 204     a.sub(ecx, 1);//从后面往前遍历 能少占用一个寄存器,但要记得先-1再遍历
 205     a.jz(FindFuncAddrOver);//减到0即遍历完
 206     a.mov(ebp, dword_ptr(esi, ecx, 2));//取到函数名称比拗最后一个函数名的RVA 等价于[esi,ecx*(2的n次方)]
 207     a.add(ebp, edi);
 208     a.cmp(dword_ptr(ebp), 0x50746547);
 209     a.jne(FindFuncAddr);
 210     a.cmp(dword_ptr(ebp, 4), 0x41636f72);
 211     a.jne(FindFuncAddr);
 212     a.cmp(dword_ptr(ebp, 8), 0x65726464);
 213     a.jne(FindFuncAddr);
 214     a.cmp(word_ptr(ebp, 12), 0x7373);
 215     a.jne(FindFuncAddr);
 216     a.cmp(byte_ptr(ebp, 14), 0);//结束符  防止类似LoadLibrary和LoadLibraryA扩展函数名偏差出现
 217     a.jne(FindFuncAddr);
 218 
 219     //此时ecx为遍历的下标 
 220     a.mov(esi, dword_ptr(ebx, 0x24));//esi=导出函数序号表RVA(上面名称对比完 回收esi)
 221     a.add(esi, edi);
 222     a.movzx(ebp, word_ptr(esi, ecx, 1));//ebp=函数序号 ebp=[esi+ecx*2一次方]
 223     //EBP:Get=2b0 Load=3c2
 224     a.mov(esi, dword_ptr(ebx, 0x1c));//esi=函数地址表RVA
 225     a.add(esi, edi);
 226     a.mov(eax, dword_ptr(esi, ebp, 2));//地址=地址表+序号*2的2次方
 227     a.add(eax, edi);
 228     //此时eax为loadlibraryA地址
 229     a.bind(FindFuncAddrOver);
 230     a.pop(ebp);
 231     a.pop(esi);
 232     a.pop(ecx);
 233     a.pop(ebx);
 234 }
 235 DWORD RVAtoFA(DWORD dwRVA)        //RVA转文件地址
 236 {
 237     PIMAGE_DOS_HEADER pDosHead = PIMAGE_DOS_HEADER(g_pFileSrc);
 238     PIMAGE_NT_HEADERS pNtHead = PIMAGE_NT_HEADERS((DWORD)pDosHead + pDosHead->e_lfanew);
 239     PIMAGE_SECTION_HEADER pSection = (PIMAGE_SECTION_HEADER)(pNtHead->FileHeader.SizeOfOptionalHeader + (DWORD)&pNtHead->OptionalHeader);
 240     int iSectionNum = pNtHead->FileHeader.NumberOfSections;
 241 
 242     for (int i = 0; i < iSectionNum; i++)
 243     {
 244         if (dwRVA >= pSection->VirtualAddress && dwRVA < (pSection->VirtualAddress + pSection->Misc.VirtualSize))
 245         {
 246             return (DWORD)g_pFileSrc + dwRVA - pSection->VirtualAddress + pSection->PointerToRawData;
 247         }
 248         pSection++;
 249     }
 250     return 0; //转换失败
 251 }
 252 
 253 DWORD FAtoRVA(DWORD dwFA)        //文件地址转RVA
 254 {
 255     PIMAGE_DOS_HEADER pDosHead = PIMAGE_DOS_HEADER(g_pFileSrc);
 256     PIMAGE_NT_HEADERS pNtHead = PIMAGE_NT_HEADERS((DWORD)pDosHead + pDosHead->e_lfanew);
 257     PIMAGE_SECTION_HEADER pSection = (PIMAGE_SECTION_HEADER)(pNtHead->FileHeader.SizeOfOptionalHeader + (DWORD)&pNtHead->OptionalHeader);
 258     int iSectionNum = pNtHead->FileHeader.NumberOfSections;
 259 
 260     for (int i = 0; i < iSectionNum; i++)
 261     {
 262         if (dwFA >= pSection->PointerToRawData && dwFA < (pSection->PointerToRawData + pSection->SizeOfRawData))
 263         {
 264             return (DWORD)dwFA - pSection->PointerToRawData + pSection->VirtualAddress;
 265         }
 266         pSection++;
 267     }
 268     return 0; //转换失败
 269 }
 270 
 271 
 272 BOOL LoadFile(char *pFileName)    //获取文件内容
 273 {
 274     HANDLE hFile = CreateFileA(pFileName,
 275         GENERIC_READ,
 276         FILE_SHARE_READ,
 277         NULL,
 278         OPEN_EXISTING,
 279         FILE_ATTRIBUTE_NORMAL,
 280         0);
 281     if (!hFile)
 282     {
 283         return false;
 284     }
 285     g_iFileSize = GetFileSize(hFile, NULL);
 286 
 287     g_pFileSrc = (UCHAR*)malloc(g_iFileSize);
 288     if (!g_pFileSrc)
 289     {
 290         cout << "申请内存失败" << endl;
 291         return false;
 292     }
 293 
 294     if (!ReadFile(hFile, g_pFileSrc, g_iFileSize, NULL, NULL))
 295     {
 296         cout << "读取文件失败" << endl;
 297         return false;
 298     }
 299 
 300     return true;
 301 }
 302 
 303 
 304 BOOL CheckPE()        //检查PE文件格式
 305 {
 306     PIMAGE_DOS_HEADER pDosHead = PIMAGE_DOS_HEADER(g_pFileSrc);
 307     PIMAGE_NT_HEADERS pNtHead = PIMAGE_NT_HEADERS((DWORD)pDosHead + pDosHead->e_lfanew);
 308     if (pDosHead->e_magic != 0x5a4d || pNtHead->Signature != 0x4550)
 309     {
 310         return false;
 311     }
 312     g_iImageBase = pNtHead->OptionalHeader.ImageBase;
 313     g_iFileAlignment = pNtHead->OptionalHeader.FileAlignment;
 314     g_iSectionAlignment = pNtHead->OptionalHeader.SectionAlignment;
 315     g_iOldOEP = pNtHead->OptionalHeader.AddressOfEntryPoint;
 316     return true;
 317 }
 318 
 319 
 320 
 321 BOOL FindCodeAddr()         //找到调用了IAT中的地址的代码位置
 322 {
 323     PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
 324     PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 325     if (!pNtHead->OptionalHeader.DataDirectory[1].VirtualAddress)
 326     {
 327         return false;
 328     }
 329 
 330     PIMAGE_IMPORT_DESCRIPTOR pImpotrList = (PIMAGE_IMPORT_DESCRIPTOR)RVAtoFA(pNtHead->OptionalHeader.DataDirectory[1].VirtualAddress);  //IAT
 331     while (pImpotrList->FirstThunk)//获得该程序的IAT地址
 332     {
 333         int i = 0;
 334         while (1)
 335         {
 336             DWORD iIatAddr = *(DWORD*)RVAtoFA(pImpotrList->FirstThunk + i * sizeof(DWORD));
 337             if (!iIatAddr)
 338             {
 339                 break;
 340             }
 341             DWORD dwIatAddr = pImpotrList->FirstThunk + i * sizeof(DWORD);
 342             g_IATaddrList.push_back(dwIatAddr);
 343             i++;
 344         }
 345         pImpotrList++;
 346     }
 347 
 348 
 349     //获取调用这些IAT地址的代码地址
 350     for (int i = 0; i < g_iFileSize - 5; i++)
 351     {
 352         //mov eax
 353         if (g_pFileSrc[i] == 0xA1)
 354         {
 355             DWORD IatAddr = *(DWORD*)(g_pFileSrc + i + 1);
 356             for (int iNum = 0; iNum < g_IATaddrList.size(); iNum++)
 357             {
 358                 if (g_IATaddrList[iNum] == (IatAddr^g_iImageBase))
 359                 {
 360                     IatAddrTab IatInfo;
 361                     IatInfo.dwCallAddr = FAtoRVA(i);
 362                     IatInfo.bType = 0;
 363                     IatInfo.wIndex = iNum;
 364                     IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 365                     g_tagIAT.push_back(IatInfo);
 366                     i += 4;   //for循环会加1,操作符+地址共5字节
 367                     continue;
 368                 }
 369             }
 370         }
 371 
 372         //mov edx、esp、esi、ecx、ebx、ebp、edi
 373         if (g_pFileSrc[i] == 0x8B && (g_pFileSrc[i + 1] == 0x15 || g_pFileSrc[i + 1] == 0x25 || g_pFileSrc[i + 1] == 0x35 ||
 374             g_pFileSrc[i + 1] == 0x0D || g_pFileSrc[i + 1] == 0x1D || g_pFileSrc[i + 1] == 0x2D || g_pFileSrc[i + 1] == 0x3D))
 375         {
 376             DWORD IatAddr = *(DWORD*)(g_pFileSrc + i + 2);
 377             for (int iNum = 0; iNum < g_IATaddrList.size(); iNum++)
 378             {
 379                 if (g_IATaddrList[iNum] == (IatAddr^g_iImageBase))
 380                 {
 381                     DWORD ddddd = FAtoRVA(i);
 382                     if (g_pFileSrc[i + 1] == 0x15)    //edx
 383                     {
 384                         IatAddrTab IatInfo;
 385                         IatInfo.dwCallAddr = FAtoRVA(i);
 386                         IatInfo.bType = 1;
 387                         IatInfo.wIndex = iNum;
 388                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 389                         g_tagIAT.push_back(IatInfo);
 390                     }
 391                     else if (g_pFileSrc[i + 1] == 0x25)  //esp
 392                     {
 393                         IatAddrTab IatInfo;
 394                         IatInfo.dwCallAddr = FAtoRVA(i);
 395                         IatInfo.bType = 2;
 396                         IatInfo.wIndex = iNum;
 397                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 398                         g_tagIAT.push_back(IatInfo);
 399                     }
 400                     else if (g_pFileSrc[i + 1] == 0x35)        //esi
 401                     {
 402                         IatAddrTab IatInfo;
 403                         IatInfo.dwCallAddr = FAtoRVA(i);
 404                         IatInfo.bType = 3;
 405                         IatInfo.wIndex = iNum;
 406                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 407                         g_tagIAT.push_back(IatInfo);
 408                     }
 409                     else if (g_pFileSrc[i + 1] == 0x0D)        //ecx
 410                     {
 411                         IatAddrTab IatInfo;
 412                         IatInfo.dwCallAddr = FAtoRVA(i);
 413                         IatInfo.bType = 4;
 414                         IatInfo.wIndex = iNum;
 415                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 416                         g_tagIAT.push_back(IatInfo);
 417                     }
 418                     else if (g_pFileSrc[i + 1] == 0x1D)        //ebx
 419                     {
 420                         IatAddrTab IatInfo;
 421                         IatInfo.dwCallAddr = FAtoRVA(i);
 422                         IatInfo.bType = 5;
 423                         IatInfo.wIndex = iNum;
 424                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 425                         g_tagIAT.push_back(IatInfo);
 426                     }
 427                     else if (g_pFileSrc[i + 1] == 0x2D)        //ebp
 428                     {
 429                         IatAddrTab IatInfo;
 430                         IatInfo.dwCallAddr = FAtoRVA(i);
 431                         IatInfo.bType = 6;
 432                         IatInfo.wIndex = iNum;
 433                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 434                         g_tagIAT.push_back(IatInfo);
 435                     }
 436                     else if (g_pFileSrc[i + 1] == 0x3D)        //edi
 437                     {
 438                         IatAddrTab IatInfo;
 439                         IatInfo.dwCallAddr = FAtoRVA(i);
 440                         IatInfo.bType = 7;
 441                         IatInfo.wIndex = iNum;
 442                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 443                         g_tagIAT.push_back(IatInfo);
 444                     }
 445                     i += 5;   //for循环会加1,操作符+地址共6字节
 446                     continue;
 447                 }
 448             }
 449         }
 450 
 451         //call jmp push
 452         if (g_pFileSrc[i] == 0xFF && (g_pFileSrc[i + 1] == 0x15 || g_pFileSrc[i + 1] == 0x25 || g_pFileSrc[i + 1] == 0x35))
 453         {
 454             DWORD IatAddr = *(DWORD*)(g_pFileSrc + i + 2);
 455             for (int iNum = 0; iNum < g_IATaddrList.size(); iNum++)
 456             {
 457                 if (g_IATaddrList[iNum] == (IatAddr^g_iImageBase))
 458                 {
 459                     DWORD ddddd = FAtoRVA(i);
 460                     if (g_pFileSrc[i + 1] == 0x15) //call
 461                     {
 462                         IatAddrTab IatInfo;
 463                         IatInfo.dwCallAddr = FAtoRVA(i);
 464                         IatInfo.bType = 8;
 465                         IatInfo.wIndex = iNum;
 466                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 467                         g_tagIAT.push_back(IatInfo);
 468                     }
 469                     else if (g_pFileSrc[i + 1] == 0x25)  //jmp
 470                     {
 471                         IatAddrTab IatInfo;
 472                         IatInfo.dwCallAddr = FAtoRVA(i);
 473                         IatInfo.bType = 9;
 474                         IatInfo.wIndex = iNum;
 475                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 476                         g_tagIAT.push_back(IatInfo);
 477                     }
 478                     else if (g_pFileSrc[i + 1] == 0x35)        //push
 479                     {
 480                         IatAddrTab IatInfo;
 481                         IatInfo.dwCallAddr = FAtoRVA(i);
 482                         IatInfo.bType = 10;
 483                         IatInfo.wIndex = iNum;
 484                         IatInfo.dwOldIatAddr = g_IATaddrList[iNum];
 485                         g_tagIAT.push_back(IatInfo);
 486                     }
 487                     i += 5;   //for循环会加1,操作符+地址共6字节
 488                     continue;
 489                 }
 490             }
 491         }
 492     }
 493 
 494     return true;
 495 }
 496 
 497 
 498 bool SaveDll() //保存DLL相关数据
 499 {
 500     PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
 501     PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 502     DWORD dwImportRVA = pNtHead->OptionalHeader.DataDirectory[1].VirtualAddress;
 503     PIMAGE_IMPORT_DESCRIPTOR pImport = (PIMAGE_IMPORT_DESCRIPTOR)RVAtoFA(dwImportRVA);
 504     while (pImport->FirstThunk)
 505     {
 506         DLLFuncTag tagDllList;//Dll信息结构
 507 
 508         char *szDllName = (char*)RVAtoFA(pImport->Name);
 509         int iDllNameLen = strlen(szDllName) + 1;
 510         char *szNewDllName = (char*)malloc(iDllNameLen);
 511         memcpy(szNewDllName, szDllName, iDllNameLen);
 512 
 513         tagDllList.szDllName = szNewDllName;
 514         tagDllList.bDllNameLenth = iDllNameLen;
 515 
 516         PIMAGE_THUNK_DATA pIAT = (PIMAGE_THUNK_DATA)RVAtoFA(pImport->FirstThunk);
 517         while (pIAT->u1.Function)
 518         {
 519             FuncTag tagFuncInfo;//函数信息结构
 520             DWORD dwFuncAddr = pIAT->u1.Function;
 521             if (dwFuncAddr & 0x80000000)
 522             {
 523                 tagDllList.bTab = 0;//按序号导入
 524                 tagFuncInfo.iFuncNameLenth = 4;
 525                 tagFuncInfo.szFuncName = (char*)(dwFuncAddr ^ 0x80000000);
 526                 tagDllList.vFuncNAMEorNo.push_back(tagFuncInfo);
 527             }
 528             else
 529             {
 530                 tagDllList.bTab = 1;//按名称导入
 531                 PIMAGE_IMPORT_BY_NAME pFunc = (PIMAGE_IMPORT_BY_NAME)RVAtoFA(pIAT->u1.Function);
 532                 int iFuncNameLen = strlen(pFunc->Name) + 1;
 533                 char *szFuncName = (char*)malloc(iFuncNameLen);
 534                 memcpy(szFuncName, pFunc->Name, iFuncNameLen);
 535                 tagFuncInfo.iFuncNameLenth = iFuncNameLen;
 536                 tagFuncInfo.szFuncName = szFuncName;
 537                 tagDllList.vFuncNAMEorNo.push_back(tagFuncInfo);
 538             }
 539             pIAT++;
 540         }
 541         tagDllList.wFuncNum = tagDllList.vFuncNAMEorNo.size();
 542         g_tagDllFunc.push_back(tagDllList);
 543         pImport++;
 544     }
 545 
 546     //将IAT表信息隐藏(每个DLL只有一个导入函数)
 547     PIMAGE_IMPORT_DESCRIPTOR pImpotrList = (PIMAGE_IMPORT_DESCRIPTOR)RVAtoFA(pNtHead->OptionalHeader.DataDirectory[1].VirtualAddress);
 548     while (pImpotrList->FirstThunk)
 549     {
 550         PIMAGE_THUNK_DATA pIAT = (PIMAGE_THUNK_DATA)RVAtoFA(pImpotrList->FirstThunk);
 551         PIMAGE_THUNK_DATA pINT = (PIMAGE_THUNK_DATA)RVAtoFA(pImpotrList->OriginalFirstThunk);
 552         pIAT++;//保留第一个
 553         pINT++;
 554         while (pIAT->u1.Function)//将IAT清空
 555         {
 556             pIAT->u1.Function = 0;
 557             pIAT++;
 558         }
 559         while (pINT->u1.Function)//将INT清空
 560         {
 561             pINT->u1.Function = 0;
 562             pINT++;
 563         }
 564         pImpotrList++;
 565     }
 566     return true;
 567 }
 568 
 569 
 570 
 571 
 572 bool NewIat()
 573 {
 574     PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
 575     PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 576     PIMAGE_SECTION_HEADER pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
 577     for (int i = 0; i < pNtHead->FileHeader.NumberOfSections; i++)
 578     {
 579         //将每个节都改为可写属性,以便在后续修改。
 580         //本来只修改.text节的属性即可,但由于该节的位置不在data数组里面记录,单凭节名判断未必准确,所以将所以节都改为可写-
 581         pSection->Characteristics += 0x80000000;
 582     }
 583     if (!(pNtHead->OptionalHeader.DataDirectory[5].VirtualAddress))//当当前程序没有重定位表
 584     {
 585         PIMAGE_SECTION_HEADER pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
 586         pSection += pNtHead->FileHeader.NumberOfSections - 1;
 587         int iNewSectionFileAddr = pSection->PointerToRawData + pSection->SizeOfRawData;
 588         int iNewSectionFileMapAddr = 0;
 589         if (!(pSection->Misc.VirtualSize % g_iSectionAlignment))
 590         {
 591             iNewSectionFileMapAddr = pSection->VirtualAddress + pSection->Misc.VirtualSize;
 592         }
 593         else
 594         {
 595             iNewSectionFileMapAddr = pSection->VirtualAddress + pSection->Misc.VirtualSize
 596                 + g_iSectionAlignment - (pSection->Misc.VirtualSize % g_iSectionAlignment);
 597         }
 598 
 599         pSection++;
 600         memcpy(pSection->Name, ".KD", 3);
 601         pSection->VirtualAddress = iNewSectionFileMapAddr;
 602         pSection->PointerToRawData = iNewSectionFileAddr;
 603         pSection->Characteristics = (0x20000000 | 0x40000000 | 0x80000000 | 0x40); //节属性 可读可写可执行已被初始化
 604         pNtHead->FileHeader.NumberOfSections += 1;//节表数量+1
 605 
 606 
 607         //将IAT的数据压入新节中数据排列分别为DLL数量(2字节)、DLL名字长度、该
 608         int iAddIatLenth = 0;//已经增加的iat数据长度
 609         //先添加2字节数据说明该程序的DLL数量
 610         g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 1);
 611         byte bDllNum = g_tagDllFunc.size();
 612         memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, &bDllNum, 1);
 613         iAddIatLenth += 2;
 614         for (int i = 0; i < bDllNum; i++)
 615         {
 616             //添加DLL名长度
 617             int bDllNameLenth = g_tagDllFunc[i].bDllNameLenth;
 618             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 2);
 619             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, &bDllNameLenth, 2);
 620             iAddIatLenth += 2;
 621 
 622             //添加DLL名
 623             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + bDllNameLenth);
 624             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, g_tagDllFunc[i].szDllName, bDllNameLenth);
 625             iAddIatLenth += bDllNameLenth;
 626 
 627             //添加该DLL中的导入函数数量  方便后续遍历
 628             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 4);
 629             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (DWORD*)&g_tagDllFunc[i].wFuncNum, 4);
 630             iAddIatLenth += 4;
 631 
 632             //添加该DLL的导入方式 0为序号1为名称
 633             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 1);
 634             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (byte*)&g_tagDllFunc[i].bTab, 1);
 635             iAddIatLenth += 1;
 636             for (int j = 0; j < g_tagDllFunc[i].wFuncNum; j++)
 637             {
 638                 //添加函数名或序号
 639                 if (!(g_tagDllFunc[i].bTab)) //序号
 640                 {
 641                     g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 6);//2长度4序号
 642                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (WORD*)&g_tagDllFunc[i].vFuncNAMEorNo[j].iFuncNameLenth, 2);
 643                     iAddIatLenth += 2;
 644                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (DWORD*)&g_tagDllFunc[i].vFuncNAMEorNo[j].szFuncName, 4);
 645                     iAddIatLenth += 4;
 646                 }
 647                 else  //名字
 648                 {
 649                     int iFuncNameLenth = g_tagDllFunc[i].vFuncNAMEorNo[j].iFuncNameLenth;//长度
 650                     g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 2 + iFuncNameLenth);//前2字节存放长度 后面为函数名称
 651                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (WORD*)&iFuncNameLenth, 2);
 652                     iAddIatLenth += 2;
 653                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, g_tagDllFunc[i].vFuncNAMEorNo[j].szFuncName, iFuncNameLenth);
 654                     iAddIatLenth += iFuncNameLenth;
 655                 }
 656             }
 657         }
 658 
 659         //获取新的OEP并修改旧的OEP
 660         g_iNewOEP = iNewSectionFileMapAddr + iAddIatLenth;//新节的
 661         pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
 662         pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 663         pNtHead->OptionalHeader.AddressOfEntryPoint = g_iNewOEP;
 664 
 665         JitRuntime        _x86RunTimeObject;
 666         X86Assembler    a(&_x86RunTimeObject);
 667 
 668         //当程序没有重定位表时,根据call 0000 0000来获得进程基址,有重定位表时则根据重定位表
 669         char szGetOEP[] = { 0xE8, 0x00, 0x00, 0x00, 0x00 }; //同理jit.call(0x00000000);
 670         a.pop(eax);
 671         a.sub(eax, 5);//此时得到oep所在的地址 oep距离基址隔着
 672         a.sub(eax, g_iNewOEP);//OEP所在的基址-偏移  得到基址
 673         a.mov(ebp, eax);    //保存进程基址到ebp
 674         a.add(eax, g_iOldOEP);
 675         a.jmp(eax);
 676 
 677         PVOID szJit = a.make();
 678         int iJitLenth = a.getCodeSize() + 5; //包括e8 0000 0000;
 679 
 680         g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + iJitLenth);
 681         memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, szGetOEP, 5);
 682         memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth + 5, szJit, iJitLenth);
 683 
 684         int iAddSrcLen = iAddIatLenth + iJitLenth;//一共增加的代码
 685         //完善节长度等数据  保守起见重新获取节表信息
 686         pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
 687         pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 688         pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
 689         pSection += pNtHead->FileHeader.NumberOfSections - 1;
 690         if (!(iAddSrcLen%g_iFileAlignment))
 691         {
 692             pSection->SizeOfRawData = iAddSrcLen;
 693         }
 694         else
 695         {
 696             pSection->SizeOfRawData = iAddSrcLen + g_iFileAlignment - (iAddSrcLen%g_iFileAlignment);
 697         }
 698         if (!(iAddSrcLen%g_iSectionAlignment))
 699         {
 700             pSection->Misc.VirtualSize = iAddSrcLen;
 701         }
 702         else
 703         {
 704             pSection->Misc.VirtualSize = iAddSrcLen + g_iSectionAlignment - (iAddSrcLen%g_iSectionAlignment);
 705         }
 706         pNtHead->OptionalHeader.SizeOfImage += pSection->Misc.VirtualSize;
 707 
 708         if (iAddSrcLen != pSection->SizeOfRawData)//当新增长度与对齐后的节长度不相等时,将其补全
 709         {
 710             int iLenth = pSection->SizeOfRawData;//先保存,以免扩容后原地址被回收
 711             //g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iLenth);
 712             UCHAR *uuu = (UCHAR*)malloc(g_iFileSize + iAddSrcLen);
 713             memcpy(uuu, g_pFileSrc, g_iFileSize + iAddSrcLen);
 714             g_pFileSrc = (UCHAR*)malloc(g_iFileSize + iLenth);
 715             memcpy(g_pFileSrc, uuu, g_iFileSize + iAddSrcLen);
 716             memset(g_pFileSrc + g_iFileSize + iAddSrcLen, 0, iLenth - iAddSrcLen);
 717         }
 718         g_iFileSize += pSection->SizeOfRawData;
 719     }
 720 
 721 
 722 
 723     /////////////////////////////////////////////////////////////////////////////
 724     //当有重定位表时,先保存相关数据,删除重定位表,新增节,再在后面还原重定位表
 725     else
 726     {
 727         //把重定位表数据移动到新节当中
 728         //获取位置和长度
 729         int iRelocationAddr = pNtHead->OptionalHeader.DataDirectory[5].VirtualAddress;
 730         int iRelocationLenth = pNtHead->OptionalHeader.DataDirectory[5].Size;//数据长度
 731         char *szR_Src = (char*)malloc(iRelocationLenth);
 732         memcpy(szR_Src, (char*)RVAtoFA(iRelocationAddr), iRelocationLenth);
 733         
 734         PIMAGE_SECTION_HEADER pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
 735         char szR_Name[8] = { 0 };
 736         int iR_MapLenth = 0;//节中映射长度
 737         int iR_FileLenth = 0;//节中文件长度
 738         while (1)
 739         {
 740             if (pSection->VirtualAddress == iRelocationAddr) //定位到重定位表节表
 741             {
 742                 strcpy(szR_Name, (char*)pSection->Name);
 743                 iR_MapLenth = pSection->Misc.VirtualSize;
 744                 iR_FileLenth = pSection->SizeOfRawData;
 745                 break;
 746             }
 747             pSection++;
 748         }
 749 
 750         //删除重定位表相关信息
 751         memset(g_pFileSrc + g_iFileSize - iR_FileLenth, 0, iR_FileLenth);//把重定位表数据用0覆盖
 752         memset(pSection, 0, sizeof(IMAGE_SECTION_HEADER));
 753         pNtHead->FileHeader.NumberOfSections--;
 754         //调整文件内存大小
 755         int iAlignmentSize = iR_MapLenth % g_iSectionAlignment;
 756         if (!iAlignmentSize)
 757         {
 758             pNtHead->OptionalHeader.SizeOfImage -= iR_MapLenth;        //调整文件内存大小
 759         }
 760         else
 761         {
 762             pNtHead->OptionalHeader.SizeOfImage =
 763                 pNtHead->OptionalHeader.SizeOfImage
 764                 - (iR_MapLenth - iAlignmentSize + g_iSectionAlignment);
 765         }
 766         g_iFileSize -= iR_FileLenth;
 767 
 768 
 769         //新增节
 770         pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
 771         pSection += pNtHead->FileHeader.NumberOfSections - 1;
 772         int iNewSectionFileAddr = pSection->PointerToRawData + pSection->SizeOfRawData;
 773         int iNewSectionFileMapAddr = 0;
 774         if (!(pSection->Misc.VirtualSize % g_iSectionAlignment))
 775         {
 776             iNewSectionFileMapAddr = pSection->VirtualAddress + pSection->Misc.VirtualSize;
 777         }
 778         else
 779         {
 780             iNewSectionFileMapAddr = pSection->VirtualAddress + pSection->Misc.VirtualSize
 781                 + g_iSectionAlignment - (pSection->Misc.VirtualSize % g_iSectionAlignment);
 782         }
 783 
 784         pSection++;
 785         memcpy(pSection->Name, ".KD", 3);
 786         pSection->VirtualAddress = iNewSectionFileMapAddr;
 787         pSection->PointerToRawData = iNewSectionFileAddr;
 788         pSection->Characteristics = (0x20000000 | 0x40000000 | 0x80000000 | 0x40); //节属性 可读可写可执行已被初始化
 789         pNtHead->FileHeader.NumberOfSections += 1;//节表数量+1
 790 
 791 
 792         //将IAT的数据压入新节中数据排列分别为DLL数量(2字节)、DLL名字长度、该
 793         int iAddIatLenth = 0;//已经增加的iat数据长度
 794         //先添加1字节数据说明该程序的DLL数量
 795         g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 1);
 796         byte bDllNum = g_tagDllFunc.size();
 797         memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, &bDllNum, 1);
 798         iAddIatLenth += 1;
 799         for (int i = 0; i < bDllNum; i++)
 800         {
 801             //添加DLL名长度
 802             byte bDllNameLenth = g_tagDllFunc[i].bDllNameLenth;
 803             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 1);
 804             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, &bDllNameLenth, 1);
 805             iAddIatLenth += 1;
 806 
 807             //添加DLL名
 808             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + bDllNameLenth);
 809             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, g_tagDllFunc[i].szDllName, bDllNameLenth);
 810             iAddIatLenth += bDllNameLenth;
 811 
 812             //添加该DLL中的导入函数数量  方便后续遍历
 813             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 2);
 814             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (DWORD*)&g_tagDllFunc[i].wFuncNum, 2);
 815             iAddIatLenth += 2;
 816 
 817             //添加该DLL的导入方式 0为序号1为名称
 818             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 1);
 819             memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (byte*)&g_tagDllFunc[i].bTab, 1);
 820             iAddIatLenth += 1;
 821             for (int j = 0; j < g_tagDllFunc[i].wFuncNum; j++)
 822             {
 823                 //添加函数名或序号
 824                 if (!(g_tagDllFunc[i].bTab)) //序号
 825                 {
 826                     g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 5);//1长度4序号
 827                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (BYTE*)&g_tagDllFunc[i].vFuncNAMEorNo[j].iFuncNameLenth, 1);
 828                     iAddIatLenth += 1;
 829                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (DWORD*)&g_tagDllFunc[i].vFuncNAMEorNo[j].szFuncName, 4);
 830                     iAddIatLenth += 4;
 831                 }
 832                 else  //名字
 833                 {
 834                     int iFuncNameLenth = g_tagDllFunc[i].vFuncNAMEorNo[j].iFuncNameLenth;//长度
 835                     g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + 1 + iFuncNameLenth);//前2字节存放长度 后面为函数名称
 836                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, (BYTE*)&iFuncNameLenth, 1);
 837                     iAddIatLenth += 1;
 838                     memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth, g_tagDllFunc[i].vFuncNAMEorNo[j].szFuncName, iFuncNameLenth);
 839                     iAddIatLenth += iFuncNameLenth;
 840                 }
 841             }
 842         }
 843 
 844         //存放加载的函数地址表的RVA
 845         int iLoadAddressTabRVA = iNewSectionFileMapAddr + iAddIatLenth;
 846         int iLoadIatLenth = g_IATaddrList.size() * 4;//用于存放加载的函数地址表长度  此处多4字节来存放基址
 847 
 848 
 849         //获取新的OEP并修改旧的OEP
 850         g_iNewOEP = iNewSectionFileMapAddr + iAddIatLenth + iLoadIatLenth;
 851         pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
 852         pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
 853          pNtHead->OptionalHeader.AddressOfEntryPoint = g_iNewOEP;
 854 
 855         JitRuntime        _x86RunTimeObject;
 856         X86Assembler    a(&_x86RunTimeObject);
 857 
 858         //跳转标记
 859         Label LoadDllBegin = a.newLabel();
 860         Label LoadDllOver = a.newLabel();
 861         
 862         Label NameExport = a.newLabel();
 863         Label NameExportBegin = a.newLabel();
 864         Label NameExportOver = a.newLabel();
 865         Label NoExportBegin = a.newLabel();
 866         Label NoExportOver = a.newLabel();
 867 
 868         //test
 869         Label lTest = a.newLabel();
 870         
 871         //当有重定位表时,将NewOEP+1新增到重定位项中,重定位后的地址-OldOEP即可得到新的基址
 872         //这里push g_iOldOEP + g_iImageBase而不是g_iImageBase(直接得到新基址 不用再-旧OEP),是因为push完还要ret到旧OEP
 873         //执行完这段后,栈上是旧OEP的地址,ebx是程序基址
 874         a.push(g_iOldOEP + g_iImageBase);
 875         a.mov(ebx, dword_ptr(esp));
 876         a.sub(ebx, g_iOldOEP);
 877         
 878         /*a.call(lTest);
 879         a.bind(lTest);
 880         a.pop(eax);*/
 881 
 882         a.pusha();
 883         a.push(ebx);//将程序基址保存到栈上
 884         a.sub(esp, 0x8);
 885         a.mov(ebp, esp); //ebp从上往下分别是LoadLibraryA函数地址、GetProcAddress函数地址和程序基址  ebp-4为Dll基址 -8为填充函数加载地址起始地址
 886         a.sub(esp, 0x8);
 887         
 888         GetKernel32Base(a);
 889         a.mov(edi, eax);//edi为所遍历到的DLL基址
 890 
 891         //计算函数地址
 892         GetLoadLibraryAAddr(a);
 893         a.mov(dword_ptr(ebp, 0), eax);//保存LoadLibraryA的值到栈上
 894         GetGetProcAddressAddr(a);
 895         a.mov(dword_ptr(ebp, 4), eax);//保存GetProcAddress的值到栈上
 896         a.mov(eax, iLoadAddressTabRVA);
 897         a.add(eax, dword_ptr(ebp, 8));//填充函数地址RVA+程序基址
 898         a.mov(dword_ptr(ebp, -8), eax);//放到ebp-8的地址上
 899 
 900 
 901         //开始遍历IAT数据,填充函数加载地址表
 902         a.mov(esi, iNewSectionFileMapAddr);
 903         a.add(esi, dword_ptr(ebp, 8));//esi为IAT数据起点
 904         a.mov(ebx, 1);//以ebx开始遍历  达到长度 退出
 905 
 906 
 907         //加载DLL
 908         a.bind(LoadDllBegin);
 909         a.cmp(ebx, iAddIatLenth);//如果遍历长度大于等于IAT数据长度
 910         a.jnl(LoadDllOver);
 911         a.movzx(ecx, byte_ptr(esi, ebx));//取得DLL名长度
 912         a.add(ebx, 1);//+Dll名长度的变量1
 913         a.lea(eax, dword_ptr(esi,ebx));//获得函数名地址
 914         a.push(eax);
 915         a.add(ebx, ecx);//+DLL名长度
 916         a.mov(eax, dword_ptr(ebp));//获得loadlibrary地址
 917         a.call(eax);
 918         a.mov(dword_ptr(ebp,-4),eax);//ebp为load.. +4为get.. +8为程序基址  -4为当前Dll基址 -8为填充函数加载地址位置
 919         a.movzx(edi, word_ptr(esi, ebx));//取出该DLL导出函数数量
 920         a.add(ebx, 2);
 921         a.movzx(edx, byte_ptr(esi, ebx));//取出导出方式
 922         a.add(ebx, 1);
 923         a.cmp(edx, 1);//为1时,名称导出
 924         a.je(NameExportBegin);
 925 
 926 
 927         //序号导出
 928         a.bind(NoExportBegin);//序号导出循环起点
 929         a.cmp(edi, 0);
 930         a.je(NoExportOver);
 931         a.add(ebx, 1);
 932         a.mov(eax, dword_ptr(esi, ebx));//取得序号
 933         a.add(ebx, 4);
 934         a.push(eax);
 935         a.push(dword_ptr(ebp, -4));
 936         a.mov(eax, dword_ptr(ebp, 4));//获得GetProcAddress
 937         a.call(eax);
 938         a.mov(edx, dword_ptr(ebp, -8));//取得装载函数表
 939         a.mov(dword_ptr(edx), eax);
 940         a.add(dword_ptr(ebp, -8), 4);//装载函数表RVA+4
 941         a.sub(edi, 1);
 942         a.jmp(NoExportBegin);
 943         a.bind(NoExportOver);//序号导出循环终点
 944         a.jmp(LoadDllBegin); //重新加载新DLL
 945 
 946         //名称导出
 947         a.bind(NameExportBegin);//名称导出循环起点
 948         a.cmp(edi, 0);
 949         a.je(NameExportOver);
 950         a.movzx(ecx, byte_ptr(esi, ebx));//取得名称长度
 951         a.add(ebx, 1);
 952         a.lea(eax, dword_ptr(esi, ebx));//名称地址
 953         a.push(eax);
 954         a.add(ebx, ecx);
 955         a.push(dword_ptr(ebp, -4));
 956         a.mov(eax, dword_ptr(ebp, 4));
 957         a.call(eax);
 958         a.mov(edx, dword_ptr(ebp, -8));//取得装载函数表
 959         a.mov(dword_ptr(edx), eax);
 960         a.add(dword_ptr(ebp, -8), 4);//装载函数表RVA+4
 961         a.sub(edi, 1);
 962         a.jmp(NameExportBegin);
 963         a.bind(NameExportOver);//名称导出循环终点
 964         a.jmp(LoadDllBegin); //重新加载新DLL
 965         
 966 
 967         
 968         ///////////开始构造替换调用代码的shellcode//////////////
 969         //注意esp为当前操作的栈顶  ebp+8为程序所在基址
 970         int iNewJitBeginAddrRva = iNewSectionFileMapAddr + iAddIatLenth + iLoadIatLenth; //替换的shellcode开始的地址
 971         int iNewJitLenth = a.getCodeSize();
 972         for (int i = 0; i < g_tagIAT.size(); i++)
 973         {
 974             if (g_tagIAT[i].bType == 0)    //EAX
 975             {
 976                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
 977                 a.push(ebx);
 978                 a.push(ebx);
 979                 a.push(ebx);
 980                 a.push(esi);
 981                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 5);
 982                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
 983                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
 984                 a.lea(ebx, dword_ptr(ebx, esi));
 985                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+5+程序基址 =返回地址
 986                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
 987                 a.lea(ebx, dword_ptr(ebx, esi));
 988                 a.mov(ebx, dword_ptr(ebx));
 989                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
 990                 a.pop(esi);
 991                 a.pop(ebx);
 992                 a.pop(eax);
 993                 a.ret();
 994                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
 995                 iNewJitLenth = a.getCodeSize();
 996             }
 997             else if (g_tagIAT[i].bType == 1) //EDX
 998             {
 999                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1000                 a.push(ebx);
1001                 a.push(ebx);
1002                 a.push(ebx);
1003                 a.push(esi);
1004                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1005                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1006                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1007                 a.lea(ebx, dword_ptr(ebx, esi));
1008                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+5+程序基址 =返回地址
1009                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1010                 a.lea(ebx, dword_ptr(ebx, esi));
1011                 a.mov(ebx, dword_ptr(ebx));
1012                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1013                 a.pop(esi);
1014                 a.pop(ebx);
1015                 a.pop(edx);
1016                 a.ret();
1017                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1018                 iNewJitLenth = a.getCodeSize();
1019             }
1020             else if (g_tagIAT[i].bType == 2)    //ESP
1021             {
1022                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1023                 a.push(ebx);
1024                 a.push(ebx);
1025                 a.push(ebx);
1026                 a.push(esi);
1027                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1028                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1029                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1030                 a.lea(ebx, dword_ptr(ebx, esi));
1031                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+6+程序基址 =返回地址
1032                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1033                 a.lea(ebx, dword_ptr(ebx, esi));
1034                 a.mov(ebx, dword_ptr(ebx));
1035                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1036                 a.pop(esi);
1037                 a.pop(ebx);
1038                 a.pop(esp);
1039                 a.ret();
1040                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1041                 iNewJitLenth = a.getCodeSize();
1042             }
1043             else if (g_tagIAT[i].bType == 3)    //ESI
1044             {
1045                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1046                 a.push(ebx);
1047                 a.push(ebx);
1048                 a.push(ebx);
1049                 a.push(esi);
1050                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1051                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1052                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1053                 a.lea(ebx, dword_ptr(ebx, esi));
1054                 a.mov(ebx, dword_ptr(ebx));
1055                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1056                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1057                 a.lea(ebx, dword_ptr(ebx, esi));
1058                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+6+程序基址 =返回地址
1059                 a.pop(esi);
1060                 a.pop(ebx);
1061                 a.pop(esi);
1062                 a.ret();
1063                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1064                 iNewJitLenth = a.getCodeSize();
1065             }
1066             else if (g_tagIAT[i].bType == 4)    //ECX
1067             {
1068                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1069                 a.push(ebx);
1070                 a.push(ebx);
1071                 a.push(ebx);
1072                 a.push(esi);
1073                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1074                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1075                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1076                 a.lea(ebx, dword_ptr(ebx, esi));
1077                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+6+程序基址 =返回地址
1078                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1079                 a.lea(ebx, dword_ptr(ebx, esi));
1080                 a.mov(ebx, dword_ptr(ebx));
1081                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1082                 a.pop(esi);
1083                 a.pop(ebx);
1084                 a.pop(ecx);
1085                 a.ret();
1086                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1087                 iNewJitLenth = a.getCodeSize();
1088             }
1089             else if (g_tagIAT[i].bType == 5)    //EBX
1090             {
1091                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1092                 a.push(ebx);
1093                 a.push(ebx);
1094                 a.push(ebx);
1095                 a.push(esi);
1096                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1097                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1098                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1099                 a.lea(ebx, dword_ptr(ebx, esi));
1100                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+6+程序基址 =返回地址
1101                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1102                 a.lea(ebx, dword_ptr(ebx, esi));
1103                 a.mov(ebx, dword_ptr(ebx));
1104                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1105                 a.pop(esi);
1106                 a.pop(ebx);
1107                 a.pop(ebx);
1108                 a.ret();
1109                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1110                 iNewJitLenth = a.getCodeSize();
1111             }
1112             else if (g_tagIAT[i].bType == 6)    //EBP
1113             {
1114                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1115                 a.push(ebx);
1116                 a.push(ebx);
1117                 a.push(ebx);
1118                 a.push(esi);
1119                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1120                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1121                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1122                 a.lea(ebx, dword_ptr(ebx, esi));
1123                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+6+程序基址 =返回地址
1124                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1125                 a.lea(ebx, dword_ptr(ebx, esi));
1126                 a.mov(ebx, dword_ptr(ebx));
1127                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1128                 a.pop(esi);
1129                 a.pop(ebx);
1130                 a.pop(ebp);
1131                 a.ret();
1132                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1133                 iNewJitLenth = a.getCodeSize();
1134             }
1135             else if (g_tagIAT[i].bType == 7)    //EDI
1136             {
1137                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1138                 a.push(ebx);
1139                 a.push(ebx);
1140                 a.push(ebx);
1141                 a.push(esi);
1142                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);
1143                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1144                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1145                 a.lea(ebx, dword_ptr(ebx, esi));
1146                 a.mov(dword_ptr(esp, 0xC), ebx);//当前指令所在RVA+6+程序基址 =返回地址
1147                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1148                 a.lea(ebx, dword_ptr(ebx, esi));
1149                 a.mov(ebx, dword_ptr(ebx));
1150                 a.mov(dword_ptr(esp, 0x8), ebx);//代替原函数地址的地址
1151                 a.pop(esi);
1152                 a.pop(ebx);
1153                 a.pop(edi);
1154                 a.ret();
1155                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1156                 iNewJitLenth = a.getCodeSize();
1157             }
1158             else if (g_tagIAT[i].bType == 8)    //Call
1159             {
1160                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1161                 a.push(ebx);
1162                 a.push(ebx);
1163                 a.push(ebx);
1164                 a.push(esi);
1165                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1166                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1167                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1168                 a.lea(ebx, dword_ptr(ebx, esi));
1169                 a.mov(ebx, dword_ptr(ebx));
1170                 a.mov(dword_ptr(esp, 8), ebx);//存放目标函数地址的地址的RVA
1171                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6);//返回地址RVA
1172                 a.lea(ebx, dword_ptr(ebx, esi));
1173                 a.mov(dword_ptr(esp, 0xC), ebx); 
1174                 a.pop(esi);
1175                 a.pop(ebx);
1176                 a.ret();
1177                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1178                 iNewJitLenth = a.getCodeSize();
1179             }
1180             else if (g_tagIAT[i].bType == 9) //JMP
1181             {
1182                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1183                 a.push(ebx);
1184                 a.push(ebx);
1185                 a.push(ebx);
1186                 a.push(esi);
1187                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1188                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1189                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1190                 a.lea(ebx, dword_ptr(ebx, esi));
1191                 a.mov(dword_ptr(esp,4), 0x3535);//填充垃圾数据
1192                 a.mov(ebx, dword_ptr(ebx));
1193                 a.mov(dword_ptr(esp, 0xC), ebx);//存放目标函数地址的地址的RVA
1194                 a.pop(esi);
1195                 a.pop(ebx);
1196                 a.pop(ebx);
1197                 a.ret();
1198                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1199                 iNewJitLenth = a.getCodeSize();
1200             }
1201             else if (g_tagIAT[i].bType == 10) //PUSH
1202             {
1203                 g_tagIAT[i].dwNewIatAddr = iNewSectionFileMapAddr + iAddIatLenth + g_tagIAT[i].wIndex * 4;
1204                 a.push(ebx);
1205                 a.push(ebx);
1206                 a.push(ebx);
1207                 a.push(esi);
1208                 a.mov(ebx, (int)g_tagIAT[i].dwNewIatAddr);
1209                 a.mov(esi, g_iImageBase);//程序基址 后续会将这个位置添加到重定位块处,运行时即变为程序基址了
1210                 g_tagIAT[i].dwRelocAddr = iNewJitBeginAddrRva + a.getCodeSize() - 4;//shellcode开始的位置+当前jit长度 再往回4字节  即为存放基址的位置
1211                 a.lea(ebx, dword_ptr(ebx, esi));
1212                 a.mov(ebx, dword_ptr(ebx));
1213                 a.mov(dword_ptr(esp, 0xC), ebx);//存放目标函数地址的地址的RVA
1214                 a.mov(ebx, (int)g_tagIAT[i].dwCallAddr + 6); //返回地址RVA
1215                 a.lea(ebx, dword_ptr(ebx, esi));
1216                 a.mov(dword_ptr(esp, 8), ebx);
1217                 a.pop(esi);
1218                 a.pop(ebx);
1219                 a.ret();
1220                 g_tagIAT[i].dwJmpAddr = iNewJitBeginAddrRva + iNewJitLenth;
1221                 iNewJitLenth = a.getCodeSize();
1222             }
1223         }
1224         a.bind(LoadDllOver);//加载函数地址表以及构建替代IAT的ShellCode完成
1225         a.mov(edi, dword_ptr(ebp, 8));//获得基址
1226         for (int i = 0; i < g_tagIAT.size(); i++)
1227         {    
1228             a.lea(ecx, dword_ptr(edi, g_tagIAT[i].dwCallAddr));
1229             a.mov(byte_ptr(ecx), 0xE9);
1230             //由于这里的E9后面的值,是偏移,所以不用加上基址。偏移量=目标地址-当前指令地址-指令长度
1231             a.mov(dword_ptr(ecx, 1), (int)(g_tagIAT[i].dwJmpAddr - g_tagIAT[i].dwCallAddr - 5));
1232             if (g_tagIAT[i].bType == 0)
1233             {
1234                 continue;
1235             }
1236             a.mov(byte_ptr(ecx, 5), 0x90);
1237         }
1238         a.add(esp, 0x10);//8+8
1239         a.pop(ebx);
1240         a.popa();
1241         a.ret();
1242 
1243         PVOID szJit = a.make();
1244         int iJitLenth = a.getCodeSize(); 
1245          g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iAddIatLenth + iLoadIatLenth + iJitLenth);
1246         memcpy(g_pFileSrc + g_iFileSize + iAddIatLenth + iLoadIatLenth , szJit, iJitLenth);
1247 
1248 
1249         //一共增加的代码=IAT相关数据+加载后的函数地址表大小+JIT代码长度
1250          int iAddSrcLen = iAddIatLenth + iLoadIatLenth + iJitLenth;
1251         //完善节长度等数据  保守起见重新获取节表信息
1252         pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
1253         pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
1254         pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
1255         pSection += pNtHead->FileHeader.NumberOfSections - 1;
1256         if (!(iAddSrcLen%g_iFileAlignment))
1257         {
1258             pSection->SizeOfRawData = iAddSrcLen;
1259         }
1260         else
1261         {
1262             pSection->SizeOfRawData = iAddSrcLen + g_iFileAlignment - (iAddSrcLen%g_iFileAlignment);
1263         }
1264         if (!(iAddSrcLen%g_iSectionAlignment))
1265         {
1266             pSection->Misc.VirtualSize = iAddSrcLen;
1267         }
1268         else
1269         {
1270             pSection->Misc.VirtualSize = iAddSrcLen + g_iSectionAlignment - (iAddSrcLen%g_iSectionAlignment);
1271         }
1272         pNtHead->OptionalHeader.SizeOfImage += pSection->Misc.VirtualSize;
1273 
1274         if (iAddSrcLen != pSection->SizeOfRawData)//当新增长度与对齐后的节长度不相等时,将其补全
1275         {
1276             int iLenth = pSection->SizeOfRawData;//先保存,以免扩容后原地址被回收
1277             g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iLenth);
1278             memset(g_pFileSrc + g_iFileSize + iAddSrcLen, 0, iLenth - iAddSrcLen);
1279         }
1280           g_iFileSize += pSection->SizeOfRawData;
1281 
1282         
1283 
1284         //将原重定位中  涉及IAT的重定位项删掉
1285         //1.先统计IAT中的地址位置代码(除了mov eax的地址位置在指令位置+1处,其他皆为+2)
1286         vector<WORD>vDeleteIatAddr;//需要删除的重定位信息
1287         for (int i = 0; i < g_tagIAT.size(); i++)
1288         {
1289             if (g_tagIAT[i].bType==0) //mov eax  重定位地址位于调用地址+1处
1290             {
1291                 vDeleteIatAddr.push_back(g_tagIAT[i].dwCallAddr + 1);
1292             }
1293             else
1294             {
1295                 vDeleteIatAddr.push_back(g_tagIAT[i].dwCallAddr + 2);
1296             }
1297             
1298         }
1299 
1300         //2.统计出重定位表有几个重定位块,每个块的基址是多少,里面有多少个偏移
1301         for (int i = 0; i < iRelocationLenth; i++)
1302         {
1303             tagRelocation addR;
1304             addR.wR_Head = *(int*)(szR_Src + i);
1305             int iR_Lenth = *(int*)(szR_Src + i + 4);
1306             for (int j = 8; j < iR_Lenth; j+=2)
1307             {
1308                 WORD ccc = *(WORD*)(szR_Src + i + j);
1309                 addR.wR_Offset.push_back(ccc);
1310             }
1311             vOldReloction.push_back(addR);
1312             i += iR_Lenth - 1;
1313         }
1314 
1315         //3.根据IAT里的地址,在重定位地址表查找,找到之后将其删除 
1316         for (int i = 0; i < vDeleteIatAddr.size(); i++)
1317         {
1318             for (int j = 0; j < vOldReloction.size(); j++)
1319             {
1320                 if ((vDeleteIatAddr[i] & 0xFFF000) > vOldReloction[j].wR_Head) //当调用地址的重定位块大于当前重定位表块时
1321                 {
1322                     continue;
1323                 }
1324                 else if ((vDeleteIatAddr[i] & 0xFFF000) < vOldReloction[j].wR_Head)
1325                 {
1326                     break;
1327                 }
1328                 else        //找到对应重定位块
1329                 {
1330                     for (int k = 0; k < vOldReloction[j].wR_Offset.size(); k++)
1331                     {
1332                         if ((vDeleteIatAddr[i] & 0xFFF) == (vOldReloction[j].wR_Offset[k] & 0xFFF))
1333                         {
1334                             vOldReloction[j].wR_Offset.erase(vOldReloction[j].wR_Offset.begin() + k);
1335                             goto NextIatAddr;
1336                         }
1337                     }
1338                 }
1339 
1340             }
1341         NextIatAddr:;    
1342         }
1343 
1344         //4.对齐重定位表数据,
1345         /*如果重定位块中项目为偶数个,则跳过
1346         如果是奇数个,看最后一个是否为0。如果为0,删掉;如果不为0,补0*/
1347         for (int i = 0; i < vOldReloction.size(); i++)
1348         {
1349             int iReloctionNum = vOldReloction[i].wR_Offset.size();
1350             if (iReloctionNum % 2) //取余  如果能取到 说明为奇数
1351             {
1352                 if (vOldReloction[i].wR_Offset[iReloctionNum-1] == 0)
1353                 {
1354                     vOldReloction[i].wR_Offset.pop_back();
1355                 }
1356                 else
1357                 {
1358                     vOldReloction[i].wR_Offset.push_back(0);
1359                 }
1360             }
1361         }
1362 
1363         //恢复重定位表
1364         szR_Src = NULL;
1365         iRelocationLenth = 0;
1366         for (int i = 0; i < vOldReloction.size(); i++)
1367         {
1368             szR_Src = (char*)realloc(szR_Src, iRelocationLenth + 8);
1369             memcpy(szR_Src + iRelocationLenth, &vOldReloction[i].wR_Head, 4);
1370             int iR_Lenth = vOldReloction[i].wR_Offset.size() * 2 + 8;
1371             memcpy(szR_Src + iRelocationLenth + 4, &iR_Lenth, 4);
1372             iRelocationLenth += 8;
1373             for (int j = 0; j < vOldReloction[i].wR_Offset.size(); j++)
1374             {
1375                 szR_Src = (char*)realloc(szR_Src, iRelocationLenth + 8 + j*2);
1376                 memcpy(szR_Src + iRelocationLenth + j*2, &vOldReloction[i].wR_Offset[j], 2);            
1377             }
1378             iRelocationLenth += vOldReloction[i].wR_Offset.size() * 2 ;
1379         }
1380         
1381 
1382         //增加新的重定位项
1383         char *szAddRelocSrc = NULL;    //总新增重定位数据
1384         char *szNowAddrelocSrc = NULL;//子新增重定位数据
1385         int iAddRelocLen = 0;        //总重定位数据长度
1386         int iNowAddRelocLen = 0;    //子重定位数据长度
1387         
1388         int iPage = 0;        //页大小
1389         int iPageOffset = 0;    //页内偏移
1390 
1391 
1392         //先增加新OEP用于求得基址的重定位项
1393         iNowAddRelocLen = 10;  //子长度
1394         szNowAddrelocSrc = (char*)malloc(iNowAddRelocLen);//子数据
1395         iPage = (g_iNewOEP + 1) & 0xfff000;    //PUSH 0000 0000  重定位数据为地址 偏移+1
1396         iPageOffset = ((g_iNewOEP + 1) & 0xfff) | 0x3000;
1397         memcpy(szNowAddrelocSrc, &iPage, 4);//页偏移
1398         memcpy(szNowAddrelocSrc + 4, &iNowAddRelocLen, 4);//页大小
1399         memcpy(szNowAddrelocSrc + 8, &iPageOffset, 2);
1400 
1401         //开始新增shellcode中的重定位项
1402         for (int i = 0; i < g_tagIAT.size(); i++)
1403         {            
1404             if (iPage == ((g_tagIAT[i].dwRelocAddr) & 0xfff000))  //判断是否与当前页大小一致
1405             {
1406                 szNowAddrelocSrc = (char*)realloc(szNowAddrelocSrc, iNowAddRelocLen + 2);
1407                 iPageOffset = (g_tagIAT[i].dwRelocAddr & 0xfff) | 0x3000;
1408                 memcpy(szNowAddrelocSrc + iNowAddRelocLen, &iPageOffset, 2);
1409                 iNowAddRelocLen += 2;
1410                 memcpy(szNowAddrelocSrc + 4, &iNowAddRelocLen, 4);//页大小
1411             }
1412             else   //开启新页
1413             {
1414                 if ((iNowAddRelocLen % 4))  //是否4字节对齐
1415                 {
1416                     szNowAddrelocSrc = (char*)realloc(szNowAddrelocSrc, iNowAddRelocLen + 2);
1417                     memset(szNowAddrelocSrc + iNowAddRelocLen, 0, 2);
1418                     iNowAddRelocLen += 2;
1419                     memcpy(szNowAddrelocSrc + 4, &iNowAddRelocLen, 4);//页大小
1420                 }
1421                 
1422                 szAddRelocSrc = (char*)realloc(szAddRelocSrc, iAddRelocLen + iNowAddRelocLen);//将总重定位数据扩容
1423                 memcpy(szAddRelocSrc + iAddRelocLen, szNowAddrelocSrc, iNowAddRelocLen);    //复制子重定位块到总重定位块中
1424                 iAddRelocLen += iNowAddRelocLen;    //更新总重定位块大小
1425 
1426                 iNowAddRelocLen = 10;
1427                 szNowAddrelocSrc = (char*)malloc(iNowAddRelocLen);//子数据
1428                 iPage = g_tagIAT[i].dwRelocAddr & 0xfff000;
1429                 iPageOffset = (g_tagIAT[i].dwRelocAddr & 0xfff) | 0x3000;
1430                 memcpy(szNowAddrelocSrc, &iPage, 4);//页偏移
1431                 memcpy(szNowAddrelocSrc + 4, &iNowAddRelocLen, 4);//页大小
1432                 memcpy(szNowAddrelocSrc + 8, &iPageOffset, 2);
1433             }
1434         }
1435         //此时 由于已经遍历到tagIAT结构最后 但当前重定位块并为添加到总重定位块中,故需要再进行填充
1436         if ((iNowAddRelocLen % 4))  //是否4字节对齐
1437         {
1438             szNowAddrelocSrc = (char*)realloc(szNowAddrelocSrc, iNowAddRelocLen + 2);
1439             memset(szNowAddrelocSrc + iNowAddRelocLen, 0, 2);
1440             iNowAddRelocLen += 2;
1441             memcpy(szNowAddrelocSrc + 4, &iNowAddRelocLen, 4);//页大小
1442         }
1443 
1444         szAddRelocSrc = (char*)realloc(szAddRelocSrc, iAddRelocLen + iNowAddRelocLen);//将总重定位数据扩容
1445         memcpy(szAddRelocSrc + iAddRelocLen, szNowAddrelocSrc, iNowAddRelocLen);    //复制子重定位块到总重定位块中
1446         iAddRelocLen += iNowAddRelocLen;    //更新总重定位块大小
1447 
1448 
1449         if ((iR_FileLenth - iRelocationLenth) < iAddRelocLen) //节表长度和实际数据长度是否足够填充新的重定位块
1450         {
1451             //扩充重定位数据
1452             //整数取余 = (新增数据总大小- 之前剩余空间间隙)%对齐大小
1453             int iZeroLenth = (iAddRelocLen - (iR_FileLenth - iRelocationLenth)) % g_iFileAlignment;
1454             if (iZeroLenth)
1455             { 
1456                 iR_FileLenth = iRelocationLenth + iAddRelocLen + g_iFileAlignment - iZeroLenth;
1457             }
1458             else
1459             {
1460                 iR_FileLenth = iRelocationLenth + iAddRelocLen;
1461             }
1462             szR_Src = (char*)realloc(szR_Src, iR_FileLenth);
1463             memcpy(szR_Src + iRelocationLenth, szAddRelocSrc, iAddRelocLen);
1464             memset(szR_Src + iRelocationLenth + iAddRelocLen, 0, iR_FileLenth - iRelocationLenth - iAddRelocLen);
1465         }
1466         else
1467         {
1468             szR_Src = (char*)realloc(szR_Src, iR_FileLenth);
1469             memcpy(szR_Src + iRelocationLenth, szAddRelocSrc, iAddRelocLen);
1470             iRelocationLenth += iAddRelocLen;
1471             memset(szR_Src + iRelocationLenth, 0, iR_FileLenth - iRelocationLenth);
1472         }
1473 
1474         //还原重定位
1475         g_pFileSrc = (UCHAR*)realloc(g_pFileSrc, g_iFileSize + iR_FileLenth);
1476         memcpy(g_pFileSrc + g_iFileSize, szR_Src, iR_FileLenth);
1477         g_iFileSize += iR_FileLenth;
1478         
1479         ////直接用realloc又抽风 用其他转移吧
1480         //char *szCopyBuff = (char*)malloc(g_iFileSize + iR_FileLenth);
1481         //memcpy(szCopyBuff, g_pFileSrc, g_iFileSize);
1482         //memcpy(szCopyBuff + g_iFileSize, szR_Src, iR_FileLenth);
1483         //g_iFileSize += iR_FileLenth;
1484         //memcpy(g_pFileSrc, szCopyBuff, g_iFileSize);
1485         
1486 
1487         pDosHead = (PIMAGE_DOS_HEADER)g_pFileSrc;
1488         pNtHead = (PIMAGE_NT_HEADERS)((DWORD)pDosHead + pDosHead->e_lfanew);
1489         pSection = (PIMAGE_SECTION_HEADER)((DWORD)&pNtHead->OptionalHeader + pNtHead->FileHeader.SizeOfOptionalHeader);
1490         pSection += pNtHead->FileHeader.NumberOfSections - 1;
1491         int iR_FileAddr = pSection->PointerToRawData + pSection->SizeOfRawData;
1492         int iR_MapAddr = 0;
1493         if (!(pSection->Misc.VirtualSize % g_iSectionAlignment))
1494         {
1495             iR_MapAddr = pSection->VirtualAddress + pSection->Misc.VirtualSize;
1496         }
1497         else
1498         {
1499             iR_MapAddr = pSection->VirtualAddress + pSection->Misc.VirtualSize
1500                 + g_iSectionAlignment - (pSection->Misc.VirtualSize % g_iSectionAlignment);
1501         }
1502 
1503         pSection++;
1504         strcpy((char*)pSection->Name, szR_Name);
1505         pSection->Characteristics = (0x20000000 | 0x40000000 | 0x80000000 | 0x40);
1506         pSection->VirtualAddress = iR_MapAddr;
1507         pSection->Misc.VirtualSize = iR_FileLenth;
1508         pSection->PointerToRawData = iR_FileAddr;
1509         pSection->SizeOfRawData = iR_FileLenth;
1510         pNtHead->OptionalHeader.DataDirectory[5].VirtualAddress = iR_MapAddr;
1511         pNtHead->OptionalHeader.DataDirectory[5].Size = iRelocationLenth;
1512         pNtHead->FileHeader.NumberOfSections += 1;
1513         if (!(iR_FileLenth%g_iSectionAlignment))
1514         {
1515             pNtHead->OptionalHeader.SizeOfImage += iR_FileLenth;
1516         }
1517         else
1518         {
1519             pNtHead->OptionalHeader.SizeOfImage += iR_FileLenth + g_iSectionAlignment - (iR_FileLenth%g_iSectionAlignment);
1520         }
1521 
1522     }
1523     return true;
1524 }
1525 
1526 
1527 
1528 int main()
1529 {
1530     //"C:\\Users\\Admin\\Desktop\\弹窗.exe
1531     char FileName[] = { "C:\\Users\\Admin\\Desktop\\弹窗.exe" };
1532     if (!LoadFile(FileName))
1533     {
1534         cout << "文件打开失败" << endl;
1535         system("pause");
1536         return -1;
1537     }
1538 
1539     if (!CheckPE())
1540     {
1541         cout << "该程序不是PE文件" << endl;
1542         system("pause");
1543         return -1;
1544     }
1545 
1546     if (!FindCodeAddr())    //找到对应调用IAT的地址
1547     {
1548         cout << "该程序没有导入表,请检查" << endl;
1549         system("pause");
1550         return -1;
1551     }
1552 
1553     if (!SaveDll())
1554     {
1555         cout << "保存DLL信息失败" << endl;
1556         system("pause");
1557         return -1;
1558     }
1559 
1560     if (!NewIat())
1561     {
1562         cout << "新建IAT表失败" << endl;
1563         system("pause");
1564         return -1;
1565     }
1566 
1567     //C:\\Users\\Admin\\Desktop\\弹窗IAT加密测试.exe
1568     char NewFilePath[] = "C:\\Users\\Admin\\Desktop\\弹窗IAT加密测试.exe";
1569     HANDLE hNewFile = CreateFileA(NewFilePath,
1570         GENERIC_READ | GENERIC_WRITE,
1571         FILE_SHARE_READ | FILE_SHARE_WRITE,
1572         NULL,
1573         CREATE_ALWAYS,   //创建并覆盖上一个文件
1574         FILE_ATTRIBUTE_ARCHIVE,
1575         NULL);
1576 
1577     if (hNewFile == INVALID_HANDLE_VALUE)
1578     {
1579         printf("文件保存失败\n");
1580         int iError = GetLastError();
1581         return 1;
1582     }
1583 
1584     LPDWORD iNum = NULL;
1585     WriteFile(hNewFile, g_pFileSrc, g_iFileSize, iNum, NULL); //写入文件
1586     CloseHandle(hNewFile);
1587     char *NewFileName1 = strrchr(NewFilePath, '\\') + 1;
1588     char *NewFileName = strtok(NewFileName1, ".");
1589     MessageBoxA(0, NewFileName, "加密成功", 0);
1590     MessageBoxA(0, "by:阿怪\n          2020.12.26", "IAT加密", 0);
1591 
1592     system("pause");
1593 }

View Code

 

 

加密效果:

浅谈IAT加密原理及过程

 

 浅谈IAT加密原理及过程

 

 浅谈IAT加密原理及过程

 

 

 

 

 

IAT加密相对于代码段加密较为复杂,特别是在自己实现获得函数地址,以及创建对应的shellcode,并把原调用指令全部一一修改的流程较为繁琐,需要用到各种变量记录位置。博主也是刚接触到这块的新手小白,如果有疑惑或者说的不对的地方欢迎在评论指出,互相学习。感谢!!

发表评论

评论已关闭。

相关文章