反调试入门篇（1）——花指令

gclome

原文链接：反调试入门篇（1）——花指令

0x01 花指令

花指令是一种反静态调试的最基础手段(对于动态调试来说就没有用处)，我们可以通过在程序的代码中添加一些不影响程序运行的垃圾机器码，进而影响反汇编结果的准确性，达到程序保护的目的

0x02 花指令分类

1、可执行花指令

见字知其意，即花指令在程序正常运行的时候被执行，通用寄存器的值不发生改变，但不影响程序原有的功能执行

2、不可执行花指令

见字知其意，即花指令在程序正常运行的时候不会被执行，不影响程序原有的功能

0x03 编写花指令

原则：保持堆栈的平衡


0x04 常用花指令

汇编小知识:

1. mov eax, 1      eax赋值为1
   
2. pop 1                 将1从栈顶弹出
   
3. pop ebp             将栈顶的值弹出赋给寄存器ebp
   
4. push 1              将1压入栈中
   
5. push ebp            将ebp的值压入栈中
   
6. sub eax, 1      eax的值减1
   
7. add eax, 1      eax的值加1
   
8. inc eax             eax的值加1
   
9. dec eax             eax的值减1
   
10. call [x]            调用地址为x的函数,call对应的硬编码为0xE8
    
11. jmp x                   跳转到x地址处，jmp对应的硬编码为0xE9
    
12. nop                     不做任何事情，相当于python中的pass,对应的硬编码为0x90
    
13. _emit                   相当于db,byte类型,1字节

复制代码

以下方式均通过内联汇编实现

0x05 标签方式的花指令

1、单节方式

1. #include "stdafx.h"
   
2. 
   
3. 
   
4. void Test(){
   
5. int a[3] = {1, 2, 3};
   
6. _asm{
   
7. jz Label;
   
8. jnz Label;
   
9. _emit 0xE8;
   
10. }
    
11. Label:
    
12. a[0] = 2;
    
13. a[1] = 5;
    
14. a[2] = 6;
    
15. printf("%d\n", a[2]);
    
16. }
    
17. 
    
18. 
    
19. int main(int argc, char* argv[]){
    
20. Test();
    
21. return 0;
    
22. }

复制代码

使用IDA打开，可以看到标红的地方就是花指令,因为call指令的存在，使得后面的4字节数据被错误识别成函数地址，进而导致接下来的分析出错


​

人工Patch花指令的方式很简单:
选中call指令所在行，点击Edit选项>Patch program>Change byte

​

将call的硬编码E8改为0x90(nop指令)

​

​

2、多节方式

1. #include "stdafx.h"
   
2. 
   
3. 
   
4. void Test(){
   
5. int a[3] = {1, 2, 3};
   
6. _asm{
   
7. jz Label1;
   
8. jnz Label1;
   
9. _emit 0xE9;
   
10. }
    
11. Label1:
    
12. a[0] = 5;
    
13. a[1] = 6;
    
14. a[2] = 7;
    
15. _asm{
    
16. jz Label2;
    
17. jnz Label2;
    
18. _emit 0xE8;
    
19. }
    
20. Label2:
    
21. a[1] = a[0] + a[2];
    
22. a[2] = a[1] + a[0];
    
23. printf("%d\n", a[2]);
    
24. }
    
25. 
    
26. 
    
27. int main(int argc, char* argv[])
    
28. {
    
29. Test();
    
30. return 0;
    
31. }

复制代码

3、多层乱序(疯狂套娃)

1. #include "stdafx.h"
   
2. 
   
3. 
   
4. void Test(){
   
5. int arr[3] = {1, 2, 3};
   
6. _asm{
   
7. jz Label3;
   
8. jnz Label3;
   
9. _emit 0xE8;
   
10. }
    
11. Label2:
    
12. _asm{
    
13. jz Label4;
    
14. jnz Label4;
    
15. _emit 0xE8;
    
16. }
    
17. 
    
18. 
    
19. Label3:
    
20. _asm{
    
21. jz Label1;
    
22. jnz Label1;
    
23. _emit 0xE9;
    
24. }
    
25. Label1:
    
26. _asm{
    
27. jz Label2;
    
28. jnz Label2;
    
29. _emit 0xE9;
    
30. }
    
31. Label4:
    
32. int a = 10;
    
33. printf("%d\n",a);
    
34. 
    
35. 
    
36. }
    
37. int main(int argc, char* argv[])
    
38. {
    
39. Test();
    
40. return 0;
    
41. }

复制代码

4.开辟堆栈的花指令

1. push 1
   
2. push ebp
   
3. mov ebp, esp
   
4. sub esp, 0x8
   
5. push eax
   
6. push ecx
   
7. pop ecx
   
8. pop eax
   
9. add esp, 0x8
   
10. pop ebp
    
11. je xxx
    
12. jne xxx

复制代码

花指令多的情况就需要自己写个IDA python脚本进行去除

5.花指令免杀

一些反病毒软件依靠特征码来判断文件是否有毒，其识别引擎在文件镜像(filebuffer)一定的偏移范围内进行扫描，比如在0x00001000~0x00006000之间，我们在其中加入一些花指令，使恶意代码偏离引擎识别的偏移范围，再使用工具修改程序入口(OEP)，就可以逃避这种方式的特征码识别