18 KiB
18 KiB
title, date, tags
| title | date | tags | |||
|---|---|---|---|---|---|
| 高地特供版CSAPP Bomb Lab全流程攻略 | 2025-02-24 15:09:11 |
|
这篇文章记录高地CSAPP课程Bomblab实验操作流程，仅供参考交流（答案是随机生成的和学号相关）。
笔者实验环境为Archlinux/CachyOS，使用lldb作为调试器（和gdb操作差不多），其余用到的工具主要为objdump，strings，neovim/helix和zellij，全程开源环境不使用IDA。
Phase_1
静态分析
strings扫描
strings bomb_linux
先用strings寻找可能与phase_1相关的字符串或函数名，运气好说不定能直接找到密码毕竟是第一题。
- 结果没有明文密码无法直接秒掉第一问，可惜。
- 但是找到
GenerateRandomString函数可能与密码生成相关。
用objdump反汇编
objdump -d bomb_linux > bomb.asm
搜索GenerateRandomString和phase_1函数的汇编代码。
assembly 401b53 <phase_1>: 401b53: endbr64 401b57: push %rbp 401b58: mov %rsp,%rbp 401b5b: sub $0x20,%rsp 401b5f: mov %rdi,-0x18(%rbp) 401b63: lea -0xb(%rbp),%rax 401b67: mov %rax,%rdi 401b6a: callq 401ac1 <GenerateRandomString> # 调用密码生成函数 401b6f: lea -0xb(%rbp),%rdx # 生成的字符串地址%rbp-0xb存入%rdx，即密码存储位置 401b73: mov -0x18(%rbp),%rax 401b77: mov %rdx,%rsi 401b7a: mov %rax,%rdi 401b7d: callq 401c0c <string_compare> # 调用字符串比较函数 401b82: test %eax,%eax 401b84: je 401b8d <phase_1+0x3a> 401b86: callq 401d67 <explode_bomb> # 比较失败则引爆炸弹
phase_1调用GenerateRandomString生成一个字符串。- 用户输入的字符串需要与此生成的字符串完全匹配。
动态调试
下面是phase_1求解的完整流程：
lldb bomb_linux <你的学号后六位>
(lldb) b phase_1 # 在phase_1入口断点
(lldb) run # 从入口开始执行
请输入第1级的密码：114514 # 随便输入触发断点
(lldb) b 0x401b6f # 在GenerateRandomString返回后断点
(lldb) continue # 继续执行
(lldb) x/s $rbp - 0xb # 计算字符串地址（-0xb偏移量）
0x7fffffffdaf5: "mJHurpQZtY" # 轻松拿下，这里是根据学号伪随机生成的哦
将得到的密码保存入bomb_<学号后六位>.txt即可，避免后续重复输入。
Phase_2
静态分析
这道题目还是比较一目了然的，观察phase_2代码不难发现其实构建了一张跳转表：
0000000000401b8e <phase_2>:
401b8e: f3 0f 1e fa endbr64
401b92: 55 push %rbp
401b93: 48 89 e5 mov %rsp,%rbp
401b96: 48 83 ec 10 sub $0x10,%rsp
401b9a: 48 89 7d f8 mov %rdi,-0x8(%rbp)
401b9e: bf 10 00 00 00 mov $0x10,%edi
401ba3: e8 05 fb ff ff call 4016ad <GenerateRandomNumber>
401ba8: 48 8b 05 71 6c 00 00 mov 0x6c71(%rip),%rax # 408820 <rand_div>
401baf: 48 83 f8 0f cmp $0xf,%rax
401bb3: 0f 87 16 01 00 00 ja 401ccf <phase_2+0x141>
401bb9: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
401bc0: 00
401bc1: 48 8d 05 4c 4a 00 00 lea 0x4a4c(%rip),%rax # 406614 <_IO_stdin_used+0x614>
401bc8: 8b 04 02 mov (%rdx,%rax,1),%eax
401bcb: 48 98 cltq
401bcd: 48 8d 15 40 4a 00 00 lea 0x4a40(%rip),%rdx # 406614 <_IO_stdin_used+0x614>
401bd4: 48 01 d0 add %rdx,%rax
401bd7: 3e ff e0 notrack jmp *%rax
401bda: 48 8b 45 f8 mov -0x8(%rbp),%rax
401bde: 48 89 c7 mov %rax,%rdi
401be1: e8 f2 00 00 00 call 401cd8 <phase_2_0>
401be6: e9 ea 00 00 00 jmp 401cd5 <phase_2+0x147>
401beb: 48 8b 45 f8 mov -0x8(%rbp),%rax
401bef: 48 89 c7 mov %rax,%rdi
401bf2: e8 8b 01 00 00 call 401d82 <phase_2_1>
401bf7: e9 d9 00 00 00 jmp 401cd5 <phase_2+0x147>
401bfc: 48 8b 45 f8 mov -0x8(%rbp),%rax
401c00: 48 89 c7 mov %rax,%rdi
...
这里面需要注意的关键点是rand_div，它会决定你的跳转方向，而你的学号又决定了它的取值。然后是GenerateRandomNumber这个函数的原理需要了解一下，而这个函数将在跳转前后分别调用一次，第一次决定你的跳转方向，第二次则决定了你的密码线索。
动态调试
理解原理就没什么难度了，自己找几个断点打好然后关注一下rand_div的值就好，观察自己的学号向哪个函数跳转并理解相应函数计算即可，比如我这里向phase_2_14跳转：
而除了phase_2_14还有其他函数也是非常好理解的，第二题依旧可以轻松拿下。
Phase_3
静态分析
和Phase_2一样开局先跳转尽可能防止同学们答案雷同互相帮助（bushi
本体其实没有什么好说的，这里我跳转的方向是Phase_3_5简要解释一下可供参考：
0000000000403001 <phase_3_5>:
403001: f3 0f 1e fa endbr64
403005: 55 push %rbp
403006: 48 89 e5 mov %rsp,%rbp
403009: 48 83 ec 20 sub $0x20,%rsp
40300d: 48 89 7d e8 mov %rdi,-0x18(%rbp)
403011: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
403018: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp)
40301f: 48 8d 4d f0 lea -0x10(%rbp),%rcx
403023: 48 8d 55 f4 lea -0xc(%rbp),%rdx
403027: 48 8b 45 e8 mov -0x18(%rbp),%rax
40302b: 48 8d 35 5a 36 00 00 lea 0x365a(%rip),%rsi # 40668c <_IO_stdin_used+0x68c>
403032: 48 89 c7 mov %rax,%rdi
403035: b8 00 00 00 00 mov $0x0,%eax
40303a: e8 51 e1 ff ff call 401190 <__isoc99_sscanf@plt>
40303f: 89 45 f8 mov %eax,-0x8(%rbp)
403042: 83 7d f8 01 cmpl $0x1,-0x8(%rbp)
403046: 7f 05 jg 40304d <phase_3_5+0x4c>
403048: e8 a9 2b 00 00 call 405bf6 <explode_bomb>
40304d: bf 08 00 00 00 mov $0x8,%edi
403052: e8 56 e6 ff ff call 4016ad <GenerateRandomNumber>
403057: 8b 45 f4 mov -0xc(%rbp),%eax
40305a: 48 63 d0 movslq %eax,%rdx
40305d: 48 8b 05 bc 57 00 00 mov 0x57bc(%rip),%rax # 408820 <rand_div>
403064: 48 39 c2 cmp %rax,%rdx
403067: 74 05 je 40306e <phase_3_5+0x6d>
403069: e8 88 2b 00 00 call 405bf6 <explode_bomb>
40306e: bf c8 00 00 00 mov $0xc8,%edi
403073: e8 35 e6 ff ff call 4016ad <GenerateRandomNumber>
403078: 8b 45 f4 mov -0xc(%rbp),%eax
40307b: 83 f8 07 cmp $0x7,%eax
40307e: 0f 87 eb 00 00 00 ja 40316f <phase_3_5+0x16e>
403084: 89 c0 mov %eax,%eax
403086: 48 8d 14 85 00 00 00 lea 0x0(,%rax,4),%rdx
40308d: 00
40308e: 48 8d 05 9f 36 00 00 lea 0x369f(%rip),%rax # 406734 <_IO_stdin_used+0x734>
403095: 8b 04 02 mov (%rdx,%rax,1),%eax
403098: 48 98 cltq
40309a: 48 8d 15 93 36 00 00 lea 0x3693(%rip),%rdx # 406734 <_IO_stdin_used+0x734>
4030a1: 48 01 d0 add %rdx,%rax
4030a4: 3e ff e0 notrack jmp *%rax
4030a7: 48 8b 05 72 57 00 00 mov 0x5772(%rip),%rax # 408820 <rand_div>
4030ae: 89 c2 mov %eax,%edx
4030b0: 8b 45 fc mov -0x4(%rbp),%eax
4030b3: 01 d0 add %edx,%eax
4030b5: 89 45 fc mov %eax,-0x4(%rbp)
4030b8: bf c8 00 00 00 mov $0xc8,%edi
4030bd: e8 eb e5 ff ff call 4016ad <GenerateRandomNumber>
...
403174: 8b 45 f0 mov -0x10(%rbp),%eax
403177: 39 45 fc cmp %eax,-0x4(%rbp) # 注意这里
40317a: 74 05 je 403181 <phase_3_5+0x180>
40317c: e8 75 2a 00 00 call 405bf6 <explode_bomb>
403181: 90 nop
403182: c9 leave
403183: c3 ret
看起来一大堆很吓人对不对？实际上确实很吓人。
但是发现其中玄机后其实简单的没边，最终答案就藏在0x403177里面，前提是确保这一步前炸弹不爆炸（意识到要爆炸了直接run一下重开qwq）。
动态调试
阅读Phase_3_5发现这一关其实需要两个输入，并且第一个输入必须是rand_div，这里建议通过si单步执行监控好rand_div值变化，确定正确结果后使用run重开正确输入第一个密码后才能进行下一步求解：
(lldb) si
Process 13376 stopped
* thread #1, name = 'bomb_linux', stop reason = instruction step into
frame #0: 0x000000000040317a bomb_linux`phase_3_5 + 377
bomb_linux`phase_3_5:
-> 0x40317a <+377>: je 0x403181 ; <+384>
0x40317c <+379>: callq 0x405bf6 ; explode_bomb
0x403181 <+384>: nop
0x403182 <+385>: leave
(lldb) x/wx $rbp-0x4
0x7fffffffdb0c: 0xffffffd7
例如这里我可以打印出第二个值结合第一个值得到第三关正确结果。
Phase_4
静态分析
本题依旧开局跳转，笔者的跳转方向是phase_4_01，如何跳转不再强调关注rand_div的值即可，下面请D指导解读一下phase_4_01的内容：
0000000000404895 <phase_4_01>:
; 函数入口，初始化栈帧
404895: f3 0f 1e fa endbr64
404899: 55 push %rbp
40489a: 48 89 e5 mov %rsp,%rbp
40489d: 48 83 ec 70 sub $0x70,%rsp ; 分配栈空间
; 初始化斐波那契数组（F(10)~F(24)的十六进制值）
4048a1: 48 89 7d 98 mov %rdi,-0x68(%rbp) ; 保存输入字符串指针
4048a5: c7 45 b0 37 00 00 00 movl $0x37,-0x50(%rbp) ; F(10)=55
4048ac: c7 45 b4 59 00 00 00 movl $0x59,-0x4c(%rbp) ; F(11)=89
4048b3: c7 45 b8 90 00 00 00 movl $0x90,-0x48(%rbp) ; F(12)=144
4048ba: c7 45 bc e9 00 00 00 movl $0xe9,-0x44(%rbp) ; F(13)=233
4048c1: c7 45 c0 79 01 00 00 movl $0x179,-0x40(%rbp) ; F(14)=377
4048c8: c7 45 c4 62 02 00 00 movl $0x262,-0x3c(%rbp) ; F(15)=610
4048cf: c7 45 c8 db 03 00 00 movl $0x3db,-0x38(%rbp) ; F(16)=987
4048d6: c7 45 cc 3d 06 00 00 movl $0x63d,-0x34(%rbp) ; F(17)=1597
4048dd: c7 45 d0 18 0a 00 00 movl $0xa18,-0x30(%rbp) ; F(18)=2584
4048e4: c7 45 d4 55 10 00 00 movl $0x1055,-0x2c(%rbp) ; F(19)=4181
4048eb: c7 45 d8 6d 1a 00 00 movl $0x1a6d,-0x28(%rbp) ; F(20)=6765
4048f2: c7 45 dc c2 2a 00 00 movl $0x2ac2,-0x24(%rbp) ; F(21)=10946
4048f9: c7 45 e0 2f 45 00 00 movl $0x452f,-0x20(%rbp) ; F(22)=17711
404900: c7 45 e4 f1 6f 00 00 movl $0x6ff1,-0x1c(%rbp) ; F(23)=28657
404907: c7 45 e8 20 b5 00 00 movl $0xb520,-0x18(%rbp) ; F(24)=46368
; 读取输入到局部变量（格式为"%d"）
40490e: 48 8d 55 ac lea -0x54(%rbp),%rdx ; 输入存储地址
404912: 48 8b 45 98 mov -0x68(%rbp),%rax ; 输入字符串
404916: 48 8d 0d 93 1f 00 00 lea 0x1f93(%rip),%rcx ; 格式字符串"%d"
40491d: 48 89 ce mov %rcx,%rsi
404920: 48 89 c7 mov %rax,%rdi
404923: b8 00 00 00 00 mov $0x0,%eax
404928: e8 63 c8 ff ff call 401190 <__isoc99_sscanf@plt>
; 验证输入有效性（必须为1个正数）
40492d: 89 45 fc mov %eax,-0x4(%rbp) ; sscanf返回值
404930: 83 7d fc 01 cmpl $0x1,-0x4(%rbp) ; 检查是否读取1个参数
404934: 75 07 jne 40493d <phase_4_01+0xa8> ; 失败则爆炸
404936: 8b 45 ac mov -0x54(%rbp),%eax ; 获取输入值N
404939: 85 c0 test %eax,%eax ; 检查N > 0
40493b: 7f 05 jg 404942 <phase_4_01+0xad>
40493d: e8 b4 12 00 00 call 405bf6 <explode_bomb>
; 检查输入值上限（必须 > 1999）
404942: 8b 45 ac mov -0x54(%rbp),%eax
404945: 3d cf 07 00 00 cmp $0x7cf,%eax ; 1999的十六进制
40494a: 7f 05 jg 404951 <phase_4_01+0xbc> ; N > 1999?
40494c: e8 a5 12 00 00 call 405bf6 <explode_bomb>
; 计算 N/2000（通过定点数乘法优化）
404951: 8b 45 ac mov -0x54(%rbp),%eax ; 输入值N
404954: 48 63 d0 movslq %eax,%rdx ; 符号扩展
404957: 48 69 d2 d3 4d 62 10 imul $0x10624dd3,%rdx,%rdx ; 乘以274877907(≈2^32/2000)
40495e: 48 c1 ea 20 shr $0x20,%rdx ; 取高32位
404962: c1 fa 07 sar $0x7,%edx ; 算术右移7位 → N/2000
404965: c1 f8 1f sar $0x1f,%eax ; 符号位扩展
404968: 89 c1 mov %eax,%ecx
40496a: 89 d0 mov %edx,%eax
40496c: 29 c8 sub %ecx,%eax ; 处理负数情况
40496e: 89 45 ac mov %eax,-0x54(%rbp) ; 保存k = N/2000
; 调用递归函数func4_0(k), 这个函数用于计算斐波那契数列
404971: 8b 45 ac mov -0x54(%rbp),%eax
404974: 89 c7 mov %eax,%edi ; 参数k
404976: e8 ce fd ff ff call 404749 <func4_0> ; 返回值eax=F(k+1)
40497b: 89 45 f8 mov %eax,-0x8(%rbp) ; 保存结果
; 生成随机索引并验证结果
40497e: bf 0f 00 00 00 mov $0xf,%edi ; 参数15
404983: e8 25 cd ff ff call 4016ad <GenerateRandomNumber> ; 生成0~14随机数
404988: 48 8b 05 91 3e 00 00 mov 0x3e91(%rip),%rax # 408820 <rand_div> ; 获取随机索引
40498f: 8b 44 85 b0 mov -0x50(%rbp,%rax,4),%eax ; 取数组[rand_div]的值
404993: 39 45 f8 cmp %eax,-0x8(%rbp) ; 比较func4_0(k) == 数组值？
404996: 74 05 je 40499d <phase_4_01+0x108>
404998: e8 59 12 00 00 call 405bf6 <explode_bomb>
所以相对还是很明了的，依旧是关注rand_div。
动态调试
先找出rand_div在最后判断前的取值，比如我下面的0xa：
(lldb) si
Process 27027 stopped
* thread #1, name = 'bomb_linux', stop reason = instruction step into
frame #0: 0x0000000000401719 bomb_linux`GenerateRandomNumber + 108
bomb_linux`GenerateRandomNumber:
-> 0x401719 <+108>: movq %rax, 0x7100(%rip) ; rand_div
0x401720 <+115>: jmp 0x401723 ; <+118>
0x401722 <+117>: nop
0x401723 <+118>: popq %rbp
(lldb) si
Process 27027 stopped
* thread #1, name = 'bomb_linux', stop reason = instruction step into
frame #0: 0x0000000000401720 bomb_linux`GenerateRandomNumber + 115
bomb_linux`GenerateRandomNumber:
-> 0x401720 <+115>: jmp 0x401723 ; <+118>
0x401722 <+117>: nop
0x401723 <+118>: popq %rbp
0x401724 <+119>: retq
(lldb) x/gx &rand_div
0x00408820: 0x000000000000000a
而当 rand_div = 0xa（即十进制 10）时，输入值 N 的计算步骤如下：
-
数组索引 10 的值是 斐波那契数列第 20 项（
F(20) = 6765）。 -
func4_0(k)实际计算的是 标准斐波那契数列的第k+1项（例如，func4_0(0) = 1 = F(2)） 需要满足：func4_0(k) = F(k+1) = F(20)解得： k + 1 = 20 → k = 19
-
k = N / 2000→N = 2000 * k = 2000 * 19 = 38000. 从而得解。
Phase_Impossible
Impossible？
从这道题开始偷懒了，掏出ghidra直接看c代码了解一下大概流程再去objdump看汇编：
void phase_impossible(char *param_1)
{
int iVar1;
size_t sVar2;
undefined local_118 [256];
long local_18;
long local_10;
local_10 = GetTickCount();
sVar2 = strlen(param_1);
if ((sVar2 < 10) || (sVar2 = strlen(param_1), 0x300 < sVar2)) {
explode_bomb();
}
memset(local_118,0,0x100);
tohex(local_118,param_1);
GenerateRandomNumber(0x400);
iVar1 = check_buf_valid(local_118,rand_div & 0xffffffff);
if (iVar1 == 0) {
puts(&DAT_00406518);
explode_bomb();
}
GenerateRandomNumber(3);
if (rand_div != 2) {
if (2 < rand_div) goto LAB_00401891;
if (rand_div == 0) {
goto_buf_0(local_118);
}
else if (rand_div != 1) goto LAB_00401891;
goto_buf_1(local_118);
}
goto_buf_2(local_118);
LAB_00401891:
explode_bomb();
GenerateRandomNumber(0x400);
if ((long)(int)result != rand_div) {
printf(&DAT_00406560,rand_div,(ulong)result);
explode_bomb();
}
local_18 = GetTickCount();
if (1000 < (ulong)(local_18 - local_10)) {
puts(&DAT_004065a8);
explode_bomb();
}
return;
}
最终任务还是很明确的，需要写一段机器码修改result的数值，但是注意要能通过check_buf_valid检测，并且最后指令必须是跳转到0x401896不然就会触发phase_impossible中0x401891处的explode_bomb函数，唯一的难点是跟踪rand_div的数值变化，建议使用register write来修改check_buf_valid的返回值使其强制通过然后监控rand_div每一次的数值变化（x/gx &rand_div），记录好rand_div的结果后开始指令设计，需要满足：
- 指令的异或和为
rand_div第一次的数值末尾八位以通过检查; - 修改
result使其数值等于rand_div第三次数值; - 跳转到
0x401896避免炸弹;
如果前几问都完成了到这里应该是没有问题的。
Phase_Secret
隐藏彩蛋，并非隐藏。汇编里写的非常清楚：
0000000000401a8b <phase_secret>:
401a8b: f3 0f 1e fa endbr64
401a8f: 55 push %rbp
401a90: 48 89 e5 mov %rsp,%rbp
401a93: 48 83 ec 10 sub $0x10,%rsp
401a97: 48 89 7d f8 mov %rdi,-0x8(%rbp)
401a9b: 48 8d 05 26 4b 00 00 lea 0x4b26(%rip),%rax # 4065c8 <_IO_stdin_used+0x5c8>
401aa2: 48 89 c7 mov %rax,%rdi
401aa5: e8 76 f6 ff ff call 401120 <puts@plt>
401aaa: 90 nop
401aab: c9 leave
401aac: c3 ret
注意到这段指令在原程序中完全没有执行说明是需要用户自己跳转的，也非常简单只需要在phase_5中设计指令时加一个要求跳转到0x401a8b即可。
完结
