原文地址：https://billc.io/2019/04/csapp-bomblab/
寫在前面
CS:APP是這學期的一門硬核課程，應該是目前接觸到最底層的課程了。學校的教學也是嘗試着盡量和CMU同步，課件和習題都直接照搬原版。包括現在着手的第二個實驗室Bomb Lab。這個lab很有意思，沒有提供全部c語言代碼，需要手動根據反匯編語言推測在每一個階段需要輸入的內容，輸入正確就可以進入下一個階段。
理論上每個人獲取到的lab都是不一樣的，但對於自學學生而言在官網http://csapp.cs.cmu.edu/3e/labs.html下載到的實驗室都是一樣的，爆炸了之后也不會把信息發送到遠程服務器扣分。
使用gdb bomb命令可以實時調試程序。結合break function、break *地址、disas、x/s $地址命令實時查看程序內的內容，同時用info registers和info frame查看寄存器信息和棧幀信息，可以拆除炸彈。
Phase 1
在Phase_1打下斷點，使用info register可以得到寄存器信息：
(gdb) info register rax 0x603780 6305664 rbx 0x0 0 rcx 0x3 3 rdx 0x1 1 rsi 0x603780 6305664 rdi 0x603780 6305664 rbp 0x402210 0x402210 <__libc_csu_init> rsp 0x7fffffffde28 0x7fffffffde28 r8 0x604674 6309492 r9 0x7ffff7fba540 140737353852224 r10 0x3 3 r11 0x7ffff7e015c0 140737352046016 r12 0x400c90 4197520 r13 0x7fffffffdf10 140737488346896 r14 0x0 0 r15 0x0 0 rip 0x400ee0 0x400ee0 <phase_1> eflags 0x206 [ PF IF ] cs 0x33 51 ss 0x2b 43 ds 0x0 0 es 0x0 0 fs 0x0 0 gs 0x0 0
得到匯編代碼如下：
Dump of assembler code for function phase_1: => 0x0000000000400ee0 <+0>: sub $0x8,%rsp 0x0000000000400ee4 <+4>: mov $0x402400,%esi 0x0000000000400ee9 <+9>: callq 0x401338 <strings_not_equal> 0x0000000000400eee <+14>: test %eax,%eax 0x0000000000400ef0 <+16>: je 0x400ef7 <phase_1+23> 0x0000000000400ef2 <+18>: callq 0x40143a <explode_bomb> 0x0000000000400ef7 <+23>: add $0x8,%rsp 0x0000000000400efb <+27>: retq
發現程序調用了strings_not_euqal函數，該函數應該是用於比較兩個字符串是否相等的。可以發現%eax是輸入的字符串數據，調用程序會將如果返回值%eax為0的話je結束函數phase_1。其中所以使用命x/s 0x402400獲取存儲的字符串，得到結果：
所以第一個炸彈的答案為：
Border relations with Canada have never been better.
Phase 2
同樣獲取這一階段的匯編代碼：
(gdb) disas Dump of assembler code for function phase_2: => 0x0000000000400efc <+0>: push %rbp 0x0000000000400efd <+1>: push %rbx 0x0000000000400efe <+2>: sub $0x28,%rsp 0x0000000000400f02 <+6>: mov %rsp,%rsi 0x0000000000400f05 <+9>: callq 0x40145c <read_six_numbers> 0x0000000000400f0a <+14>: cmpl $0x1,(%rsp) 0x0000000000400f0e <+18>: je 0x400f30 <phase_2+52> 0x0000000000400f10 <+20>: callq 0x40143a <explode_bomb> 0x0000000000400f15 <+25>: jmp 0x400f30 <phase_2+52> 0x0000000000400f17 <+27>: mov -0x4(%rbx),%eax 0x0000000000400f1a <+30>: add %eax,%eax 0x0000000000400f1c <+32>: cmp %eax,(%rbx) 0x0000000000400f1e <+34>: je 0x400f25 <phase_2+41> 0x0000000000400f20 <+36>: callq 0x40143a <explode_bomb> 0x0000000000400f25 <+41>: add $0x4,%rbx 0x0000000000400f29 <+45>: cmp %rbp,%rbx 0x0000000000400f2c <+48>: jne 0x400f17 <phase_2+27> 0x0000000000400f2e <+50>: jmp 0x400f3c <phase_2+64> 0x0000000000400f30 <+52>: lea 0x4(%rsp),%rbx 0x0000000000400f35 <+57>: lea 0x18(%rsp),%rbp 0x0000000000400f3a <+62>: jmp 0x400f17 <phase_2+27> 0x0000000000400f3c <+64>: add $0x28,%rsp 0x0000000000400f40 <+68>: pop %rbx 0x0000000000400f41 <+69>: pop %rbp 0x0000000000400f42 <+70>: retq End of assembler dump.
有一個read_six_numbers的函數，猜測會從輸入中讀取六個數字。所以可以隨便輸入6個數字測試以一下。查看read_six_numbers的匯編代碼：
Dump of assembler code for function read_six_numbers: 0x000000000040145c <+0>: sub $0x18,%rsp 0x0000000000401460 <+4>: mov %rsi,%rdx 0x0000000000401463 <+7>: lea 0x4(%rsi),%rcx 0x0000000000401467 <+11>: lea 0x14(%rsi),%rax 0x000000000040146b <+15>: mov %rax,0x8(%rsp) 0x0000000000401470 <+20>: lea 0x10(%rsi),%rax 0x0000000000401474 <+24>: mov %rax,(%rsp) 0x0000000000401478 <+28>: lea 0xc(%rsi),%r9 0x000000000040147c <+32>: lea 0x8(%rsi),%r8 0x0000000000401480 <+36>: mov $0x4025c3,%esi 0x0000000000401485 <+41>: mov $0x0,%eax 0x000000000040148a <+46>: callq 0x400bf0 <__isoc99_sscanf@plt> 0x000000000040148f <+51>: cmp $0x5,%eax 0x0000000000401492 <+54>: jg 0x401499 <read_six_numbers+61> 0x0000000000401494 <+56>: callq 0x40143a <explode_bomb> 0x0000000000401499 <+61>: add $0x18,%rsp 0x000000000040149d <+65>: retq End of assembler dump.
通過觀察寄存器的信息，可以發現輸入的數據存儲在了 %rsp 下的各個位置，分別為%rsp + 1， %rsp + 2……等等（可以通過(gdb) print /d *0x7fffffffddf0 + 4 $5 = 5來檢查，更多的是通過函數的名稱猜測出來的，因為不太確定scanf的機制，猜測這里scanf的返回值應該存儲在eax內，為成功讀取到的數據個數，cmp $0x5,%eax這句會使成功讀取的數據少於5的時候炸彈爆炸。）
對於phase_2的匯編代碼，第一條cmp語句可以看出在比較輸入的第一個數字，如果不為1就爆炸。之后的結構中有許多的跳轉語句，可以判斷這是一個循環。循環中把后面一個數字傳入%rbx中，再把前一個數字傳入%eax中。add %eax,%eax一句再講前一個數字乘以二，如果相等的話就可以跳過這個+36處的爆炸點。緊接着將%rbx指向下一個整數，比較是否和%rsp相等，也就是達到了最后一個整數的情況，如果沒有就繼續循環，達到了就跳到+64處，炸彈解除。所以只要每一個數都是前一個的兩倍就可以了，答案為：
1 2 4 8 16 32
Phase 3
接下來觀察phase_3的匯編代碼：
Dump of assembler code for function phase_3:
=> 0x0000000000400f43 <+0>: sub $0x18,%rsp
0x0000000000400f47 <+4>: lea 0xc(%rsp),%rcx
0x0000000000400f4c <+9>: lea 0x8(%rsp),%rdx
# ️x/s 0x4025cf可以得到"%d %d"，這就是需要輸入的兩個數據
0x0000000000400f51 <+14>: mov $0x4025cf,%esi
0x0000000000400f56 <+19>: mov $0x0,%eax
0x0000000000400f5b <+24>: callq 0x400bf0 <__isoc99_sscanf@plt>
# ️%scanf如果返回值為1也就是讀取成功的個數為1的話就會爆炸，所以猜測這里需要至少讀取兩個數據才能跳過下一個爆炸點。
0x0000000000400f60 <+29>: cmp $0x1,%eax
0x0000000000400f63 <+32>: jg 0x400f6a <phase_3+39>
0x0000000000400f65 <+34>: callq 0x40143a <explode_bomb>
0x0000000000400f6a <+39>: cmpl $0x7,0x8(%rsp)
# ️%rsp + 8 如果大於7，則炸彈會爆炸。觀察發現 %rsp + 8 存儲的是第一個輸入的整數。由於ja是無符號比較，所以輸入的值必須大於等於0，否則也一定會爆炸。
0x0000000000400f6f <+44>: ja 0x400fad <phase_3+106>
0x0000000000400f71 <+46>: mov 0x8(%rsp),%eax
# ️這里是個switch語句，根據rax的值去查找跳轉表對應的值。rax是輸入的第一個整數。
0x0000000000400f75 <+50>: jmpq *0x402470(,%rax,8)
0x0000000000400f7c <+57>: mov $0xcf,%eax
0x0000000000400f81 <+62>: jmp 0x400fbe <phase_3+123>
0x0000000000400f83 <+64>: mov $0x2c3,%eax
0x0000000000400f88 <+69>: jmp 0x400fbe <phase_3+123>
0x0000000000400f8a <+71>: mov $0x100,%eax
0x0000000000400f8f <+76>: jmp 0x400fbe <phase_3+123>
0x0000000000400f91 <+78>: mov $0x185,%eax
0x0000000000400f96 <+83>: jmp 0x400fbe <phase_3+123>
0x0000000000400f98 <+85>: mov $0xce,%eax
0x0000000000400f9d <+90>: jmp 0x400fbe <phase_3+123>
0x0000000000400f9f <+92>: mov $0x2aa,%eax
0x0000000000400fa4 <+97>: jmp 0x400fbe <phase_3+123>
0x0000000000400fa6 <+99>: mov $0x147,%eax
0x0000000000400fab <+104>: jmp 0x400fbe <phase_3+123>
0x0000000000400fad <+106>: callq 0x40143a <explode_bomb>
0x0000000000400fb2 <+111>: mov $0x0,%eax
0x0000000000400fb7 <+116>: jmp 0x400fbe <phase_3+123>
0x0000000000400fb9 <+118>: mov $0x137,%eax
# ️這里會比較%rsp+12的值（可以發現就是我們輸入的第二個值）和%eax中的數據是否相等，一樣的話就跳過爆炸點。
0x0000000000400fbe <+123>: cmp 0xc(%rsp),%eax
0x0000000000400fc2 <+127>: je 0x400fc9 <phase_3+134>
0x0000000000400fc4 <+129>: callq 0x40143a <explode_bomb>
0x0000000000400fc9 <+134>: add $0x18,%rsp
0x0000000000400fcd <+138>: retq
End of assembler dump.
分析已經插入在了匯編代碼中。中間的switch語句可以通過輸入不同的值和斷點來探索出對應跳轉的地方。比如我在這里第一個數字為2后，將斷點設置在print /x *(0x402470 + 16)
顯示出來的位置，可以發現程序跳轉到了 => 0x0000000000400f83 <+64>: mov $0x2c3,%eax的語句。
這里的0x2c3就應該是第二個數的答案。轉換為十進制為707。可以推測這個題目一共有八個解答，只要輸入的第二個數字和第一個數字對應的跳轉關系相對應即可。進一步多次解析，可以得到第三個炸彈答案表如下：
| 第一個數字 | 跳轉到的語句 | 第二個數字 |
|---|---|---|
| 0 | 400f7c <+57>: mov $0xcf,%eax | 207 |
| 1 | 400fb9 <+118>: mov $0x137,%eax | 311 |
| 2 | 400f83 <+64>: mov $0x2c3,%eax | 707 |
| 3 | 400f8a <+71>: mov $0x100,%eax | 256 |
| 4 | 400f91 <+78>: mov $0x185,%eax | 389 |
| 5 | 400f98 <+85>: mov $0xce,%eax | 206 |
| 6 | 400f9f <+92>: mov $0x2aa,%eax | 682 |
| 7 | 400fa6 <+99>: mov $0x147,%eax | 327 |
Phase 4
匯編代碼及分析如下：
Dump of assembler code for function phase_4:
=> 0x000000000040100c <+0>: sub $0x18,%rsp
0x0000000000401010 <+4>: lea 0xc(%rsp),%rcx
0x0000000000401015 <+9>: lea 0x8(%rsp),%rdx
# ️查看scanf的格式化輸入（在0x4025cf）可得到"%d %d"，所以需要輸入兩個整形數據。
0x000000000040101a <+14>: mov $0x4025cf,%esi
0x000000000040101f <+19>: mov $0x0,%eax
0x0000000000401024 <+24>: callq 0x400bf0 <__isoc99_sscanf@plt>
# ️必須輸入兩個數據，否則就會直接跳轉到爆炸點。
0x0000000000401029 <+29>: cmp $0x2,%eax
0x000000000040102c <+32>: jne 0x401035 <phase_4+41>
# ️比較0xe和輸入的第一個數據的大小，數據必須要小於或等於0xe(14)才能跳過爆炸點
0x000000000040102e <+34>: cmpl $0xe,0x8(%rsp)
0x0000000000401033 <+39>: jbe 0x40103a <phase_4+46>
0x0000000000401035 <+41>: callq 0x40143a <explode_bomb>
0x000000000040103a <+46>: mov $0xe,%edx
0x000000000040103f <+51>: mov $0x0,%esi
0x0000000000401044 <+56>: mov 0x8(%rsp),%edi
# ️調用fuc4函數，此時edx等於14，esi等於0，edi等於輸入的第一個數x，
相當於調用func4(x, 0, 14)
0x0000000000401048 <+60>: callq 0x400fce <func4>
0x000000000040104d <+65>: test %eax,%eax
# ️測試func4返回值是否為0。如果不為0的話會直接跳到爆炸點。
0x000000000040104f <+67>: jne 0x401058 <phase_4+76>
# ️比較rp+12，應該是第二個數字是否為0，如果為0的話可以跳過爆炸點。
0x0000000000401051 <+69>: cmpl $0x0,0xc(%rsp)
0x0000000000401056 <+74>: je 0x40105d <phase_4+81>
0x0000000000401058 <+76>: callq 0x40143a <explode_bomb>
0x000000000040105d <+81>: add $0x18,%rsp
0x0000000000401061 <+85>: retq
End of assembler dump.
發現+60處會調用func4函數，反匯編func4如下。在func4內部還會再次調用func4，可以看出這是一個遞歸的函數過程，進一步分析：
(gdb) disas func4
Dump of assembler code for function func4:
0x0000000000400fce <+0>: sub $0x8,%rsp
0x0000000000400fd2 <+4>: mov %edx,%eax
0x0000000000400fd4 <+6>: sub %esi,%eax
0x0000000000400fd6 <+8>: mov %eax,%ecx
# ️將%ecx右移31位（可以用來判斷eax的正負，比較第二個參數和第三個參數的大小
0x0000000000400fd8 <+10>: shr $0x1f,%ecx
0x0000000000400fdb <+13>: add %ecx,%eax
# ️將eax算數右移一位，即除以2
0x0000000000400fdd <+15>: sar %eax
0x0000000000400fdf <+17>: lea (%rax,%rsi,1),%ecx
0x0000000000400fe2 <+20>: cmp %edi,%ecx
# ️如果%ecx小於%edi就跳轉到36並把返回值設置為0。
0x0000000000400fe4 <+22>: jle 0x400ff2 <func4+36>
# 否則將rcx減去1傳給edx。
相當於遞歸調用
0x0000000000400fe6 <+24>: lea -0x1(%rcx),%edx
0x0000000000400fe9 <+27>: callq 0x400fce <func4>
0x0000000000400fee <+32>: add %eax,%eax
0x0000000000400ff0 <+34>: jmp 0x401007 <func4+57>
0x0000000000400ff2 <+36>: mov $0x0,%eax
0x0000000000400ff7 <+41>: cmp %edi,%ecx
# ️如果%ecx大於%edi就結束函數，否則繼續調用下一層遞歸。
0x0000000000400ff9 <+43>: jge 0x401007 <func4+57>
# ️把%rcx + 1 傳遞到%esi中，作為下一個func4的參數。
0x0000000000400ffb <+45>: lea 0x1(%rcx),%esi
0x0000000000400ffe <+48>: callq 0x400fce <func4>
0x0000000000401003 <+53>: lea 0x1(%rax,%rax,1),%eax
0x0000000000401007 <+57>: add $0x8,%rsp
0x000000000040100b <+61>: retq
End of assembler dump.
結構比較復雜，嘗試逐行翻譯成C語言代碼如下：
func4(x, 0 ,14)
int func4(int a, int b, int c){
// t in %eax , q in % ecx
// a in %rdi, b in %rsi, c in %rdx
int t = c;
t = t - b;
int q = t;
q = q >> 31;
t = t + q;
t = t/2;
q = t + b;
if (q <= a){
t = 0;
if (q >= a){
return t;
}
else{
b = q + 1;
func4(a, b, c);
}
}
else{
c = q - 1;
func4(a, b, c);
t = 2t;
}
return t;
}
分析發現第一次運行的時候，q會被賦值為7，而當x=7的時候可以直接跳過遞歸部分，解除炸彈。所以答案為：
7 0
Phase 5
匯編代碼如下：
(gdb) disas phase_5
Dump of assembler code for function phase_5:
0x0000000000401062 <+0>: push %rbx
0x0000000000401063 <+1>: sub $0x20,%rsp
0x0000000000401067 <+5>: mov %rdi,%rbx
0x000000000040106a <+8>: mov %fs:0x28,%rax
0x0000000000401073 <+17>: mov %rax,0x18(%rsp)
0x0000000000401078 <+22>: xor %eax,%eax
0x000000000040107a <+24>: callq 0x40131b <string_length>
0x000000000040107f <+29>: cmp $0x6,%eax
0x0000000000401082 <+32>: je 0x4010d2 <phase_5+112>
# ️這里有一個爆炸點，上面的函數為string_length，所以推斷應該輸入長度為6的字符串。
0x0000000000401084 <+34>: callq 0x40143a <explode_bomb>
0x0000000000401089 <+39>: jmp 0x4010d2 <phase_5+112>
0x000000000040108b <+41>: movzbl (%rbx,%rax,1),%ecx
0x000000000040108f <+45>: mov %cl,(%rsp)
0x0000000000401092 <+48>: mov (%rsp),%rdx
# 將傳入的%edx和0xf做與運算，相當於只保留這一個字符的ASCII碼的最后的4位。
0x0000000000401096 <+52>: and $0xf,%edx
# ️movzbl為做了0擴展的字節傳送，0x4024b0 存儲的是一個字符串。這里用%rdx的偏移量將字符串中的某一個字符傳遞到edx中。。
0x0000000000401099 <+55>: movzbl 0x4024b0(%rdx),%edx
0x00000000004010a0 <+62>: mov %dl,0x10(%rsp,%rax,1)
# ️rax加一，作為循環的計數器。循環6次以后跳出。
0x00000000004010a4 <+66>: add $0x1,%rax
0x00000000004010a8 <+70>: cmp $0x6,%rax
0x00000000004010ac <+74>: jne 0x40108b <phase_5+41>
0x00000000004010ae <+76>: movb $0x0,0x16(%rsp)
0x00000000004010b3 <+81>: mov $0x40245e,%esi
0x00000000004010b8 <+86>: lea 0x10(%rsp),%rdi
# 比較%rsp里存儲的字符串是否與0x4025e相等。
0x00000000004010bd <+91>: callq 0x401338 <strings_not_equal>
0x00000000004010c2 <+96>: test %eax,%eax
# ️eax必須等於0（字符串相等），否則爆炸。
0x00000000004010c4 <+98>: je 0x4010d9 <phase_5+119>
0x00000000004010c6 <+100>: callq 0x40143a <explode_bomb>
0x00000000004010cb <+105>: nopl 0x0(%rax,%rax,1)
0x00000000004010d0 <+110>: jmp 0x4010d9 <phase_5+119>
0x00000000004010d2 <+112>: mov $0x0,%eax
0x00000000004010d7 <+117>: jmp 0x40108b <phase_5+41>
0x00000000004010d9 <+119>: mov 0x18(%rsp),%rax
0x00000000004010de <+124>: xor %fs:0x28,%rax
0x00000000004010e7 <+133>: je 0x4010ee <phase_5+140>
0x00000000004010e9 <+135>: callq 0x400b30 <__stack_chk_fail@plt>
0x00000000004010ee <+140>: add $0x20,%rsp
0x00000000004010f2 <+144>: pop %rbx
0x00000000004010f3 <+145>: retq
End of assembler dump.
可以看到0x4024b0里存儲了一個字符串：
0x245e里也存儲了一個字符串：
確定必須輸入長度為6的字符串之后，隨便輸入fgr123，執行到+55行。由於使用了%cl這種只能存儲char類型的寄存器，所以繼續用print /c 探索寄存器里的數據：
探索核心語句movzbl 0x4024b0(%rdx),%edx和mov %dl,0x10(%rsp,%rax,1)。在這里輸入的第一個字符為f，他的二進制ASCII碼為0x66，二進制為0110 0110：
取后四位，0110是十進制的6，用6做索引，取string[6]，得到字符'r'，正好是寄存器%dl里存儲的字符。
所以以此類推，可以得到phase5的邏輯大致如下：
- 讀取長度為6的字符串
- 逐個字符讀取，取每一個字符的ASCII碼的后4位
- 以這后4為作為索引，取0x4024b0中的第n個字符，並將這一個字符存入到
0x10(%rsp)中 - 循環6次，依次讀取
- 將最后得到的字符串
0x10(%rsp)同flyers比較，相同則通過。
由於后4位的二進制數能存儲的最大數字為15，所以能夠起到作用的只有長字符串的前16位，必須要在前16位中查找。
flyers每個字母在字符串中的序列依次為：9 15 14 5 6 7。依次轉換成二進制為：
1001 1111 1110 0101 0110 0111。所以需要找6個字符，他們的ASCII碼的二進制后4位滿足以上序列就可以了。
拿來一張具有二進制表示的ASCII碼表：
可以得到一個答案為：
ION567
Phase 6
得到巨大的匯編代碼（實在是太可怕了）。
這個炸彈的部分語句由於時間有限我也沒有完全逐步分析，這里有一個很詳細的分析，可以參考一下：https://www.viseator.com/2017/06/21/CS_APP_BombLab/#階段六
拆分開來，分成幾個部分分析：
Dump of assembler code for function phase_6:
0x00000000004010f4 <+0>: push %r14
0x00000000004010f6 <+2>: push %r13
0x00000000004010f8 <+4>: push %r12
0x00000000004010fa <+6>: push %rbp
0x00000000004010fb <+7>: push %rbx
0x00000000004010fc <+8>: sub $0x50,%rsp
0x0000000000401100 <+12>: mov %rsp,%r13
0x0000000000401103 <+15>: mov %rsp,%rsi
0x0000000000401106 <+18>: callq 0x40145c <read_six_numbers>
# r14里存儲了數組的初始化地址
0x000000000040110b <+23>: mov %rsp,%r14
發現同樣是讀取了六個數字，所以隨便輸入1 2 3 4 5 6，發現這里取了六個整數並存儲在棧幀里：
0x000000000040110e <+26>: mov $0x0,%r12d
0x0000000000401114 <+32>: mov %r13,%rbp
0x0000000000401117 <+35>: mov 0x0(%r13),%eax
# %eax減1后和5比較
0x000000000040111b <+39>: sub $0x1,%eax
0x000000000040111e <+42>: cmp $0x5,%eax
# 如果任何一個數字小於等於5，則跳過爆炸點
0x0000000000401121 <+45>: jbe 0x401128 <phase_6+52>
0x0000000000401123 <+47>: callq 0x40143a <explode_bomb>
目前為止讀取了6個數字，必須是在1~6之間。
0x0000000000401128 <+52>: add $0x1,%r12d
0x000000000040112c <+56>: cmp $0x6,%r12d
0x0000000000401130 <+60>: je 0x401153 <phase_6+95>
#%ebx在這里是數組指針，后面會被存儲在%rax中。
0x0000000000401132 <+62>: mov %r12d,%ebx
0x0000000000401135 <+65>: movslq %ebx,%rax
0x0000000000401138 <+68>: mov (%rsp,%rax,4),%eax
# 判斷下一個元素是否和%rax指向的元素相等，如果相等就爆炸。
0x000000000040113b <+71>: cmp %eax,0x0(%rbp)
0x000000000040113e <+74>: jne 0x401145 <phase_6+81>
0x0000000000401140 <+76>: callq 0x40143a <explode_bomb>
0x0000000000401145 <+81>: add $0x1,%ebx
# 判斷數組下標是否到達了5
0x0000000000401148 <+84>: cmp $0x5,%ebx
0x000000000040114b <+87>: jle 0x401135 <phase_6+65>
0x000000000040114d <+89>: add $0x4,%r13
0x0000000000401151 <+93>: jmp 0x401114 <phase_6+32>
這一部分用於判斷數組6個數是否存在重復值，若存在則引爆炸彈。這里是一個循環結構，分別將每一個元素和數組后面的所有元素進行比較。
#把數組最后一個元素的位置傳給了%rsi。
0x0000000000401153 <+95>: lea 0x18(%rsp),%rsi
0x0000000000401158 <+100>: mov %r14,%rax
# 用7減去每一個元素
0x000000000040115b <+103>: mov $0x7,%ecx
0x0000000000401160 <+108>: mov %ecx,%edx
0x0000000000401162 <+110>: sub (%rax),%edx
0x0000000000401164 <+112>: mov %edx,(%rax)
0x0000000000401166 <+114>: add $0x4,%rax
# 比較%rax是否指向了數組末尾的位置，如果到達就跳出循環。
0x000000000040116a <+118>: cmp %rsi,%rax
0x000000000040116d <+121>: jne 0x401160 <phase_6+108>
上面這一部分把數組的每個數字用7去減。目的不明（？
# 將%esi初始化為0，作為數組下標
0x000000000040116f <+123>: mov $0x0,%esi
0x0000000000401174 <+128>: jmp 0x401197 <phase_6+163>
# 偏移量為8，類似於 p = p -> next
0x0000000000401176 <+130>: mov 0x8(%rdx),%rdx
0x000000000040117a <+134>: add $0x1,%eax
# 在第一次循環里，判斷棧里的第一個數字判斷是否為1，如果是1，就把0x6032d0放在棧里，否則就對下一個數字進行判斷。
0x000000000040117d <+137>: cmp %ecx,%eax
0x000000000040117f <+139>: jne 0x401176 <phase_6+130>
0x0000000000401181 <+141>: jmp 0x401188 <phase_6+148>
# 把一個鏈表的指針傳給%eax。
0x0000000000401183 <+143>: mov $0x6032d0,%edx
0x0000000000401188 <+148>: mov %rdx,0x20(%rsp,%rsi,2)
0x000000000040118d <+153>: add $0x4,%rsi
0x0000000000401191 <+157>: cmp $0x18,%rsi
0x0000000000401195 <+161>: je 0x4011ab <phase_6+183>
0x0000000000401197 <+163>: mov (%rsp,%rsi,1),%ecx
# 比較%ecx是否為1（因為%ecx不可能為0）
0x000000000040119a <+166>: cmp $0x1,%ecx
0x000000000040119d <+169>: jle 0x401183 <phase_6+143>
0x000000000040119f <+171>: mov $0x1,%eax
0x00000000004011a4 <+176>: mov $0x6032d0,%edx
0x00000000004011a9 <+181>: jmp 0x401176 <phase_6+130>
這個地方在+143處有一個常量指針，多次嘗試輸出值，發現這里存儲了一個鏈表結構。使用x/12xg 0x6032d0可以看到，打印出來的名稱node也提示這是一個鏈表：
每個節點第一個是long類型（推測），第二個是一個指向下一個node的指針，所以偏移量都是8。進一步依次用類似於*0x6032d0的語句來探索鏈表里每個節點存儲的數值。可以得到鏈表里存儲的數據如下：
| node1 | node2 | node3 | node4 | node5 | node6 |
|---|---|---|---|---|---|
| 332 | 168 | 924 | 691 | 477 | 443 |
上面這一部分可以根據輸入的數字來讀取鏈表的第n位，並把第n位的節點存儲進0x20(%rsp,%rsi,2)內用於后續操作。也就是說這個幀里存儲着按照特定順序排列好的節點，這個順序就是我們輸入的數字經過7-x的結果。
接下來的部分：
# 開始從%rsp + 20的位置開始讀取剛才存儲在這里的節點
0x00000000004011ab <+183>: mov 0x20(%rsp),%rbx
# 第2個元素的地址
0x00000000004011b0 <+188>: lea 0x28(%rsp),%rax
0x00000000004011b5 <+193>: lea 0x50(%rsp),%rsi
0x00000000004011ba <+198>: mov %rbx,%rcx
0x00000000004011bd <+201>: mov (%rax),%rdx
# 把下一個節點的地址存儲在上一個指針的next里
0x00000000004011c0 <+204>: mov %rdx,0x8(%rcx)
0x00000000004011c4 <+208>: add $0x8,%rax
0x00000000004011c8 <+212>: cmp %rsi,%rax
# 如果%rax到達結尾位置就結束循環
0x00000000004011cb <+215>: je 0x4011d2 <phase_6+222>
0x00000000004011cd <+217>: mov %rdx,%rcx
0x00000000004011d0 <+220>: jmp 0x4011bd <phase_6+201>
在%rsp+20處存儲了更換了順序之后的6個節點，這里是需要把每個節點的next都重新鏈接，使他們重新按照指定的順序連接起來。
0x00000000004011d2 <+222>: movq $0x0,0x8(%rdx)
0x00000000004011da <+230>: mov $0x5,%ebp
# 偏移量為8，准備判斷下一個數字
0x00000000004011df <+235>: mov 0x8(%rbx),%rax
0x00000000004011e3 <+239>: mov (%rax),%eax
0x00000000004011e5 <+241>: cmp %eax,(%rbx)
# 判斷是否為遞減的數列。
0x00000000004011e7 <+243>: jge 0x4011ee <phase_6+250>
0x00000000004011e9 <+245>: callq 0x40143a <explode_bomb>
# 偏移量為8，准備判斷下一個數字
0x00000000004011ee <+250>: mov 0x8(%rbx),%rbx
0x00000000004011f2 <+254>: sub $0x1,%ebp
0x00000000004011f5 <+257>: jne 0x4011df <phase_6+235>
這一部分就是比較新的這一個序列的節點里，是否里面存儲的數字是遞減的，一旦發現不是遞減的就引爆炸彈。
最后清空內存。
0x00000000004011f7 <+259>: add $0x50,%rsp 0x00000000004011fb <+263>: pop %rbx 0x00000000004011fc <+264>: pop %rbp 0x00000000004011fd <+265>: pop %r12 0x00000000004011ff <+267>: pop %r13 0x0000000000401201 <+269>: pop %r14 0x0000000000401203 <+271>: retq End of assembler dump.
按照上面分析的邏輯，只要輸入6個在1-6的整數x，按照7-x的順序重新排序節點，判斷排序之后的節點是否為遞減數列，如果是的話就成功解除炸彈。
再次檢查原始鏈表里存儲的數字：
| node1 | node2 | node3 | node4 | node5 | node6 |
|---|---|---|---|---|---|
| 332 | 168 | 924 | 691 | 477 | 443 |
所以為了讓他們成為遞減數列，需要按照3 4 5 6 1 2的順序排列。但由於3 4 5 6 1 2是由輸入的數據被7減去得來的，所以最后一個炸彈的答案應該為：
4 3 2 1 6 5
寫在后面
拆完炸彈的時候已經是凌晨三點了，實在是太可怕了。嚴格來說還有一個secret_phase可以食用，但最近實在是沒有這么多時間認真分析。總體來說熟悉了基本操作之后后面的流程會順利許多，至少不會感到完全的不知所措。也是非常敬佩這個炸彈的作者，做完之后感覺對匯編語言和gdb的調試命令也相比之前有了更深的理解。果然CMU里的牛人們都是神仙。