攻城攻心的肴杂大师——深入解析第十八届CISCN x 第二届长城杯初赛Reverse ...

前言


    在初赛结束近两月之际，笔者在复盘过程中意外发现了这道当时无人能解的困难。经过两日深入的探索与研讨，笔者终于成功地对这道赛题进行了全面的解构。在品味破译flag所带来的喜悦之余，笔者亦深感此题蕴含了诸多精妙之处，特撰此文与诸君分享。
   

    一、 赛题初窥


    拿到样本re.exe，照例先拖入DIE分析，结果让人大吃一惊：

 
    DIE检测出了云云多的保护器，几乎涵盖了平常见过的所有种类。再拖入IDA看一眼：

 
 
    从上面灰色、赤色的部分占据绝大部分可以看出，整个程序几乎没有多少精确识别的函数，似乎比较符合虚拟机保护的特征。倘若到此你直接将它拖入接纳站的话，则正中出题人下怀，被其用精妙的心理战击退。仔细观察程序的代码，可以发现故意义的指令分别位于.text和UPX0段，且指令间存在很明显的被花指令肴杂的痕迹，而其它与虚拟机有关的段（.vmp0、.winlice等）均没有任何代码，这表明程序并未使用虚拟化保护，只是接纳增长特定段来诱骗DIE。此外，直接运行程序会迅速闪退，而调试运行程序会不停运行下去（比赛时运行了几个小时都没结束......），这都大大增强了“不战而屈人之兵”的效果。
   

    二、 去除语法肴杂

    在初步分析后，我们可以发现不能像该比赛中的逆向dump赛题那样通过简朴的黑盒测试分析结果，必须要先去除花指令的语法肴杂，从而实现静态分析。由于程序使用了大量的花指令，逐个patch耗时且容易出错，笔者考虑使用idc脚本实现该功能。
   

    该样本的花指令主要有以下几种范例：
    1. jz + 1

 



    该范例花指令跳过了一个字节，特征码为0F 84 01 00 00 00。如图所示，由简朴的数据流分析可知，0x401599处的指令肯定会跳转，因此0x40159F处的指令永远不会到达，patch方法为直接nop该字节。

   

    2. jz + 2

 
    同jz + 1范例，特征码为0F 84 02 00 00 00，直接patch跳过的2个字节即可。
   

    3. jz + 8

    同jz + 1范例，特征码为0F 84 08 00 00 00，直接patch跳过的8个字节即可。
   

    4. jge + 6

 
    该范例花指令特征码为0F 8D 06 00 00 00，其不能像前几种一样通过数据流分析直接观察出肯定跳转，但若程序实行到0x401AFB处，则最终肯定会崩溃。笔者的做法偏向保守，将跳过的6个字节前2个patch为ud2指令，后4个指令patch为nop指令，这样静态分析得到的伪代码也能提示跳转到此处会产生BUG。
   

    5. jmp + 6

    同jz + 1范例，特征码为E9 06 00 00 00 00（多使用一个00避免误报），直接patch跳过的6个字节即可。
   

6. jmp - 23

    同jge + 6范例，特征码为EB E9， 将该指令patch为ud2指令，其后的4个字节patch为nop指令。

   

    7. cmp al, 0E9h

    同jge + 6范例，特征码为3C E9， 将该指令patch为ud2指令，其后的4个字节patch为nop指令。
   

    8. 特殊

•             0x413824处的指令jmp     qword ptr cs:45BF481Dh非法，查找交叉引用发现0x413826处有跳转到这里的条件分支，因此将该处前2个字节patch为ud2指令。        
  
•             0x41669E处的两个00直接patch为nop指令。        
  
•             0x41878D处patch一个ud2指令加上9字节的nop，否则会干扰sub_418779的函数分析。
          
  

   

    综上所述，我们可以编写出处理花指令肴杂的解肴杂idc脚本：

1. #include <idc.idc>
3. static main()
4. {
5.         auto seg, current_ea, ea;
7.         // 遍历所有段
8.         for (seg = get_first_seg(); seg != BADADDR; seg = get_next_seg(seg))
9.         {
10.                 auto seg_name = get_segm_name(seg);
12.                 // 检查段名是否符合要求
13.                 if (seg_name != ".text" && seg_name != "UPX0")
14.                 {
15.                         //Message("跳过段: %s (0x%X)\n", seg_name, seg);
16.                         continue;
17.                 }
19.                 Message("正在处理段: %s (0x%X)\n", seg_name, seg);
21.                 // 获取段的起始和结束地址
22.                 auto start_ea = seg;
23.                 auto end_ea = get_segm_end(seg);
25.                 current_ea = start_ea;
26.                 auto pattern1 = "0F 84 01 00 00 00";
27.                 while (1)
28.                 {
29.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern1);
30.                         if (ea > end_ea || ea == BADADDR)
31.                                 break;
33.                         Message("Found pattern1 at 0x%X\n", ea);
34.                         patch_byte(ea + 6, 0x90);       
35.                         current_ea = ea + 1;
36.                 }
38.                 current_ea = start_ea;
39.                 auto pattern2 = "0F 84 02 00 00 00";
40.                 while (1)
41.                 {
42.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern2);
43.                         if (ea > end_ea || ea == BADADDR)
44.                                 break;
46.                         Message("Found pattern2 at 0x%X\n", ea);
47.                         patch_word(ea + 6, 0x9090);                               
48.                         current_ea = ea + 1;
49.                 }
51.                 current_ea = start_ea;
52.                 auto pattern3 = "0F 84 08 00 00 00";
53.                 while (1)
54.                 {
55.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern3);
56.                         if (ea > end_ea || ea == BADADDR)
57.                                 break;
59.                         Message("Found pattern3 at 0x%X\n", ea);
60.                         patch_qword(ea + 6, 0x9090909090909090);       
61.                         current_ea = ea + 1;
62.                 }
64.                 current_ea = start_ea;
65.                 auto pattern4 = "0F 8D 06 00 00 00";
66.                 while (1)
67.                 {
68.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern4);
69.                         if (ea > end_ea || ea == BADADDR)
70.                                 break;
72.                         Message("Found pattern4 at 0x%X\n", ea);
73.                         patch_word(ea + 6, 0x0B0F);                               
74.                         patch_dword(ea + 8, 0x90909090);       
75.                         current_ea = ea + 1;
76.                 }
78.                 current_ea = start_ea;
79.                 auto pattern5 = "E9 06 00 00 00 00";
80.                 while (1)
81.                 {
82.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern5);
83.                         if (ea > end_ea || ea == BADADDR)
84.                                 break;
86.                         Message("Found pattern5 at 0x%X\n", ea);
87.                         patch_word(ea + 5, 0x0B0F);                               
88.                         patch_dword(ea + 7, 0x90909090);       
89.                         current_ea = ea + 1;
90.                 }
92.                 current_ea = start_ea;
93.                 auto pattern6 = "EB E9";
94.                 while (1)
95.                 {
96.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern6);
97.                         if (ea > end_ea || ea == BADADDR)
98.                                 break;
100.                         Message("Found pattern6 at 0x%X\n", ea);
101.                         patch_word(ea, 0x0B0F);                                       
102.                         patch_dword(ea + 2, 0x90909090);       
103.                         current_ea = ea + 1;
104.                 }
106.                 current_ea = start_ea;
107.                 auto pattern7 = "3C E9";
108.                 while (1)
109.                 {
110.                         ea = find_binary(current_ea, SEARCH_DOWN, pattern7);
111.                         if (ea > end_ea || ea == BADADDR)
112.                                 break;
114.                         Message("Found pattern7 at 0x%X\n", ea);
115.                         patch_word(ea + 2, 0x0B0F);                                // ud2
116.                         patch_word(ea + 4, 0x9090);                                // nop
117.                         current_ea = ea + 1;
118.                 }
120.         }
122.         patch_word(0x413824, 0x0B0F);
123.         patch_word(0x41669E, 0x0B0F);
124.         patch_word(0x41878D, 0x0B0F);
125.         patch_qword(0x41878F, 0x9090909090909090);
126.         patch_byte(0x418797, 0x90);       
128.         Message("Finished.\n");
129. }

复制代码

运行脚本后，将patch后文件保存为re-new1.exe，IDA打开此文件后，发现大部分函数已经被识别出来：

 
 
手工把剩下没有自动识别成函数的位置按P键生成函数，至此我们完全实现了语法解肴杂：

 
   

    三、 去除语义肴杂


从start函数中，不难发现sub_4098F0为main函数，F5反编译代码如下：

 
可以发现程序还黑白常难以阅读，不外此时笔者发现下面区域的字节都是固定常数0-9：

 
    交叉引用发现它们只被读而没被写，因此可以分别重命名为byte0-9：

    重新分析反编译代码，发现它们被用来实现语法肴杂，例如155行的条件分支永远为真，v147永远为0等。因此我们可以考虑把对这些常量的引用的指令酿成对常数引用的指令，利用IDA的优化来去除这些永真永假跳转。
    以byte0为例，其指令情势为movsx   ecx/eax/edx, cs:byte0，占7个字节，我们可以将其改为mov     ecx/eax/edx, 0（占5个字节），再填充2字节的nop指令，对byte0-byte9使用idc脚本去除肴杂，代码如下：

1. #include <idc.idc>
3. static main()
4. {
5.     auto seg, current_ea, mnemonic, op1, op2;
7.     // 遍历所有段
8.     for (seg = get_first_seg(); seg != BADADDR; seg = get_next_seg(seg))
9.     {
10.         auto seg_name = get_segm_name(seg);
12.         // 检查段名是否符合要求
13.         if (seg_name != ".text" && seg_name != "UPX0")
14.         {
15.             //Message("跳过段: %s (0x%X)\n", seg_name, seg);
16.             continue;
17.         }
19.         Message("正在处理段: %s (0x%X)\n", seg_name, seg);
21.         // 获取段的起始和结束地址
22.         auto start_ea = seg;
23.         auto end_ea = get_segm_end(seg);
25.         // 遍历段中的每一条指令
26.         current_ea = start_ea;
27.         while (current_ea < end_ea && current_ea != BADADDR)
28.         {
29.             // 获取指令的助记符和操作数
30.             mnemonic = print_insn_mnem(current_ea);
31.             op1 = print_operand(current_ea, 0);
32.             op2 = print_operand(current_ea, 1);
34.             // 检查是否是目标指令
35.             if (mnemonic == "movsx" && op2 == "cs:byte0")
36.             {
37.                 Message("Target Ins at: 0x%X\n", current_ea);
38.                 if (op1 == "eax")
39.                 {
40.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
41.                 }
42.                 else if (op1 == "ecx")
43.                 {
44.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
45.                 }
46.                 else if (op1 == "edx")
47.                 {
48.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
49.                 }
51.                 // 设置 imm32 = 0
52.                 patch_dword(current_ea + 1, 0);      // imm32 = 0
53.                 patch_word(current_ea + 5, 0x9090);        // nop
54.                 create_insn(current_ea);             // 重新分析指令
55.             }
57.             // 检查是否是目标指令
58.             if (mnemonic == "movsx" && op2 == "cs:byte1")
59.             {
60.                 Message("Target Ins at: 0x%X\n", current_ea);
61.                 if (op1 == "eax")
62.                 {
63.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
64.                 }
65.                 else if (op1 == "ecx")
66.                 {
67.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
68.                 }
69.                 else if (op1 == "edx")
70.                 {
71.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
72.                 }
74.                 // 设置 imm32 = 1
75.                 patch_dword(current_ea + 1, 1);      // imm32 = 1
76.                 patch_word(current_ea + 5, 0x9090);        // nop
77.                 create_insn(current_ea);             // 重新分析指令
78.             }
80.             // 检查是否是目标指令
81.             if (mnemonic == "movsx" && op2 == "cs:byte2")
82.             {
83.                 Message("Target Ins at: 0x%X\n", current_ea);
84.                 if (op1 == "eax")
85.                 {
86.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
87.                 }
88.                 else if (op1 == "ecx")
89.                 {
90.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
91.                 }
92.                 else if (op1 == "edx")
93.                 {
94.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
95.                 }
97.                 // 设置 imm32 = 2
98.                 patch_dword(current_ea + 1, 2);      // imm32 = 2
99.                 patch_word(current_ea + 5, 0x9090);        // nop
100.                 create_insn(current_ea);             // 重新分析指令
101.             }
103.             // 检查是否是目标指令
104.             if (mnemonic == "movsx" && op2 == "cs:byte3")
105.             {
106.                 Message("Target Ins at: 0x%X\n", current_ea);
107.                 if (op1 == "eax")
108.                 {
109.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
110.                 }
111.                 else if (op1 == "ecx")
112.                 {
113.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
114.                 }
115.                 else if (op1 == "edx")
116.                 {
117.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
118.                 }
120.                 // 设置 imm32 = 3
121.                 patch_dword(current_ea + 1, 3);      // imm32 = 3
122.                 patch_word(current_ea + 5, 0x9090);        // nop
123.                 create_insn(current_ea);             // 重新分析指令
124.             }
126.             // 检查是否是目标指令
127.             if (mnemonic == "movsx" && op2 == "cs:byte4")
128.             {
129.                 Message("Target Ins at: 0x%X\n", current_ea);
130.                 if (op1 == "eax")
131.                 {
132.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
133.                 }
134.                 else if (op1 == "ecx")
135.                 {
136.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
137.                 }
138.                 else if (op1 == "edx")
139.                 {
140.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
141.                 }
143.                 // 设置 imm32 = 4
144.                 patch_dword(current_ea + 1, 4);      // imm32 = 4
145.                 patch_word(current_ea + 5, 0x9090);        // nop
146.                 create_insn(current_ea);             // 重新分析指令
147.             }
149.             // 检查是否是目标指令
150.             if (mnemonic == "movsx" && op2 == "cs:byte5")
151.             {
152.                 Message("Target Ins at: 0x%X\n", current_ea);
153.                 if (op1 == "eax")
154.                 {
155.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
156.                 }
157.                 else if (op1 == "ecx")
158.                 {
159.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
160.                 }
161.                 else if (op1 == "edx")
162.                 {
163.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
164.                 }
166.                 // 设置 imm32 = 5
167.                 patch_dword(current_ea + 1, 5);      // imm32 = 5
168.                 patch_word(current_ea + 5, 0x9090);        // nop
169.                 create_insn(current_ea);             // 重新分析指令
170.             }
172.             // 检查是否是目标指令
173.             if (mnemonic == "movsx" && op2 == "cs:byte6")
174.             {
175.                 Message("Target Ins at: 0x%X\n", current_ea);
176.                 if (op1 == "eax")
177.                 {
178.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
179.                 }
180.                 else if (op1 == "ecx")
181.                 {
182.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
183.                 }
184.                 else if (op1 == "edx")
185.                 {
186.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
187.                 }
189.                 // 设置 imm32 = 6
190.                 patch_dword(current_ea + 1, 6);      // imm32 = 6
191.                 patch_word(current_ea + 5, 0x9090);        // nop
192.                 create_insn(current_ea);             // 重新分析指令
193.             }
195.             // 检查是否是目标指令
196.             if (mnemonic == "movsx" && op2 == "cs:byte7")
197.             {
198.                 Message("Target Ins at: 0x%X\n", current_ea);
199.                 if (op1 == "eax")
200.                 {
201.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
202.                 }
203.                 else if (op1 == "ecx")
204.                 {
205.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
206.                 }
207.                 else if (op1 == "edx")
208.                 {
209.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
210.                 }
212.                 // 设置 imm32 = 7
213.                 patch_dword(current_ea + 1, 7);      // imm32 = 7
214.                 patch_word(current_ea + 5, 0x9090);        // nop
215.                 create_insn(current_ea);             // 重新分析指令
216.             }
218.             // 检查是否是目标指令
219.             if (mnemonic == "movsx" && op2 == "cs:byte8")
220.             {
221.                 Message("Target Ins at: 0x%X\n", current_ea);
222.                 if (op1 == "eax")
223.                 {
224.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
225.                 }
226.                 else if (op1 == "ecx")
227.                 {
228.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
229.                 }
230.                 else if (op1 == "edx")
231.                 {
232.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
233.                 }
235.                 // 设置 imm32 = 8
236.                 patch_dword(current_ea + 1, 8);      // imm32 = 0
237.                 patch_word(current_ea + 5, 0x9090);        // nop
238.                 create_insn(current_ea);             // 重新分析指令
239.             }
241.             // 检查是否是目标指令
242.             if (mnemonic == "movsx" && op2 == "cs:byte9")
243.             {
244.                 Message("Target Ins at: 0x%X\n", current_ea);
245.                 if (op1 == "eax")
246.                 {
247.                     patch_byte(current_ea, 0xB8);       // mov eax, imm32 的操作码
248.                 }
249.                 else if (op1 == "ecx")
250.                 {
251.                     patch_byte(current_ea, 0xB9);       // mov ecx, imm32 的操作码
252.                 }
253.                 else if (op1 == "edx")
254.                 {
255.                     patch_byte(current_ea, 0xBA);       // mov edx, imm32 的操作码
256.                 }
258.                 // 设置 imm32 = 9
259.                 patch_dword(current_ea + 1, 9);      // imm32 = 9
260.                 patch_word(current_ea + 5, 0x9090);        // nop
261.                 create_insn(current_ea);             // 重新分析指令
262.             }
265.             // 移动到下一条指令（避免死循环）
266.             auto next_ea = next_head(current_ea, end_ea);
267.             if (next_ea == BADADDR || next_ea <= current_ea)
268.                 break;
270.             current_ea = next_ea;
271.         }
272.     }
274.     Message("Finished.\n");
275. }

复制代码

最终程序输出为79 bc，这表明我们的命令行第二个参数内容为"79BC"即可。

   
    四、 输出结果


    结合上述分析，我们得到了获取flag的步骤：

•             打开一个新历程（例如notepad.exe），获取其PID。        
  
•             运行原始的re.exe，参数为79BC PID。        
  

 

    运行后得到结果flag{MjExNTY3MzE3NTQzMjI=}。
   
    五、 总结


   

    行文至此，笔者不禁再次感叹这道题目的精妙之处——它在多个层面上都运用了奇妙的肴杂技术：从表面上看，题目伪装成被虚拟机大量保护的程序，与解题者展开心理博弈；在内部实现上，则采用了大量花指令进行语法肴杂，并通过引入常量运算和函数运算得到固定结果、增长永真永假分支、函数多次跳转、包装体系API等手段进行语义肴杂。此外，题目还运用了自创的虚拟化技术对关键运算函数进行肴杂，并针对硬件断点实行了反调试步伐。在逻辑分析层面，选手需要绕过反调试机制获取异或数组、运用爆破头脑，并输入一个历程PID作为条件。总体而言，这道题目在设计和实现上都堪称优秀。
   
    然而，笔者也以为这道题目也存在肯定的不足之处，即它更得当出如今时间更为充裕的竞赛中。在初赛阶段，其性价比相对较低，大概无法充分发挥其应有的挑战性和价值。
   

   


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。