逆向工程实战:拆解BombLab中的密码谜题与GDB调试艺术
在计算机安全与系统编程的领域中,逆向工程一直是一项充满挑战又极具魅力的技能。它要求我们像侦探一样,从二进制程序的蛛丝马迹中还原出原始逻辑,甚至破解其中的秘密。CMU的CSAPP课程中的BombLab实验,正是这样一个绝佳的实战平台——它通过六个逐渐复杂的"炸弹"阶段,带领我们深入理解汇编代码、内存管理和调试技巧。
想象一下,你面前有一个正在倒计时的数字炸弹,每个阶段都需要输入正确的密码才能解除引信。错误的选择会导致立即"爆炸",而正确的答案则让你向最终胜利迈进一步。这不仅仅是编程挑战,更是一场智力与耐心的较量。接下来,我将带你深入BombLab的核心机制,分享如何用GDB这一强大工具逐层拆解这些精心设计的谜题。
1. 环境准备与工具配置
工欲善其事,必先利其器。在开始拆弹之前,我们需要配置一个高效的逆向工程环境。推荐使用Ubuntu系统,因为其与Linux工具的兼容性最佳。
首先安装必要的调试工具:
sudo apt-get update
sudo apt-get install gdb gdb-multiarch
GDB的配置对提高调试效率至关重要。创建~/.gdbinit文件并添加以下配置:
set disassembly-flavor intel
set pagination off
define asm
layout asm
layout regs
end
这个配置设置了Intel风格的汇编语法显示(比AT&T语法更易读),关闭了分页显示,并创建了一个快捷命令asm来同时显示汇编代码和寄存器状态。
关键技巧:使用GDB的TUI模式可以极大地提升调试体验。在启动gdb时添加-tui参数,或者在gdb内部使用layout asm命令,可以同时查看源代码/汇编、寄存器和命令窗口。
为了更高效地分析程序,我们还需要生成汇编代码清单:
objdump -d bomb > bomb.asm
这样我们就可以在文本编辑器中方便地查看整个程序的汇编代码,而不必完全依赖GDB的实时反汇编。
2. 第一阶段:字符串比较与内存查看技巧
第一阶段是入门关卡,设计目的是让学习者熟悉基本的GDB操作和内存查看方法。让我们开始设置断点并分析:
gdb bomb
(gdb) break phase_1
(gdb) run
当程序在phase_1断点处停止时,使用disassemble命令查看汇编代码:
(gdb) disassemble phase_1
Dump of assembler code for function phase_1:
0x0000000000400ee0 <+0>: sub rsp,0x8
0x0000000000400ee4 <+4>: mov esi,0x402400
0x0000000000400ee9 <+9>: call 0x401338 <strings_not_equal>
0x0000000000400eee <+14>: test eax,eax
0x0000000000400ef0 <+16>: je 0x400ef7 <phase_1+23>
0x0000000000400ef2 <+18>: call 0x40143a <explode_bomb>
0x0000000000400ef7 <+23>: add rsp,0x8
0x0000000000400efb <+27>: ret
这段代码的关键在第二行:mov esi, 0x402400。这里将0x402400地址加载到esi寄存器中,而esi通常是函数调用的第二个参数。结合后面调用的strings_not_equal函数,我们可以推断这里是在比较输入字符串与内存中预存的字符串。
使用GDB检查这个内存地址的内容:
(gdb) x/s 0x402400
0x402400: "Border relations with Canada have never been better."
成功! 我们找到了第一阶段的密码。这个阶段教会了我们两个重要技能:
- 如何通过反汇编理解程序逻辑
- 如何使用
x/s命令查看内存中的字符串内容
提示:
x/s命令用于检查内存中的字符串,而x/wx用于检查字数据,x/gx用于检查64位数据。灵活运用这些命令是逆向工程的基础。
3. 第二阶段:循环结构与数组处理
第二阶段引入了循环和数组处理的概念。照例我们先设置断点并反汇编:
(gdb) disassemble phase_2
Dump of assembler code for function phase_2:
0x0000000000400efc <+0>: push rbp
0x0000000000400efd <+1>: push rbx
0x0000000000400efe <+2>: sub rsp,0x28
0x0000000000400f02 <+6>: mov rsi,rsp
0x0000000000400f05 <+9>: call 0x40145c <read_six_numbers>
...
注意到这里调用了read_six_numbers,表明需要输入6个数字。继续分析后续汇编代码,我们会发现一个循环结构,检查每个数字是否满足特定条件。
关键汇编片段通常如下所示:
cmpl $0x1,(%rsp) # 检查第一个数字是否为1
je ... # 如果相等则继续
call 0x40143a <explode_bomb> # 否则引爆炸弹
# 循环检查后续数字
mov ebx,0x1
loop_start:
mov eax,ebx
add eax,eax # eax = ebx * 2
cmp eax,DWORD PTR [rsp+rbx*4] # 检查当前数字是否为前一个的两倍
je loop_continue
call 0x40143a <explode_bomb>
loop_continue:
add ebx,0x1
cmp ebx,0x5
jle loop_start
从这段代码可以清晰地看出:第一个数字必须为1,每个后续数字必须是前一个的两倍。因此密码是:1 2 4 8 16 32
逆向技巧:识别循环模式是理解程序逻辑的关键。寻找cmp和条件跳转指令(如jle、jl、je等),它们通常标志着循环的开始或结束。
4. 第三阶段:条件分支与跳转表解析
第三阶段引入了条件分支和跳转表的概念,难度显著提升。反汇编phase_3后,我们会看到类似下面的模式:
0x0000000000400f43 <+0>: sub rsp,0x18
0x0000000000400f47 <+4>: lea rcx,[rsp+0xc]
0x0000000000400f4c <+9>: lea rdx,[rsp+0x8]
0x0000000000400f51 <+14>: mov esi,0x4025cf
0x0000000000400f56 <+19>: mov eax,0x0
0x0000000000400f5b <+24>: call 0x400bf0 <__isoc99_sscanf@plt>
0x0000000000400f60 <+29>: cmp eax,0x2
0x0000000000400f63 <+32>: jg 0x400f6a <phase_3+39>
0x0000000000400f65 <+34>: call 0x40143a <explode_bomb>
首先检查sscanf的调用,通过查看0x4025cf处的格式字符串:
(gdb) x/s 0x4025cf
0x4025cf: "%d %d"
这表明需要输入两个整数。继续分析,我们会发现第一个输入值用于跳转表索引:
0x0000000000400f6a <+39>: cmpl $0x7,0x8(%rsp)
0x0000000000400f6f <+44>: ja 0x400fad <phase_3+106> # 如果第一个数>7则爆炸
0x0000000000400f71 <+46>: mov 0x8(%rsp),%eax
0x0000000000400f75 <+50>: jmp *0x402470(,%rax,8) # 跳转表
这里第一个输入必须小于等于7,然后根据这个值通过跳转表跳转到不同的代码段。每个代码段会将一个特定值赋给eax,然后与第二个输入比较。
通过分析各个跳转目标,我们可以构建出对应的值表:
| 第一个输入 | 第二个输入 |
|---|---|
| 0 | 207 |
| 1 | 311 |
| 2 | 707 |
| 3 | 256 |
| 4 | 389 |
| 5 | 206 |
| 6 | 682 |
| 7 | 327 |
因此,任何匹配上述组合的输入都可以通过这一阶段,例如"1 311"。
高级技巧:使用GDB的jump命令可以强制程序执行流,跳过爆炸函数。这在测试理论时非常有用,但要注意这可能影响程序状态。
5. 第四阶段:递归函数与栈帧分析
第四阶段引入了递归函数调用,需要我们深入理解栈帧和函数调用约定。反汇编phase_4:
0x000000000040100c <+0>: sub rsp,0x18
...
0x000000000040102e <+34>: cmpl $0xe,0x8(%rsp)
0x0000000000401033 <+39>: jbe 0x40103a <phase_4+46>
0x0000000000401035 <+41>: call 0x40143a <explode_bomb>
0x000000000040103a <+46>: mov edx,0xe
0x000000000040103f <+51>: mov esi,0x0
0x0000000000401044 <+56>: mov edi,DWORD PTR [rsp+0x8]
0x0000000000401048 <+60>: call 0x400fce <func4>
0x000000000040104d <+65>: test eax,eax
0x000000000040104f <+67>: jne 0x401058 <phase_4+76>
0x0000000000401051 <+69>: cmpl $0x0,0xc(%rsp)
0x0000000000401056 <+74>: je 0x40105d <phase_4+81>
0x0000000000401058 <+76>: call 0x40143a <explode_bomb>
同样需要两个整数输入,第一个必须小于等于14(0xe),第二个必须为0。关键在func4调用,它必须返回0。
分析func4的汇编代码,我们可以将其转化为等价的C代码:
int func4(int a, int b, int c) {
int t = c - b;
int k = t >> 31; // 算术右移,用于处理负数
t = (t + k) >> 1; // 除以2,考虑符号位
k = t + b;
if (k <= a) {
if (k >= a) {
return 0;
} else {
return 2 * func4(a, k + 1, c) + 1;
}
} else {
return 2 * func4(a, b, k - 1);
}
}
通过分析,我们发现当第一个输入为7时,func4返回0。因此正确答案是"7 0"。
栈帧分析技巧:在递归函数中,使用GDB的backtrace命令可以查看调用栈,info frame可以查看当前栈帧的详细信息。这对于理解递归过程非常有帮助。
6. 第五阶段:字符处理与位操作
第五阶段涉及字符串处理和位操作,是前面知识的综合应用。反汇编phase_5:
0x0000000000401062 <+0>: push rbx
0x0000000000401063 <+1>: sub rsp,0x20
...
0x000000000040107a <+24>: call 0x40131b <string_length>
0x000000000040107f <+29>: cmp eax,0x6
0x0000000000401082 <+32>: je 0x4010d2 <phase_5+112>
0x0000000000401084 <+34>: call 0x40143a <explode_bomb>
首先检查输入字符串长度是否为6。然后进入一个循环:
0x000000000040108b <+41>: movzx ecx,BYTE PTR [rbx+rax*1]
0x000000000040108f <+45>: mov BYTE PTR [rsp],cl
0x0000000000401092 <+48>: mov rdx,QWORD PTR [rsp]
0x0000000000401096 <+52>: and edx,0xf
0x0000000000401099 <+55>: movzx edx,BYTE PTR [rdx+0x4024b0]
0x00000000004010a0 <+62>: mov BYTE PTR [rsp+rax*1+0x10],dl
0x00000000004010a4 <+66>: add rax,0x1
0x00000000004010a8 <+70>: cmp rax,0x6
0x00000000004010ac <+74>: jne 0x40108b <phase_5+41>
这个循环对输入字符串的每个字符进行以下处理:
- 取字符的ASCII码
- 保留低4位(与0xf进行与操作)
- 以这个4位值为索引,从0x4024b0处的字符数组中取出对应字符
- 将取出的字符存入新字符串
检查0x4024b0处的数组:
(gdb) x/s 0x4024b0
0x4024b0 <array.3449>: "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
循环处理后,新字符串必须等于0x40245e处的字符串:
(gdb) x/s 0x40245e
0x40245e: "flyers"
因此,我们需要找到6个字符,它们的低4位作为索引时,从数组中取出的字符正好是'f','l','y','e','r','s'。
计算索引值:'f'在数组中的位置是9,'l'是15,'y'是14,'e'是5,'r'是6,'s'是7。因此需要输入字符其低4位分别为9、15、14、5、6、7。
例如,字符'i'的ASCII码是105(二进制01101001),低4位是1001(9),符合第一个要求。通过类似方法,我们可以找到解:"ionefg"。
位操作技巧:逆向工程中经常遇到位操作。熟练掌握AND、OR、XOR、移位等操作的含义对快速分析至关重要。GDB的print/t命令可以以二进制形式显示数值,便于位分析。
7. 第六阶段:链表结构与内存布局
第六阶段是最复杂的,涉及链表数据结构和内存操作。反汇编phase_6:
0x00000000004010f4 <+0>: push r14
0x00000000004010f6 <+2>: push r13
0x00000000004010f8 <+4>: push r12
...
0x0000000000401106 <+18>: call 0x40145c <read_six_numbers>
同样需要输入6个数字,每个数字必须在1到6之间且互不相同。然后代码分为四个主要部分:
- 输入验证:检查数字范围和唯一性
- 数值转换:将每个输入转换为7减去该值
- 链表遍历:根据转换后的值重新排列链表节点
- 顺序验证:检查重排后的链表是否按特定顺序排列
关键在于理解链表结构。通过GDB检查内存:
(gdb) x/24wx 0x6032d0
0x6032d0 <node1>: 0x0000014c 0x00000001 0x006032e0 0x00000000
0x6032e0 <node2>: 0x000000a8 0x00000002 0x006032f0 0x00000000
0x6032f0 <node3>: 0x0000039c 0x00000003 0x00603300 0x00000000
0x603300 <node4>: 0x000002b3 0x00000004 0x00603310 0x00000000
0x603310 <node5>: 0x000001dd 0x00000005 0x00603320 0x00000000
0x603320 <node6>: 0x000001bb 0x00000006 0x00000000 0x00000000
这是一个包含6个节点的链表,每个节点结构为:
- 4字节:值
- 4字节:节点编号
- 8字节:下一个节点指针
节点的值分别为:332(0x14c), 168(0xa8), 924(0x39c), 691(0x2b3), 477(0x1dd), 443(0x1bb)
phase_6要求重新排列节点,使它们的值按降序排列:924 → 691 → 477 → 443 → 332 → 168
即节点3 → 节点4 → 节点5 → 节点6 → 节点1 → 节点2
由于之前有7-x的转换,原始输入应该是4 3 2 1 6 5
链表分析技巧:在逆向工程中遇到数据结构时,先找出内存布局规律,绘制出结构图,再分析算法逻辑。使用GDB的x命令系列可以方便地查看内存内容。
8. 隐藏阶段与综合技巧
除了官方6个阶段,BombLab还有一个隐藏阶段,需要在phase_4的特定输入后触发。这个阶段结合了前面所有技巧,是对逆向工程能力的终极考验。
发现隐藏阶段需要字符串搜索技巧:
(gdb) strings bomb | grep -i secret
或者仔细分析phase_4的汇编代码,可能会发现对特定字符串的引用。
综合调试策略:
- 多断点设置:在每个phase开始和可能爆炸的地方设置断点
- 寄存器监控:使用
info registers频繁检查寄存器状态 - 内存监视:使用
watch命令监视关键内存地址的变化 - 反向执行:GDB的
reverse-step和reverse-next可以反向执行,对于理解错误原因很有帮助
注意:逆向工程是一个需要耐心和细致的过程。每个阶段都可能有多解,但只有符合设计者意图的输入才能通过。遇到困难时,休息一下再回来往往会有新的发现。
通过BombLab的实践,我们不仅学会了GDB的高级用法,更重要的是培养了系统级的思维方式——如何从机器角度理解程序行为。这种能力在安全分析、性能优化和系统编程中都极为宝贵。
288



被折叠的 条评论
为什么被折叠?



