二進位制拆彈（20181023-20181026）
阿新 • • 發佈：2018-12-17
二進位制拆彈一共設有七個關卡：
- phase_1：字串比較
- phase_2：迴圈
- phase_3：switch
- phase_4：遞迴
- phase_5：指標
- phase_6：連結串列/指標/結構
- secret_phase：隱藏關（還未做）
Phase1-6通關截圖
準備工作
- 我的電腦是windows的，所以需要在虛擬機器上安裝VMware，並且安裝gdb（百度尋找教程）。
- 使用objdump反彙編bomb可執行程式，得到bomb的彙編程式碼asm.txt檔案：objdump -d bomb > asm.txt
- 使用gdb除錯bomb程式，進入除錯狀態，如圖1所示：gdb bomb
phase_1
08048b90 <phase_1>: 8048b90: 83 ec 1c sub $0x1c,%esp 8048b93: c7 44 24 04 e4 a1 04 movl $0x804a1e4,0x4(%esp) //取0x804a1e4的內容，到%esp+0x4 8048b9a: 08 8048b9b: 8b 44 24 20 mov 0x20(%esp),%eax 8048b9f: 89 04 24 mov %eax,(%esp) //把使用者的輸入放入%esp 8048ba2: e8 03 05 00 00 call 80490aa <strings_not_equal> 8048ba7: 85 c0 test %eax,%eax //判斷eax是否為0 8048ba9: 74 05 je 8048bb0 <phase_1+0x20> //為0跳轉 8048bab: e8 05 06 00 00 call 80491b5 <explode_bomb> //不為0爆炸 8048bb0: 83 c4 1c add $0x1c,%esp 8048bb3: c3 ret
程式解讀：
- 取記憶體0x804a1e4處的內容
- 取使用者輸入的內容
- 比較兩者的值，相同則進入下一關，不相同則爆炸
獲取x804a1e4處的內容： p (char *) 0x804a1e4
可以看到，第一關的密碼為：Houses will begat jobs, jobs will begat houses.
phase_2
08048bb4 <phase_2>: //程式第一部分 8048bb4: 53 push %ebx 8048bb5: 83 ec 38 sub $0x38,%esp 8048bb8: 8d 44 24 18 lea 0x18(%esp),%eax 8048bbc: 89 44 24 04 mov %eax,0x4(%esp) 8048bc0: 8b 44 24 40 mov 0x40(%esp),%eax 8048bc4: 89 04 24 mov %eax,(%esp) 8048bc7: e8 10 06 00 00 call 80491dc <read_six_numbers> //讀入6個數字 8048bcc: 83 7c 24 18 00 cmpl $0x0,0x18(%esp) //判斷第一個數字是否為0 8048bd1: 79 22 jns 8048bf5 <phase_2+0x41> //如果不為0，則跳轉到8048bf5處 8048bd3: e8 dd 05 00 00 call 80491b5 <explode_bomb> //如果為0，爆炸！！！ 8048bd8: eb 1b jmp 8048bf5 <phase_2+0x41> //程式第二部分，此處是一個迴圈 8048bda: 89 d8 mov %ebx,%eax //%ebx的值賦值給%eax 8048bdc: 03 44 9c 14 add 0x14(%esp,%ebx,4),%eax //取了0x14+%esp+4*%ebx的值加上%eax的值，存到%eax中 8048be0: 39 44 9c 18 cmp %eax,0x18(%esp,%ebx,4) 8048be4: 74 05 je 8048beb <phase_2+0x37> 8048be6: e8 ca 05 00 00 call 80491b5 <explode_bomb> 8048beb: 83 c3 01 add $0x1,%ebx 8048bee: 83 fb 06 cmp $0x6,%ebx 8048bf1: 75 e7 jne 8048bda <phase_2+0x26> //程式第三部分 8048bf3: eb 07 jmp 8048bfc <phase_2+0x48> 8048bf5: bb 01 00 00 00 mov $0x1,%ebx //第一個數字不為0時跳轉到這裡來啦！！！ %ebx裡面存的是一個迴圈變數 8048bfa: eb de jmp 8048bda <phase_2+0x26> 8048bfc: 83 c4 38 add $0x38,%esp 8048bff: 5b pop %ebx 8048c00: c3 ret
程式分析：
- 通過對程式第一部分的分析，可以瞭解到是要輸入6個數字，且第一個數字不能為0；
- 第一個數字不為0時，跳轉到8048bf5處。此處設定了一個新的變數，並且初始化為1。然後跳轉到8048bda
- 0x14(%esp,%ebx,4)是比例變址定址方式，地址是 0x14+%esp+4*%ebx
- 然後比較%eax和0x18(%esp,%ebx,4)的運算元的值，如果相等的話，%eax的值++（迴圈變數++），如果不為6，則繼續迴圈，如果迴圈體中沒有explode_bomb的話，則會迴圈5次。
- 迴圈體如果沒有explode_bomb，則第二關破解。所以，關鍵是迴圈體8048be0處比較的是何處的值。實際比較的是後一個數字（0x18(%esp,%ebx,4)）是否等於 當前數字+迴圈變數（%eax）。
- 如果我們第一個輸入的數字是1，則第二關的密碼應該為 1 2(1+1) 4(2+2) 7(4+3) 1(7+4) 16(11+5) 即 1 2 4 7 11 16，答案不唯一，滿足這個規律即可，但是第一個數字不能為0.
phase_3
08048c01 <phase_3>:
8048c01: 83 ec 3c sub $0x3c,%esp
//輸入
8048c04: 8d 44 24 2c lea 0x2c(%esp),%eax
8048c08: 89 44 24 10 mov %eax,0x10(%esp)
8048c0c: 8d 44 24 27 lea 0x27(%esp),%eax
8048c10: 89 44 24 0c mov %eax,0xc(%esp)
8048c14: 8d 44 24 28 lea 0x28(%esp),%eax
8048c18: 89 44 24 08 mov %eax,0x8(%esp)
8048c1c: c7 44 24 04 3a a2 04 movl $0x804a23a,0x4(%esp) //取出入內容，這裡可以看出入的數值型別
8048c23: 08
8048c24: 8b 44 24 40 mov 0x40(%esp),%eax
8048c28: 89 04 24 mov %eax,(%esp)
8048c2b: e8 30 fc ff ff call 8048860 <[email protected]>
//輸入的第一個數字要大於2，小於等於7，否則爆炸
8048c30: 83 f8 02 cmp $0x2,%eax
8048c33: 7f 05 jg 8048c3a <phase_3+0x39>
8048c35: e8 7b 05 00 00 call 80491b5 <explode_bomb>
8048c3a: 83 7c 24 28 07 cmpl $0x7,0x28(%esp) //後者的值是輸入的第一個數字，假設輸入的第一個數字是5
8048c3f: 0f 87 fc 00 00 00 ja 8048d41 <phase_3+0x140>
8048c45: 8b 44 24 28 mov 0x28(%esp),%eax
//根據輸入的數值進行跳轉，這裡可以通過除錯，把所有可能的跳轉地址都輸出
8048c49: ff 24 85 60 a2 04 08 jmp *0x804a260(,%eax,4)
8048c50: b8 76 00 00 00 mov $0x76,%eax
8048c55: 81 7c 24 2c f1 00 00 cmpl $0xf1,0x2c(%esp)
8048c5c: 00
8048c5d: 0f 84 e8 00 00 00 je 8048d4b <phase_3+0x14a>
8048c63: e8 4d 05 00 00 call 80491b5 <explode_bomb>
8048c68: b8 76 00 00 00 mov $0x76,%eax
8048c6d: e9 d9 00 00 00 jmp 8048d4b <phase_3+0x14a>
8048c72: b8 69 00 00 00 mov $0x69,%eax
8048c77: 81 7c 24 2c aa 01 00 cmpl $0x1aa,0x2c(%esp)
8048c7e: 00
8048c7f: 0f 84 c6 00 00 00 je 8048d4b <phase_3+0x14a>
8048c85: e8 2b 05 00 00 call 80491b5 <explode_bomb>
8048c8a: b8 69 00 00 00 mov $0x69,%eax
8048c8f: e9 b7 00 00 00 jmp 8048d4b <phase_3+0x14a>
8048c94: b8 67 00 00 00 mov $0x67,%eax
8048c99: 81 7c 24 2c 15 03 00 cmpl $0x315,0x2c(%esp)
8048ca0: 00
8048ca1: 0f 84 a4 00 00 00 je 8048d4b <phase_3+0x14a>
8048ca7: e8 09 05 00 00 call 80491b5 <explode_bomb>
8048cac: b8 67 00 00 00 mov $0x67,%eax
8048cb1: e9 95 00 00 00 jmp 8048d4b <phase_3+0x14a>
8048cb6: b8 62 00 00 00 mov $0x62,%eax
8048cbb: 81 7c 24 2c fd 01 00 cmpl $0x1fd,0x2c(%esp)
8048cc2: 00
8048cc3: 0f 84 82 00 00 00 je 8048d4b <phase_3+0x14a>
8048cc9: e8 e7 04 00 00 call 80491b5 <explode_bomb>
8048cce: b8 62 00 00 00 mov $0x62,%eax
8048cd3: eb 76 jmp 8048d4b <phase_3+0x14a>
8048cd5: b8 74 00 00 00 mov $0x74,%eax
8048cda: 81 7c 24 2c 7b 02 00 cmpl $0x27b,0x2c(%esp)
8048ce1: 00
8048ce2: 74 67 je 8048d4b <phase_3+0x14a>
8048ce4: e8 cc 04 00 00 call 80491b5 <explode_bomb>
8048ce9: b8 74 00 00 00 mov $0x74,%eax
8048cee: eb 5b jmp 8048d4b <phase_3+0x14a>
8048cf0: b8 79 00 00 00 mov $0x79,%eax //第一數字是5的時候，跳轉到這裡來啦！！！！
8048cf5: 81 7c 24 2c 3a 01 00 cmpl $0x13a,0x2c(%esp) //判斷第二個數字的值是不是 0x13a,即十進位制的314
8048cfc: 00
8048cfd: 74 4c je 8048d4b <phase_3+0x14a>
8048cff: e8 b1 04 00 00 call 80491b5 <explode_bomb>
8048d04: b8 79 00 00 00 mov $0x79,%eax
8048d09: eb 40 jmp 8048d4b <phase_3+0x14a>
8048d0b: b8 70 00 00 00 mov $0x70,%eax
8048d10: 81 7c 24 2c cf 02 00 cmpl $0x2cf,0x2c(%esp)
8048d17: 00
8048d18: 74 31 je 8048d4b <phase_3+0x14a>
8048d1a: e8 96 04 00 00 call 80491b5 <explode_bomb>
8048d1f: b8 70 00 00 00 mov $0x70,%eax
8048d24: eb 25 jmp 8048d4b <phase_3+0x14a>
8048d26: b8 71 00 00 00 mov $0x71,%eax
8048d2b: 81 7c 24 2c 7b 01 00 cmpl $0x17b,0x2c(%esp)
8048d32: 00
8048d33: 74 16 je 8048d4b <phase_3+0x14a>
8048d35: e8 7b 04 00 00 call 80491b5 <explode_bomb>
8048d3a: b8 71 00 00 00 mov $0x71,%eax
8048d3f: eb 0a jmp 8048d4b <phase_3+0x14a>
8048d41: e8 6f 04 00 00 call 80491b5 <explode_bomb>
//如果第二個數字是314，就會跳轉到這裡來啦, 判斷輸入的字元是不是 0x65,即字母y
8048d46: b8 65 00 00 00 mov $0x65,%eax
8048d4b: 3a 44 24 27 cmp 0x27(%esp),%al
8048d4f: 74 05 je 8048d56 <phase_3+0x155>
8048d51: e8 5f 04 00 00 call 80491b5 <explode_bomb>
8048d56: 83 c4 3c add $0x3c,%esp
8048d59: c3 ret 程式分析：
- 檢視輸入的資料型別，可以看到輸入為 整型數值、字元、整型數值
(gdb) p (char*)0x804a23a
$16 = 0x804a23a "%d %c %d"- 檢視所有可能的跳轉地址，假設輸入的第一個數是5，則應該跳轉到的地址是 p/x *(0x804a274)的結果，即跳轉到 0x8048cf0
- 然後順著地址跳轉就行了，我通過的密碼是：5 y 314 解不唯一
phase_4
08048d5a <func4>:
8048d5a: 56 push %esi
8048d5b: 53 push %ebx
8048d5c: 83 ec 14 sub $0x14,%esp
8048d5f: 8b 54 24 20 mov 0x20(%esp),%edx
8048d63: 8b 44 24 24 mov 0x24(%esp),%eax
8048d67: 8b 5c 24 28 mov 0x28(%esp),%ebx
8048d6b: 89 d9 mov %ebx,%ecx
8048d6d: 29 c1 sub %eax(0),%ecx(14)
8048d6f: 89 ce mov %ecx,%esi
8048d71: c1 ee 1f shr $0x1f,%esi
8048d74: 01 f1 add %esi,%ecx
8048d76: d1 f9 sar %ecx
8048d78: 01 c1 add %eax,%ecx
8048d7a: 39 d1 cmp %edx,%ecx
8048d7c: 7e 17 jle 8048d95 <func4+0x3b> //不大於則轉移
8048d7e: 83 e9 01 sub $0x1,%ecx
8048d81: 89 4c 24 08 mov %ecx,0x8(%esp)
8048d85: 89 44 24 04 mov %eax,0x4(%esp)
8048d89: 89 14 24 mov %edx,(%esp)
8048d8c: e8 c9 ff ff ff call 8048d5a <func4>
8048d91: 01 c0 add %eax,%eax
8048d93: eb 20 jmp 8048db5 <func4+0x5b>
8048d95: b8 00 00 00 00 mov $0x0,%eax
8048d9a: 39 d1 cmp %edx,%ecx
8048d9c: 7d 17 jge 8048db5 <func4+0x5b>//大於或等於則轉移
8048d9e: 89 5c 24 08 mov %ebx,0x8(%esp)
8048da2: 83 c1 01 add $0x1,%ecx
8048da5: 89 4c 24 04 mov %ecx,0x4(%esp)
8048da9: 89 14 24 mov %edx,(%esp)
8048dac: e8 a9 ff ff ff call 8048d5a <func4>
8048db1: 8d 44 00 01 lea 0x1(%eax,%eax,1),%eax
8048db5: 83 c4 14 add $0x14,%esp
8048db8: 5b pop %ebx
8048db9: 5e pop %esi
8048dba: c3 ret
08048dbb <phase_4>:
8048dbb: 83 ec 2c sub $0x2c,%esp
//輸入兩個值
8048dbe: 8d 44 24 1c lea 0x1c(%esp),%eax
8048dc2: 89 44 24 0c mov %eax,0xc(%esp)
8048dc6: 8d 44 24 18 lea 0x18(%esp),%eax
8048dca: 89 44 24 08 mov %eax,0x8(%esp)
8048dce: c7 44 24 04 cf a3 04 movl $0x804a3cf,0x4(%esp)
8048dd5: 08
8048dd6: 8b 44 24 30 mov 0x30(%esp),%eax
8048dda: 89 04 24 mov %eax,(%esp)
//呼叫函式
8048ddd: e8 7e fa ff ff call 8048860 <[email protected]>
//比較返回值是否為2，不是2則爆炸
8048de2: 83 f8 02 cmp $0x2,%eax
8048de5: 75 07 jne 8048dee <phase_4+0x33>
//比較輸入的第一個數是否小於等於14，如果大於15則爆炸
8048de7: 83 7c 24 18 0e cmpl $0xe,0x18(%esp)
8048dec: 76 05 jbe 8048df3 <phase_4+0x38>
8048dee: e8 c2 03 00 00 call 80491b5 <explode_bomb>
//定義了兩個變數，值分別為14 0
8048df3: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
8048dfa: 00
8048dfb: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
8048e02: 00
8048e03: 8b 44 24 18 mov 0x18(%esp),%eax
8048e07: 89 04 24 mov %eax,(%esp)
//傳入引數，呼叫函式fun4，傳入的引數的順序，從左到右為：輸入的第一個數 0 14
8048e0a: e8 4b ff ff ff call 8048d5a <func4>
//判斷返回的值是否為7，不是7則爆炸
8048e0f: 83 f8 07 cmp $0x7,%eax
8048e12: 75 07 jne 8048e1b <phase_4+0x60>
//判斷輸入的第二個引數是否為7，不是則爆炸，所以可以確定第二個引數值為7
8048e14: 83 7c 24 1c 07 cmpl $0x7,0x1c(%esp)
8048e19: 74 05 je 8048e20 <phase_4+0x65>
8048e1b: e8 95 03 00 00 call 80491b5 <explode_bomb>
8048e20: 83 c4 2c add $0x2c,%esp
8048e23: c3 ret 第四關是遞迴，核心是要寫出遞迴函式。
我得到的遞迴函式是：
int func4(int a1, int a2, int a3)
{
int v3; // ecx
int result; // eax
v3 = a2 + (a3 - a2) / 2;
if ( v3 > a1 )
return 2 * func4(a1, a2, v3 - 1);
result = 0;
if ( v3 < a1 )
result = 2 * func4(a1, v3 + 1, a3) + 1;
return result;
}- 第一次呼叫fun4的時候，傳入的第二個引數值是0，第三個引數值是14
- 分析phase_4，可以知道只有fun4的返回值是7的時候，才能不爆炸
- 我們輸入的第一個數不大於14，所以嘗試求解，可以看到，當輸入14的時候，返回值為7，所以第四關的密碼是 14 7
phase_5
08048e24 <phase_5>:
8048e24: 53 push %ebx
8048e25: 83 ec 18 sub $0x18,%esp
8048e28: 8b 5c 24 20 mov 0x20(%esp),%ebx
8048e2c: 89 1c 24 mov %ebx,(%esp)
8048e2f: e8 57 02 00 00 call 804908b <string_length>
//輸入字串的長度不等於6，則爆炸
//所以輸入是長度為6的字串
8048e34: 83 f8 06 cmp $0x6,%eax
8048e37: 74 05 je 8048e3e <phase_5+0x1a>
8048e39: e8 77 03 00 00 call 80491b5 <explode_bomb>
8048e3e: ba 00 00 00 00 mov $0x0,%edx
8048e43: b8 00 00 00 00 mov $0x0,%eax
//這裡是一個迴圈
8048e48: 0f b6 0c 03 movzbl (%ebx,%eax,1),%ecx
//取低四位
8048e4c: 83 e1 0f and $0xf,%ecx //這裡是關鍵！！！
//相加
8048e4f: 03 14 8d 80 a2 04 08 add 0x804a280(,%ecx,4),%edx //這裡是關鍵！！！
8048e56: 83 c0 01 add $0x1,%eax
8048e59: 83 f8 06 cmp $0x6,%eax
8048e5c: 75 ea jne 8048e48 <phase_5+0x24>
//判斷%edx中的運算元是不是0x2b，即十進位制的43
8048e5e: 83 fa 2b cmp $0x2b,%edx
8048e61: 74 05 je 8048e68 <phase_5+0x44>
8048e63: e8 4d 03 00 00 call 80491b5 <explode_bomb>
8048e68: 83 c4 18 add $0x18,%esp
8048e6b: 5b pop %ebx
8048e6c: c3 ret 程式分析：
- 輸入一個長度為6的字串
- 經過一個迴圈操作
- 判斷某個變數的值是不是43，如果是43則通關
- 檢視一下0x804a280(,%ecx,4)的內容，%ecx依次取0 1 2 3 4 ....
- 43 = 10+10+10+10+1+2 = 0xa + 0xa + 0xa + 0xa + 0x1 + 0x2
- 0xa對應的%ecx中的值為1，所以只要 輸入的字元的二進位制表示&0f == 1 即可，例如a的ASCII碼的二進位制表示是01100001,01100001&0f =1
- 0x1對應的%ecx中的值為3, 01100011，對應的字元是c
- 0x1對應的%ecx中的值為0, 01110000，對應的字元是p
- 所以密碼之一是：aaaacp（答案不唯一）
phase_6
08048e6d <phase_6>:
8048e6d: 56 push %esi
8048e6e: 53 push %ebx
8048e6f: 83 ec 44 sub $0x44,%esp
8048e72: 8d 44 24 10 lea 0x10(%esp),%eax
8048e76: 89 44 24 04 mov %eax,0x4(%esp)
8048e7a: 8b 44 24 50 mov 0x50(%esp),%eax
8048e7e: 89 04 24 mov %eax,(%esp)
8048e81: e8 56 03 00 00 call 80491dc <read_six_numbers>
8048e86: be 00 00 00 00 mov $0x0,%esi
//這是第一個迴圈，第一個迴圈裡面還嵌入著一個小迴圈 這裡的條件是陣列中所有的元素都小於等於6，且不能存在兩個數相同。所以輸入的數字是1-6的排列組合之一
8048e8b: 8b 44 b4 10 mov 0x10(%esp,%esi,4),%eax
8048e8f: 83 e8 01 sub $0x1,%eax
8048e92: 83 f8 05 cmp $0x5,%eax
8048e95: 76 05 jbe 8048e9c <phase_6+0x2f> //%eax-1 <= 5則繼續，否則爆炸
8048e97: e8 19 03 00 00 call 80491b5 <explode_bomb> //爆炸
8048e9c: 83 c6 01 add $0x1,%esi //計數器加1，如果不等於6則迴圈
8048e9f: 83 fe 06 cmp $0x6,%esi
8048ea2: 75 07 jne 8048eab <phase_6+0x3e>
8048ea4: bb 00 00 00 00 mov $0x0,%ebx
8048ea9: eb 38 jmp 8048ee3 <phase_6+0x76> //此處是第一個大迴圈的出口
8048eab: 89 f3 mov %esi,%ebx
8048ead: 8b 44 9c 10 mov 0x10(%esp,%ebx,4),%eax //取陣列中的下一個值 小迴圈開始
8048eb1: 39 44 b4 0c cmp %eax,0xc(%esp,%esi,4) //進行了一次比較，列印看看值是多少
8048eb5: 75 05 jne 8048ebc <phase_6+0x4f>
8048eb7: e8 f9 02 00 00 call 80491b5 <explode_bomb>
8048ebc: 83 c3 01 add $0x1,%ebx
8048ebf: 83 fb 05 cmp $0x5,%ebx
8048ec2: 7e e9 jle 8048ead <phase_6+0x40> //小於等於則跳轉 小迴圈結束
8048ec4: eb c5 jmp 8048e8b <phase_6+0x1e>
//這是第二個迴圈
8048ec6: 8b 52 08 mov 0x8(%edx),%edx
8048ec9: 83 c0 01 add $0x1,%eax
8048ecc: 39 c8 cmp %ecx,%eax
8048ece: 75 f6 jne 8048ec6 <phase_6+0x59>
8048ed0: eb 05 jmp 8048ed7 <phase_6+0x6a>
8048ed2: ba 3c c1 04 08 mov $0x804c13c,%edx //這裡存的是一個地址值
8048ed7: 89 54 b4 28 mov %edx,0x28(%esp,%esi,4) //把地址傳給了一個結點
8048edb: 83 c3 01 add $0x1,%ebx //++
8048ede: 83 fb 06 cmp $0x6,%ebx
8048ee1: 74 17 je 8048efa <phase_6+0x8d> //
8048ee3: 89 de mov %ebx,%esi //從此處進入第二個迴圈，%ebx暫存器內的初始值是0
8048ee5: 8b 4c 9c 10 mov 0x10(%esp,%ebx,4),%ecx //取陣列中的第一個元素
8048ee9: 83 f9 01 cmp $0x1,%ecx
8048eec: 7e e4 jle 8048ed2 <phase_6+0x65> //小於等於1則跳轉
8048eee: b8 01 00 00 00 mov $0x1,%eax
8048ef3: ba 3c c1 04 08 mov $0x804c13c,%edx
8048ef8: eb cc jmp 8048ec6 <phase_6+0x59>
8048efa: 8b 5c 24 28 mov 0x28(%esp),%ebx
8048efe: 8d 44 24 2c lea 0x2c(%esp),%eax
8048f02: 8d 74 24 40 lea 0x40(%esp),%esi
8048f06: 89 d9 mov %ebx,%ecx
8048f08: 8b 10 mov (%eax),%edx //間接定址
8048f0a: 89 51 08 mov %edx,0x8(%ecx)
8048f0d: 83 c0 04 add $0x4,%eax
8048f10: 39 f0 cmp %esi,%eax
8048f12: 74 04 je 8048f18 <phase_6+0xab>
8048f14: 89 d1 mov %edx,%ecx
8048f16: eb f0 jmp 8048f08 <phase_6+0x9b>
8048f18: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
//這是第四個迴圈，前一個節點中的值要比後一個結點中的值大，從大到小排序
8048f1f: be 05 00 00 00 mov $0x5,%esi
8048f24: 8b 43 08 mov 0x8(%ebx),%eax
8048f27: 8b 00 mov (%eax),%eax
8048f29: 39 03 cmp %eax,(%ebx)
8048f2b: 7d 05 jge 8048f32 <phase_6+0xc5>
8048f2d: e8 83 02 00 00 call 80491b5 <explode_bomb>
8048f32: 8b 5b 08 mov 0x8(%ebx),%ebx
8048f35: 83 ee 01 sub $0x1,%esi
8048f38: 75 ea jne 8048f24 <phase_6+0xb7>
8048f3a: 83 c4 44 add $0x44,%esp
8048f3d: 5b pop %ebx
8048f3e: 5e pop %esi
8048f3f: c3 ret 程式分析：如下如，各節點儲存的值分別為：0x4d<1> 0x11a<2> 0x223<3> 0x3d9<4> 0x106<5> 0x202<6> ，然後由大到小排序：4 3 6 2 5 1
