實驗二—BombLab
實驗材料
- 一個能夠運行的Linux或者Unix系統(tǒng)
- 官網(wǎng)的實習手冊
實驗規(guī)則
實驗共有6個關卡，分別是phase_1到phase_6，對于每一個關卡，你需要輸入相應的數(shù)字或者字符串，你應該仔細研究它們的匯編語句，根據(jù)這些匯編語句來推測出你需要輸入的數(shù)據(jù)，避免程序跳轉到explode_bomb函數(shù)，這意味著炸彈拆除失敗。
開始實驗前，你應該確保你已經(jīng)從官網(wǎng)下載了實習手冊，然后，你的系統(tǒng)應該要安裝好gdb調試器，因為我們接下來的調試都是基于gdb調試的。
2BombLab
關卡一
我們首先鍵入以下語句，來將bomb的匯編語句輸出到bomb.txt文本中：
objdump -d bomb > bomb.txt
我們找到main函數(shù)語句的入口：
0000000000400da0 <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
400ed6: c3 retq
400ed7: 90 nop
400ed8: 90 nop
400ed9: 90 nop
400eda: 90 nop
400edb: 90 nop
400edc: 90 nop
400edd: 90 nop
400ede: 90 nop
400edf: 90 nop
400f41: 5d pop %rbp
400f42: c3 retq
這看上去很嚇人，但是別急，我們只需要找到和第一關相關的語句就可以了：
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>
在這里我們看到了函數(shù)read_line，顧名思義，應該是讓我們輸入一行數(shù)據(jù)，然后將返回值作為第一個參數(shù)進入第一關，這個返回值應該就是我們輸入的一行數(shù)據(jù)的值或者地址，現(xiàn)在它被保存在%rdi中進入第一關。
我們命令行中鍵入gdb bomb以進入gdb調試模式，隨后我們設置斷點在第一關函數(shù)的起始位置，我們需要鍵入命令break phase_1來完成這個目的，然后輸入run(或者r)以啟動它。在進入第一關前，就像我們剛剛所說的，我們需要輸入一行數(shù)據(jù)，這里我們隨便輸入一行數(shù)據(jù)：”abcdefg”。
輸入完成之后，程序如愿的在phase_1的起始位置停了下來，我們鍵入命令 disas 來查看當前函數(shù)的匯編代碼：
0000000000400ee0 <phase_1>:
1 400ee0: 48 83 ec 08 sub $0x8,%rsp /*棧指針減*/
2 400ee4: be 00 24 40 00 mov $0x402400,%esi /*將0x402400移入%esi作為第二個參數(shù)*/
3 400ee9: e8 4a 04 00 00 callq 401338 <strings_not_equal> /*調用函數(shù)*/
4 400eee: 85 c0 test %eax,%eax /*測試返回值是否為0*/
5 400ef0: 74 05 je 400ef7 <phase_1+0x17> /*如果不為0，爆炸*/
6 400ef2: e8 43 05 00 00 callq 40143a <explode_bomb>
7 400ef7: 48 83 c4 08 add $0x8,%rsp
8 400efb: c3 retq
在這一段代碼中我們看到程序調用了一個函數(shù)<strings_not_equal>，顧名思義，它用來測試字符串是否不相等，事實上這段函數(shù)的匯編代碼告訴我們它確實是如此的，如果函數(shù)不相等返回1，相等則返回0。而這段代碼要求我們返回值一定為0，否則就會爆炸，所以我們要保證這兩個字符串相等，這就是拆除炸彈的秘訣了。
而在第二行我們看到程序將0x402400作為第二個參數(shù)，這很顯然不是一個字符串，那么它應該是一個地址，保存著一個字符串。那么第一個參數(shù)%rdi呢？我們在之前已經(jīng)分析過了，我們所輸入的字符串的值或者地址被保存在%rdi中，它將作為第一個參數(shù)。那么答案已經(jīng)很明顯了，我們要保證我們輸入的字符串與地址0x402400中的字符串相等，那么我們鍵入 x/s 0x402400 以字符串顯示的形式來查看這個地址保存的內容:
“Border relations with Canada have never been better.”
所以第一關的答案就是字符串：
Border relations with Canada have never been better.
關卡二
我們重新啟動gdb調試模式，這一次，我們將斷點設置在第二關，即鍵入beak phase_2。期間我們需要輸入第一關的答案，然后我們會來到第二關，先來看看與main函數(shù)中第二關有關的匯編代碼：
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>
和第一關一樣，同樣是需要輸入一行數(shù)據(jù)，程序相要到達斷點phase_2，我們必須要輸入這一行數(shù)據(jù)，我們隨便輸入：”abcdefg”，然后鍵入*disas將第二關代碼以匯編語句輸出：
0 0000000000400efc <phase_2>:
1 400efc: 55 push %rbp /*保存信息*/
2 400efd: 53 push %rbx
3 400efe: 48 83 ec 28 sub $0x28,%rsp /*棧指針減40*/
4 400f02: 48 89 e6 mov %rsp,%rsi /*%rsi = %rsp作為第二個參數(shù)*/
5 400f05: e8 52 05 00 00 callq 40145c <read_six_numbers> /*讀取六個數(shù)字*/
6 400f0a: 83 3c 24 01 cmpl $0x1,(%rsp) /*將內存(%rsp)與1比較*/
7 400f0e: 74 20 je 400f30 <phase_2+0x34> /*if == 1, jmp 400f30,否則,bomb!*/
/*進入關鍵循環(huán)*/
8 400f10: e8 25 05 00 00 callq 40143a <explode_bomb>
9 400f15: eb 19 jmp 400f30 <phase_2+0x34>
10 400f17: 8b 43 fc mov -0x4(%rbx),%eax /*%eax = (%rbx - 4) = n[x-1]*/
11 400f1a: 01 c0 add %eax,%eax /*%eax = 2 * %eax*/
12 400f1c: 39 03 cmp %eax,(%rbx) /*將%eax與(%rbp)比較*/
13 400f1e: 74 05 je 400f25 <phase_2+0x29> /*必須要2 * n[x-1] = n[x],否則,bomb!*/
14 400f20: e8 15 05 00 00 callq 40143a <explode_bomb>
15 400f25: 48 83 c3 04 add $0x4,%rbx /*%rbx = %rbx + 4, 引用下一個數(shù)*/
16 400f29: 48 39 eb cmp %rbp,%rbx /*與%rsp + 24對比*/
17 400f2c: 75 e9 jne 400f17 <phase_2+0x1b> /*if != ,jmp 400f17*/
18 400f2e: eb 0c jmp 400f3c <phase_2+0x40>
19 400f30: 48 8d 5c 24 04 lea 0x4(%rsp),%rbx /*%rbx = %rsp + 4*/
20 400f35: 48 8d 6c 24 18 lea 0x18(%rsp),%rbp /*%rbp = %rsp + 24*/
21 400f3a: eb db jmp 400f17 <phase_2+0x1b> /*jmp 400f17*/
22 400f3c: 48 83 c4 28 add $0x28,%rsp
23 400f40: 5b pop %rbx
由第5行可以看出，我們應該輸入6個數(shù)字。由6，7，8行得出，內存(%rsp)的值必須為1，否則就會爆炸。我們嘗試將關鍵循環(huán)的部分翻譯成熟悉的C語言風格：
for (auto x = %rsp + 4; x != %rsp + 24; x += 4){
int val1 = *(x - 4), val2 = *(x);
if (val1 * 2 != val2)//這說明*(x)必須要等有2倍的*(x-4)
Bomb!
}
由于內存(%rsp)的值必須為1，這就意味著內存(%rsp + 4)必須為2，內存(%rsp + 8)必須為4，內存(%rsp + 12)必須為8，內存(%rsp + 16)必須為16，內存(%rsp + 20)必須為32。其實我們已經(jīng)猜到了這就是我們需要的答案，但是答案順序是怎么樣的呢？來看看函數(shù)read_six_numbers內究竟發(fā)生了什么！我們鍵入disas read_six_numbers來看看它的匯編代碼：
0 /*%rsi = %rrsp, %rdi = read_line*/
1 000000000040145c <read_six_numbers>:
2 40145c: 48 83 ec 18 sub $0x18,%rsp /*%rsp - 24*/
3 401460: 48 89 f2 mov %rsi,%rdx /*%rdx = %rrsp*/
4 401463: 48 8d 4e 04 lea 0x4(%rsi),%rcx /*%rcx = %rrsp + 4*/
5 401467: 48 8d 46 14 lea 0x14(%rsi),%rax /*%rax = %rrsp + 20*/
6 40146b: 48 89 44 24 08 mov %rax,0x8(%rsp) /*(%rsp + 8) = %rrsp + 20*/
7 401470: 48 8d 46 10 lea 0x10(%rsi),%rax /*%rax = %rrsp + 16*/
8 401474: 48 89 04 24 mov %rax,(%rsp) /*(%rsp) = %rrsp + 16*/
9 401478: 4c 8d 4e 0c lea 0xc(%rsi),%r9 /*%r9 = %rrsp + 12*/
10 40147c: 4c 8d 46 08 lea 0x8(%rsi),%r8 /*%r8 = %rrsp + 8*/
11 401480: be c3 25 40 00 mov $0x4025c3,%esi /*%esi = 0x4025c3*/
12 401485: b8 00 00 00 00 mov $0x0,%eax /*%eax = 0*/
13 40148a: e8 61 f7 ff ff callq 400bf0 <__isoc99_sscanf@plt>
14 40148f: 83 f8 05 cmp $0x5,%eax /*必須要正確讀6個數(shù)或以上，否則爆炸*/
15 401492: 7f 05 jg 401499 <read_six_numbers+0x3d>
16 401494: e8 a1 ff ff ff callq 40143a <explode_bomb>
17 401499: 48 83 c4 18 add $0x18,%rsp
18 40149d: c3 retq
這段代碼中，我們以%rrsp表示我們?yōu)檫M入函數(shù)時原先的棧指針，以區(qū)分當前減小了的棧指針。這段代碼中我們看到了sscanf函數(shù)，這是一個我們熟悉的函數(shù)，11行的有個數(shù)字很唐突，我們鍵入x/s 0x4025c3來看看sscanf的第二個參數(shù)是什么：
image.png
竟然是六個格式化的輸入形式，而sscanf的第一個參數(shù)是%rdi，它是我們輸入的一行數(shù)據(jù)的地址或值，根據(jù)第二個參數(shù)的信息可以看出，sscanf后面應該還會有第3到第8個參數(shù)來將我們輸入的六個數(shù)字格式化輸出到這六個參數(shù)中?？磥磉@六個參數(shù)就是關鍵了，參考第3.4節(jié)基本寄存器以及我們的匯編注釋，第三個參數(shù)到第六個參數(shù)分別是%rrsp,%%rrsp+4,%rrsp+8,%rrsp+12，而第七個第八個參數(shù)會依次保存至調用者的棧中上(參考3.8節(jié))，即第七個參數(shù)對于(%rsp) = %rrsp + 16，第八個參數(shù)對于(%rsp + 8) = %rrsp + 20。好了，讓我們回到第二關，現(xiàn)在我們已經(jīng)知道%rsp到%rsp+20依次對應我們輸入數(shù)字的地址，那么答案已經(jīng)很明顯了，我們需要輸入的六個數(shù)字分別為:
1 2 4 8 16 32
關卡三
我們按照之前的步驟，來到斷點phase_3處，并輸出第三關的匯編語句：
1 400f43: sub $0x18,%rsp # 棧指針減24
2 400f47: lea 0xc(%rsp),%rcx # %rcx = %rsp + 12，第4個參數(shù)
3 400f4c: lea 0x8(%rsp),%rdx # %rdx = %rsp + 8，第3個參數(shù)
4 400f51: mov $0x4025cf,%esi # %esi作為第二個入?yún)蕚溥M行函數(shù)調用
5 400f56: mov $0x0,%eax # 為%eax賦值0
6 400f5b: callq 400bf0 <__isoc99_sscanf@plt>
7 400f60: cmp $0x1,%eax # 如果正確輸入的值的數(shù)量大于1
8 400f63: jg 400f6a <phase_3+0x27> # jmp 400f6a
9 400f65: callq 40143a <explode_bomb> # 否則爆炸
10 400f6a: cmpl $0x7,0x8(%rsp) # %rsp+8的內存值與7比較
11 400f6f: ja 400fad <phase_3+0x6a> # 如果大于，爆炸
12 400f71: mov 0x8(%rsp),%eax # %eax = (%rsp + 0x8)
13 400f75: jmpq *0x402470(,%rax,8) # 并跳轉至%rax*8+0x402470的內存保存的地址上；
14 400f7c: mov $0xcf,%eax
15 400f81: jmp 400fbe <phase_3+0x7b>
16 400f83: mov $0x2c3,%eax
17 400f88: jmp 400fbe <phase_3+0x7b>
18 400f8a: mov $0x100,%eax
19 400f8f: jmp 400fbe <phase_3+0x7b>
20 400f91: mov $0x185,%eax
21 400f96: jmp 400fbe <phase_3+0x7b>
22 400f98: mov $0xce,%eax
23 400f9d: jmp 400fbe <phase_3+0x7b>
24 400f9f: mov $0x2aa,%eax
25 400fa4: jmp 400fbe <phase_3+0x7b>
26 400fa6: mov $0x147,%eax
27 400fab: jmp 400fbe <phase_3+0x7b>
28 400fad: callq 40143a <explode_bomb>
29 400fb2: mov $0x0,%eax
30 400fb7: jmp 400fbe <phase_3+0x7b>
31 400fb9: mov $0x137,%eax
32 400fbe: cmp 0xc(%rsp),%eax
33 400fc2: je 400fc9 <phase_3+0x86>
34 400fc4: callq 40143a <explode_bomb>
35 400fc9: add $0x18,%rsp
36 400fcd: retq
我們又看到了sscanf函數(shù)，同之前一樣，我們打印地址0x4025cf的字符串，發(fā)現(xiàn)這次需要我們輸入兩個數(shù)字:
(gdb) x/s 0x4025cf
0x4025cf: "%d %d"
同樣的分析，我們發(fā)現(xiàn)sscanf第三個參數(shù)%rdx = %rsp + 8，第四個參數(shù)%rcx = %rsp + 12，這意味著我們輸入的第一個數(shù)被保存在地址%rsp + 8中，第二個數(shù)被保存在地址%rsp + 12中，由第10，11行可知，第一個參數(shù)應該小于等于7。來看看第13行的代碼：400f75: jmpq 0x402470(,%rax,8)，它跳轉到(0x402470 + 8 * %rax)的位置，而%rax此時等于我們的第一個數(shù)，這段代碼的意思是以輸入的第一個數(shù)為下標，跳轉到以0x402470為起始地址，數(shù)組元素大小為8字節(jié)的數(shù)組的內存位置，我們試著打印0x402470的值，這一次，我們以16進制格式打印，我們鍵入x/8x 0x402470*:
(gdb) x/8a 0x402470
0x402470: 0x400f7c <phase_3+57> 0x400fb9 <phase_3+118>
0x402480: 0x400f83 <phase_3+64> 0x400f8a <phase_3+71>
0x402490: 0x400f91 <phase_3+78> 0x400f98 <phase_3+85>
0x4024a0: 0x400f9f <phase_3+92> 0x400fa6 <phase_3+99>
那么這個數(shù)組應該為array[8] = {0x400f7c,0x400fb9,0x400f83,...,0x400fa6}，假設我們的第一個數(shù)為0，那么我們應該會跳轉到0x400f7c位置處，我們抽取相應的代碼：
14 400f7c: mov $0xcf,%eax /*%eax = 0xcf = 207*/
15 400f81: jmp 400fbe <phase_3+0x7b> /*jmp 400fbe*/
......
32 400fbe: cmp 0xc(%rsp),%eax /*將0xcf與我們的第二個參數(shù)對比*/
33 400fc2: je 400fc9 <phase_3+0x86> /*如果等于，拆除成功，否則爆炸！*/
34 400fc4: callq 40143a <explode_bomb>
對應的第二個數(shù)應該為207，事實上應該有8中不同的答案，這僅僅是其中一種答案：
0 207
關卡四
現(xiàn)在，我們來到了關卡四，來看看它的匯編代碼：
0 000000000040100c <phase_4>:
1 40100c: sub $0x18,%rsp
2 401010: lea 0xc(%rsp),%rcx # %rcx = %rsp + 12
3 401015: lea 0x8(%rsp),%rdx # %rdx = %rsp + 8
4 40101a: mov $0x4025cf,%esi # 0x4025cf是"%d %d"
5 40101f: mov $0x0,%eax
6 401024: callq 400bf0 <__isoc99_sscanf@plt>
7 401029: cmp $0x2,%eax # 正確輸入值的個數(shù)只能為2個
8 40102c: jne 401035 <phase_4+0x29> # 否則爆炸
9 40102e: cmpl $0xe,0x8(%rsp) # 第一個數(shù)和14比較
10 401033: jbe 40103a <phase_4+0x2e> # 如果這個數(shù) <= 14 jmp
11 401035: callq 40143a <explode_bomb> # 否則爆炸
12 40103a: mov $0xe,%edx # %edx = 14 第三個入?yún)?13 40103f: mov $0x0,%esi # %esi = 0 第二個入?yún)?14 401044: mov 0x8(%rsp),%edi # 第一個數(shù)作為第一個參數(shù)
15 401048: callq 400fce <func4> # 調用函數(shù)
16 40104d: test %eax,%eax # 返回值結果
17 40104f: jne 401058 <phase_4+0x4c> # 不等于0時，爆炸
18 401051: cmpl $0x0,0xc(%rsp) # 第二個數(shù)和0比較
19 401056: je 40105d <phase_4+0x51> # 相等，返回
20 401058: callq 40143a <explode_bomb> # 不相等 爆炸
21 40105d: add $0x18,%rsp
22 401061: retq
我們依然看到了sscanf這個函數(shù)，我們同之前一樣的分析，會發(fā)現(xiàn)這一關依然只需要我們輸入兩個整數(shù)，并且它們被放在地址%rsp + 8 和 %rsp + 12的內存位置中。通過第18、19行可以看出，第二個數(shù)一定得為0。而對于第一個數(shù)而言，由第10行可知，它必須小于等于14，分析第12行到第17行，我們發(fā)現(xiàn)第一個數(shù)被當作第一個參數(shù)調用了函數(shù)func4，而這個函數(shù)調用的結果必須為0，那么，我們鍵入disas func4來看看這個函數(shù)到底做了什么：
0 /*%rdi = n[0], %rsi = 0, %rdx = 14*/
1 0000000000400fce <func4>:
2 400fce: 48 83 ec 08 sub $0x8,%rsp # %rsp - 8
3 400fd2: 89 d0 mov %edx,%eax # %eax = %edx = 14
4 400fd4: 29 f0 sub %esi,%eax # %eax -= %esi(初始值為0)
5 400fd6: 89 c1 mov %eax,%ecx # %ecx = %eax = 14
6 400fd8: c1 e9 1f shr $0x1f,%ecx # %ecx >> 31 = 0, 邏輯右移
7 400fdb: 01 c8 add %ecx,%eax # %eax += %ecx = 14
8 400fdd: d1 f8 sar %eax # %eax >> 1 = 7, 算術右移
9 400fdf: 8d 0c 30 lea (%rax,%rsi,1),%ecx # %ecx = %rax + %rsi = 7
10 400fe2: 39 f9 cmp %edi,%ecx # 將%ecx 與 n[0] 比較
11 400fe4: 7e 0c jle 400ff2 <func4+0x24> # if 7 小于等于 n[0], jmp 400ff2
12 400fe6: 8d 51 ff lea -0x1(%rcx),%edx # 否則 %edx = % rcx - 1
13 400fe9: e8 e0 ff ff ff callq 400fce <func4> # 遞歸調用
14 400fee: 01 c0 add %eax,%eax # return %rax + %rax
15 400ff0: eb 15 jmp 401007 <func4+0x39>
16 400ff2: b8 00 00 00 00 mov $0x0,%eax # 設置返回值 = 0
17 400ff7: 39 f9 cmp %edi,%ecx # 將%ecx 與 n[0] 比較
18 400ff9: 7d 0c jge 401007 <func4+0x39> # if %ecx >= n[0], return
19 400ffb: 8d 71 01 lea 0x1(%rcx),%esi # 否則, %esi = %rcx + 1
20 400ffe: e8 cb ff ff ff callq 400fce <func4> # 遞歸調用
21 401003: 8d 44 00 01 lea 0x1(%rax,%rax,1),%eax # %eax = %rax + %rax + 1
22 401007: 48 83 c4 08 add $0x8,%rsp
23 40100b: c3 retq
可以看出來這是一段遞歸的調用，它的等價C語言很好寫出來：
int func4(int nums, int x, int y){
int ret = y - x;
int k = (unsigned)(ret) >> 31;
ret = (k + ret) >> 1;
k = ret + x;
if (k > nums)
return 2 * func4(nums, x, k - 1);
ret = 0;
if (k < nums)
return 2 * func4(nums, k + 1, y) + 1;
return ret;
}
首先我們必須肯定我們要輸入的第一個數(shù)nums必須大于等于0，否則這段代碼將會陷入死循環(huán)，那么我們枚舉包括0到14之間所有的值，判斷func4的返回值是否為0，這個枚舉循環(huán)很好寫：
for(int i = 0; i <= 14; i++)
if(func4(i, 0, 14) == 0)
printf("%d\n", i);
我們可以得到輸出0、1、3、7，那么我們任選其一作為第一個數(shù)，這里我們選擇0，而第二個數(shù)必須為0，于是有答案：
0 0
關卡五
現(xiàn)在，我們來到了倒數(shù)第二關，輸出第五關的匯編代碼如下：
31 0000000000401062 <phase_5>:
32 401062: push %rbx
33 401063: sub $0x20,%rsp
34 401067: mov %rdi,%rbx # %rdi是我們輸入子串的地址，現(xiàn)在它保存在%rbx中
35 40106a: mov %fs:0x28,%rax
36 401071:
37 401073: mov %rax,0x18(%rsp) # (%rsp + 0x18) = %rax
38 401078: xor %eax,%eax # %eax = 0
39 40107a: callq 40131b <string_length> # 顧名思義，計算字符串長度函數(shù)
40 40107f: cmp $0x6,%eax # 要求輸入的字符序列長度為6
41 401082: je 4010d2 <phase_5+0x70> # jmp 4010d2
42 401084: callq 40143a <explode_bomb> # 不然爆炸
43 401089: jmp 4010d2 <phase_5+0x70> # jmp 4010d2
44 # 關鍵循環(huán)部分
45 40108b: movzbl (%rbx,%rax,1),%ecx # %ecx = (%rbx + 0)(我們輸入的字串) = str[0] = str[%rax]
46 40108f: mov %cl,(%rsp) # (%rsp) = str[%rax]
47 401092: mov (%rsp),%rdx # %rdx = (%rsp) = str[%rax]
48 401096: and $0xf,%edx # %rdx = str[%rax] & 0xf
49 401099: movzbl 0x4024b0(%rdx),%edx # %rdx = 訪問(0x4024b0 + %rdx)地址處的值,設為arr[%rdx]
50 4010a0: mov %dl,0x10(%rsp,%rax,1) # (%rsp + %rax + 0x10) = arr[%rdx]
51 4010a4: add $0x1,%rax # %rax += 1
52 4010a8: cmp $0x6,%rax # 運行6次之后跳出
53 4010ac: jne 40108b <phase_5+0x29>
54 #
55 4010ae: movb $0x0,0x16(%rsp) # (%rsp + 0x16) = 0
56 4010b3: mov $0x40245e,%esi # 第二個入?yún)ⅲ?x40245e字的符串"flyers"
57 4010b8: lea 0x10(%rsp),%rdi # 第一個入?yún)ⅲ荷鲜鲅h(huán)壓棧的字符
58 4010bd: callq 401338 <strings_not_equal>
59 4010c2: test %eax,%eax
60 4010c4: je 4010d9 <phase_5+0x77> # 字符串相等， return
61 4010c6: callq 40143a <explode_bomb> # 否則, bomb!
62 4010cb: nopl 0x0(%rax,%rax,1)
63 4010d0: jmp 4010d9 <phase_5+0x77>
64 4010d2: mov $0x0,%eax
65 4010d7: jmp 40108b <phase_5+0x29>
66 4010d9: mov 0x18(%rsp),%rax
67 4010de: xor %fs:0x28,%rax
68 4010e5:
69 4010e7: je 4010ee <phase_5+0x8c>
70 4010e9: callq 400b30 <__stack_chk_fail@plt>
71 4010ee: add $0x20,%rsp
72 4010f2: pop %rbx
73 4010f3: retq
根據(jù)39到41行可以看出，這一關要求我們輸入一個字符串，并且字符串的長度一定得等于6。然后讓我們來著重分析這一關的關鍵循環(huán)部分，根據(jù)我們的注釋，循環(huán)一共執(zhí)行了6次，它以我們輸入的每一個字符串與0xf得到的結果作為下標，訪問0x4024b0處的字符，并將得到的字符依次放地址為%rsp + 0x10 到 %rsp + 5 + 0x10的內存中。
image.png
來看看0x4024b0處的字符串：”maduiersnfotvbylso you think you can stop the bomb with ctrl-c, do you?”，這段話的奧義很神妙，我們姑且放一放。55到61行將我們循環(huán)部分中壓入的6個字符與”flyers”對比，當它們相等時，我們才能成功拆除炸彈。這說明我們循環(huán)壓入棧中的6個字符應該依次為’f’ ‘l’ ‘y’ ‘e’ ‘r’ ‘s’(56行)，我們假設我們輸入的6個字符串為str，0x4024b0位置的字符串為arr，這就意味著我們必須要滿足:
arr[str[0] & 0xf] = ‘f’
arr[str[1] & 0xf] = ‘l’
arr[str[2] & 0xf] = ‘y’
arr[str[3] & 0xf] = ‘e’
arr[str[4] & 0xf] = ‘r’
arr[str[5] & 0xf] = ‘s’
這會有很多種答案，我們僅給出一種答案，我們挑選arr[9] = ‘f’、arr[15] = ‘l’、arr[14] = ‘y’、arr[5] = ‘e’、arr[6] = ‘r’和 arr[7] = ‘s’，然后我們給出輸入的答案：”)/>5&7”，它們ASCII碼對應十進制數(shù)與0xf的值分別為9、15、14、5、6、7，因此，這是一個合法的答案：
)/>5&7
關卡六
這是我們的最后一彈，也是最難的一彈，來看看它的匯編代碼，我將它分為四個部分：
00000000004010f4 <phase_6>:
##第一部分
1 4010f4: 41 56 push %r14 /*一些準備工作*/
2 4010f6: 41 55 push %r13
3 4010f8: 41 54 push %r12
4 4010fa: 55 push %rbp
5 4010fb: 53 push %rbx
6 4010fc: 48 83 ec 50 sub $0x50,%rsp /*棧指針減80*/
7 401100: 49 89 e5 mov %rsp,%r13 /*%r13 = %rsp*/
8 401103: 48 89 e6 mov %rsp,%rsi /*%rsi = %rsp*/
9 401106: e8 51 03 00 00 callq 40145c <read_six_numbers> /*調用函數(shù)，讀六個數(shù)字*/
10 40110b: 49 89 e6 mov %rsp,%r14 /*%r14 = %rsp*/
11 40110e: 41 bc 00 00 00 00 mov $0x0,%r12d /*%r12d = 0*/
12 401114: 4c 89 ed mov %r13,%rbp /*%rbp = %r13 = %rsp*/
13 401117: 41 8b 45 00 mov 0x0(%r13),%eax /*%eax = (%rsp) = n[0]*/
14 40111b: 83 e8 01 sub $0x1,%eax /*%eax = (%rsp) - 1= n[0] - 1*/
15 40111e: 83 f8 05 cmp $0x5,%eax /*n[0] - 1與 5比較*/
16 401121: 76 05 jbe 401128 <phase_6+0x34> /*if (n[0] <= 6), jmp 401128*/
17 401123: e8 12 03 00 00 callq 40143a <explode_bomb> /*bomb*/
18 401128: 41 83 c4 01 add $0x1,%r12d /*%r12d++*/
19 40112c: 41 83 fc 06 cmp $0x6,%r12d /*if (%12d == 6), jmp 401153*/
20 401130: 74 21 je 401153 <phase_6+0x5f>
21 401132: 44 89 e3 mov %r12d,%ebx /*%ebx = %12d*/
22 401135: 48 63 c3 movslq %ebx,%rax /*%rax = %ebx = %12d*/
23 401138: 8b 04 84 mov (%rsp,%rax,4),%eax /*%eax = n[%rax]*/
24 40113b: 39 45 00 cmp %eax,0x0(%rbp) /*比較當前棧內存與當前輸入數(shù)字*/
25 40113e: 75 05 jne 401145 <phase_6+0x51> /*if (n[%rax] == n[i]), bomb*/
26 401140: e8 f5 02 00 00 callq 40143a <explode_bomb>
27 401145: 83 c3 01 add $0x1,%ebx /*%ebx++*/
28 401148: 83 fb 05 cmp $0x5,%ebx /*比較%ebx與5*/
29 40114b: 7e e8 jle 401135 <phase_6+0x41> /*if (%ebx <= 5), jmp 401135*/
30 40114d: 49 83 c5 04 add $0x4,%r13 /*%r13 += 4*/
31 401151: eb c1 jmp 401114 <phase_6+0x20> /*無條件跳轉到401114*/
##
##第二部分
32 401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi /*%rsi = %rsp + 24*/
33 401158: 4c 89 f0 mov %r14,%rax /*%rax = %r14 = %rsp*/
34 40115b: b9 07 00 00 00 mov $0x7,%ecx /*%ecx = 7*/
35 401160: 89 ca mov %ecx,%edx /*%edx = %ecx = 7*/
36 401162: 2b 10 sub (%rax),%edx /*(%rax) = n[x], %edx = 7 - n[x]*/
37 401164: 89 10 mov %edx,(%rax) /*(%rax) = %edx = 7 - n[x]*/
38 401166: 48 83 c0 04 add $0x4,%rax /*%rax = %rsp + 4*/
39 40116a: 48 39 f0 cmp %rsi,%rax /*比較%rsp + x 與 %rsp + 24*/
40 40116d: 75 f1 jne 401160 <phase_6+0x6c> /*if (x != 24), jmp 401160*/
##
##第三部分
%rax = %rsp + 24
41 40116f: be 00 00 00 00 mov $0x0,%esi /*%esi = 0*/
42 401174: eb 21 jmp 401197 <phase_6+0xa3> /*jmp 40117*/
43 401176: 48 8b 52 08 mov 0x8(%rdx),%rdx /*%rdx = (%rdx + 8)*/
44 40117a: 83 c0 01 add $0x1,%eax /*%eax++*/
45 40117d: 39 c8 cmp %ecx,%eax /*比較%eax 與 %ecx*/
46 40117f: 75 f5 jne 401176 <phase_6+0x82> /*if (%eax != %%ecx), jmp 401176*/
47 401181: eb 05 jmp 401188 <phase_6+0x94> /*jmp 401188*/
48 401183: ba d0 32 60 00 mov $0x6032d0,%edx /*%edx = 0x6032d0*/
49 401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2) /*%(%rsp + 2*%rsi + 0x20) = %rdx*/
50 40118d: 48 83 c6 04 add $0x4,%rsi /*%rsi += 4*/
51 401191: 48 83 fe 18 cmp $0x18,%rsi /*比較%rsp + 4x 與 %rsp + 24*/
52 401195: 74 14 je 4011ab <phase_6+0xb7> /*if ==, jmp 4011ab*/
53 401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx /*%ecx = n[%rsp / 4]*/
54 40119a: 83 f9 01 cmp $0x1,%ecx /*%ecx ? 1*/
55 40119d: 7e e4 jle 401183 <phase_6+0x8f> /*if (n[x] <= 1), jmp 401183*/
56 40119f: b8 01 00 00 00 mov $0x1,%eax /*%eax = 1*/
57 4011a4: ba d0 32 60 00 mov $0x6032d0,%edx /*%edx = 0x6032d0*/
58 4011a9: eb cb jmp 401176 <phase_6+0x82> /*jmp 401176*/
#
59 4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx /*%rbx = (%rsp + 0x20)*/
60 4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax /*%rax = %rsp + 0x28*/
61 4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi /*%rsi = %rsp + 0x50*/
62 4011ba: 48 89 d9 mov %rbx,%rcx /*%rcx = %rbx = (%rsp + 0x20)*/
63 4011bd: 48 8b 10 mov (%rax),%rdx /*%rdx = (%rax) = (%rsp + 0x28)*/
64 4011c0: 48 89 51 08 mov %rdx,0x8(%rcx) /*(%rsp + 0x28) = (%rsp + 0x28)*/
65 4011c4: 48 83 c0 08 add $0x8,%rax /*%rax= %rax + 8*/
66 4011c8: 48 39 f0 cmp %rsi,%rax /*%rax ? %rsp + 0x50*/
67 4011cb: 74 05 je 4011d2 <phase_6+0xde> /*if ==, jmp 4011d2*/
68 4011cd: 48 89 d1 mov %rdx,%rcx /*if !=, %rcx = %rdx*/
69 4011d0: eb eb jmp 4011bd <phase_6+0xc9> /*jmp 4011bd*/
70 4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx) /*(rdx+8) = 0*/
##
##第四部分
%rdx = 0x6032e0
%rbx = *(%rsp + 0x20)
71 4011d9: 00
72 4011da: bd 05 00 00 00 mov $0x5,%ebp /*%ebp = 5*/
73 4011df: 48 8b 43 08 mov 0x8(%rbx),%rax /*%rax = (%rbx + 8) = node<2>->val*/
74 4011e3: 8b 00 mov (%rax),%eax /*%eax = node<2>->val*/
75 4011e5: 39 03 cmp %eax,(%rbx) /*node<1>->val ? node<2>->val*/
76 4011e7: 7d 05 jge 4011ee <phase_6+0xfa> /*if <, bomb!*/
77 4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb>
78 4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx /*%rbx = node<2>*/
79 4011f2: 83 ed 01 sub $0x1,%ebp /*%ebp--*/
80 4011f5: 75 e8 jne 4011df <phase_6+0xeb> /*if (%ebp != 0), jmp 4011df*/
81 4011f7: 48 83 c4 50 add $0x50,%rsp
82 4011fb: 5b pop %rbx
83 4011fc: 5d pop %rbp
84 4011fd: 41 5c pop %r12
85 4011ff: 41 5d pop %r13
86 401201: 41 5e pop %r14
86 401203: c3 retq
##結束了
第一部分
代碼很長，但是別怕，讓我們逐個擊破，先提取出第一部分：
##第一部分
1 4010f4: 41 56 push %r14 /*一些準備工作*/
2 4010f6: 41 55 push %r13
3 4010f8: 41 54 push %r12
4 4010fa: 55 push %rbp
5 4010fb: 53 push %rbx
6 4010fc: 48 83 ec 50 sub $0x50,%rsp /*棧指針減80*/
7 401100: 49 89 e5 mov %rsp,%r13 /*%r13 = %rsp*/
8 401103: 48 89 e6 mov %rsp,%rsi /*%rsi = %rsp*/
9 401106: e8 51 03 00 00 callq 40145c <read_six_numbers> /*調用函數(shù)，讀六個數(shù)字*/
10 40110b: 49 89 e6 mov %rsp,%r14 /*%r14 = %rsp*/
11 40110e: 41 bc 00 00 00 00 mov $0x0,%r12d /*%r12d = 0*/
12 401114: 4c 89 ed mov %r13,%rbp /*%rbp = %r13 = %rsp*/
13 401117: 41 8b 45 00 mov 0x0(%r13),%eax /*%eax = (%rsp) = n[0]*/
14 40111b: 83 e8 01 sub $0x1,%eax /*%eax = (%rsp) - 1= n[0] - 1*/
15 40111e: 83 f8 05 cmp $0x5,%eax /*n[0] - 1與 5比較*/
16 401121: 76 05 jbe 401128 <phase_6+0x34> /*if (n[0] <= 6), jmp 401128*/
17 401123: e8 12 03 00 00 callq 40143a <explode_bomb> /*bomb*/
18 401128: 41 83 c4 01 add $0x1,%r12d /*%r12d++*/
19 40112c: 41 83 fc 06 cmp $0x6,%r12d /*if (%12d == 6), jmp 401153*/
20 401130: 74 21 je 401153 <phase_6+0x5f>
21 401132: 44 89 e3 mov %r12d,%ebx /*%ebx = %12d*/
22 401135: 48 63 c3 movslq %ebx,%rax /*%rax = %ebx = %12d*/
23 401138: 8b 04 84 mov (%rsp,%rax,4),%eax /*%eax = n[%rax]*/
24 40113b: 39 45 00 cmp %eax,0x0(%rbp) /*比較當前棧內存與當前輸入數(shù)字*/
25 40113e: 75 05 jne 401145 <phase_6+0x51> /*if (n[%rax] == n[i]), bomb*/
26 401140: e8 f5 02 00 00 callq 40143a <explode_bomb>
27 401145: 83 c3 01 add $0x1,%ebx /*%ebx++*/
28 401148: 83 fb 05 cmp $0x5,%ebx /*比較%ebx與5*/
29 40114b: 7e e8 jle 401135 <phase_6+0x41> /*if (%ebx <= 5), jmp 401135*/
30 40114d: 49 83 c5 04 add $0x4,%r13 /*%r13 += 4*/
31 401151: eb c1 jmp 401114 <phase_6+0x20> /*無條件跳轉到401114*/
##
這題同第二題一樣，也是調用了read_six_numbers，那么說明我們應該輸入六個數(shù)字，并且這六個數(shù)字會被保存在內存 (%rsp) 到 (%rsp + 20) 中。對于第一部分，首先通過31行判定這是一個循環(huán)體，它將%r13 + 4，考慮第13行到16行，這個操作會使得我們輸入的六個數(shù)(n[0-5])都會被強制性要求小于6，而在第18行到29行之間，又有一個內循環(huán)，它使得每一個數(shù)字之間兩兩對比，這段代碼的等價C語言為：
for (int i = 0; i < 6; i++){
if (n[0] > 6)
Bomb!
for (int j = i + 1; j < 6; j++){
if (n[j] == n[i])
Bomb!
}
}
所以，第一部分使得我們輸入的六個數(shù)均小于等于6，且互不相同。
第二部分
##第二部分
32 401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi /*%rsi = %rsp + 24*/
33 401158: 4c 89 f0 mov %r14,%rax /*%rax = %r14 = %rsp*/
34 40115b: b9 07 00 00 00 mov $0x7,%ecx /*%ecx = 7*/
35 401160: 89 ca mov %ecx,%edx /*%edx = %ecx = 7*/
36 401162: 2b 10 sub (%rax),%edx /*(%rax) = n[x], %edx = 7 - n[x]*/
37 401164: 89 10 mov %edx,(%rax) /*(%rax) = %edx = 7 - n[x]*/
38 401166: 48 83 c0 04 add $0x4,%rax /*%rax = %rsp + 4*/
39 40116a: 48 39 f0 cmp %rsi,%rax /*比較%rsp + x 與 %rsp + 24*/
40 40116d: 75 f1 jne 401160 <phase_6+0x6c> /*if (x != 24), jmp 401160*/
##
第二部分相對而言比較簡單，它將我們輸入的每一個數(shù)都用7減，等價的C語言是：
for (int i = 0; i < 6; i++){
int t = 7 - n[i];
n[i] = t;
}
第三部分
第三部分是最難的部分，我又將第三部分分為兩個小部分，先來看看第一個小部分：
##第三部分
%rax = %rsp + 24
41 40116f: be 00 00 00 00 mov $0x0,%esi /*%esi = 0*/
42 401174: eb 21 jmp 401197 <phase_6+0xa3> /*jmp 40117*/
43 401176: 48 8b 52 08 mov 0x8(%rdx),%rdx /*%rdx = (%rdx + 8)*/
44 40117a: 83 c0 01 add $0x1,%eax /*%eax++*/
45 40117d: 39 c8 cmp %ecx,%eax /*比較%eax 與 %ecx*/
46 40117f: 75 f5 jne 401176 <phase_6+0x82> /*if (%eax != %%ecx), jmp 401176*/
47 401181: eb 05 jmp 401188 <phase_6+0x94> /*jmp 401188*/
48 401183: ba d0 32 60 00 mov $0x6032d0,%edx /*%edx = 0x6032d0*/
49 401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2) /*%(%rsp + 2*%rsi + 0x20) = %rdx*/
50 40118d: 48 83 c6 04 add $0x4,%rsi /*%rsi += 4*/
51 401191: 48 83 fe 18 cmp $0x18,%rsi /*比較%rsp + 4x 與 %rsp + 24*/
52 401195: 74 14 je 4011ab <phase_6+0xb7> /*if ==, jmp 4011ab*/
53 401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx /*%ecx = n[%rsp / 4]*/
54 40119a: 83 f9 01 cmp $0x1,%ecx /*%ecx ? 1*/
55 40119d: 7e e4 jle 401183 <phase_6+0x8f> /*if (n[x] <= 1), jmp 401183*/
56 40119f: b8 01 00 00 00 mov $0x1,%eax /*%eax = 1*/
57 4011a4: ba d0 32 60 00 mov $0x6032d0,%edx /*%edx = 0x6032d0*/
58 4011a9: eb cb jmp 401176 <phase_6+0x82> /*jmp 401176*/
48行的一個地址很唐突，先來看看這里面放的是什么：
# (gdb) x/24w 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
其實題目已經(jīng)提示我們它是一個node了，它的第一個字節(jié)暫定，我們不知道是什么意思，它的第二個字節(jié)我們很敏感，這應該就是我們要輸入的六個數(shù)了，第三個字節(jié)是下一個節(jié)點的地址，而下一字節(jié)為0，這讓我們意識到這應該是一個大小為8字節(jié)的指針，保存這4字節(jié)大小的地址。那么我們可以看出它應該是一個這樣的結構體：
struct node{
int val;
int data(要輸入的六個數(shù)之一);
struct node* next;
};
來看看它的匯編版本的C代碼：
goto 401197;
401176:
do{
%edx = *(%edx + 8);
%eax++;
}while (n[%rsi/4] != %eax)
goto 401188;
401183:
%edx = 0x6032d0;
401188:
*(%rsp + 2 * %rsi + 0x20) = %edx;
%rsi = %rsi + 4;
if (%rsi == %rsp + 24) gooto 4011ab;
401197:
if (n[%rsi/4] <= 1) goto 401183
%eax = 1;
%edx = 0x6032d0;
goto 401176;
我們來將它翻譯成等價的C代碼：
for (int %rsi = 0; %rsi < 24; %rsi += 4){
%ecx = nums[%rsi / 4];
if (%ecx > 1){
%eax = 1;
%edx = 0x6032d0;
do{
%edx = *(%edx + 8);
%eax++;
}while (n[%rsi/4] != %eax)
}else{
%edx = 0x6032d0;
}
*(%rsp + 2 * %rsi + 0x20) = %edx;
}
此時我們可能還是不知道它做了什么，不妨來模擬一下，假設此時經(jīng)過被7減之后，到達第三部分的六個數(shù)為6, 5, 4, 3, 2, 1。我們必須要知道C代碼中的(%edx + 8)的含義，由于0x6032d0是一個上面分析的結構體，那么初始時%edx = 0x6032d0為結構體的起始位置，而%edx + 8是結構體成員next指針的地址，它保存著下一結構體的起始地址，那么*(%edx + 8)起始就是下一結構體的起始地址，那么經(jīng)過這一段代碼后，6使得%rdx循環(huán)五次變?yōu)閚ode6，5使得%rdx循環(huán)4次變?yōu)閚ode5...會有：
(%rsp + 0x20) = 0x603320 <node6>
(%rsp + 0x28) = 0x603310 <node5>
(%rsp + 0x30) = 0x603300 <node4>
(%rsp + 0x38) = 0x6032f0 <node3>
(%rsp + 0x40) = 0x6032e0 <node2>
(%rsp + 0x48) = 0x6032d0 <node1>
%rsi = %rsp + 0x50
我們發(fā)現(xiàn)程序將(%rsp + 0x20)到(%rsp + 0x48)分別設置成了node6、node5、node4、node3、node2、node1，這恰好與我們當前數(shù)字6、5、4、3、2、1相吻合，這并不是偶然，這就是這段程序的作用，我們可以換個數(shù)字模擬，依然會得到同樣的結果。
繼續(xù)看看另一個小部分：
#
59 4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx /*%rbx = (%rsp + 0x20)*/
60 4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax /*%rax = %rsp + 0x28*/
61 4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi /*%rsi = %rsp + 0x50*/
62 4011ba: 48 89 d9 mov %rbx,%rcx /*%rcx = %rbx = (%rsp + 0x20)*/
63 4011bd: 48 8b 10 mov (%rax),%rdx /*%rdx = (%rax) = (%rsp + 0x28)*/
64 4011c0: 48 89 51 08 mov %rdx,0x8(%rcx) /*(%rsp + 0x28) = (%rsp + 0x28)*/
65 4011c4: 48 83 c0 08 add $0x8,%rax /*%rax= %rax + 8*/
66 4011c8: 48 39 f0 cmp %rsi,%rax /*%rax ? %rsp + 0x50*/
67 4011cb: 74 05 je 4011d2 <phase_6+0xde> /*if ==, jmp 4011d2*/
68 4011cd: 48 89 d1 mov %rdx,%rcx /*if !=, %rcx = %rdx*/
69 4011d0: eb eb jmp 4011bd <phase_6+0xc9> /*jmp 4011bd*/
70 4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx) /*(rdx+8) = 0*/
##
不做任何優(yōu)化的等價C語言為：
%rbx = *(%rsp + 0x20)
%rax = %rsp + 0x28
%rsi = %rsp + 0x50
%rcx = %rbx = *(%rsp + 0x20)
while (1){
%rdx = *%rax;
*(%rcx + 8) = %rdx;
rax += 8;
if (%rax == %rsp + 0x50)
break;
%rcx = %rdx;
}
*(rdx+8) = 0
讓我們以剛剛得到的結果繼續(xù)模擬一遍：
初始化：
%rbx = *(%rsp + 0x20) = 0x603320 <node6>;
%rax = %rsp + 0x28 # 計數(shù)器
%rsi = %rsp + 0x50 # 計數(shù)器 ， 共循環(huán)5次
%rcx = %rbx = 0x603320 <node6>
第一次循環(huán)：
%rdx = *%rax = *(%rsp + 0x28) = 0x603310 <node5>;
*(%rcx + 8) = node6->next = 0x603310 <node5>;
%rax = %rsp + 0x30;
%rcx = 0x603310 <node5>;
#第一次循環(huán)使得<node6>的next指針指向了<node5>
第一次循環(huán)：
%rdx = *%rax = *(%rsp + 0x30) = 0x603300 <node4>;
*(%rcx + 8) = node4->next = 0x603300 <node4>;
%rax = %rsp + 0x38;
%rcx = 0x603300 <node4>;
#第一次循環(huán)使得<node5>的next指針指向了<node4>
如此反復循環(huán)，共5次
很顯然，這段代碼在修正各節(jié)點的next指針的指向，一共執(zhí)行五次，最后一個節(jié)點的next指針指向在程序的最后被修改為0，那么此時，地址(%rsp + 0x20)所存放的便是該鏈表的頭指針，而后的每八個數(shù)據(jù)塊中，存放的是下一個鏈表節(jié)點。如果我們將斷點打到4011d2處，并讓程序執(zhí)行這條語句，我們再次審視0x6032d0的值：
# (gdb) x/24w 0x6032d0
# 0x6032d0 <node1>: 0x0000014c 0x00000001 0x00000000 0x00000000
# 0x6032e0 <node2>: 0x000000a8 0x00000002 0x006032d0 0x00000000
# 0x6032f0 <node3>: 0x0000039c 0x00000003 0x006032e0 0x00000000
# 0x603300 <node4>: 0x000002b3 0x00000004 0x006032f0 0x00000000
# 0x603310 <node5>: 0x000001dd 0x00000005 0x00603300 0x00000000
# 0x603320 <node6>: 0x000001bb 0x00000006 0x00603310 0x00000000
正如我們分析的，<node6>成為了頭節(jié)點。
總結一下第三部分代碼，它將0x6032d0處的鏈表打亂，以當前達到的6位數(shù)字X1、X2、...、X6為基準，使得鏈表的順序變?yōu)閚odeX1 -> nodeX2 -> ... -> nodeX6 -> 0x0，并將這些節(jié)點放在以%rsp + 0x20地址開始的連續(xù)8字節(jié)塊的內存中。
第四部分
##第四部分
%rdx = 0x6032e0
%rbx = *(%rsp + 0x20)
71 4011d9: 00
72 4011da: bd 05 00 00 00 mov $0x5,%ebp /*%ebp = 5*/
73 4011df: 48 8b 43 08 mov 0x8(%rbx),%rax /*%rax = (%rbx + 8) = node<2>->val*/
74 4011e3: 8b 00 mov (%rax),%eax /*%eax = node<2>->val*/
75 4011e5: 39 03 cmp %eax,(%rbx) /*node<1>->val ? node<2>->val*/
76 4011e7: 7d 05 jge 4011ee <phase_6+0xfa> /*if <, bomb!*/
77 4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb>
78 4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx /*%rbx = node<2>*/
79 4011f2: 83 ed 01 sub $0x1,%ebp /*%ebp--*/
80 4011f5: 75 e8 jne 4011df <phase_6+0xeb> /*if (%ebp != 0), jmp 4011df*/
81 4011f7: 48 83 c4 50 add $0x50,%rsp
82 4011fb: 5b pop %rbx
83 4011fc: 5d pop %rbp
84 4011fd: 41 5c pop %r12
85 4011ff: 41 5d pop %r13
86 401201: 41 5e pop %r14
86 401203: c3 retq
##結束了
觀察74到80行，這是一個循環(huán)，它嚴格保證下一節(jié)點的val值小于當前節(jié)點的val值，這就意味著我們經(jīng)過第三部分得到的新鏈表的val值必須是單調遞減的，我們來看看最初的鏈表：
# 0x6032d0 <node1>: 0x0000014c(332) 0x00000001 0x006032e0 0x00000000
# 0x6032e0 <node2>: 0x000000a8(168) 0x00000002 0x006032f0 0x00000000
# 0x6032f0 <node3>: 0x0000039c(924) 0x00000003 0x00603300 0x00000000
# 0x603300 <node4>: 0x000002b3(691) 0x00000004 0x00603310 0x00000000
# 0x603310 <node5>: 0x000001dd(477) 0x00000005 0x00603320 0x00000000
# 0x603320 <node6>: 0x000001bb(443) 0x00000006 0x00000000 0x00000000
可以看出val值遞減的順序是node3 -> node4 -> node5 -> node6 -> node1 -> node2，根據(jù)我們第三部分的結論，到達第三部分的數(shù)據(jù)必須是 3 4 5 6 1 2，而它又是被7減過的，那么結束了，答案是：
4 3 2 1 6 5
