3.1 IDA Pro编写IDC脚本入门

IDA Pro内置的IDC脚本语言是一种灵活的、C语言风格的脚本语言，旨在帮助逆向工程师更轻松地进行反汇编和静态分析。IDC脚本语言支持变量、表达式、循环、分支、函数等C语言中的常见语法结构，并且还提供了许多特定于反汇编和静态分析的函数和操作符。由于其灵活性和可扩展性，许多逆向工程师都喜欢使用IDC脚本语言来自动化反汇编和静态分析过程，以提高效率和准确性。
在IDA中如果读者按下Shift + F2则可调出脚本编辑器，如下图所示，其中左侧代表当前脚本的名称列表，右侧则代表脚本的具体实现细节，底部存在三个菜单，第一个按钮是运行脚本，第二个按钮是覆盖导入脚本，第三个则是追加导入，他们之间的功能个有不同，读者可自行体会；

3.1.1 IF语句的构建

IF语句的使用非常容易，如下代码，通过ScreenEA()函数识别到当前光标所在位置处的指令内存地址，并对比该内存地址是否符合特定的条件，如果符合则输出，不符合则最终输出没有找到；

1. #include <idc.idc>
3. static main()
4. {
5.     auto CurrAddress = ScreenEA();
6.     if(CurrAddress == 0x0046E31A)
7.     {
8.        Message("程序OEP => 0x%x \n",CurrAddress);
9.     }
10.     else if(CurrAddress == 0x0046E331)
11.     {
12.        Message("程序OEP => 0x%x \n",CurrAddress);
13.     }
14.     else
15.     {
16.       Message("没有扎到OEP \n");
17.     }
18. }

复制代码

3.1.2 FOR语句的构建

与C语言格式几乎一致，For语句的构建也很容易理解，首先程序通过GetFunctionAttr()函数并设置FUNCATTR_START属性获取到当前光标所指向程序段的开始地址，通过FUNCATTR_END设置光标的结束位置，最后调用For循环，一次输出当前内存地址及下一个内存地址，直到将本段内容全部输出为止；

1. #include <idc.idc>
3. static main()
4. {
5.     auto origEA,currEA,funcStart,funcEnd;
6.     origEA = ScreenEA();
7.    
8.     // origEA = OEP 如果origEA 不在函数内则返回-1
9.     funcStart = GetFunctionAttr(origEA,FUNCATTR_START);
10.     funcEnd = GetFunctionAttr(origEA,FUNCATTR_END);
11.     Message("OEP: %x 起始地址: %x --> 结束地址: %x \n",origEA,funcStart,funcEnd);
12.    
13.     // NextHead 在currEA开始的位置寻找下一条指令的地址
14.     for(currEA = funcStart; currEA != -1; currEA=NextHead(currEA,funcEnd))
15.     {
16.         Message("指令地址：%8x \n",currEA);
17.     }
18. }

复制代码

3.1.3 WHILE语句的构建

该语句的构建与FOR语句基本一致，与FOR语句唯一的不同在于该语句只能接受一个参数，如下代码中读者需要注意GetFunctionName()可用于获取当前光标所在位置处所属函数的名称。

1. #include <idc.idc>
3. static main()
4. {
5.     auto origEA,currEA,funcStart,funcEnd;
6.     origEA = ScreenEA();
8.     // origEA = OEP 如果origEA 不在函数内则返回-1
9.     funcStart = GetFunctionAttr(origEA,FUNCATTR_START);
10.     funcEnd = GetFunctionAttr(origEA,FUNCATTR_END);
11.     Message("OEP: %x 起始地址: %x --> 结束地址: %x \n",origEA,funcStart,funcEnd);
12.    
13.     while(currEA != BADADDR)
14.     {
15.         Message("--> %x name: %s \n",currEA,GetFunctionName(currEA));
16.         currEA = NextHead(currEA,funcEnd);
17.     }
18. }

复制代码

3.1.4 函数的实现

IDA中使用函数通常可在一个字符串之前定义为static，函数的参数列表一般而言是以逗号进行间隔开的，当函数存在返回值是则通过return语句返回。

1. #include <idc.idc>
3. // 定义一个函数
4. static OutPutAddress(MyString)
5. {
6.     auto currAddress;
7.     currAddress = ScreenEA();
8.     Message("%d \n",MyString);
9.     return currAddress;
10. }
12. // 传递多个参数
13. static OutPutAddressB(x,y)
14. {
15.     return x+y;
16. }
18. static main()
19. {
20.     auto ret = OutPutAddress(123);
21.     Message("返回当前地址 = 0x%x \n",ret);
22.    
23.     auto ref = OutPutAddressB(100,200);
24.     Message("计算数值 = %d \n",ref);
25.    
26. }

复制代码

3.1.5 定义并使用数组

与高级语言类似，IDC脚本中同样支持数组操作，不同于C语言中的数组，IDC中在使用时首先需要通过CreateArray("array")创建一个数组，当数组指针被创建成功后下一步则是通过GetArrayId("array")得到该数组的指针，通过指针读者可以使用SetArrayString设置一个字符串变量，或使用SetArrayLong设置整数变量，当用户需要使用变量时则需要通过GetArrayElement()函数对数组内的数据进行提取，提取时AR_STR代表提取字符串，AR_LONG则代表提取整数类型，当读者需要删除数组内的特定元素可使用DelArrayElement()函数，最后使用结束调用DeleteArray()注销整个数组；

1. #include <idc.idc>
3. static main()
4. {
5.     // 创建数组元素
6.     auto array_ptr = CreateArray("array");
7.     // 获取数组指针
8.     auto ptr = GetArrayId("array");
9.    
10.     Message("获取到的操作指针: %x \n",ptr);
11.    
12.     // 设置两个字符串变量
13.     SetArrayString(ptr,0,"hello");
14.     SetArrayString(ptr,1,"lyshark");
15.    
16.     // 设置两个整数变量
17.     SetArrayLong(ptr,2,100);
18.     SetArrayLong(ptr,3,200);
19.    
20.     // 如果提取字符串使用 AR_STR 标记 ，提取整数使用 AR_LONG
21.     auto st = GetArrayElement(AR_STR,ptr,0);
22.     auto st1 = GetArrayElement(AR_STR,ptr,1);
23.     Message("提取字符串变量: %s %s !\n",st,st1);
24.    
25.     auto lo = GetArrayElement(AR_LONG,ptr,2);
26.     Message("提取整数变量: %d \n",lo);
27.    
28.     // 删除数组的0号元素
29.     DelArrayElement(AR_STR,ptr,0);
30.     // 注销整个数组
31.     DeleteArray(ptr);
32. }

复制代码

3.1.6 字符串处理

IDC中读者可以使用form()函数实现对特定字符串的格式化输出操作，IDC中同样也内置了各类转换函数，如下代码所示，则是IDC中可以经常被用到的函数调用，读者可自行参考；

1. #include <idc.idc>
3. static main()
4. {
5.     // 格式化字符串,类似于sprintf
6.     auto name = form("hello %s","lyshark");
7.     Message("格式化后的内容: %s \n",name);
8.    
9.     Message("十六进制转为整数: %d \n",xtol("0x41"));
10.     Message("十进制100转为八进制: %d \n",ltoa(100,8));
11.     Message("十进制100转换二进制: %d \n",ltoa(100,2));
12.     Message("字符A的ASCII: %d \n",ord("A"));
13.     Message("计算字符串长度: %d \n",strlen("hello lyshark"));
14.    
15.     // 在主字符串中寻找子串
16.     auto main = "hello lyshark";
17.     auto sub = "lyshark";
18.     Message("寻找子串: %d \n",strstr(main,sub));
19. }

复制代码

3.1.7 枚举所有函数

如下脚本实现了枚举当前指针所在位置处所有函数名称及地址，首先通过ScreenEA()函数获取当前指针所在位置，通过SegStart()用于获取该指针所在位置处模块的开始地址，与之对应的是SegEnd();则用于获取结束地址，接着通过调用GetFunctionName();得到当前地址处的函数名，并依次通过NextFunction();得到下一个模块地址，最终输出所有函数名及其地址信息；

1. #include <idc.idc>
3. static main()
4. {
5.     auto currAddr,func,endSeg,funcName,counter;
6.    
7.     currAddr = ScreenEA();
8.     func = SegStart(currAddr);
9.     endSeg = SegEnd(currAddr);
10.     Message("%x --> %x \n",func,endSeg);
11.    
12.     counter = 0;
13.     while(func != BADADDR && func < endSeg)
14.     {
15.         funcName = GetFunctionName(func);
16.         if(funcName != " ")
17.         {
18.             Message("%x --> %s \n",func,funcName);
19.             counter++;
20.         }
21.         func = NextFunction(func);
22.     }
23. }

复制代码

当然读者可以通过增加IF语句来判断funcName函数名是否是我们所需要枚举的，如果是则输出，如果不是则继续下一个函数，依次类推实现函数枚举功能，读者只需要在上述代码基础上稍加改进即可实现；

1. #include <idc.idc>
3. static main()
4. {
5.     auto currAddr,func,endSeg,funcName,counter;
6.    
7.     currAddr = ScreenEA();
8.     func = SegStart(currAddr);
9.     endSeg = SegEnd(currAddr);
10.     Message("%x --> %x \n",func,endSeg);
11.     counter = 0;
12.    
13.     while(func != BADADDR && func < endSeg)
14.     {
15.         funcName = GetFunctionName(func);
16.         if(funcName != " ")
17.         {
18.             if(funcName == "__lock")
19.             {
20.                 Message("%x --> %s \n",func,funcName);
21.             }
22.             counter++;
23.         }
24.         func = NextFunction(func);
25.     }
26. }

复制代码

3.1.8 设置内存区域标签高亮

标签高亮功能的实现依赖于SetColor函数，该函数传入三个参数，其中参数1用于指定需要检索的范围，该范围可以通过NextHead()函数获取到，只要该节点不会返回BADADDR则可以继续遍历下一个节点，第二个参数则代表标注类型，第三个参数代表要在那个位置进行标注；

1. #include <idc.idc>
3. static main(void)
4. {
5.     auto head, op;
6.     head = NextHead(0x00000000, 0xFFFFFFFF);
7.     while ( head != BADADDR )
8.     {
9.         op = GetMnem(head);
10.         Message("%x %s \n",head,op);
12.         
13.         if ( op == "jmp" || op == "call" )
14.             SetColor(head, CIC_ITEM, 0x010187);
15.             
16.         if (op == "xor")
17.             SetColor(head, CIC_ITEM, 0x010198);
18.         head = NextHead(head, 0xFFFFFFFF);
19.     }
20. }

复制代码

3.1.9 地址反汇编输出

在IDA中有时我们需要对特定位置进行反汇编，并以脚本的方式输出，此时读者可使用GetDisasm(inst)函数来实现，该函数传入一个RfirstB生成的迭代类型，并依次循环输出，直到对100行输出为止；

1. #include <idc.idc>
3. static main(void)
4. {
5.     auto decode = 0x401000;
6.     auto xref;
7.    
8.     for(xref = RfirstB(decode); xref != BADADDR; xref = RnextB(decode,xref))
9.     {
10.         Message("xref: %x\n",xref);
11.         auto i = 0;
12.         auto inst = xref;
13.         auto op;
14.         
15.        while((i < 100) )
16.        {
17.             // 向后枚举下一个
18.             inst = FindCode(inst,0x00);
19.         
20.             // 输出反汇编
21.             op = GetDisasm(inst);
22.             Message("%x --> %s \n",inst,op);
23.             i++;
24.        }
25.     }
26. }

复制代码

当具备了反汇编功能后，那么读者则可通过各种方式实现对指令集的判断，并以此来实现过滤特定指令地址并输出的目的，如下所示，通过strstr()函数对符合特定条件的字符串进行过滤，当找到后返回该函数的所在位置；

1. #include <idc.idc>
3. static main()
4. {
5.     auto currAddr,startSeg,endSeg;
6.    
7.     currAddr = ScreenEA();
8.     startSeg = SegStart(currAddr);
9.     endSeg = SegEnd(currAddr);
10.    
11.     Message("OEP = %x 起始地址: %x 结束地址: %x \n",currAddr,startSeg,endSeg);
12.    
13.     while(startSeg < endSeg)
14.     {
15.         auto op = GetDisasm(startSeg);
16.         
17.         // 查找第一条指令
18.         if(strstr(op,"push    esi")==0)
19.         {
20.             startSeg++;
21.             op = GetDisasm(startSeg);
22.             if(strstr(op,"push    edi"))
23.             {
24.                 Message("特征: %x \n",startSeg-1);
25.             }
26.         }
27.         startSeg++;
28.     }
29. }

复制代码

当然反汇编函数并非只有GetDisasm读者同样可以使用GetMnem返回位于特定地址处的指令，GetOpnd用于返回特定位置处的机器码，同样可以使用FindBinary实现对特定地址的特征码搜索功能；

1. #include <idc.idc>
3. static main()
4. {
5.     // 搜索特征码
6.     auto code = FindBinary(0x401020,1,"55 8B EC");
7.     Message("%x \n",code);
9.     // 返回反汇编代码
10.     code = GetDisasm(0x401000);
11.     Message("%s \n",code);
12.    
13.     // 返回位于地址处的指令
14.     code = GetMnem(0x401000);
15.     Message("%s \n",code);
16.    
17.     // 返回opcode机器码
18.     code = GetOpnd(0x401070,0);
19.     Message("%s \n",code);
20. }

复制代码

3.1.10 枚举函数栈帧

生成每个函数的栈帧，通过NextFunction()函数可实现枚举当前模块内所有函数地址，通过循环并调用GetFram()来得到当前函数栈帧大小，并使用GetMemberOffset()保存栈中返回地址偏移量，依次循环输出当前函数内的完整栈帧数据；

1. #include <idc.idc>
3. static main()
4. {
5.     auto addr,args,end,locals,frame,firstArg,name,ret;
6.    
7.     for(addr = NextFunction(addr); addr != BADADDR; addr = NextFunction(addr))
8.     {
9.         name = Name(addr);
10.         end = GetFunctionAttr(addr,FUNCATTR_END);
11.         locals = GetFunctionAttr(addr,FUNCATTR_FRSIZE);
12.         
13.         // 得到栈帧大小
14.         frame = GetFrame(addr);
15.         
16.         // 栈中保存返回地址偏移量
17.         ret = GetMemberOffset(frame," r");
18.         if(ret == -1)
19.         {
20.             continue;
21.         }
22.         
23.         firstArg = ret +4;
24.         args = GetStrucSize(frame) - firstArg;
25.         
26.         Message("函数: %s 开始: 0x%x 结束: 0x%x 大小: %d bytes 栈帧: %d bytes (%d args) \n",name,addr,end,locals,args,args/4);
27.     }
28. }

复制代码

3.1.11 检索交叉引用

枚举当前模块中的交叉引用，通过XrefType()函数可枚举出当前被分析程序中的交叉引用情况，如下案例中实现了对当前程序内所有交叉引用的枚举工作，并输出三个参数，参数1代表主函数，参数2代表被引用函数，参数3代表当前函数的内存地址；

1. #include <idc.idc>
3. static main()
4. {
5.     auto func,end,target,inst,name,flags,xref;
6.     flags = SEARCH_DOWN | SEARCH_NEXT;
7.     func = GetFunctionAttr(ScreenEA(),FUNCATTR_START);
8.    
9.     if(func != -1)
10.     {
11.         name =Name(func);
12.         end = GetFunctionAttr(func,FUNCATTR_END);
13.         for(inst = func;inst < end; inst = FindCode(inst,flags))
14.         {
15.             for(target = Rfirst(inst);target != BADADDR; target = Rnext(inst,target))
16.             {
17.                 xref = XrefType();
18.                 if(xref == fl_CN || xref == fl_CF)
19.                 {
20.                     Message("%s | %s | %x \n",name,Name(target),inst);
21.                 }
22.             }
23.         }
24.     }
25. }

复制代码

如果读者想要实现枚举特定一个函数的交叉引用信息，则可通过使用LocByName(bad_func)增加过滤条件，并依次实现过滤特定函数的目的，代码的修改只需要小改即可；

1. #include <idc.idc>
3. static FindFunction(bad_func)
4. {
5.     auto func,addr,xref,source;
6.    
7.     func = LocByName(bad_func);
8.     if(func == BADADDR)
9.     {
10.         Message("error \n");
11.     }
12.     else
13.     {
14.         for(addr = RfirstB(func);addr != BADADDR; addr = RnextB(func,addr))
15.         {
16.             xref = XrefType();
17.             if(xref == fl_CN || xref == fl_CF)
18.             {
19.                 source = GetFunctionName(addr);
20.                 Message("%s call => %0x in %s \n",bad_func,addr,source);
21.             }
22.         }
23.     }  
24. }
26. static main()
27. {
28.     FindFunction("LoadString");
29. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！