深刻理解計算機系統 (CS:APP) Lab2 - Bomb Lab 解析

時間 2020-08-09

標籤深刻理解計算機系統 app lab2 lab bomb 解析简体版

原文原文鏈接

原文地址：https://billc.io/2019/04/csapp-bomblab/html

寫在前面

CS:APP是這學期的一門硬核課程，應該是目前接觸到最底層的課程了。學校的教學也是嘗試着儘可能和CMU同步，~~課件和習題都直接照搬原版~~。包括如今着手的第二個實驗室Bomb Lab。這個lab頗有意思，沒有提供所有c語言代碼，須要手動根據反彙編語言推測在每個階段須要輸入的內容，輸入正確就能夠進入下一個階段。node

理論上每一個人獲取到的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能夠獲得寄存器信息：app

(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獲取存儲的字符串，獲得結果：post

因此第一個炸彈的答案爲：測試

Border relations with Canada have never been better.ui

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裏的牛人們都是神仙。