深入理解计算机系统（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发挥最好的作用。
最后附上成功拆弹图：
最新文章
- ruby 资源收集
- bzoj 4358 permu
- 八大排序算法之二希尔排序（Shell Sort）
- SQL中迁移sql用户及密码脚本
- [改善Java代码]多线程使用Vector或HashTable
- DBMS_RLS包实现数据库表中的行级安全控制
- js void运用
- MATLAB导入数据importdata功能
- JavaScript基础：创建对象
- 高性能MySQL之【第十五章 备份与恢复】学习记录
- 基于diango简易BLOG图片预览
- ActiveMQ的两种消息模式，主题、队列
- MySQL的show profile(已过时)简介以及该功能在MySQL 5.7中performance_schema中的替代
- caffe---mnist数据集训练与测试
- Leetcode 题解 First Missing Positive
- windows Server 2012/2016 路由和远程访问,PPPOE,ADSL,连接接口时出现一个错误,连接被远程计算机终止
- SGU 275. To xor or not to xor （高斯消元法）
- C++ 内置宏定义 与 预编译指令
- IDEA14/Eclipse+Tomcat7热部署，jrebel6破解与eclipse配置
- Mongodb 常用语法