bomblab

准备工作

首先我们将目标程序转换成汇编代码写入到bomb.txt方便查看
然后打开这个文件查看内容

phase_1

这里我们直接转换成伪c代码：

// 先将栈区减少8
esi = 0x402400;
strings_not_equal(rdi, rsi);
if (eax != 0) {explode_bomb();
}
return;
// 恢复栈区

我们可以看到他把0x402400传入到一个strings_not_equal的函数了，那么里面肯定判断的是两个字符串是否相等，不相等就爆炸。所以我们输出0x402400位置的字符串即可。

第一题答案即为Border relations with Canada have never been better.

phase_2

这里我们直接转换成伪c代码：

// stack init
rsi = rbp;
read_six_numbers();
if (*rsp != 1) {expoload_bomb();
}
rbx = rsp + 4;
rbp = rsp + 20;
400f17:
eax = *(rbx - 4);
eax = eax + eax;
if (*rbx != eax) {expload_bomb();
}
rbx += 4;
if (rbx != rbp) {jmp 400f17;
}
// stack init

首先我们在分析一下read_six_numbers():
我们发现esi中存的是0x4025c3，我们将这个内存地址指向的东西输出：

发现是六个数。
然后我们分析phase_2:
rbx是读入的第二个数，rbp是读入的最后一个数，首先我们判断读入的第一个数是否是1，如果不是爆炸，是的话我们比较后一项是否是前一项的两倍，如果不是也爆炸，所以最后我们得出的结果是：

一共六个数，读入的第一个数是1
每一个数是前面的数的两倍

即答案为1 2 4 8 16 32

phase_3

0000000000400f43 <phase_3>:400f43:       48 83 ec 18             sub    $0x18,%rsp400f47:       48 8d 4c 24 0c          lea    0xc(%rsp),%rcx400f4c:       48 8d 54 24 08          lea    0x8(%rsp),%rdx400f51:       be cf 25 40 00          mov    $0x4025cf,%esi400f56:       b8 00 00 00 00          mov    $0x0,%eax400f5b:       e8 90 fc ff ff          call   400bf0 <__isoc99_sscanf@plt>400f60:       83 f8 01                cmp    $0x1,%eax400f63:       7f 05                   jg     400f6a <phase_3+0x27>400f65:       e8 d0 04 00 00          call   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),%eax400f75:       ff 24 c5 70 24 40 00    jmp    *0x402470(,%rax,8)400f7c:       b8 cf 00 00 00          mov    $0xcf,%eax400f81:       eb 3b                   jmp    400fbe <phase_3+0x7b>400f83:       b8 c3 02 00 00          mov    $0x2c3,%eax400f88:       eb 34                   jmp    400fbe <phase_3+0x7b>400f8a:       b8 00 01 00 00          mov    $0x100,%eax400f8f:       eb 2d                   jmp    400fbe <phase_3+0x7b>400f91:       b8 85 01 00 00          mov    $0x185,%eax400f96:       eb 26                   jmp    400fbe <phase_3+0x7b>400f98:       b8 ce 00 00 00          mov    $0xce,%eax400f9d:       eb 1f                   jmp    400fbe <phase_3+0x7b>400f9f:       b8 aa 02 00 00          mov    $0x2aa,%eax400fa4:       eb 18                   jmp    400fbe <phase_3+0x7b>400fa6:       b8 47 01 00 00          mov    $0x147,%eax400fab:       eb 11                   jmp    400fbe <phase_3+0x7b>400fad:       e8 88 04 00 00          call   40143a <explode_bomb>400fb2:       b8 00 00 00 00          mov    $0x0,%eax400fb7:       eb 05                   jmp    400fbe <phase_3+0x7b>400fb9:       b8 37 01 00 00          mov    $0x137,%eax400fbe:       3b 44 24 0c             cmp    0xc(%rsp),%eax400fc2:       74 05                   je     400fc9 <phase_3+0x86>400fc4:       e8 71 04 00 00          call   40143a <explode_bomb>400fc9:       48 83 c4 18             add    $0x18,%rsp400fcd:       c3                      ret

这里我们直接转换成伪c代码：

// stack init
rcx = rsp + 12;
rdx = rsp + 8;
esi = 0x4025cf;
eax = 0;
__isoc99_sscanf@plt();
if (eax <= 1) {expload_bomb();
}
if (*(rsp + 8) > 7) {jmp 400fad;
}
eax = *(rsp + 8);
jmp *0x402470(, %rax, 8);
switch {case 0:eax = 0xcf;break;case 2:eax = 0x2c3;break;case 3:eax = 0x100;break;case 4:eax = 0x185;break;case 5:eax = 0xce;break;case 6:eax = 0x2aa;break;case 7:eax = 0x147;break;case 1:eax = 0x137;break;
}
400fad:
explode_bomb();
eax = 0;
if (eax != *(rsp + 12)) {explode_bomb();
}
// stack init

首先我们看一下esi中指向的内容，发现我们需要输入的应该是两个整数

其次，根据

  400f75:       ff 24 c5 70 24 40 00    jmp    *0x402470(,%rax,8)

我们可以知道这里应该是switch case 语句，所以我们需要去找每个跳转语句的条件，我们输出出来一一对应

发现如果我们输入的第一个数和eax的关系：

0  0xcf
1  0x137
2  0x2c3
3  0x100
4  0x185
5  0xce
6  0x2aa
7  0x147

所以我们要确保输入的第一个数和他得到的eax与输入的第二个数相同，即答案可以是

phase_4

0000000000400fce <func4>:400fce:       48 83 ec 08             sub    $0x8,%rsp400fd2:       89 d0                   mov    %edx,%eax400fd4:       29 f0                   sub    %esi,%eax400fd6:       89 c1                   mov    %eax,%ecx400fd8:       c1 e9 1f                shr    $0x1f,%ecx400fdb:       01 c8                   add    %ecx,%eax400fdd:       d1 f8                   sar    %eax400fdf:       8d 0c 30                lea    (%rax,%rsi,1),%ecx400fe2:       39 f9                   cmp    %edi,%ecx400fe4:       7e 0c                   jle    400ff2 <func4+0x24>400fe6:       8d 51 ff                lea    -0x1(%rcx),%edx400fe9:       e8 e0 ff ff ff          call   400fce <func4>400fee:       01 c0                   add    %eax,%eax400ff0:       eb 15                   jmp    401007 <func4+0x39>400ff2:       b8 00 00 00 00          mov    $0x0,%eax400ff7:       39 f9                   cmp    %edi,%ecx400ff9:       7d 0c                   jge    401007 <func4+0x39>400ffb:       8d 71 01                lea    0x1(%rcx),%esi400ffe:       e8 cb ff ff ff          call   400fce <func4>401003:       8d 44 00 01             lea    0x1(%rax,%rax,1),%eax401007:       48 83 c4 08             add    $0x8,%rsp40100b:       c3                      ret000000000040100c <phase_4>:40100c:       48 83 ec 18             sub    $0x18,%rsp401010:       48 8d 4c 24 0c          lea    0xc(%rsp),%rcx401015:       48 8d 54 24 08          lea    0x8(%rsp),%rdx40101a:       be cf 25 40 00          mov    $0x4025cf,%esi40101f:       b8 00 00 00 00          mov    $0x0,%eax401024:       e8 c7 fb ff ff          call   400bf0 <__isoc99_sscanf@plt>401029:       83 f8 02                cmp    $0x2,%eax40102c:       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>401035:       e8 00 04 00 00          call   40143a <explode_bomb>40103a:       ba 0e 00 00 00          mov    $0xe,%edx40103f:       be 00 00 00 00          mov    $0x0,%esi401044:       8b 7c 24 08             mov    0x8(%rsp),%edi401048:       e8 81 ff ff ff          call   400fce <func4>40104d:       85 c0                   test   %eax,%eax40104f:       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          call   40143a <explode_bomb>40105d:       48 83 c4 18             add    $0x18,%rsp401061:       c3                      ret

这里我们直接转换成伪c代码：

func4(rdi, rsi, rdx) {// stack initeax = edx;eax -= esi;eax = ecx;ecx >>= 31;eax += ecx;eax >>= 1;ecx = rax + rsi + 1;if (ecx <= edi) {jmp 400ff2;}edx = rcx - 1;func4(rdi, rsi, rdx)eax = eax + eax;jmp 401007;eax = 0;
400ff2:if (ecx >= edi) {jmp 4010007;}esi = rcx + 1;func4(rdi, rsi, rdx);eax = eax + eax + 1;
401007:// stack init
}phase_4(){//stack init rcx = rsp + 12;rdx = rsp + 8;esi = 0x4025cf;eax = 0;__isoc99_sscanf@plt();if (eax != 2) {expload_bomb();}else if (*(rsp + 8) > 14) {expload_bomb();}edx = 14;esi = 0;edi = *(rsp + 8);func4(rdi, rsi, rdx);if (eax != 0) {expload_bomb();}else if (*(rsp + 12) != 0) {expload_bomb();}// stack init
}

这里我们可以再化简下fun4()

func4(int val, int l, int r) {m = (r - l + (r - l) >> 31) >> 1; c = m + l;if (c < val) {return 2 * func4(val, l, m - 1) + 1;} else if (c > val) {return 2 * func4(val, l + 1, m);}else {return 0;}
}

我们可以看出fun4其实就是二分查找，那么对于phase_4，我们需要查找的是我们输入的第一个数，查找的左右边界为0，14，最后我们要得到的结果是eax为0，那么我们可以知道，最后找到的时候返回值为0，所以往上几层每一层都要是往左走，所以得到的答案可以是

phase_5

0000000000401062 <phase_5>:401062:       53                      push   %rbx401063:       48 83 ec 20             sub    $0x20,%rsp401067:       48 89 fb                mov    %rdi,%rbx40106a:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax401071:       00 00401073:       48 89 44 24 18          mov    %rax,0x18(%rsp)401078:       31 c0                   xor    %eax,%eax40107a:       e8 9c 02 00 00          call   40131b <string_length>40107f:       83 f8 06                cmp    $0x6,%eax401082:       74 4e                   je     4010d2 <phase_5+0x70>401084:       e8 b1 03 00 00          call   40143a <explode_bomb>401089:       eb 47                   jmp    4010d2 <phase_5+0x70>40108b:       0f b6 0c 03             movzbl (%rbx,%rax,1),%ecx40108f:       88 0c 24                mov    %cl,(%rsp)401092:       48 8b 14 24             mov    (%rsp),%rdx401096:       83 e2 0f                and    $0xf,%edx401099:       0f b6 92 b0 24 40 00    movzbl 0x4024b0(%rdx),%edx4010a0:       88 54 04 10             mov    %dl,0x10(%rsp,%rax,1)4010a4:       48 83 c0 01             add    $0x1,%rax4010a8:       48 83 f8 06             cmp    $0x6,%rax4010ac:       75 dd                   jne    40108b <phase_5+0x29>4010ae:       c6 44 24 16 00          movb   $0x0,0x16(%rsp)4010b3:       be 5e 24 40 00          mov    $0x40245e,%esi4010b8:       48 8d 7c 24 10          lea    0x10(%rsp),%rdi4010bd:       e8 76 02 00 00          call   401338 <strings_not_equal>4010c2:       85 c0                   test   %eax,%eax4010c4:       74 13                   je     4010d9 <phase_5+0x77>4010c6:       e8 6f 03 00 00          call   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,%eax4010d7:       eb b2                   jmp    40108b <phase_5+0x29>4010d9:       48 8b 44 24 18          mov    0x18(%rsp),%rax4010de:       64 48 33 04 25 28 00    xor    %fs:0x28,%rax4010e5:       00 004010e7:       74 05                   je     4010ee <phase_5+0x8c>4010e9:       e8 42 fa ff ff          call   400b30 <__stack_chk_fail@plt>4010ee:       48 83 c4 20             add    $0x20,%rsp4010f2:       5b                      pop    %rbx4010f3:       c3                      ret

这里我们直接转换成伪c代码：

// stack init
rbx = rdi;
rax = fs:0x28 (金丝雀值，这里可以看书上的定义)
*(rsp + 24) = rax;
eax ^= eax;
eax = string_length();
if (eax != 6) {expload_bomb();
}
jmp 4010d2;
40108b:
ecx = rax + rbx;
*rsp = cl;
rdx = *rsp;
edx &= 0xf;
edx = *(rdx + 0x4024b0);
*(rsp + rax + 16) = dl;
rax += 1;
if (rax != 6) {jmp 40108b;
}
*(rsp + 22) = 0;
esi = 0x40245e;
rdi = rsp + 16;
string_not_equal(rdi, rsi);
if (eax == 0) {jmp 4010d9;
}
explode_bomb();
jmp 4010d9;
4010d2:
eax = 0;
jmp 40108b;
4010d9:
rax = *(rsp + 24);
if (rax != fs:0x28) {__stack_chk_fail@plt();
} // 输入的字符串导致金丝雀值发生改变
// stack init

化简一下可以得到：

// stack init
rbx = rdi;
rax = fs:0x28 // 金丝雀值，这里可以看书上的定义
*(rsp + 24) = rax;
eax ^= eax;
eax = string_length();
if (eax != 6) {expload_bomb();
}
for (rax = 0; rax != 6; rax++) {ecx = rax + rbx; // rdi + rax*rsp = cl; // 取出字符rdx = *rsp; edx &= 0xf; // 把字符的ascii和0xf按位与edx = *(rdx + 0x4024b0); // *(rsp + rax + 16) = dl; // 将字符放到rsp + rax + 16的位置上
}
*(rsp + 22) = 0; // 字符串结尾
esi = 0x40245e;
rdi = rsp + 16;
string_not_equal(rdi, rsi); // 最后得到的rdi要和rsi相同
if (eax != 0) {explode_bomb();
}
rax = *(rsp + 24);
if (rax != fs:0x28) {__stack_chk_fail@plt();
} // 输入的字符串导致金丝雀值发生改变
// stack init

首先我们将rsi代表的字符串找出来：
然后我们将重心放到循环内部，我们可以看到就是取输入的字符串的每一个字符与0xf按位与后再放到栈中，后面要使得按位与后的字符组成的字符串为"flyers"，直接查阅ascii码，发现有很多答案，我们取其中一个即可。
答案：ionefg

phase_6

00000000004010f4 <phase_6>:4010f4: 41 56                   push   %r144010f6:  41 55                   push   %r134010f8:  41 54                   push   %r124010fa:  55                      push   %rbp4010fb:  53                      push   %rbx4010fc:  48 83 ec 50             sub    $0x50,%rsp401100:    49 89 e5                mov    %rsp,%r13401103: 48 89 e6                mov    %rsp,%rsi401106: e8 51 03 00 00          call   40145c <read_six_numbers>40110b:   49 89 e6                mov    %rsp,%r1440110e: 41 bc 00 00 00 00       mov    $0x0,%r12d401114:    4c 89 ed                mov    %r13,%rbp401117: 41 8b 45 00             mov    0x0(%r13),%eax40111b:    83 e8 01                sub    $0x1,%eax40111e: 83 f8 05                cmp    $0x5,%eax401121: 76 05                   jbe    401128 <phase_6+0x34>401123:  e8 12 03 00 00          call   40143a <explode_bomb>401128:   41 83 c4 01             add    $0x1,%r12d40112c:    41 83 fc 06             cmp    $0x6,%r12d401130:    74 21                   je     401153 <phase_6+0x5f>401132:  44 89 e3                mov    %r12d,%ebx401135:    48 63 c3                movslq %ebx,%rax401138: 8b 04 84                mov    (%rsp,%rax,4),%eax40113b:    39 45 00                cmp    %eax,0x0(%rbp)40113e:    75 05                   jne    401145 <phase_6+0x51>401140:  e8 f5 02 00 00          call   40143a <explode_bomb>401145:   83 c3 01                add    $0x1,%ebx401148: 83 fb 05                cmp    $0x5,%ebx40114b: 7e e8                   jle    401135 <phase_6+0x41>40114d:  49 83 c5 04             add    $0x4,%r13401151: eb c1                   jmp    401114 <phase_6+0x20>401153:  48 8d 74 24 18          lea    0x18(%rsp),%rsi401158:   4c 89 f0                mov    %r14,%rax40115b: b9 07 00 00 00          mov    $0x7,%ecx401160: 89 ca                   mov    %ecx,%edx401162: 2b 10                   sub    (%rax),%edx401164:   89 10                   mov    %edx,(%rax)401166:   48 83 c0 04             add    $0x4,%rax40116a: 48 39 f0                cmp    %rsi,%rax40116d: 75 f1                   jne    401160 <phase_6+0x6c>40116f:  be 00 00 00 00          mov    $0x0,%esi401174: eb 21                   jmp    401197 <phase_6+0xa3>401176:  48 8b 52 08             mov    0x8(%rdx),%rdx40117a:    83 c0 01                add    $0x1,%eax40117d: 39 c8                   cmp    %ecx,%eax40117f: 75 f5                   jne    401176 <phase_6+0x82>401181:  eb 05                   jmp    401188 <phase_6+0x94>401183:  ba d0 32 60 00          mov    $0x6032d0,%edx401188:    48 89 54 74 20          mov    %rdx,0x20(%rsp,%rsi,2)40118d:    48 83 c6 04             add    $0x4,%rsi401191: 48 83 fe 18             cmp    $0x18,%rsi401195:    74 14                   je     4011ab <phase_6+0xb7>401197:  8b 0c 34                mov    (%rsp,%rsi,1),%ecx40119a:    83 f9 01                cmp    $0x1,%ecx40119d: 7e e4                   jle    401183 <phase_6+0x8f>40119f:  b8 01 00 00 00          mov    $0x1,%eax4011a4: ba d0 32 60 00          mov    $0x6032d0,%edx4011a9:    eb cb                   jmp    401176 <phase_6+0x82>4011ab:  48 8b 5c 24 20          mov    0x20(%rsp),%rbx4011b0:   48 8d 44 24 28          lea    0x28(%rsp),%rax4011b5:   48 8d 74 24 50          lea    0x50(%rsp),%rsi4011ba:   48 89 d9                mov    %rbx,%rcx4011bd: 48 8b 10                mov    (%rax),%rdx4011c0:   48 89 51 08             mov    %rdx,0x8(%rcx)4011c4:    48 83 c0 08             add    $0x8,%rax4011c8: 48 39 f0                cmp    %rsi,%rax4011cb: 74 05                   je     4011d2 <phase_6+0xde>4011cd:  48 89 d1                mov    %rdx,%rcx4011d0: eb eb                   jmp    4011bd <phase_6+0xc9>4011d2:  48 c7 42 08 00 00 00    movq   $0x0,0x8(%rdx)4011d9:    00 4011da:  bd 05 00 00 00          mov    $0x5,%ebp4011df: 48 8b 43 08             mov    0x8(%rbx),%rax4011e3:    8b 00                   mov    (%rax),%eax4011e5:   39 03                   cmp    %eax,(%rbx)4011e7:   7d 05                   jge    4011ee <phase_6+0xfa>4011e9:  e8 4c 02 00 00          call   40143a <explode_bomb>4011ee:   48 8b 5b 08             mov    0x8(%rbx),%rbx4011f2:    83 ed 01                sub    $0x1,%ebp4011f5: 75 e8                   jne    4011df <phase_6+0xeb>4011f7:  48 83 c4 50             add    $0x50,%rsp4011fb:    5b                      pop    %rbx4011fc:  5d                      pop    %rbp4011fd:  41 5c                   pop    %r124011ff:  41 5d                   pop    %r13401201:  41 5e                   pop    %r14401203:  c3                      ret

我们先写出伪c代码：

phase_6(){// stack initr13 = rsp;rsi = rsp;read_six_numbers(rdi, rsi);r14 = rsp;for (r12d = 0; r12d != 6; r12d++) {rbp = r13;eax = *r13;eax -= 1;if (eax > 5) {explode_bomb();}for (ebx = r12d + 1; ebx <= 5; ebx++) {rax = ebx;eax = *(rsp + 4rax);if (*rbp == eax){explode_bomb();}      }r13 += 4;}// 这一个循环是判断每个数是否都小于6并且每个数都不能相等rsi = rsp + 24;rax = r14;ecx = 7;for (rax = r14; rax != rsi; rax += 4) {edx = ecx;edx -= *rax;*rax = edx;}// 这个循环是将每个数x都变为7 - xfor (rsi = 0; rsi != 24; rsi+=4) {ecx = *(rsp + rsi);edx = 0x6032d0;if(ecx > 1) {for (eax = 1; eax != ecx; eax++) {rdx = *(rdx+8); }}*(rsp + 2 * rsi + 32) = rdx;}// 这个循环是取每个数如果这个数大于1那么edx = edx + 8// 然后将得到的edx赋给内存的一块区域，可以看到区域的大小应该为8rbx = *(rsp + 32);// 这个就是第一个edx存放的地方rcx = rbx;for (rax = rsp + 40; rax != rsi + 80; rax += 8){rdx = *rax;*(rcx + 8) = rdx;rcx = rdx;}// 这个循环是将rbx+8的指向*rax*(rdx + 8) = 0;for (ebp = 5; ebp != 0; ebp--) {rax = *(rbx + 8);eax = *rax;if (eax < *rbx) {explode_bomb();}rbx = *(rbx + 8);}// 这个循环是在比较rbx + 8和rbx的大小，如果和位置相反则爆炸// stack init
}

再优化：

void phase_6(char* output)
{int array[6];ListNode* node_array[6];read_six_numbers(output, array);// 数字范围必须为1-6且互不重复for (int i = 0; i != 6; i++) {int num = array[i];num--;if ((unsigned int)num > 5)       // 最大为6explode_bomb();for (int j = i+1; j <= 5; j++) {if (array[i] == array[j])   // 每个元素都不重复explode_bomb();}}// 修改 arrayfor (int i = 0; i < 6; i ++) {array[i] = (7 - array[i]);}// 生成 node_arrayfor (int i = 0; i < 6; i ++) {int cur = array[i];ListNode* node = 0x6032d0;      // 链表headif (cur > 1) {for (int j = 1; j < cur; j++) {node = node->next;}}node_array[i] = node;}for (int i = 0; i < 5; i++) {node_array[i]->next = node_array[i+1];}ListNode* ptr = node_array[0];for (int i = 5; i > 0; i--) {if (ptr->val < ptr->next->val)explode_bomb();ptr = ptr->next;}
}

从这里看，从大到小应该是345612，我们要使得最后链表的值递减，所以应该输入432165，然后转换后为345612，将第三个安排在第一位，第四个安排在第二位…

CSAPP bomblab相关推荐

CSAPP lab2 经典的bomblab二次学习
csapp上的实验一直收到广泛好评,其中第二个实验bomblab则是一个学习C语言及其转化汇编指令的非常好的小项目,前段时间刚刚借鉴了很多教程完成了整个lab的6个小实验(还有一个secret pha ...
CSAPP深入理解计算机——bomblab（2018）
准备工作 1. 做该实验,务必已经看完了深入理解计算机系统的第三章节.了解常见c语言结构对应的汇编代码的常见形式. 2. 同时,请务必去卡梅隆大学课程官网,查看说明文件.下载gdb,一般ubuntu自 ...
堆栈图解CSAPP Bomb Lab实验解析
CSAPP Bomb Lab 实验解析 Bomblab是csapp的第二个配套实验,该实验提供了一个bomb二进制文件和一个bomb.c源文件,我们的目标是运行bomb并按照提示一步步输入字符串,直到 ...
CSAPP Lab2 实验记录 ---- Bomb Lab（Phase 1 - Phase 6详细解答 + Secret Phase彩蛋解析）
文章目录 Lab 总结博客链接实验前提引子实验需要指令及准备 Phase 1 Phase 2 Phase 3 Phase 4 Phase 5 Phase 6 Phase Secret(彩蛋Phas ...
国外计算机课程lab,计算机系统实验之bomblab
今天刚刚验收CSAPP实验3,趁着余温,记录一下这个实验,顺便回顾下CSAPP课程的相关知识. 实验目的 1.使用gdb工具反汇编出汇编代码,结合c语言文件找到每个关卡的入口函数.然后分析汇编代码,分 ...
csapp炸弹实验_bomb_lab详解
个人博客:sekyoro.top 之前图床挂了(没错是gitee),现在更新一下文章目录开始的准备 objdump与gdb常用命令 objdump gdb readelf 正式开始 initial ...
csapp 、sicp 、深入理解计算机系统、计算机程序的构造和解释
CSAPP 第一版的英文版深入理解计算机系统第一版中文版这个是csdn账号这里上传文件大小在10M以内这个pdf是19+M的深入理解计算机系统第二版的中文版下载第一版英文版的介绍原书 ...
CSAPP第五章就在“扯淡”！
"你的时间有限,所以不要为别人而活.不要被教条所限,不要活在别人的观念里.不要让别人的意见左右自己内心的声音.最重要的是,勇敢的去追随自己的心灵和直觉,只有自己的心灵和直觉才知道你自己的真实 ...
csapp:无符号数可能造成的程序bug
出自csapp练习2.26 size_t strlen(const char *s); int strloner(char *s,char *t) {return strlen(s)-strlen(t ...

CSAPP bomblab

bomblab

准备工作

phase_1

phase_2

phase_3

phase_4

phase_5

phase_6

CSAPP bomblab相关推荐

最新文章

热门文章