csapp(3e)的bomblab的phase_6詳解(沒有詳細到逐行解析的程度)
阿新 • • 發佈：2020-11-01
phase_6我做了三個多小時, 必須記錄一下. 我覺得難度挺大的, 因為它就是由好幾個迴圈組成的, 還有幾個雙層迴圈(其中1個雙層迴圈還挺費解). 迴圈多而且相互關聯, 而且是以記憶體的形式相互關聯.
先貼一下反彙編得到的程式碼:
00000000004010f4 <phase_6>: 4010f4: 41 56 push %r14 4010f6: 41 55 push %r13 4010f8: 41 54 push %r12 4010fa: 55 push %rbp 4010fb: 53 push %rbx 4010fc: 48 83 ec 50 sub $0x50,%rsp 401100: 49 89 e5 mov %rsp,%r13 401103: 48 89 e6 mov %rsp,%rsi 401106: e8 51 03 00 00 callq 40145c <read_six_numbers> 40110b: 49 89 e6 mov %rsp,%r14 40110e: 41 bc 00 00 00 00 mov $0x0,%r12d # 401151:直接跳轉 401114: 4c 89 ed mov %r13,%rbp 401117: 41 8b 45 00 mov 0x0(%r13),%eax 40111b: 83 e8 01 sub $0x1,%eax 40111e: 83 f8 05 cmp $0x5,%eax 401121: 76 05 jbe 401128 <phase_6+0x34> 401123: e8 12 03 00 00 callq 40143a <explode_bomb> # 401121:if eax <= 5 401128: 41 83 c4 01 add $0x1,%r12d 40112c: 41 83 fc 06 cmp $0x6,%r12d 401130: 74 21 je 401153 <phase_6+0x5f> 401132: 44 89 e3 mov %r12d,%ebx # 40114b:if ebx <= 5 401135: 48 63 c3 movslq %ebx,%rax 401138: 8b 04 84 mov (%rsp,%rax,4),%eax 40113b: 39 45 00 cmp %eax,0x0(%rbp) 40113e: 75 05 jne 401145 <phase_6+0x51> 401140: e8 f5 02 00 00 callq 40143a <explode_bomb> # 40113e:if eax!=(%rbp) 401145: 83 c3 01 add $0x1,%ebx 401148: 83 fb 05 cmp $0x5,%ebx 40114b: 7e e8 jle 401135 <phase_6+0x41> 40114d: 49 83 c5 04 add $0x4,%r13 401151: eb c1 jmp 401114 <phase_6+0x20> # if r12d==6(已經不會再跳轉到這裡), loop2之前 401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi 401158: 4c 89 f0 mov %r14,%rax 40115b: b9 07 00 00 00 mov $0x7,%ecx # if rax!=rsi(loop2) 401160: 89 ca mov %ecx,%edx 401162: 2b 10 sub (%rax),%edx 401164: 89 10 mov %edx,(%rax) 401166: 48 83 c0 04 add $0x4,%rax 40116a: 48 39 f0 cmp %rsi,%rax 40116d: 75 f1 jne 401160 <phase_6+0x6c> # loop2結束 40116f: be 00 00 00 00 mov $0x0,%esi 401174: eb 21 jmp 401197 <phase_6+0xa3> # 直接跳轉, 或者 # if eax!=ecx 401176: 48 8b 52 08 mov 0x8(%rdx),%rdx 40117a: 83 c0 01 add $0x1,%eax 40117d: 39 c8 cmp %ecx,%eax 40117f: 75 f5 jne 401176 <phase_6+0x82> 401181: eb 05 jmp 401188 <phase_6+0x94> # if ecx<=1 401183: ba d0 32 60 00 mov $0x6032d0,%edx # 直接跳轉 401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2) 40118d: 48 83 c6 04 add $0x4,%rsi 401191: 48 83 fe 18 cmp $0x18,%rsi 401195: 74 14 je 4011ab <phase_6+0xb7> # 直接跳轉 401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx 40119a: 83 f9 01 cmp $0x1,%ecx 40119d: 7e e4 jle 401183 <phase_6+0x8f> 40119f: b8 01 00 00 00 mov $0x1,%eax 4011a4: ba d0 32 60 00 mov $0x6032d0,%edx 4011a9: eb cb jmp 401176 <phase_6+0x82> # if rsi==0x18, 這是新的開始, 且不會再被跳轉 4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx 4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax 4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi 4011ba: 48 89 d9 mov %rbx,%rcx # 直接跳轉 4011bd: 48 8b 10 mov (%rax),%rdx 4011c0: 48 89 51 08 mov %rdx,0x8(%rcx) 4011c4: 48 83 c0 08 add $0x8,%rax 4011c8: 48 39 f0 cmp %rsi,%rax 4011cb: 74 05 je 4011d2 <phase_6+0xde> 4011cd: 48 89 d1 mov %rdx,%rcx 4011d0: eb eb jmp 4011bd <phase_6+0xc9> # if rsi==rax 4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx) 4011d9: 00 4011da: bd 05 00 00 00 mov $0x5,%ebp # if ebp!=0 4011df: 48 8b 43 08 mov 0x8(%rbx),%rax 4011e3: 8b 00 mov (%rax),%eax 4011e5: 39 03 cmp %eax,(%rbx) 4011e7: 7d 05 jge 4011ee <phase_6+0xfa> 4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb> # if (%rbx)<=eax 4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx 4011f2: 83 ed 01 sub $0x1,%ebp 4011f5: 75 e8 jne 4011df <phase_6+0xeb> 4011f7: 48 83 c4 50 add $0x50,%rsp 4011fb: 5b pop %rbx 4011fc: 5d pop %rbp 4011fd: 41 5c pop %r12 4011ff: 41 5d pop %r13 401201: 41 5e pop %r14 401203: c3 retq
劃分程式塊
我感覺, 應該做的第一件事, 是把程式碼分成塊. 怎麼做? 看跳轉關係. 具體來說, 我們看所有的jmp指令的地址, 標出這些跳轉到的地址, 並且標出它是從哪一行跳轉過來的.
如果, 發現某一個範圍, 沒有來自更靠下的地址的跳轉, 那麼這就是一個程式塊.
第一個塊
按這個做法, 劃分的第一個程式塊是:
# 401151:直接跳轉 # 這一小塊是在說, 401114: 4c 89 ed mov %r13,%rbp # rsp 401117: 41 8b 45 00 mov 0x0(%r13),%eax 40111b: 83 e8 01 sub $0x1,%eax 40111e: 83 f8 05 cmp $0x5,%eax 401121: 76 05 jbe 401128 <phase_6+0x34> 401123: e8 12 03 00 00 callq 40143a <explode_bomb> # 401121:if eax <= 5 401128: 41 83 c4 01 add $0x1,%r12d # 本來為0, 現在為1 40112c: 41 83 fc 06 cmp $0x6,%r12d 401130: 74 21 je 401153 <phase_6+0x5f> # 結束 401132: 44 89 e3 mov %r12d,%ebx # 40114b:if ebx <= 5 401135: 48 63 c3 movslq %ebx,%rax 401138: 8b 04 84 mov (%rsp,%rax,4),%eax 40113b: 39 45 00 cmp %eax,0x0(%rbp) 40113e: 75 05 jne 401145 <phase_6+0x51> 401140: e8 f5 02 00 00 callq 40143a <explode_bomb> # 40113e:if eax!=(%rbp) 401145: 83 c3 01 add $0x1,%ebx 401148: 83 fb 05 cmp $0x5,%ebx 40114b: 7e e8 jle 401135 <phase_6+0x41> 40114d: 49 83 c5 04 add $0x4,%r13 401151: eb c1 jmp 401114 <phase_6+0x20>
我們還得知道這個程式塊的入口是啥, 也就是從哪一行開始執行, 初始狀態怎樣. 這裡的入口就是401114, 而且因為我們標註了跳轉關係, 所以也會知道哪些只會執行一次.
也需要知道出口, 出口不可能是51, 因為它是jmp, 一定是某個跳轉指令, 是401130.
讀這一段, 是雙層迴圈, 不爆炸的條件是, 這6個數互不相等, 而且都在1到6之間, 也就是說, 構成了一個1到6的排列. 因此我們大概知道了答案大概長啥樣.
第二個塊
401153: 48 8d 74 24 18 lea 0x18(%rsp),%rsi 401158: 4c 89 f0 mov %r14,%rax 40115b: b9 07 00 00 00 mov $0x7,%ecx # if rax!=rsi(loop2) 401160: 89 ca mov %ecx,%edx 401162: 2b 10 sub (%rax),%edx 401164: 89 10 mov %edx,(%rax) 401166: 48 83 c0 04 add $0x4,%rax 40116a: 48 39 f0 cmp %rsi,%rax 40116d: 75 f1 jne 401160 <phase_6+0x6c>
這個迴圈很簡單, 其實就是對輸入的6個數, 用7-一遍. 比如1 2 3 4 5 6, 得到就會是6 5 4 3 2 1.
第三個塊
40116f: be 00 00 00 00 mov $0x0,%esi
401174: eb 21 jmp 401197 <phase_6+0xa3>
# 直接跳轉, 或者
# if eax!=ecx
401176: 48 8b 52 08 mov 0x8(%rdx),%rdx
40117a: 83 c0 01 add $0x1,%eax
40117d: 39 c8 cmp %ecx,%eax
40117f: 75 f5 jne 401176 <phase_6+0x82>
401181: eb 05 jmp 401188 <phase_6+0x94>
# if ecx<=1
401183: ba d0 32 60 00 mov $0x6032d0,%edx
# 直接跳轉
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2)
40118d: 48 83 c6 04 add $0x4,%rsi
401191: 48 83 fe 18 cmp $0x18,%rsi
401195: 74 14 je 4011ab <phase_6+0xb7>
# 直接跳轉
401197: 8b 0c 34 mov (%rsp,%rsi,1),%ecx
40119a: 83 f9 01 cmp $0x1,%ecx
40119d: 7e e4 jle 401183 <phase_6+0x8f>
40119f: b8 01 00 00 00 mov $0x1,%eax
4011a4: ba d0 32 60 00 mov $0x6032d0,%edx
4011a9: eb cb jmp 401176 <phase_6+0x82>
這個塊, 就費解很多了. 它的入口也是第一行, 不過簡單做了初始化, 就跳到401197了.
第一個分支cmp $0x1,%ecx, 這裡%ecx是從第1個數到第6個數, 不過已經是7-了的. 必然在1到6之間. 所以實際上是在說, 如果==1會怎樣, 如果 !=1會怎樣.
如果==1, 執行的是
# if ecx<=1
401183: ba d0 32 60 00 mov $0x6032d0,%edx
# 直接跳轉
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2)
也就是賦值給了0x20+%rsp開始的一片區域, 這裡值得注意的地方是0x20(%rsp,%rsi,2), 輸入6個數是4位元組, 現在每個數對應1個8位元組的. 如果是1, 存的內容是$0x6032d0.
如果>1, 執行的是:
初始化:
40119f: b8 01 00 00 00 mov $0x1,%eax
4011a4: ba d0 32 60 00 mov $0x6032d0,%edx
401176: 48 8b 52 08 mov 0x8(%rdx),%rdx
40117a: 83 c0 01 add $0x1,%eax
40117d: 39 c8 cmp %ecx,%eax
40117f: 75 f5 jne 401176 <phase_6+0x82>
401188: 48 89 54 74 20 mov %rdx,0x20(%rsp,%rsi,2)
40118d: 48 83 c6 04 add $0x4,%rsi
401191: 48 83 fe 18 cmp $0x18,%rsi
401195: 74 14 je 4011ab <phase_6+0xb7>
最費解的是這句話:mov 0x8(%rdx),%rdx, 這句話是在一個記憶體迴圈中, 執行的次數是%ecx-1次, 比如如果%ecx是6, 那麼執行5次.
這句話不改變記憶體, 僅僅影響%rdx, 實際上構成了一個對映關係: 1個輸入對應1個%rdx.
這個對映關係怎麼描述呢?(6-input)次執行mov 0x8(%rdx),%rdx.
但mov 0x8(%rdx),%rdx還是很不直觀.
那就檢視一下記憶體. 用10進製表示0x6032d0是6304464
# 初始是0x6032d0
# 記憶體地址:存的值
6304464+8:6304480
6304480+8:6304496
6304496+8=6304504:6304512
6304512+8:6304528
觀察會知道, 0x8(%rdx)其實就是%rdx+16. 因此我們可以用更直觀的方式來描述這個從輸入到%rdx的映射了, 6304464(0x6032d0)+16*(6-input). 比如, 如果我們給的字串是1 2 3 4 5 6. 那麼這個1會對應6304464+80=6304544. 後面同樣是存入.
而且, 我們還可以發現, 這兩個分支對應的都是同樣一個對映, 當這個程式塊輸入為1, 那麼原輸入就是6, 16*(6-input)=0, 這與第一個分支%rdx直接是0x6032d0, 是一致的.
第4個塊
4011ab: 48 8b 5c 24 20 mov 0x20(%rsp),%rbx
4011b0: 48 8d 44 24 28 lea 0x28(%rsp),%rax
4011b5: 48 8d 74 24 50 lea 0x50(%rsp),%rsi
4011ba: 48 89 d9 mov %rbx,%rcx
# 直接跳轉
4011bd: 48 8b 10 mov (%rax),%rdx
4011c0: 48 89 51 08 mov %rdx,0x8(%rcx)
4011c4: 48 83 c0 08 add $0x8,%rax
4011c8: 48 39 f0 cmp %rsi,%rax
4011cb: 74 05 je 4011d2 <phase_6+0xde>
4011cd: 48 89 d1 mov %rdx,%rcx
4011d0: eb eb jmp 4011bd <phase_6+0xc9>
我們把第3個塊得到的6個對映結果(起始地址為0x20(%rsp), 也就是%rbx), 分別記作a1,a2,a3,a4,a5,a6. 用這種記號, 再逐一寫出迴圈, 是:
(a1+8)=(a2)
(a2+8)=(a3)
(a3+8)=(a4)
(a4+8)=(a5)
(a5+8)=(a6)
第5個塊
# if rsi==rax
4011d2: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx)
4011d9: 00
4011da: bd 05 00 00 00 mov $0x5,%ebp
# if ebp!=0
4011df: 48 8b 43 08 mov 0x8(%rbx),%rax
4011e3: 8b 00 mov (%rax),%eax
4011e5: 39 03 cmp %eax,(%rbx)
4011e7: 7d 05 jge 4011ee <phase_6+0xfa>
4011e9: e8 4c 02 00 00 callq 40143a <explode_bomb>
# if (%rbx)<=eax
4011ee: 48 8b 5b 08 mov 0x8(%rbx),%rbx
4011f2: 83 ed 01 sub $0x1,%ebp
4011f5: 75 e8 jne 4011df <phase_6+0xeb>
這又是單層迴圈, 固定次數為5次.
4011df: 48 8b 43 08 mov 0x8(%rbx),%rax
4011e3: 8b 00 mov (%rax),%eax
4011e5: 39 03 cmp %eax,(%rbx)
4011e7: 7d 05 jge 4011ee <phase_6+0xfa>
還用a1的翻譯方式, 是在說:
(a1)>=(a2)>=(a3)>=(a4)>=(a5)>=(a6)
怎麼知道是這樣的呢? 這還需要結合第4個塊的翻譯結果來看.
但這裡有個易錯點, 就是我犯了的錯誤, 那就是, 比較的是低32位, 而之前存的(a1)等是64位.
我們知道a1到a6會取哪些值(就是第3個塊的翻譯過程), 那就一一檢視這些地址存的內容:
6304544: 25769804219 443
6304528: 21474836957 477
6304512: 17179869875 691
6304496: 12884902812 924
6304480: 8589934760 168
6304464: 4294967628 332
最右邊是%2^32^的結果, 因為只需要比較低32位.
從大到小排序就知道是4 3 2 1 5 6了. 這就是答案.
回看一遍, 還是要感嘆, 這個推理真不容易啊. 但看到這個結果:
Congratulations! You've defused the bomb!
感覺超開心.