深入理解计算机系统（CSAPP）bomblab实验进阶之nuclearlab——详细题解

前言

本实验是难度高于bomblab的一个补充实验，该实验部分题目难度已经达到CTF入门水平，且这个实验据说是上一届的某个学长原创，因此互联网上几乎找不到类似的题目。在间断地思考了几周后我最终完成了所有题目，并打算在这篇随笔里详细地给大家分享我的解题过程。

核弹样本（可本地断网运行）：https://wwi.lanzoup.com/ifFGo0kmrndg

第0关：准备工作

将文件拖入Detect It Easy进行查壳：64位程序，无壳

这个时候按照我们做bomblab的经验，应该会先objdump这个程序，然后用gdb在main函数下断点，但运行程序会发现如下的异常：

如果继续执行会发现程序由于除以0错误引发异常，从而进入explode函数，结合check_debugger名称我们可以推断出这个程序具有反gdb调试功能，因此我们可以考虑更换其他工具继续实验，这里我选择了IDA pro。

（IDA pro介绍：https://blog.csdn.net/yi_rui_jie/article/details/127865485）

理论上而言我们应该阅读汇编代码再进行逆向分析，但IDA pro的强大之处在于它可以自动帮助我们把汇编语言翻译成高级语言，按F5快捷键即可。

特别说明：

1. IDA的汇编代码是Intel风格，且实际中掌握Intel风格的汇编语言是非常必要的。

2. 高级语言分析不代表不再需要看懂汇编代码，相反地，许多关键之处IDA的分析往往不能令人满意，需要进行修补，对汇编能力有较高的要求。下文中你就可以更好地明白这一点的意义。

3. 这篇题解不会具体介绍IDA的用法（如查看汇编代码和高级代码、创建函数、修改字节、保存文件、远程调试等），请自行查阅资料。

我们首先查看main函数的c语言代码：

 1 int __cdecl main(int argc, const char **argv, const char **envp)
 2 {
 3   if ( argc != 3 )
 4   {
 5     __fprintf_chk(stderr, 1LL, "Usage: %s studentId password\n", *argv);
 6     exit(8);
 7   }
 8   strncpy(userid, argv[1], 0x80uLL);
 9   byte_4045FF = 0;
10   strncpy(userpwd, argv[2], 0x80uLL);
11   byte_40467F = 0;
12   ((void (*)(void))bomb_initialize)();
13   __printf_chk(1LL, "%s: ", "pupil");
14   readNextLine(128);
15   pupil();
16   bomb_defused();
17   __printf_chk(1LL, "%s: ", "tr1vial");
18   readNextLine(128);
19   tr1vial();
20   bomb_defused();
21   __printf_chk(1LL, "%s: ", "rainb0w");
22   readNextLine(128);
23   rainb0w();
24   bomb_defused();
25   __printf_chk(1LL, "%s: ", "q_math");
26   readNextLine(128);
27   q_math();
28   bomb_defused();
29   __printf_chk(1LL, "%s: ", "hothothot");
30   readNextLine(128);
31   hothothot();
32   bomb_defused();
33   __printf_chk(1LL, "%s: ", "tran$f0rm");
34   readNextLine(128);
35   ((void (*)(void))tran_f0rm)();
36   bomb_defused();
37   return 0;
38 }

不难看出这个程序的大致流程是：首先读取两个命令行参数并存储，接着第12行进入bomb初始化函数，然后和bomblab一样需要完成6个小实验。由于该实验需要联网，我们需要先对bomb_initialize函数（初始化函数）进行修改。

找到初始化函数的位置，发现IDA无法识别该函数的后半段代码：

仔细观察该程序逻辑，在call语句后面的三句指令对程序自身进行了修改：

于是我们在0x4035EA处下断点并运行到此，观察al的值发现是1：

这个时候继续调试会出现如下提醒（实际上每次调试都会出现），说明该程序会检查程序运行时间，过长（说明有调试）则抛出信号，这里我们选择No即可放弃将信号传递给程序处理，从而继续调试：

然后我们就会发现程序跳入0x4035F3处执行，而0x4035F2处的指令永远不会执行，是故意塞入而干扰分析的指令，这种干扰的方法也被称为花指令。

后面的代码分析同上，如下图所示，我们只需将两个check函数nop掉，即可完成对初始化函数的修补：

下面我们再对结果判断的两个函数完成修补：

如下图，将bomb_defused和bomb_explode两函数矩形内的联网代码nop掉，即可使该程序能在本地完成调试，且用户名和密码可以随意输入：

建议以文本文件作为输入，因为后续题目可能需要输入非ASCII字符。如./nuclearlab user pwd < answer.txt

第1关：pupil

 1 unsigned __int64 pupil()
 2 {
 3   int v0; // edi
 4   unsigned int v2; // [rsp+4h] [rbp-14h] BYREF
 5   unsigned __int64 v3; // [rsp+8h] [rbp-10h]
 6
 7   v0 = (int)now_input;
 8   v3 = __readfsqword(0x28u);
 9   if ( (unsigned int)__isoc99_sscanf(now_input, "%d", &v2) != 1 )
10     bomb_explode(v0);
11   if ( (unsigned int)pupil_pow_mod(233333LL, v2) != 1 )
12     bomb_explode(233333);
13   return __readfsqword(0x28u) ^ v3;
14 }

由代码可知，我们需要pupil_pow_mod(233333, v2)值为1，而v2是我们输入的值，下面查看该函数代码：

 1 __int64 __fastcall pupil_pow_mod(__int64 a1, int a2)
 2 {
 3   __int64 result; // rax
 4   int v3; // eax
 5   __int64 v4; // rcx
 6
 7   result = 1LL;
 8   if ( a2 )
 9   {
10     v3 = pupil_pow_mod(a1, (unsigned int)(a2 >> 1));
11     v4 = v3 * (__int64)v3 % 998244353;
12     result = v4;
13     if ( (a2 & 1) != 0 )
14       return (unsigned int)(v4 * (int)a1 % 998244353);
15   }
16   return result;
17 }

可以看到result本身值为1，因此只要输入的值为0，函数便会直接返回1，从而通过该关，确实挺符合它的名字，，，，，，

第2关：tr1vial

 1 unsigned __int64 tr1vial()
 2 {
 3   char *v0; // r12
 4   size_t v1; // rcx
 5   unsigned __int64 v2; // rdx
 6   __int64 *v3; // rdi
 7   __int16 v4; // dx
 8   signed __int64 v5; // rdx
 9   void *v6; // rsp
10   bool v7; // cf
11   bool v8; // zf
12   const char *v9; // rsi
13   __int64 v10; // rcx
14   const char *v11; // rdi
15   _BYTE v14[4088]; // [rsp+8h] [rbp-1020h] BYREF
16   __int64 v15; // [rsp+1008h] [rbp-20h] BYREF
17   unsigned __int64 v16; // [rsp+1010h] [rbp-18h]
18
19   v0 = now_input;
20   v16 = __readfsqword(0x28u);
21   v1 = strlen(now_input);
22   v2 = 4 * ((v1 + 2) / 3) + 16;
23   v3 = (__int64 *)((char *)&v15 - (v2 & 0xFFFFFFFFFFFFF000LL));
24   v4 = v2 & 0xFFF0;
25   if ( &v15 != v3 )
26   {
27     while ( v14 != (_BYTE *)v3 )
28       ;
29   }
30   v5 = v4 & 0xFFF;
31   v6 = alloca(v5);
32   if ( v5 )
33     *(_QWORD *)&v14[v5 - 8] = *(_QWORD *)&v14[v5 - 8];
34   EVP_EncodeBlock(v14, v0, (unsigned int)v1);
35   v9 = v14;
36   v10 = 17LL;
37   v11 = "fkdM8J+Sr0hGfg==";
38   do
39   {
40     if ( !v10 )
41       break;
42     v7 = *v9 < (unsigned int)*v11;
43     v8 = *v9++ == *v11++;
44     --v10;
45   }
46   while ( v8 );
47   if ( (!v7 && !v8) != v7 )
48     bomb_explode((int)v11);
49   return __readfsqword(0x28u) ^ v16;
50 }

首先关注第47行，分析可知只有v7=0，v8!=0时不会进explode函数，而38-45行的循环分析可知，当v9和v11所指向的字符串完全相等时才能满足这个要求。v9=v14=

EVP_EncodeBlock(v14, v0, (unsigned int)v1)，其中v0是输入的字符串。查询资料可知这个函数对v0进行base64加密，因而我们对v11解密即可。

base64介绍：https://blog.csdn.net/qq_19782019/article/details/88117150

python解密脚本：

1 import base64
2 import math
3
4 ss="fkdM8J+Sr0hGfg0="
5 print(base64.b64decode(ss))

可得答案为~GL\xf0\x9f\x92\xafHF~，由于字符串中含有非ASCII字符，因此需要先写入文本，再读入文本作为输入。如果直接到网站上解密可能无法显示不可见字符（被坑惨了炸了好几次），事实上中间的字符是，这个字符串"~GLHF~"意思是：Good Luck and Have Fun，祝你取得满分。

第3关：rainb0w

 1 unsigned __int64 rainb0w()
 2 {
 3   char *v0; // r12
 4   int *v1; // rbx
 5   size_t v2; // rax
 6   int *v3; // rdi
 7   char vars0; // [rsp+0h] [rbp+0h] BYREF
 8   int vars10; // [rsp+10h] [rbp+10h] BYREF
 9   __int16 vars14; // [rsp+14h] [rbp+14h]
10   char vars30; // [rsp+30h] [rbp+30h] BYREF
11   unsigned __int64 vars38; // [rsp+38h] [rbp+38h]
12
13   v0 = now_input;
14   vars38 = __readfsqword(0x28u);
15   v1 = &vars10;
16   v2 = strlen(now_input);
17   MD5(v0, v2, &vars0);
18   do
19   {
20     v3 = v1;
21     v1 = (int *)((char *)v1 + 2);
22     __sprintf_chk(v3, 1LL, -1LL, "%2.2hhX", (unsigned int)vars0);
23   }
24   while ( v1 != (int *)&vars30 );
25   if ( vars10 != 859124024 || vars14 != 16691 )
26     bomb_explode((int)v3);
27   return __readfsqword(0x28u) ^ vars38;
28 }

首先还是关注explode的条件。由于vars10和vars14与其它变量似乎没有直接关联，我们转到其汇编代码0x4019FB处下断点并运行到此处，以123456作为试探输入：

这时我们点击vars10，跳转到它对应的栈位置：

由cmp内容可知，我们需要把所指位置（实际上是rbp处）当成一个int指针，解该指针得到的值为0x33353138，根据小端顺序，我们可以判断出前四个字符为8153。再点击0x401A30处的vars14，发现跳转至第5个字符'D'处，同理可得第5、6个字符为3A：

而根据前面的MD5函数，我们有理由猜测这个字符串"E10ADC3949BA59ABBE56E057F20F883E"就是123456的MD5加密32位值，在MD5加密网站上输入123456可得到相同结果，证明猜想正确。

于是题目转化为，输入一个字符串，使得它的MD5加密值前六位是字符串“81533A”，这样的字符串有很多，但由于MD5的不可逆性，即我们不能通过算法逆向解密某个加密后的值，因此我们只能从正向突破，其中一种方法是尝试从数字开始枚举，得到一个答案为1914718：

1 import hashlib
2
3 for i in range(10000000):
4     s=str(i)
5     if(hashlib.md5(s.encode()).hexdigest()[:6]=='81533a'):
6         print(i)
7         break

第4关：qmath

 1 unsigned __int64 q_math()
 2 {
 3   int v0; // edi
 4   unsigned int v1; // edx
 5   int v2; // ebp
 6   unsigned int v3; // ebx
 7   int v5; // [rsp+4h] [rbp-24h] BYREF
 8   unsigned __int64 v6; // [rsp+8h] [rbp-20h]
 9
10   v6 = __readfsqword(0x28u);
11   __isoc99_sscanf(now_input, "%u", &v5);
12   magic = (1431655766 * (unsigned __int64)(unsigned int)magic) >> 32;
13   v0 = v5;
14   v2 = t00rerauqs((unsigned int)v5) + 1;
15   if ( v2 <= 29999 )
16     bomb_explode(v0);
17   if ( v2 > 40000 )
18     bomb_explode(v0);
19   v3 = 2;
20   while ( 1 )
21   {
22     if ( !(v1 % v3) )
23       bomb_explode(v0);
24     if ( ++v3 > v2 )
25       break;
26     v1 = v5;
27   }
28   return __readfsqword(0x28u) ^ v6;
29 }

从第14行我们可以看出v2是把我们输入的值通过一个函数进行处理而得到的，由于具体找出公式较复杂，我们可以在15行处下断点，然后动态地输入一组数据来观察v2的变化规律，这里我发现v2随输入值的增大而增大。那么我们不断地以10的指数去尝试，使得v2最终落在30000-40000之间，这时我们可以确定一个相对的范围。然后我们再观察while循环，不难看出它要满足[2,v2]之间的所有整数都不是输入值的因子，那么我们在区间内写一个循环判断即可得到答案，其中一种为1000166183。

第5关：hothothot

 1 unsigned __int64 hothothot()
 2 {
 3   __int64 v1; // [rsp+0h] [rbp-98h] BYREF
 4   unsigned __int64 v2; // [rsp+88h] [rbp-10h]
 5
 6   v2 = __readfsqword(0x28u);
 7   ((void (*)(void))hothothot_you_shouldnt_read_this_part_0)();
 8   convert_text_enc0ding(now_input, &v1, 128LL);
 9   if ( !__sigsetjmp(&buf, 1) )
10     return hothothot_cold();
11   ((void (__fastcall *)(_QWORD))hothothot_you_shouldnt_read_this)(0LL);
12   return __readfsqword(0x28u) ^ v2;
13 }

这道题应该是6个关卡中难度最高的一个，本质上来说它已经属于pwn的范畴了，，，，，，

首先我们会进入一个hothothot_you_shouldnt_read_this_part_0函数，从字面上看它不要我们阅读这段代码，但很显然我的好奇被它激发了，，，，，这段代码汇编如下：

我们可以看到与准备阶段相似的花指令，dword_404468被设置为1来使10变成01，从而使jmp语句跳入0x401705处，后面是一些信号处理函数，对解题没有什么影响，看来的确没啥读的必要。接着我们重点关注convert函数：

 1 unsigned __int64 __fastcall convert_text_enc0ding(char *a1, char *a2, size_t a3)
 2 {
 3   iconv_t v3; // rax
 4   size_t outbytesleft; // [rsp+8h] [rbp-30h] BYREF
 5   char *outbuf; // [rsp+10h] [rbp-28h] BYREF
 6   char *inbuf; // [rsp+18h] [rbp-20h] BYREF
 7   size_t inbytesleft; // [rsp+20h] [rbp-18h] BYREF
 8   unsigned __int64 v9; // [rsp+28h] [rbp-10h]
 9
10   outbytesleft = a3;
11   inbuf = a1;
12   outbuf = a2;
13   v9 = __readfsqword(0x28u);
14   inbytesleft = strlen(a1);
15   v3 = iconv_open("GBK", "UTF-8");
16   iconv(v3, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
17   return __readfsqword(0x28u) ^ v9;
18 }

查询iconv函数可知，这个函数会把我们的输入以UTF-8编码读入，然后转换为GBK编码。当输入的为ASCII字符时，转换后没有任何变化；而当输入其它字符时（如\xe8\x8a\x92在UTF-8下表示“芒”），会把它转换为GBK编码（\xc3\x92在GBK下表示“芒”），因而我们输入\xe8\x8a\x92就能得到\xc3\x92。

附上GBK编码表：https://blog.csdn.net/itnerd/article/details/118615080

接下来回到hothothot函数，查询资料可知sigsetjmp函数在正常情况下会返回0，因而我们进入hothothot_cold函数查看：

看了以后直接傻眼，没有字符串比较之类的语句？？这个函数既然直接让rip指向rsp的位置，那我们只能动调来看看它到底想干什么，不妨输入12345678：

观察栈结构我们可以发现，这个函数直接跳入了我们输入的字符串开头，并将我们的输入当作指令执行！！！因而我们有理由推断，这一关要求我们输入一道字符序列，它从UTF-8转换为GBK后的指令能够正常返回函数的0x401CEB处即可成功。

特别注意以下几点：

1. GBK总体编码范围为 8140-FEFE，首字节在 81-FE 之间，尾字节在 40-FE 之间，剔除 xx7F 一条线。因此最后构造的指令中如果有非ASCII字符，则必须两两成对且落在指定区间内，再找到GBK对应的汉字，以这个汉字的UTF-8编码输入。

2. 构造指令中不能含有空字符（\x00），它会被转换为\x20等其它非空字符。

基于上述两点，一些简单的构造都失效了：

jmp 寄存器　　出现FF字符，找不到对应GBK编码

push 0x401CEB　　出现00字符，空字符失效

mov 寄存器，0x401CEB　　出现00字符，空字符失效

mov 寄存器，[内存地址+偏移]　　偏移为0时出现00字符，空字符失效

我们可以利用栈中已有的地址和空闲寄存器（如r8）的地址，把它们不断累加得到0x401CEB（注意让偏移不为0），然后再push+ret即可，下面是我的构造方法：

48 e5 86 ad 09 4c 03 40 01 49 e5 85 9d 0c 41 50 e8 8a 92　　UTF-8

48 83 e8      09 4c 03 40 01 49 83 c0      0c 41 50 c3 a2　　　  GBK

GBK的字符串为机器码，执行指令如图，实际上retn只需要c3即可，后面的a2是不会执行的，可以替换为其它字符：

最终成功返回所需地址。

第6关：tran$f0rm

观察发现同样的花指令混淆，我们把10改为01，再nop掉0x401D53处的48，之后我们即可创建transform函数，F5得到如下代码：

 1 unsigned __int64 tran_f0rm()
 2 {
 3   int v0; // edi
 4   int v1; // edx
 5   int v3; // [rsp+Ch] [rbp-1Ch] BYREF
 6   int v4; // [rsp+10h] [rbp-18h] BYREF
 7   int v5; // [rsp+14h] [rbp-14h]
 8   unsigned __int64 v6; // [rsp+18h] [rbp-10h]
 9
10   v0 = (int)now_input;
11   v6 = __readfsqword(0x28u);
12   __isoc99_sscanf(now_input, "%d%d", &v3, &v4);
13   *(&loc_401D51 + 1) = 16;
14   ma1f0rm();
15   v5 = v1;
16   if ( v3 <= 100 )
17     bomb_explode(v0);
18   if ( v4 != v5 )
19     bomb_explode(v0);
20   return __readfsqword(0x28u) ^ v6;
21 }

这道题甚至比qmath还简单，我们先输入一个大于100的整数，再动调得到v5的值，即可得到一组答案。我的答案是：120 12869

反gdb调试分析

由之前的分析可知，该文件在debugger_check_caller函数内检测gdb环境，进入其函数查看：

显然核心代码在check_debugger内，进入该函数：

又是熟悉的花指令混淆，我们运用之前的方法去除所有的混淆代码，再创建函数：

查阅文档可知，getppid函数取得父进程的标识码整数x，sprintf使v3字符串为"/proc/x/exe"，readlink函数会把参数v3的符号链接内容存储到参数v4所指的内存空间，并返回字符串个数，最终使v4成为一个代表调试器路径的字符串，而basename函数则取v4最后一个'/'之后的内容。

例如我们用IDA调试时，在第15行下断点可得到各个参数值：

v3=221066，v4="/home/kali/Desktop/linux_server64"（IDA调试文件的路径），s="linux_server64"，这样所得的s在第15行运算时不会发生除以0的异常。

观察对应的汇编代码，我们容易发现返回值rax就是字符串s，而第15行的运算只用到s，因此下面我们用gdb在0x4015EF处下断点观察rax值：

我们发现rax = s = "gdb"，因此*(_WORD *)&s[strlen(s) - 2] = *(short*)&s[1] = 0x6264 = 25188，代入(*(_WORD *)&s[strlen(s) - 2] | 0x2020) - 25188) & 0x7FFFFFFF可得该式值为0，从而引发了除以0异常。不过相应的处理方法也很简单，在0x401622指令处下断点，将ecx的值改成一个正数即可。

那可能有人要问了，你为什么一定要把ecx改成正数，负数不行吗？答案是：不行！因为根据&0x7fffffff可知，正常逻辑下除数一定是一个非负数，既然除数不能为0，那么只能修改为正数。如果修改ecx为负数，会出现什么结果呢？我们继续探究：

由第15行可知，正常情况下，被除数是一个负数，除数是一个正数，因此此时该变量是一个负数；第17行使该变量成为-1，第19行使该变量成为1。

如果我们修改ecx为负数，那么第15行该变量是正数，第17行成为0，第19行依然为0，故该变量的值成为0。

再次观察一下C代码，这个dword_404468变量似乎在前面的某处分析出现过？？如果不记得了请看下面这张图片：

在准备阶段时，我们动调发现了al的值是1，但是当时并没有解释它的由来。现在根据0x4035E2处指令可知这个值正是dword_404468，接着我们查找一下这个变量的交叉引用：

可以发现只有3处位置写了这个变量，它们正是check_debugger函数C代码的15、17、19行处，也就是说如果我们把ecx修改为负数，会导致这个全局变量始终为0，从而使程序无法正确跳过干扰指令，最终产生SIGILL异常而进入bomb_explode函数：

总结：

1. 当正向分析困难时就多尝试动调得到结果，省时省力。

2. 对于花指令、反调试等混淆技术要学会辨认、清除，这样才能让IDA发挥最好的作用。

最后附上成功拆弹图：