CSAPP: Bomb Lab 詳細實驗解析
微信搜索🔍「編程指北」，關注這個寫乾貨的程序員，回覆「資源」，便可獲取後臺開發學習路線和書籍html
前言
這是CSAPP這本書，最著名的lab之一，bomb lab，須要你去拆掉這個程序裏的隱藏炸彈，很是有意思，能夠看下。linux
實驗材料
這是這學期上系統級編程課的實驗之一，是從CMU引入的，源代碼和資料能夠CMU課程網站得到，直接選擇第二個實驗的Self-Study Handout下載便可。 作這個實驗須要反彙編和與調試，建議使用gdb和objdump，若是還不會gdb 能夠看看這個簡易gdb使用指南，關於objdump簡單看看這個就好了畢竟作這個實驗我也只用了一個命令 objdump -d filename。程序員
準備工做
下載的解壓包裏面就三個文件，有用的也就是那個可執行文件bomb,還有一個bomb.c可讓你看清楚整個程序執行流程 
這是main函數主要的部分，能夠看到程序分爲6個phase，每個都須要你輸入一行字符串，而後對應調用phase_n()函數進行判斷是否觸發炸彈 先用objdump -d bomb > bomb.asm 反彙編保存到bomb.asm,而後用tmux開分屏,左邊是gdb調試bomb 首先定位到main函數以下:面試
00000000000400da0 <main>:
400da0: 53 push %rbx
400da1: 83 ff 01 cmp $0x1,%edi
400da4: 75 10 jne 400db6 <main+0x16>
400da6: 48 8b 05 9b 29 20 00 mov 0x20299b(%rip),%rax # 603748 <stdin@@GLIBC_2.2.5>
400dad: 48 89 05 b4 29 20 00 mov %rax,0x2029b4(%rip) # 603768 <infile>
400db4: eb 63 jmp 400e19 <main+0x79>
400db6: 48 89 f3 mov %rsi,%rbx
400db9: 83 ff 02 cmp $0x2,%edi
400dbc: 75 3a jne 400df8 <main+0x58>
400dbe: 48 8b 7e 08 mov 0x8(%rsi),%rdi
400dc2: be b4 22 40 00 mov $0x4022b4,%esi
400dc7: e8 44 fe ff ff callq 400c10 <fopen@plt>
400dcc: 48 89 05 95 29 20 00 mov %rax,0x202995(%rip) # 603768 <infile>
400dd3: 48 85 c0 test %rax,%rax
400dd6: 75 41 jne 400e19 <main+0x79>
400dd8: 48 8b 4b 08 mov 0x8(%rbx),%rcx
400ddc: 48 8b 13 mov (%rbx),%rdx
400ddf: be b6 22 40 00 mov $0x4022b6,%esi
400de4: bf 01 00 00 00 mov $0x1,%edi
400de9: e8 12 fe ff ff callq 400c00 <__printf_chk@plt>
400dee: bf 08 00 00 00 mov $0x8,%edi
400df3: e8 28 fe ff ff callq 400c20 <exit@plt>
400df8: 48 8b 16 mov (%rsi),%rdx
400dfb: be d3 22 40 00 mov $0x4022d3,%esi
400e00: bf 01 00 00 00 mov $0x1,%edi
400e05: b8 00 00 00 00 mov $0x0,%eax
400e0a: e8 f1 fd ff ff callq 400c00 <__printf_chk@plt>
400e0f: bf 08 00 00 00 mov $0x8,%edi
400e14: e8 07 fe ff ff callq 400c20 <exit@plt>
400e19: e8 84 05 00 00 callq 4013a2 <initialize_bomb>
400e1e: bf 38 23 40 00 mov $0x402338,%edi
400e23: e8 e8 fc ff ff callq 400b10 <puts@plt>
400e28: bf 78 23 40 00 mov $0x402378,%edi
400e2d: e8 de fc ff ff callq 400b10 <puts@plt>
400e32: e8 67 06 00 00 callq 40149e <read_line>
400e37: 48 89 c7 mov %rax,%rdi
400e3a: e8 a1 00 00 00 callq 400ee0 <phase_1>
400e3f: e8 80 07 00 00 callq 4015c4 <phase_defused>
400e44: bf a8 23 40 00 mov $0x4023a8,%edi
400e49: e8 c2 fc ff ff callq 400b10 <puts@plt>
400e4e: e8 4b 06 00 00 callq 40149e <read_line>
400e53: 48 89 c7 mov %rax,%rdi
400e56: e8 a1 00 00 00 callq 400efc <phase_2>
400e5b: e8 64 07 00 00 callq 4015c4 <phase_defused>
400e60: bf ed 22 40 00 mov $0x4022ed,%edi
400e65: e8 a6 fc ff ff callq 400b10 <puts@plt>
400e6a: e8 2f 06 00 00 callq 40149e <read_line>
400e6f: 48 89 c7 mov %rax,%rdi
400e72: e8 cc 00 00 00 callq 400f43 <phase_3>
400e77: e8 48 07 00 00 callq 4015c4 <phase_defused>
400e7c: bf 0b 23 40 00 mov $0x40230b,%edi
400e81: e8 8a fc ff ff callq 400b10 <puts@plt>
400e86: e8 13 06 00 00 callq 40149e <read_line>
400e8b: 48 89 c7 mov %rax,%rdi
400e8e: e8 79 01 00 00 callq 40100c <phase_4>
400e93: e8 2c 07 00 00 callq 4015c4 <phase_defused>
400e98: bf d8 23 40 00 mov $0x4023d8,%edi
400e9d: e8 6e fc ff ff callq 400b10 <puts@plt>
400ea2: e8 f7 05 00 00 callq 40149e <read_line>
400ea7: 48 89 c7 mov %rax,%rdi
400eaa: e8 b3 01 00 00 callq 401062 <phase_5>
400eaf: e8 10 07 00 00 callq 4015c4 <phase_defused>
400eb4: bf 1a 23 40 00 mov $0x40231a,%edi
400eb9: e8 52 fc ff ff callq 400b10 <puts@plt>
400ebe: e8 db 05 00 00 callq 40149e <read_line>
400ec3: 48 89 c7 mov %rax,%rdi
400ec6: e8 29 02 00 00 callq 4010f4 <phase_6>
400ecb: e8 f4 06 00 00 callq 4015c4 <phase_defused>
400ed0: b8 00 00 00 00 mov $0x0,%eax
400ed5: 5b pop %rbx
複製代碼
和咱們在bomb.c中看到的是同樣的，main函數內每次先調用read_line,而後將返回的地址傳遞給phase_n函數，若是輸入的不正確那麼就會執行爆炸函數。因此固然就順着main函數執行軌跡一個個來排雷~編程
Phase_1
先查看phase_1反彙編代碼:數組
0000000000400ee0 <phase_1>:
400ee0: 48 83 ec 08 sub $0x8,%rsp
400ee4: be 00 24 40 00 mov $0x402400,%esi
400ee9: e8 4a 04 00 00 callq 401338 <strings_not_equal>
400eee: 85 c0 test %eax,%eax
400ef0: 74 05 je 400ef7 <phase_1+0x17>
400ef2: e8 43 05 00 00 callq 40143a <explode_bomb>
400ef7: 48 83 c4 08 add $0x8,%rsp
400efb: c3 retq
複製代碼
phase_1彙編代碼很是簡潔, 在這以前首先說明一下微信
read_line函數會將讀入字符串地址存放在rdi 和rsi中，strings_not_equal函數會使用edi和esi中的值當作兩個字符址，而且判斷他們是否相等，相等返回0markdown
再看phase_1函數首先將0x402400這個賦值給esi，而後調用strings_not_equal, 剛纔分析了，在每次調用phase_n以前都會先調用read_line讀入一行而且放在edi和esi。顯然這裏是調用字符串比較函數比較咱們輸入的字符串和存放在0x402400地址的字符串是否相等，緊接着調用test指令，若是eax爲0也就是兩個字符串相等就跳轉到函數結尾，不然調用explode_bomb函數，這個就是引爆炸彈的函數。到這裏答案也就出來了，咱們須要輸入的就是存放在0x402400處的字符串。接下來用gdb開始調試app
(gdb) b phase_1 ;打斷點
(gdb) run ;執行到下一個斷點
(gdb) info r ;查看寄存器值
(gdb) print (char*)(0x402400) ;查看內存中字符串
複製代碼
經過上面調試窗口能夠看到($edi)處存放的正是我輸入的hello ,而地址0x402400處的"Border relations with Canada have never been better."正是答案。接着從新打開調試窗口輸入這個字符串，經過phase_1。函數
能夠把以前解出來的答案寫到一個文件裏，每一個答案一行，而後開始調試時設置下命令行參數 set args xixi(這裏是你的答案文件名)便可後續直接輸入已經解出的答案
Phase_2
仍是先看看彙編代碼，這個函數要長很多，並且中間多了不少條件跳轉指令，很不利於理解代碼做用，我通常喜歡在分支處標明
0000000000400efc <phase_2>:
400efc: 55 push %rbp
400efd: 53 push %rbx
400efe: 48 83 ec 28 sub $0x28,%rsp
400f02: 48 89 e6 mov %rsp,%rsi
400f05: e8 52 05 00 00 callq 40145c <read_six_numbers> ;讀入六個數，第一個存在($rsp)處
400f0a: 83 3c 24 01 cmpl $0x1,(%rsp) ;第一個數和1比較
400f0e: 74 20 je 400f30 <phase_2+0x34> ；等於１跳轉
400f10: e8 25 05 00 00 callq 40143a <explode_bomb> ;不然爆炸
400f15: eb 19 jmp 400f30 <phase_2+0x34>
400f17: 8b 43 fc mov -0x4(%rbx),%eax ;取出rbx-4處的值賦給eax
400f1a: 01 c0 add %eax,%eax ; eax = eax *2
400f1c: 39 03 cmp %eax,(%rbx)
;比較eax*2和rbx處的值,注意:eax是ebx-4處的值，即將rbx和前一個數的兩倍比較
400f1e: 74 05 je 400f25 <phase_2+0x29>
；若是相等就跳轉，而跳轉處的代碼是將rbx+4
400f20: e8 15 05 00 00 callq 40143a <explode_bomb> ;不然爆炸
400f25: 48 83 c3 04 add $0x4,%rbx ; 將rbx+4
400f29: 48 39 eb cmp %rbp,%rbx
;將加4後的值和rbp比較，注意rbp是rsp+24,而rsp是第一個數，一個數四個字節。那麼rbp就應該是
後那個數後面那個地址，即rbp是個循環哨兵
400f2c: 75 e9 jne 400f17 <phase_2+0x1b> ；不等就繼續跳轉去循環
400f2e: eb 0c jmp 400f3c <phase_2+0x40> ; 相等就結束跳轉到函數結尾
400f30: 48 8d 5c 24 04 lea 0x4(%rsp),%rbx ；將rsp+4存到rbx
400f35: 48 8d 6c 24 18 lea 0x18(%rsp),%rbp ;將rsp +24 存到rbp
400f3a: eb db jmp 400f17 <phase_2+0x1b> ;跳轉
400f3c: 48 83 c4 28 add $0x28,%rsp
400f40: 5b pop %rbx
400f41: 5d pop %rbp
400f42: c3 retq
複製代碼
能夠很明顯的看到調用了read_six_numbers，這個函數做用名字已經告訴咱們了，只是有一點須要去看看它的代碼才知道，它會把第一個數存在地址($rsp),之後依次遞增。這段代碼註釋已經很清楚了，主體就是一個循環，而每一輪循環要作的就是判斷當前數和前一個數的兩倍是否相等，一旦不相等就爆炸。加上要求第一個數必須爲1，那麼輸入的六個數就應該是 1 2 4 8 16 32,用gdb調試驗證
phase_3
仍是先放第三行的代碼：
0000000000400f43 <phase_3>:
400f43: 48 83 ec 18 sub $0x18,%rsp
400f47: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx
400f4c: 48 8d 54 24 08 lea 0x8(%rsp),%rdx
400f51: be cf 25 40 00 mov $0x4025cf,%esi
400f56: b8 00 00 00 00 mov $0x0,%eax
400f5b: e8 90 fc ff ff callq 400bf0 <__isoc99_sscanf@plt>
400f60: 83 f8 01 cmp $0x1,%eax
400f63: 7f 05 jg 400f6a <phase_3+0x27>
400f65: e8 d0 04 00 00 callq 40143a <explode_bomb>
400f6a: 83 7c 24 08 07 cmpl $0x7,0x8(%rsp)
400f6f: 77 3c ja 400fad <phase_3+0x6a> #將第一個數和７比較，大於跳轉到炸彈
400f71: 8b 44 24 08 mov 0x8(%rsp),%eax
400f75: ff 24 c5 70 24 40 00 jmpq (,*0x402470%rax,8)
400f7c: b8 cf 00 00 00 mov $0xcf,%eax
400f81: eb 3b jmp 400fbe <phase_3+0x7b>
400f83: b8 c3 02 00 00 mov $0x2c3,%eax
400f88: eb 34 jmp 400fbe <phase_3+0x7b>
400f8a: b8 00 01 00 00 mov $0x100,%eax
400f8f: eb 2d jmp 400fbe <phase_3+0x7b>
400f91: b8 85 01 00 00 mov $0x185,%eax
400f96: eb 26 jmp 400fbe <phase_3+0x7b>
400f98: b8 ce 00 00 00 mov $0xce,%eax
400f9d: eb 1f jmp 400fbe <phase_3+0x7b>
400f9f: b8 aa 02 00 00 mov $0x2aa,%eax
400fa4: eb 18 jmp 400fbe <phase_3+0x7b>
400fa6: b8 47 01 00 00 mov $0x147,%eax
400fab: eb 11 jmp 400fbe <phase_3+0x7b>
400fad: e8 88 04 00 00 callq 40143a <explode_bomb>
400fb2: b8 00 00 00 00 mov $0x0,%eax
400fb7: eb 05 jmp 400fbe <phase_3+0x7b>
400fb9: b8 37 01 00 00 mov $0x137,%eax
400fbe: 3b 44 24 0c cmp 0xc(%rsp),%eax
400fc2: 74 05 je 400fc9 <phase_3+0x86>
400fc4: e8 71 04 00 00 callq 40143a <explode_bomb>
400fc9: 48 83 c4 18 add $0x18,%rsp
400fcd: c3 retq
複製代碼
首先看到了，sscanf，因此這個函數前面必定會有一個字符串常量存儲須要讀取的數據格式，因此字符串常量必定是$0x4025cf， 用gdb打印出來確認格式 咱們看到格式是"%d %d",因此咱們須要輸入兩個整數。日後看彙編，這段代碼的後面有不少的jmp語句，並且極其的有規律，估計是個跳轉表即switch語句，要跳轉過去的地址是0x402470+%rax+8,而eax就是咱們輸入的第一個數，而後每個jmp能夠看作是一個case語句，每個case語句咱們看到都是在將一個參數賦值給eax,好比0xcf、0x2c3等，而後全部case統一跳轉到0x400fbe，而在這個地方則是將咱們輸入的第二個數和eax中的值比較，相等就跳過炸彈不然爆炸，而剛纔分析了eax的值是根據第一個值跳轉到不一樣的case獲得的。那麼有多少個case就應該有多少個解題的答案，咱們只須要肯定第一個數而後順着挑戰到其中一個case，而後看這個case中的常量值是多少即爲咱們輸入的第二個值。要注意輸入的第一個值必須小於７，這在彙編中有註釋，可見應該有７個case. 我選擇第一個數輸入３，順着找到了第二個數爲0x100即十進制256。
因此此題的其中一個解爲3 256
複製代碼
phase_4
反彙編代碼:
000000000040100c <phase_4>:
40100c: 48 83 ec 18 sub $0x18,%rsp
401010: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx
401015: 48 8d 54 24 08 lea 0x8(%rsp),%rdx
40101a: be cf 25 40 00 mov $0x4025cf,%esi
40101f: b8 00 00 00 00 mov $0x0,%eax
401024: e8 c7 fb ff ff callq 400bf0 <__isoc99_sscanf@plt>
401029: 83 f8 02 cmp $0x2,%eax
40102c: 75 07 jne 401035 <phase_4+0x29>
40102e: 83 7c 24 08 0e cmpl $0xe,0x8(%rsp)
401033: 76 05 jbe 40103a <phase_4+0x2e> #第一個數小與等於0xe跳轉
401035: e8 00 04 00 00 callq 40143a <explode_bomb>
40103a: ba 0e 00 00 00 mov $0xe,%edx
40103f: be 00 00 00 00 mov $0x0,%esi
401044: 8b 7c 24 08 mov 0x8(%rsp),%edi
401048: e8 81 ff ff ff callq 400fce <func4>
40104d: 85 c0 test %eax,%eax #測試返回值是否爲０，否就爆炸
40104f: 75 07 jne 401058 <phase_4+0x4c>
401051: 83 7c 24 0c 00 cmpl $0x0,0xc(%rsp)
401056: 74 05 je 40105d <phase_4+0x51>
401058: e8 dd 03 00 00 callq 40143a <explode_bomb>
40105d: 48 83 c4 18 add $0x18,%rsp
401061: c3 retq
複製代碼
仍是出現了sscan,此次直接先看輸入的格式，0x4025cf不正是上一題的格式字符串"%d %d"嗎，看來這題仍是須要輸入兩個整數 ，phase_4彙編中還會調用func4函數，這個func４函數是關鍵，反彙編以下：
0000000000400fce <func4>:
400fce: sub $0x8,%rsp ;; 分配棧幀
400fd2: mov %edx,%eax ;; C eax
400fd4: sub %esi,%eax ;; C - B 更新 eax
400fd6: mov %eax,%ecx ;; C - B ecx
400fd8: shr $0x1f,%ecx ;; 右移 31 位， ecx 長爲 32 位（也就是以前的最高位變爲最低位，其他 31 位填充補 0），能夠認爲 ecx = 0
400fdb: add %ecx,%eax ;; C - B eax
400fdd: sar %eax ;; 這裏是一個縮寫 sar $1,%eax (對應的機器碼爲 D1F8) eax = (C-B)/2
400fdf: lea (%rax,%rsi,1),%ecx ;; (C+B)/2 ecx
400fe2: cmp %edi,%ecx ;; ecx 與 A 進行比較 (1)
400fe4: jle 400ff2 <func4+0x24> ;; ecx 小於等於 A 則跳轉
400fe6: lea -0x1(%rcx),%edx ;; C = (C+B)/2 - 1
400fe9: callq 400fce <func4> ;; 遞歸調用
400fee: add %eax,%eax ;; 遞歸返回值加倍
400ff0: jmp 401007 <func4+0x39> ;; 跳轉到 func 函數的出口處
400ff2: mov $0x0,%eax ;; eax = 0 (2)
400ff7: cmp %edi,%ecx ;; ecx 與 A 進行比較
400ff9: jge 401007 <func4+0x39> ;; eax 大於等於 A 則跳轉
400ffb: lea 0x1(%rcx),%esi ;; B = ecx + 1
400ffe: callq 400fce <func4> ;; 遞歸調用
401003: lea 0x1(%rax,%rax,1),%eax ;; 遞歸返回值加倍並再加上 1
401007: add $0x8,%rsp ;; 釋放棧幀
40100b: retq ;; 函數返回
複製代碼
在這個函數中咱們很明確的看到了func4內部在調用func4，這不就是遞歸的彙編。嘗試着寫出對應的c語言代碼以下：
int func4(int target, int step, int limit) {
/* edi = target; esi = step; edx = limit */
int temp = (limit - step) * 0.5;
int mid = temp + step;
if (mid > target) {
limit = mid - 1;
int ret1 = func4(target, step, limit);
return 2 * ret1;
} else {
if (mid >= target) {
return 0;
} else {
step = mid + 1;
int ret2 = func4(target, step, limit);
return (2 * ret2 + 1);
}
}
}
複製代碼
最後根據c語言代碼推出一個答案(7,0),可是此題還有其它的解。
phase_5
0000000000401062 <phase_5>:
401062: 53 push %rbx
401063: 48 83 ec 20 sub $0x20,%rsp
401067: 48 89 fb mov %rdi,%rbx
40106a: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
401071: 00 00
401073: 48 89 44 24 18 mov %rax,0x18(%rsp)
401078: 31 c0 xor %eax,%eax
40107a: e8 9c 02 00 00 callq 40131b <string_length>
40107f: 83 f8 06 cmp $0x6,%eax #要求輸入的字符串長度爲6
401082: 74 4e je 4010d2 <phase_5+0x70>
401084: e8 b1 03 00 00 callq 40143a <explode_bomb>
401089: eb 47 jmp 4010d2 <phase_5+0x70>
40108b: 0f b6 0c 03 movzbl (%rbx,%rax,1),%ecx
40108f: 88 0c 24 mov %cl,(%rsp)
401092: 48 8b 14 24 mov (%rsp),%rdx
401096: 83 e2 0f and $0xf,%edx # 取edx後四位
401099: 0f b6 92 b0 24 40 00 movzbl 0x4024b0(%rdx),%edx #將edx後四位做爲0x4024b0字符數組的索引值
4010a0: 88 54 04 10 mov %dl,0x10(%rsp,%rax,1) # 依次拷貝字符數組到0x10((%rsp,%rax,1))
4010a4: 48 83 c0 01 add $0x1,%rax #循環計數+1
4010a8: 48 83 f8 06 cmp $0x6,%rax #循環計數和6比較，即循環6次
4010ac: 75 dd jne 40108b <phase_5+0x29>
4010ae: c6 44 24 16 00 movb $0x0,0x16(%rsp) #字符串末尾添加"\0"
4010b3: be 5e 24 40 00 mov $0x40245e,%esi # 字符串常量
4010b8: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi
4010bd: e8 76 02 00 00 callq 401338 <strings_not_equal> # 和字符串常量比較
4010c2: 85 c0 test %eax,%eax
4010c4: 74 13 je 4010d9 <phase_5+0x77>
4010c6: e8 6f 03 00 00 callq 40143a <explode_bomb>
4010cb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
4010d0: eb 07 jmp 4010d9 <phase_5+0x77>
4010d2: b8 00 00 00 00 mov $0x0,%eax
4010d7: eb b2 jmp 40108b <phase_5+0x29>
4010d9: 48 8b 44 24 18 mov 0x18(%rsp),%rax
4010de: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
4010e5: 00 00
4010e7: 74 05 je 4010ee <phase_5+0x8c>
4010e9: e8 42 fa ff ff callq 400b30 <__stack_chk_fail@plt>
4010ee: 48 83 c4 20 add $0x20,%rsp
4010f2: 5b pop %rbx
4010f3: c3 retq
複製代碼
這裏後面會有一個和字符串常量比較的地方，咱們先看看這個字符串常量是什麼： "flyers" 這段彙編還有一個字符串常量0x4024b0: "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
因爲彙編代碼比較長，我就直接說明這一段到底在幹什麼： 1.要求輸入6個字符，而後依次循環這個輸入的字符數組 2.每一輪循環取一個字符，而後取這個字符的後四位做爲索引，在第二個字符常量處取一個字符 依次存放到0x10(%rsp)處 3.最後將新0x10(%rsp)處的字符串和"flyers"比較，相同則經過，不然爆炸 因此咱們須要根據結果倒推，好比flyers中的f字符是由咱們輸入的第一個字符的後四位做爲索引在 "maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"取得，可是咱們知道四位二進制最多索引16 個位置，因此這一長串的字符只有前16個能夠來取咱們須要的字符。因此f的索引爲9,即二進制1001，只須要查詢ascii表後四位爲1001的字符都可，我取的Ｙ。以此類推獲得6個字符的一個組合：YONEFw
phase_6
這一關的彙編真的太難看懂了，我只是讀懂了局部一些，還沒能串起來，因此這裏就不貼反彙編了。 我獲得的信息大概也是須要輸入6個數字且小於等於6。並且在循環過程當中還會翻轉每一個數(a = 7 -a)。 在網上查閱別人的答案 4 3 2 1 6 5
Secret_phase
這個不看反彙編代碼根本不知道有這個雷存在，如今咱們就來看看這個祕密炸彈 老規矩仍是看反彙編
0000000000401242 <secret_phase>:
401242: 53 push %rbx
401243: e8 56 02 00 00 callq 40149e <read_line>
401248: ba 0a 00 00 00 mov $0xa,%edx
40124d: be 00 00 00 00 mov $0x0,%esi
401252: 48 89 c7 mov %rax,%rdi
401255: e8 76 f9 ff ff callq 400bd0 <strtol@plt>
40125a: 48 89 c3 mov %rax,%rbx
40125d: 8d 40 ff lea -0x1(%rax),%eax
401260: 3d e8 03 00 00 cmp $0x3e8,%eax
401265: 76 05 jbe 40126c <secret_phase+0x2a>
401267: e8 ce 01 00 00 callq 40143a <explode_bomb>
40126c: 89 de mov %ebx,%esi
40126e: bf f0 30 60 00 mov $0x6030f0,%edi
401273: e8 8c ff ff ff callq 401204 <fun7>
401278: 83 f8 02 cmp $0x2,%eax
40127b: 74 05 je 401282 <secret_phase+0x40>
40127d: e8 b8 01 00 00 callq 40143a <explode_bomb>
401282: bf 38 24 40 00 mov $0x402438,%edi
401287: e8 84 f8 ff ff callq 400b10 <puts@plt>
40128c: e8 33 03 00 00 callq 4015c4 <phase_defused>
401291: 5b pop %rbx
401292: c3 retq
複製代碼
可是有個問題，main函數裏咱們沒有看到顯示調用secret_phase函數的指令啊，那麼是哪裏被調用的呢，在全局搜索關鍵字能夠發如今phase_defused這個函數裏調用了，而phase_defused是在每次經過一個phase時都會被執行的，那麼接下來就是分析在什麼狀況下會觸發調用secret_phase
進入前的戲
00000000004015c4 <phase_defused>:
4015c4: 48 83 ec 78 sub $0x78,%rsp
4015c8: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
4015cf: 00 00
4015d1: 48 89 44 24 68 mov %rax,0x68(%rsp)
4015d6: 31 c0 xor %eax,%eax
比較輸入的字符串數目是否等於6，不等於則跳轉至程序結束
4015d8: 83 3d 81 21 20 00 06 cmpl $0x6,0x202181(%rip) # 603760 <num_input_strings>
4015df: 75 5e jne 40163f <phase_defused+0x7b>
4015e1: 4c 8d 44 24 10 lea 0x10(%rsp),%r8
4015e6: 48 8d 4c 24 0c lea 0xc(%rsp),%rcx
4015eb: 48 8d 54 24 08 lea 0x8(%rsp),%rdx
4015f0: be 19 26 40 00 mov $0x402619,%esi
4015f5: bf 70 38 60 00 mov $0x603870,%edi
4015fa: e8 f1 f5 ff ff callq 400bf0 <__isoc99_sscanf@plt>
4015ff: 83 f8 03 cmp $0x3,%eax
401602: 75 31 jne 401635 <phase_defused+0x71>
401604: be 22 26 40 00 mov $0x402622,%esi
401609: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi
40160e: e8 25 fd ff ff callq 401338 <strings_not_equal>
401613: 85 c0 test %eax,%eax
401615: 75 1e jne 401635 <phase_defused+0x71>
401617: bf f8 24 40 00 mov $0x4024f8,%edi
40161c: e8 ef f4 ff ff callq 400b10 <puts@plt>
401621: bf 20 25 40 00 mov $0x402520,%edi
401626: e8 e5 f4 ff ff callq 400b10 <puts@plt>
40162b: b8 00 00 00 00 mov $0x0,%eax
401630: e8 0d fc ff ff callq 401242 <secret_phase> ；調用secret_phase
401635: bf 58 25 40 00 mov $0x402558,%edi
40163a: e8 d1 f4 ff ff callq 400b10 <puts@plt>
40163f: 48 8b 44 24 68 mov 0x68(%rsp),%rax
401644: 64 48 33 04 25 28 00 xor %fs:0x28,%rax
40164b: 00 00
40164d: 74 05 je 401654 <phase_defused+0x90>
40164f: e8 dc f4 ff ff callq 400b30 <__stack_chk_fail@plt>
401654: 48 83 c4 78 add $0x78,%rsp
401658: c3 retq
複製代碼
咱們來一段一段分析上面的代碼 首先是
4015d6: 31 c0 xor %eax,%eax
比較輸入的字符串數目是否等於6，不等於則跳轉至程序結束
4015d8: 83 3d 81 21 20 00 06 cmpl $0x6,0x202181(%rip) # 603760 <num_input_strings>
4015df: 75 5e jne 40163f <phase_defused+0x7b>
複製代碼
而後若是輸入的是六個字符串，也就是說你經過了前六個phase並且沒有觸發爆炸就能進入接下來的代碼
4015f0: be 19 26 40 00 mov $0x402619,%esi
4015f5: bf 70 38 60 00 mov $0x603870,%edi
4015fa: e8 f1 f5 ff ff callq 400bf0 <__isoc99_sscanf@plt>
4015ff: 83 f8 03 cmp $0x3,%eax
401602: 75 31 jne 401635 <phase_defused+0x71>
複製代碼
這裏的esi 和edi顯然是兩個字符串的地址，接下來會調用sscanf，因此有一個必然是咱們輸入的字符串，另一個是scanf("formate",&,&)中的formate，咱們接下來用gdb看看這兩個字符串究竟是什麼 可見esi裏放的是"%d %d %s" 而edi則是咱們作phase_4輸入的答案"7 0"可是這確定不配啊，%s無法匹配。咱們繼續看
4015fa: e8 f1 f5 ff ff callq 400bf0 <__isoc99_sscanf@plt>
4015ff: 83 f8 03 cmp $0x3,%eax
401602: 75 31 jne 401635 <phase_defused+0x71>
複製代碼
在調用sscanf後，判斷返回值eax(即正確匹配的通配符個數)是否爲3，不等於的話就跳轉到函數末尾打印這句話
401635: bf 58 25 40 00 mov $0x402558,%edi
40163a: e8 d1 f4 ff ff callq 400b10 <puts@plt>
複製代碼
咱們看看0x402558這裏放的是什麼 正是順利經過前六個phase提示語，可是咱們沒有進入secret_phase 因此如今咱們假設咱們輸入的匹配3個也就是在第四個題解後面加一個字符串會執行到哪
401604: be 22 26 40 00 mov $0x402622,%esi
401609: 48 8d 7c 24 10 lea 0x10(%rsp),%rdi
40160e: e8 25 fd ff ff callq 401338 <strings_not_equal>
401613: 85 c0 test %eax,%eax
401615: 75 1e jne 401635 <phase_defused+0x71>
401617: bf f8 24 40 00 mov $0x4024f8,%edi
40161c: e8 ef f4 ff ff callq 400b10 <puts@plt>
401621: bf 20 25 40 00 mov $0x402520,%edi
401626: e8 e5 f4 ff ff callq 400b10 <puts@plt>
40162b: b8 00 00 00 00 mov $0x0,%eax
401630: e8 0d fc ff ff callq 401242 <secret_phase> ；調用secret_phase
複製代碼
這裏又是將兩個字符串地址傳到esi和edi而後調用字符串比較函數，不等仍是會跳轉到函數結束而後打印那句祝賀，若是相等則會先打印出0x4024f8和0x402520處的字符串而後調用secret_phase，看來想進入祕密關卡關鍵就是讓edi和esi中的字符串相等。咱們先來看看這兩個地方究竟是什麼。爲了可以執行到這一步咱們先在第四題的題解後面加一個字符串也就是"7 0"變"7 0 xixi"(xixi是隨便加的)，下面放gdb查看字符串截圖 ！！！！！！！這正是想的那樣，rdi裏放的是%s匹配的那一個字符串，而rsi裏放的就是一個提早設定好的。只要這兩個相等咱們就能進入祕密關卡，好，咱們拿着鑰匙"DrEvil"去替換"xixi"，開始正式進入secret_phase(搞這麼大半天才進入。。。。
前戲後的主角
按照慣例仍是先放反彙編代碼，雖然前面放過了，可是隔太遠了...
0000000000401242 <secret_phase>:
401242: 53 push %rbx
401243: e8 56 02 00 00 callq 40149e <read_line>
401248: ba 0a 00 00 00 mov $0xa,%edx
40124d: be 00 00 00 00 mov $0x0,%esi
401252: 48 89 c7 mov %rax,%rdi
401255: e8 76 f9 ff ff callq 400bd0 <strtol@plt>
40125a: 48 89 c3 mov %rax,%rbx
40125d: 8d 40 ff lea -0x1(%rax),%eax
401260: 3d e8 03 00 00 cmp $0x3e8,%eax
401265: 76 05 jbe 40126c <secret_phase+0x2a>
401267: e8 ce 01 00 00 callq 40143a <explode_bomb>
40126c: 89 de mov %ebx,%esi
40126e: bf f0 30 60 00 mov $0x6030f0,%edi
401273: e8 8c ff ff ff callq 401204 <fun7>
401278: 83 f8 02 cmp $0x2,%eax
40127b: 74 05 je 401282 <secret_phase+0x40>
40127d: e8 b8 01 00 00 callq 40143a <explode_bomb>
401282: bf 38 24 40 00 mov $0x402438,%edi
401287: e8 84 f8 ff ff callq 400b10 <puts@plt>
40128c: e8 33 03 00 00 callq 4015c4 <phase_defused>
401291: 5b pop %rbx
401292: c3 retq
複製代碼
仍是一段一段分析
401243: e8 56 02 00 00 callq 40149e <read_line>
401248: ba 0a 00 00 00 mov $0xa,%edx
40124d: be 00 00 00 00 mov $0x0,%esi
401252: 48 89 c7 mov %rax,%rdi
401255: e8 76 f9 ff ff callq 400bd0 <strtol@plt>
40125a: 48 89 c3 mov %rax,%rbx
複製代碼
這裏很明顯是先讀入一行而後調用strtol函數，這個是c語言中的用於字符串轉long的，函數原型以下:
描述: C 庫函數 *long int strtol(const char str, char endptr, int base) 把參數 str 所指向的字符串根據給定的 base 轉換爲一個長整數（類型爲 long int 型），base 必須介於 2 和 36（包含）之間，或者是特殊值 0。
聲明: long int strtol(const char *str, char **endptr, int base)
那麼大概能夠猜出rdi中存放的read_line返回值rax是str參數，而edx中的0xa應該是表明十進制，esi應該是特殊值０ 接着分析strtol返回後的
40125a: 48 89 c3 mov %rax,%rbx ;將rax保存到rbx中
40125d: 8d 40 ff lea -0x1(%rax),%eax ; eax =eax -1
401260: 3d e8 03 00 00 cmp $0x3e8,%eax ;cmp 1000, eax
401265: 76 05 jbe 40126c <secret_phase+0x2a> ;if eax < = 1000 then 跳過炸彈
401267: e8 ce 01 00 00 callq 40143a <explode_bomb> ;炸彈
40126c: 89 de mov %ebx,%esi ; 傳參
40126e: bf f0 30 60 00 mov $0x6030f0,%edi ; 傳參
401273: e8 8c ff ff ff callq 401204 <fun7> ; 調用fun7
401278: 83 f8 02 cmp $0x2,%eax ;比較返回值和2
40127b: 74 05 je 401282 <secret_phase+0x40> ;相等就跳轉輸出0x402438處的字符串並返回
40127d: e8 b8 01 00 00 callq 40143a <explode_bomb> ;不等就爆炸
401282: bf 38 24 40 00 mov $0x402438,%edi
401287: e8 84 f8 ff ff callq 400b10 <puts@plt>
複製代碼
看了來secret_phase總體就是要輸入一個字符串，而後把字符串轉爲long類型，轉換出錯或者轉換後的數>1000都會爆炸，而後用轉換來的數傳入fun7函數，若是返回值爲2則順利通這一關，不然就爆炸。 那麼如今關鍵就是fun7究竟是個什麼函數，咱們進去一探究竟: fun7:
0000000000401204 <fun7>:
401204: 48 83 ec 08 sub $0x8,%rsp
401208: 48 85 ff test %rdi,%rdi
40120b: 74 2b je 401238 <fun7+0x34>
40120d: 8b 17 mov (%rdi),%edx
40120f: 39 f2 cmp %esi,%edx
401211: 7e 0d jle 401220 <fun7+0x1c>
401213: 48 8b 7f 08 mov 0x8(%rdi),%rdi ;rdi = (rdi+8)
401217: e8 e8 ff ff ff callq 401204 <fun7> ;遞歸1
40121c: 01 c0 add %eax,%eax
40121e: eb 1d jmp 40123d <fun7+0x39>
401220: b8 00 00 00 00 mov $0x0,%eax
401225: 39 f2 cmp %esi,%edx
401227: 74 14 je 40123d <fun7+0x39>
401229: 48 8b 7f 10 mov 0x10(%rdi),%rdi
40122d: e8 d2 ff ff ff callq 401204 <fun7> ;遞歸2
401232: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax
401236: eb 05 jmp 40123d <fun7+0x39>
401238: b8 ff ff ff ff mov $0xffffffff,%eax
40123d: 48 83 c4 08 add $0x8,%rsp
401241: c3 retq
複製代碼
其實這個函數我一眼看過去的就是有兩個遞歸調用，那麼咱們去找出口在哪，仍是一段一段來
401208: 48 85 ff test %rdi,%rdi ;edi若是爲0則跳轉並返回-1
40120b: 74 2b je 401238 <fun7+0x34>
複製代碼
測試傳入的edi是否爲０，是就跳轉至結束並返回0xffffffff即0
40120d: 8b 17 mov (%rdi),%edx ;取出rdi地址的值賦給edx
40120f: 39 f2 cmp %esi,%edx ;比較edx和esi的值
401211: 7e 0d jle 401220 <fun7+0x1c> ；if edx <= esi(這就是strtol轉換來的數字)，跳轉
401213: 48 8b 7f 08 mov 0x8(%rdi),%rdi ;不然執行遞歸 rdi = (rdi+8)
401217: e8 e8 ff ff ff callq 401204 <fun7> ; 遞歸
40121c: 01 c0 add %eax,%eax ;遞歸返回值*2
40121e: eb 1d jmp 40123d <fun7+0x39> ;跳轉至返回
複製代碼
這一段
401220: b8 00 00 00 00 mov $0x0,%eax ; 提早將eax置0,這實際上是返回值
401225: 39 f2 cmp %esi,%edx ; 仍是比較esi和edx
401227: 74 14 je 40123d <fun7+0x39> ; 若是相等就跳轉並返回0
401229: 48 8b 7f 10 mov 0x10(%rdi),%rdi ;若是不相等就 edi = (edi+16)
40122d: e8 d2 ff ff ff callq 401204 <fun7> ;遞歸2
401232: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax ;遞歸返回值 eax = 2*eax+1
401236: eb 05 jmp 40123d <fun7+0x39> 跳轉至返回
複製代碼
可是問題是咱們以前分析出來須要fun7返回2才能經過，那麼怎麼才能返回2呢 代碼細節已經註釋得很清楚了，下面給一個遞歸的僞c語言對應版本
fun7(esi, void *rdi){
if(rdi == 0)
return -1;
if(*rdi <= esi ){
if(*rdi == esi)
return 0; step1
else
a = fun7(esi, *(rdi+16))
return 2*1+1 step2
} else {
return 2 * fun7(esi, *(rdi+8)) step3
}
}
複製代碼
其實咱們能夠看到兩次遞歸rdi的變化是不樣的，那麼爲了返回2,遞歸調用的順序應該是step3->step2->step1 也就是*rdi的值先要 *rdi > esi ,而後 *rdi < esi ， 最後 *rdi == esi 而esi是咱們輸入的，rdi在第一次調用fun7的時候就是固定的一個數
40126e: bf f0 30 60 00 mov $0x6030f0,%edi ; 傳參
401273: e8 8c ff ff ff callq 401204 <fun7> ; 調用fun7
複製代碼
如今咱們順着前面分析的去看看0x6030f0放的數是什麼： 36！！因此咱們輸入的數,因此咱們能夠輸入一個小於36的數去看第二步rdi是什麼 8 ！！因此輸入的數要大於8才能進入到第三步，那麼繼續這樣直到第三步的時候就能經過rdi == esi 這個等式來找出esi即咱們應該輸入的數, 接着gdb執行程序到第三步打印出rdi對應的值 22 ！！！！！！如今要作的只是驗證22對不對
我把全部題解放到xixi文件中，執行./bomb xixi Wow!順利經過六關和一個隱藏關哦，分析完這個祕密關卡已經一點半了....
絮叨
這篇文章寫了挺久的，從作lab、調格式每一步都很花時間。若是以爲對你有幫助的話，能夠點個關注或者點個贊鼓勵下~
文章持續更新，微信搜索「 編程指北 」第一時間獲取，回覆【資料】有我準備的一線 BAT 大廠面試資料和簡歷模板。
- 1. csapp bomb lab phase_1
- 2. csapp bomb lab phase_3
- 3. CSAPP: bomb lab
- 4. csapp bomb lab phase_2
- 5. csapp bomb lab phase_4
- 6. csapp bomb lab phase_5
- 7. Bomb Lab (csapp) 「最後一彈」
- 8. CSAPP Bomb Lab 實驗記錄 [yy-b]
- 9. bomb lab
- 10. csapp lab2 bomb
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • 免費ARP詳解 - TCP/IP教程
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
- • Flink 數據傳輸及反壓詳解
-
每一个你不满意的现在，都有一个你没有努力的曾经。