1. 实验内容

包含一个二进制应用bomb，需要根据该应用猜测程序的运行过程。程序主体包含了六个函数phase_1到phase_6，每个函数会根据用户的输入做出反应，当输入符合要求时，会炸弹拆解成功，进入到下一步，否则炸弹爆炸，打印"Boom!!!"并退出

2. 预置知识

二进制程序反汇编：objdump

gdb调试工具：gdb

寄存器信息（x86）：注意用于传递参数的rdi/rsi/rdx/rcx以及r8 r9，储存返回值的寄存器rax

3. 实验解答

main函数分析

  • if else的汇编实现：cmp+jne+jmp指令，cmp判断条件，jne进入下一个分支，jmp跳出if-else代码段
  • 函数调用的过程：
    • 在调用者中将函数参数传递到rdi rsi rdx rcx r8 r9等寄存器中
    • 调用callq进入函数
    • 在被调用函数中将需要使用的寄存器压栈，比如后文在phase_2函数中，先将rbp rbx压栈
    • 执行函数
    • 将压栈的寄存器弹出，恢复到初始状态
    • 返回，返回前会将函数的结果移动到寄存器rax中
  1. 0000000000400da0 <main>:
  2.   400da0:	53                   	push   %rbx #后面需要使用，所以将旧值压栈
  4.   // 对应读取文件的三个判断
  5.   // edi为函数的第一个参数，也就是main函数的输入
  6.   // edi = 1： stdin输入
  7.   // edi = 2： 从文件读入
  8.   // 其他：报错
  9.   # 第一种情况
  10.   400da1:	83 ff 01             	cmp    $0x1,%edi
  11.   400da4:	75 10                	jne    400db6 <main+0x16>
  12.   400da6:	48 8b 05 9b 29 20 00 	mov    0x20299b(%rip),%rax        # 603748 <stdin@@GLIBC_2.2.5>
  13.   400dad:	48 89 05 b4 29 20 00 	mov    %rax,0x2029b4(%rip)        # 603768 <infile>
  14.   400db4:	eb 63                	jmp    400e19 <main+0x79>
  16.   # 第二种情况
  17.   400db6:	48 89 f3             	mov    %rsi,%rbx
  18.   400db9:	83 ff 02             	cmp    $0x2,%edi
  19.   400dbc:	75 3a                	jne    400df8 <main+0x58>
  20.   400dbe:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
  21.   400dc2:	be b4 22 40 00       	mov    $0x4022b4,%esi
  22.   400dc7:	e8 44 fe ff ff       	callq  400c10 <fopen@plt>
  23.   400dcc:	48 89 05 95 29 20 00 	mov    %rax,0x202995(%rip)        # 603768 <infile>
  24.   400dd3:	48 85 c0             	test   %rax,%rax
  25.   400dd6:	75 41                	jne    400e19 <main+0x79>
  26.   400dd8:	48 8b 4b 08          	mov    0x8(%rbx),%rcx
  27.   400ddc:	48 8b 13             	mov    (%rbx),%rdx
  28.   400ddf:	be b6 22 40 00       	mov    $0x4022b6,%esi
  29.   400de4:	bf 01 00 00 00       	mov    $0x1,%edi
  30.   400de9:	e8 12 fe ff ff       	callq  400c00 <__printf_chk@plt>
  31.   400dee:	bf 08 00 00 00       	mov    $0x8,%edi
  32.   400df3:	e8 28 fe ff ff       	callq  400c20 <exit@plt>
  34.   # 第三种情况
  35.   400df8:	48 8b 16             	mov    (%rsi),%rdx
  36.   400dfb:	be d3 22 40 00       	mov    $0x4022d3,%esi
  37.   400e00:	bf 01 00 00 00       	mov    $0x1,%edi
  38.   400e05:	b8 00 00 00 00       	mov    $0x0,%eax
  39.   400e0a:	e8 f1 fd ff ff       	callq  400c00 <__printf_chk@plt>
  40.   400e0f:	bf 08 00 00 00       	mov    $0x8,%edi
  41.   400e14:	e8 07 fe ff ff       	callq  400c20 <exit@plt>
  43.   // 初始化bomb
  44.   400e19:	e8 84 05 00 00       	callq  4013a2 <initialize_bomb>
  46.   // 开始6个阶段的测试
  47.   # 输出两句问候
  48.   # 0x402338：Welcome to my fiendish little bomb. You have 6 phases with
  49.   # 0x402378：which to blow yourself up. Have a nice day!
  50.   # 函数调用的过程就是先将参数移动到rdi rsi等寄存器中，然后使用callq命令进入函数，函数的执行结果放到rax中
  52.   400e1e:	bf 38 23 40 00       	mov    $0x402338,%edi
  53.   400e23:	e8 e8 fc ff ff       	callq  400b10 <puts@plt>
  54.   400e28:	bf 78 23 40 00       	mov    $0x402378,%edi
  55.   400e2d:	e8 de fc ff ff       	callq  400b10 <puts@plt>
  57.   # phase_1
  58.   # 调用read_line函数，并将他的结果从rax移动到rdi中，作为下一个调用的函数的参数
  59.   400e32:	e8 67 06 00 00       	callq  40149e <read_line>
  60.   400e37:	48 89 c7             	mov    %rax,%rdi
  61.   400e3a:	e8 a1 00 00 00       	callq  400ee0 <phase_1>
  62.   400e3f:	e8 80 07 00 00       	callq  4015c4 <phase_defused>
  64.   # 输出字符串
  65.   400e44:	bf a8 23 40 00       	mov    $0x4023a8,%edi
  66.   400e49:	e8 c2 fc ff ff       	callq  400b10 <puts@plt>
  68.   # phase_2，同phase_1
  69.   400e4e:	e8 4b 06 00 00       	callq  40149e <read_line>
  70.   400e53:	48 89 c7             	mov    %rax,%rdi
  71.   400e56:	e8 a1 00 00 00       	callq  400efc <phase_2>
  72.   400e5b:	e8 64 07 00 00       	callq  4015c4 <phase_defused>
  74.   # phase_3
  75.   400e60:	bf ed 22 40 00       	mov    $0x4022ed,%edi
  76.   400e65:	e8 a6 fc ff ff       	callq  400b10 <puts@plt>
  77.   400e6a:	e8 2f 06 00 00       	callq  40149e <read_line>
  78.   400e6f:	48 89 c7             	mov    %rax,%rdi
  79.   400e72:	e8 cc 00 00 00       	callq  400f43 <phase_3>
  80.   400e77:	e8 48 07 00 00       	callq  4015c4 <phase_defused>
  82.   # phase_4
  83.   400e7c:	bf 0b 23 40 00       	mov    $0x40230b,%edi
  84.   400e81:	e8 8a fc ff ff       	callq  400b10 <puts@plt>
  85.   400e86:	e8 13 06 00 00       	callq  40149e <read_line>
  86.   400e8b:	48 89 c7             	mov    %rax,%rdi
  87.   400e8e:	e8 79 01 00 00       	callq  40100c <phase_4>
  88.   400e93:	e8 2c 07 00 00       	callq  4015c4 <phase_defused>
  90.   # phase_5
  91.   400e98:	bf d8 23 40 00       	mov    $0x4023d8,%edi
  92.   400e9d:	e8 6e fc ff ff       	callq  400b10 <puts@plt>
  93.   400ea2:	e8 f7 05 00 00       	callq  40149e <read_line>
  94.   400ea7:	48 89 c7             	mov    %rax,%rdi
  95.   400eaa:	e8 b3 01 00 00       	callq  401062 <phase_5>
  96.   400eaf:	e8 10 07 00 00       	callq  4015c4 <phase_defused>
  98.   # phase_6
  99.   400eb4:	bf 1a 23 40 00       	mov    $0x40231a,%edi
  100.   400eb9:	e8 52 fc ff ff       	callq  400b10 <puts@plt>
  101.   400ebe:	e8 db 05 00 00       	callq  40149e <read_line>
  102.   400ec3:	48 89 c7             	mov    %rax,%rdi
  103.   400ec6:	e8 29 02 00 00       	callq  4010f4 <phase_6>
  104.   400ecb:	e8 f4 06 00 00       	callq  4015c4 <phase_defused>
  106.   # 正常退出，main函数返回0,也就是将0存到rax寄存器中
  107.   400ed0:	b8 00 00 00 00       	mov    $0x0,%eax
  108.   400ed5:	5b                   	pop    %rbx
  109.   400ed6:	c3                   	retq
  110.   400ed7:	90                   	nop
  111.   400ed8:	90                   	nop
  112.   400ed9:	90                   	nop
  113.   400eda:	90                   	nop
  114.   400edb:	90                   	nop
  115.   400edc:	90                   	nop
  116.   400edd:	90                   	nop
  117.   400ede:	90                   	nop
  118.   400edf:	90                   	nop

phase_1

phase_1比较简单，中间只涉及一个string_not_equal函数，用户输入的内容input被放在了rdi寄存器中了（main函数的分析），然后将0x402400中的内容放到了第二个参数寄存器esi，那么说明这里面就是正确答案。使用print (char*)0x402400即可查看到，内容是Border relations with Canada have never been better.

指令:

  • test：对两个数做AND操作，当与操作的结果为0，将ZF置1
  • je：相当于jz，看ZF标志位，当ZF为0时跳转
  1. 0000000000400ee0 <phase_1>:
  2.   400ee0:	48 83 ec 08          	sub    $0x8,%rsp
  3.   400ee4:	be 00 24 40 00       	mov    $0x402400,%esi
  4.   400ee9:	e8 4a 04 00 00       	callq  401338 <strings_not_equal>
  5.   400eee:	85 c0                	test   %eax,%eax
  6.   400ef0:	74 05                	je     400ef7 <phase_1+0x17>
  7.   400ef2:	e8 43 05 00 00       	callq  40143a <explode_bomb>
  8.   400ef7:	48 83 c4 08          	add    $0x8,%rsp
  9.   400efb:	c3                   	retq

phase_2

根据代码可知，phase_2中先将输入的字符串解析成为6个数字，然后使用循环判断它是不是1 2 4 6 8 16

问题：

为什么要在栈中分配40个字节作为read_six_numbers的返回值？

  1. 0000000000400efc <phase_2>:
  3.   # 后面要用到rbp rbx寄存器，先压栈
  4.   400efc:	55                   	push   %rbp
  5.   400efd:	53                   	push   %rbx
  7.   # 可以看出栈指针被当做第二个参数传递给了read_six_numbers函数，此处的28为十六进制数，
  8.   400efe:	48 83 ec 28          	sub    $0x28,%rsp
  9.   400f02:	48 89 e6             	mov    %rsp,%rsi
  10.   400f05:	e8 52 05 00 00       	callq  40145c <read_six_numbers>
  12.   # cmp + je + jmp，典型的if-else结构
  13.   # 首先是将rsp中的值和1比，不相等时炸弹爆炸，说明存储的数字序列中第一个为1
  15.   400f0a:	83 3c 24 01          	cmpl   $0x1,(%rsp)
  16.   400f0e:	74 20                	je     400f30 <phase_2+0x34>
  17.   400f10:	e8 25 05 00 00       	callq  40143a <explode_bomb>
  18.   400f15:	eb 19                	jmp    400f30 <phase_2+0x34>
  20.   # 循环逻辑
  21.   400f17:	8b 43 fc             	mov    -0x4(%rbx),%eax # rbx对应array[i]，eax对应array[i-1]
  22.   400f1a:	01 c0                	add    %eax,%eax  # 对应2*array[i-1]
  23.   400f1c:	39 03                	cmp    %eax,(%rbx) # 2*array[i-1] == array[i]?
  24.   400f1e:	74 05                	je     400f25 <phase_2+0x29>
  25.   400f20:	e8 15 05 00 00       	callq  40143a <explode_bomb>
  27.   # 循环边界的判断
  28.   400f25:	48 83 c3 04          	add    $0x4,%rbx
  29.   400f29:	48 39 eb             	cmp    %rbp,%rbx
  30.   400f2c:	75 e9                	jne    400f17 <phase_2+0x1b>
  31.   400f2e:	eb 0c                	jmp    400f3c <phase_2+0x40>
  33.   # 循环初始化，rbp充当end的角色，rbx为循环的变量，18对应十进制为24，刚好6个数字，说明该序列包含了6个数
  34.   400f30:	48 8d 5c 24 04       	lea    0x4(%rsp),%rbx
  35.   400f35:	48 8d 6c 24 18       	lea    0x18(%rsp),%rbp
  36.   400f3a:	eb db                	jmp    400f17 <phase_2+0x1b>
  38.   # 恢复初始状态，read_six_numbers的结果也丢失了
  39.   400f3c:	48 83 c4 28          	add    $0x28,%rsp
  40.   400f40:	5b                   	pop    %rbx
  41.   400f41:	5d                   	pop    %rbp
  42.   400f42:	c3                   	retq

进一步分析read_six_numbers函数：

看不懂了。。。。。反正就是调用了ssacnf函数，第二个参数时一个字符串"%d %d %d %d %d %d"

  1. // 用于传递参数的rdi/rsi/rdx/rcx以及r8 r9，储存返回值的寄存器rax
  2. 000000000040145c <read_six_numbers>:
  3.   40145c:	48 83 ec 18          	sub    $0x18,%rsp
  5.   # rdi中装的是input字符串，rsi装的是rsp栈指针
  6.   # rsi: rsp
  7.   # rdx: rsp
  8.   # rcx: rsp + 4
  9.   # r8:  rsp + 12
  10.   # r9:	 rsp + 8
  11.   # rsp + 8: rsp + 20
  13.   401460:	48 89 f2             	mov    %rsi,%rdx
  14.   401463:	48 8d 4e 04          	lea    0x4(%rsi),%rcx
  15.   401467:	48 8d 46 14          	lea    0x14(%rsi),%rax
  16.   40146b:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  17.   401470:	48 8d 46 10          	lea    0x10(%rsi),%rax
  18.   401474:	48 89 04 24          	mov    %rax,(%rsp)
  19.   401478:	4c 8d 4e 0c          	lea    0xc(%rsi),%r9
  20.   40147c:	4c 8d 46 08          	lea    0x8(%rsi),%r8
  22.   401480:	be c3 25 40 00       	mov    $0x4025c3,%esi
  23.   401485:	b8 00 00 00 00       	mov    $0x0,%eax
  24.   40148a:	e8 61 f7 ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  25.   40148f:	83 f8 05             	cmp    $0x5,%eax
  26.   401492:	7f 05                	jg     401499 <read_six_numbers+0x3d>
  27.   401494:	e8 a1 ff ff ff       	callq  40143a <explode_bomb>
  28.   401499:	48 83 c4 18          	add    $0x18,%rsp
  29.   40149d:	c3                   	retq

phase_3

依然是scanf+判断，第一个数字被放进rsp+8,第二个被放进rsp+12，这里出现了switch，注意jmpq的用法。最后的答案应该是：

0 0xcf, 1 0xc3, 2 0x100...

  1. 0000000000400f43 <phase_3>:
  2.   # 在栈上开辟出24个字节的空间，依然是调用sscanf函数
  3.   400f43:	48 83 ec 18          	sub    $0x18,%rsp
  4.   400f47:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
  5.   400f4c:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
  6.   400f51:	be cf 25 40 00       	mov    $0x4025cf,%esi
  7.   400f56:	b8 00 00 00 00       	mov    $0x0,%eax
  8.   400f5b:	e8 90 fc ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  9.   400f60:	83 f8 01             	cmp    $0x1,%eax
  10.   400f63:	7f 05                	jg     400f6a <phase_3+0x27> # eax < 1会跳转，成功
  12.   400f65:	e8 d0 04 00 00       	callq  40143a <explode_bomb>
  14.   400f6a:	83 7c 24 08 07       	cmpl   $0x7,0x8(%rsp) # rsp+8 < 7会跳转，失败
  15.   400f6f:	77 3c                	ja     400fad <phase_3+0x6a>
  17.   400f71:	8b 44 24 08          	mov    0x8(%rsp),%eax
  19.   # 这相当于一个switch指令，跳转表的基地址为0x402470，每个单元的长度为8,按rax的值进行下标访问
  20.   # 不过也能猜到从400f7c就是我们要的
  21.   # (gdb) x/8a0x402470
  22.   #  0x402470:       0x400f7c <phase_3+57>   0x400fb9 <phase_3+118>
  23.   #  0x402480:       0x400f83 <phase_3+64>   0x400f8a <phase_3+71>
  24.   #  0x402490:       0x400f91 <phase_3+78>   0x400f98 <phase_3+85>
  25.   #  0x4024a0:       0x400f9f <phase_3+92>   0x400fa6 <phase_3+99>
  27.   400f75:	ff 24 c5 70 24 40 00 	jmpq   *0x402470(,%rax,8) 
  29.   400f7c:	b8 cf 00 00 00       	mov    $0xcf,%eax
  30.   400f81:	eb 3b                	jmp    400fbe <phase_3+0x7b>
  31.   400f83:	b8 c3 02 00 00       	mov    $0x2c3,%eax
  32.   400f88:	eb 34                	jmp    400fbe <phase_3+0x7b>
  33.   400f8a:	b8 00 01 00 00       	mov    $0x100,%eax
  34.   400f8f:	eb 2d                	jmp    400fbe <phase_3+0x7b>
  35.   400f91:	b8 85 01 00 00       	mov    $0x185,%eax
  36.   400f96:	eb 26                	jmp    400fbe <phase_3+0x7b>
  37.   400f98:	b8 ce 00 00 00       	mov    $0xce,%eax
  38.   400f9d:	eb 1f                	jmp    400fbe <phase_3+0x7b>
  39.   400f9f:	b8 aa 02 00 00       	mov    $0x2aa,%eax
  40.   400fa4:	eb 18                	jmp    400fbe <phase_3+0x7b>
  41.   400fa6:	b8 47 01 00 00       	mov    $0x147,%eax
  42.   400fab:	eb 11                	jmp    400fbe <phase_3+0x7b>
  44.   400fad:	e8 88 04 00 00       	callq  40143a <explode_bomb>
  45.   400fb2:	b8 00 00 00 00       	mov    $0x0,%eax
  46.   400fb7:	eb 05                	jmp    400fbe <phase_3+0x7b>
  47.   400fb9:	b8 37 01 00 00       	mov    $0x137,%eax
  49.   # rsp+12刚好是第二个数
  50.   400fbe:	3b 44 24 0c          	cmp    0xc(%rsp),%eax
  51.   400fc2:	74 05                	je     400fc9 <phase_3+0x86>
  52.   400fc4:	e8 71 04 00 00       	callq  40143a <explode_bomb>
  54.   400fc9:	48 83 c4 18          	add    $0x18,%rsp
  55.   400fcd:	c3                   	retq

phase_4

  1. 000000000040100c <phase_4>:
  2. # 依然是sscanf函数
  3. # 字符串格式为：%d %d，说明解析出来的是两个整数
  4.   40100c:	48 83 ec 18          	sub    $0x18,%rsp
  5.   401010:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
  6.   401015:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
  7.   40101a:	be cf 25 40 00       	mov    $0x4025cf,%esi
  8.   40101f:	b8 00 00 00 00       	mov    $0x0,%eax
  9.   401024:	e8 c7 fb ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  10.   401029:	83 f8 02             	cmp    $0x2,%eax
  11.   40102c:	75 07                	jne    401035 <phase_4+0x29>  # 再次印证应该是两个数
  13.   40102e:	83 7c 24 08 0e       	cmpl   $0xe,0x8(%rsp)
  14.   401033:	76 05                	jbe    40103a <phase_4+0x2e> # 小于或者等于时跳转，rsp + 8 < 14，否则会爆炸
  16.   401035:	e8 00 04 00 00       	callq  40143a <explode_bomb>
  18.   # 用于传递参数的rdi/rsi/rdx/rcx以及r8 r9，储存返回值的寄存器rax
  19.   # func4(rsp + 8, 0x0, 0xe)
  20.   # 第一个数只能根据func4获得
  21.   40103a:	ba 0e 00 00 00       	mov    $0xe,%edx
  22.   40103f:	be 00 00 00 00       	mov    $0x0,%esi
  23.   401044:	8b 7c 24 08          	mov    0x8(%rsp),%edi
  24.   401048:	e8 81 ff ff ff       	callq  400fce <func4>
  25.   40104d:	85 c0                	test   %eax,%eax
  26.   40104f:	75 07                	jne    401058 <phase_4+0x4c>
  28.   401051:	83 7c 24 0c 00       	cmpl   $0x0,0xc(%rsp) # 关于第二个数，等于0的时候正常，说明第二个数是0
  29.   401056:	74 05                	je     40105d <phase_4+0x51>
  30.   401058:	e8 dd 03 00 00       	callq  40143a <explode_bomb>
  31.   40105d:	48 83 c4 18          	add    $0x18,%rsp
  32.   401061:	c3                   	retq

恶心。。。。竟然有一个递归函数

  • 递归函数的汇编写法
  • 注意寻址方式，见课本p121
  • lea的用法：将有效地址写入到寄存器，以lea (%rax,%rsi,1),%ecx为例，(%rax,%rsi,1)是一个比例变址寻址，表示MM[%rax + %rsi * 1]
  • 注意AT&T汇编的格式

根据汇编改写的递归程序可知，0~7都是答案

  1. # func4(x, y, z)
  2. 0000000000400fce <func4>:
  4.   400fce:	48 83 ec 08          	sub    $0x8,%rsp
  6.   400fd2:	89 d0                	mov    %edx,%eax
  7.   400fd4:	29 f0                	sub    %esi,%eax
  8.   400fd6:	89 c1                	mov    %eax,%ecx
  10.   400fd8:	c1 e9 1f             	shr    $0x1f,%ecx
  11.   400fdb:	01 c8                	add    %ecx,%eax
  12.   400fdd:	d1 f8                	sar    %eax 
  14.   400fdf:	8d 0c 30             	lea    (%rax,%rsi,1),%ecx
  16.   400fe2:	39 f9                	cmp    %edi,%ecx
  17.   400fe4:	7e 0c                	jle    400ff2 <func4+0x24>
  18.   400fe6:	8d 51 ff             	lea    -0x1(%rcx),%edx
  19.   400fe9:	e8 e0 ff ff ff       	callq  400fce <func4>
  20.   400fee:	01 c0                	add    %eax,%eax
  21.   400ff0:	eb 15                	jmp    401007 <func4+0x39>
  23.   400ff2:	b8 00 00 00 00       	mov    $0x0,%eax
  24.   400ff7:	39 f9                	cmp    %edi,%ecx
  25.   400ff9:	7d 0c                	jge    401007 <func4+0x39>
  26.   400ffb:	8d 71 01             	lea    0x1(%rcx),%esi
  27.   400ffe:	e8 cb ff ff ff       	callq  400fce <func4>
  28.   401003:	8d 44 00 01          	lea    0x1(%rax,%rax,1),%eax
  29.   401007:	48 83 c4 08          	add    $0x8,%rsp
  30.   40100b:	c3                   	retq

y = 0, z = 14

mid = (y + z) / 2;

if(x <= mid) {

​ if(z >= x) {

​ return 0;

​ } else {

​ y = mid + 1;

​ return 2*func(x, y, z) + 1;

​ }

} else {

​ z = mid-1;

​ return 2*func(x, y, z);

}

edx: z, esi: y, edi: x, eax: tmp1, ecx: tmp2

phase_5

  1. # 用于传递参数的rdi/rsi/rdx/rcx以及r8 r9，储存返回值的寄存器rax
  2. 0000000000401062 <phase_5>:
  3.   401062:	53                   	push   %rbx
  5.   401063:	48 83 ec 20          	sub    $0x20,%rsp
  6.   401067:	48 89 fb             	mov    %rdi,%rbx
  7.   40106a:	64 48 8b 04 25 28 00 	mov    %fs:0x28,%rax
  8.   401071:	00 00
  9.   401073:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
  10.   401078:	31 c0                	xor    %eax,%eax
  12.  # eax = 0，计算字符串的长度
  13.   40107a:	e8 9c 02 00 00       	callq  40131b <string_length>
  14.   40107f:	83 f8 06             	cmp    $0x6,%eax
  15.   401082:	74 4e                	je     4010d2 <phase_5+0x70> # 说明字符串的长度必须是6
  16.   401084:	e8 b1 03 00 00       	callq  40143a <explode_bomb>
  17.   401089:	eb 47                	jmp    4010d2 <phase_5+0x70>
  19.   40108b:	0f b6 0c 03          	movzbl (%rbx,%rax,1),%ecx # ch[i]，将第一个字符取出来
  20.   40108f:	88 0c 24             	mov    %cl,(%rsp)
  21.   401092:	48 8b 14 24          	mov    (%rsp),%rdx # 将ch[i]放到rdx中
  23.   401096:	83 e2 0f             	and    $0xf,%edx  # 取低4位，可以忽略
  25.   #"maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"
  26.   #str
  27.   # rsp空出了20个字节，
  28.   401099:	0f b6 92 b0 24 40 00 	movzbl 0x4024b0(%rdx),%edx # str[ch[i]]的内容放到edx中，类似于整数数组
  29.   4010a0:	88 54 04 10          	mov    %dl,0x10(%rsp,%rax,1) # rdx，将上一个内容放到(rsp + i + 0x10)
  31.   4010a4:	48 83 c0 01          	add    $0x1,%rax
  32.   4010a8:	48 83 f8 06          	cmp    $0x6,%rax # 循环
  34.   4010ac:	75 dd                	jne    40108b <phase_5+0x29>
  36.   4010ae:	c6 44 24 16 00       	movb   $0x0,0x16(%rsp) # 在创建的字符串那加一个结束符，我们的新字符串是从rsp+10~rsp+16
  38.   4010b3:	be 5e 24 40 00       	mov    $0x40245e,%esi # "flyers"，比较函数的第二个参数
  39.   4010b8:	48 8d 7c 24 10       	lea    0x10(%rsp),%rdi #比较函数的第一个参数，也就是新创建的字符串的首地址
  41.   # maduiersnfotvbyl
  42.   # 9 15 14 5 6 7 --> char
  43.   # 9 f e 5 6 7 （0x-7x）
  44.   # 9: 水平制表符 结束符 ) 9 I Y i y
  45.   # f: shift 单元分隔符 / ? O _ o DEL(Delete)
  46.   # e: SO(Shift Out) RS(Record Separator) . > N ^ n ~
  47.   # 5:   % 	5 E U e u
  48.   # 6:   &  6 F V f v
  49.   # 7:   '  7 G W g w
  51.   4010bd:	e8 76 02 00 00       	callq  401338 <strings_not_equal>
  52.   4010c2:	85 c0                	test   %eax,%eax
  53.   4010c4:	74 13                	je     4010d9 <phase_5+0x77>
  55.   4010c6:	e8 6f 03 00 00       	callq  40143a <explode_bomb>
  56.   4010cb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  57.   4010d0:	eb 07                	jmp    4010d9 <phase_5+0x77>
  58.   4010d2:	b8 00 00 00 00       	mov    $0x0,%eax
  59.   4010d7:	eb b2                	jmp    40108b <phase_5+0x29>
  61.   4010d9:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  62.   4010de:	64 48 33 04 25 28 00 	xor    %fs:0x28,%rax
  63.   4010e5:	00 00
  64.   4010e7:	74 05                	je     4010ee <phase_5+0x8c>
  65.   4010e9:	e8 42 fa ff ff       	callq  400b30 <__stack_chk_fail@plt>
  66.   4010ee:	48 83 c4 20          	add    $0x20,%rsp
  67.   4010f2:	5b                   	pop    %rbx
  68.   4010f3:	c3                   	retq

phase_6

第一段：读6个数字，没什么可说，结果存在rsp到rsp+4*5(rsp+0x14)

  1. 00000000004010f4 <phase_6>:
  2.   4010f4:	41 56                	push   %r14
  3.   4010f6:	41 55                	push   %r13
  4.   4010f8:	41 54                	push   %r12
  5.   4010fa:	55                   	push   %rbp
  6.   4010fb:	53                   	push   %rbx
  7.   4010fc:	48 83 ec 50          	sub    $0x50,%rsp
  8.   401100:	49 89 e5             	mov    %rsp,%r13
  9.   401103:	48 89 e6             	mov    %rsp,%rsi
  10.   401106:	e8 51 03 00 00       	callq  40145c <read_six_numbers>

第二段：注意到循环的翻译方式，这一段包含了两个循环。按顺序阅读，在401128到401130的自增+cmp+跳转，可以确定是循环的边界判断，r12d为一个循环的标志变量，看跳转的401153，直接进入到下一个流程，而401151直接跳转到401114，可以确定这是一个while循环，guard-done的翻译方式。

401114到401123包含了一个访存和判断，如果将r12d认为是循环变量i，rsp中存的数组记作array[],那这一块的代码框架为：

  1. int i = 0;
  2. while(1) {
  3. 	int a = array[i];
  4.     if(a - 1 <= 5) bomb();
  5.     i = i + 1;
  6.     if(i == 6) break;
  7.     ...
  8. }

其中array[i]这一步其实是通过r13实现的，在外层循环中会对r13加4的操作，说明了数组中存放的是int型数据

看内层循环的边界判断401145到40114b，说明ebx存放的是内层的循环变量j，401132是j的初始化代码，初始值为i。401135到401140为内层循环的主体，401138读取了array[j]，然后和a[i]比较，如果相等会爆炸。这样循环代码的框架可以被写成：

  1. int i = 0;
  2. while(1) {
  3. 	int a = array[i];
  4.     if(a - 1 <= 5) bomb();
  5.     i = i + 1;
  6.     if(i == 6) break;
  7.     int j = i;
  8.     for(int j = i; j + 1 <= 5; j++) { // 有点奇怪
  9.         if(array[j] == a) bomb();
  10.     }
  11. }
  1.   40110b:	49 89 e6             	mov    %rsp,%r14
  2.   40110e:	41 bc 00 00 00 00    	mov    $0x0,%r12d
  4.   401114:	4c 89 ed             	mov    %r13,%rbp
  5.   401117:	41 8b 45 00          	mov    0x0(%r13),%eax
  6.   40111b:	83 e8 01             	sub    $0x1,%eax
  7.   40111e:	83 f8 05             	cmp    $0x5,%eax
  8.   401121:	76 05                	jbe    401128 <phase_6+0x34>
  9.   401123:	e8 12 03 00 00       	callq  40143a <explode_bomb> # 一个退出
  11.   401128:	41 83 c4 01          	add    $0x1,%r12d
  12.   40112c:	41 83 fc 06          	cmp    $0x6,%r12d
  13.   401130:	74 21                	je     401153 <phase_6+0x5f> # 这个地方的自增+cmp+跳转，可以确定是循环的边界判断，r12d为一个循环的标志变量
  15.   401132:	44 89 e3             	mov    %r12d,%ebx
  17.   401135:	48 63 c3             	movslq %ebx,%rax
  18.   401138:	8b 04 84             	mov    (%rsp,%rax,4),%eax
  19.   40113b:	39 45 00             	cmp    %eax,0x0(%rbp)
  20.   40113e:	75 05                	jne    401145 <phase_6+0x51>
  21.   401140:	e8 f5 02 00 00       	callq  40143a <explode_bomb>
  23.   401145:	83 c3 01             	add    $0x1,%ebx
  24.   401148:	83 fb 05             	cmp    $0x5,%ebx
  25.   40114b:	7e e8                	jle    401135 <phase_6+0x41>
  27.   40114d:	49 83 c5 04          	add    $0x4,%r13
  28.   401151:	eb c1                	jmp    401114 <phase_6+0x20>

因此第二段的功能就是判断array[i]中每个数小于或者等于6，并且后一个和前一个不相等。

第三段：依然是一个循环，rsp+18为array最后一个元素结尾的位置，可以认为是array的end，r14为array的初始地址。循环的主体就三句话，功能是array[i] = 7 - array[i]。

  1.   401153:	48 8d 74 24 18       	lea    0x18(%rsp),%rsi
  2.   401158:	4c 89 f0             	mov    %r14,%rax
  3.   40115b:	b9 07 00 00 00       	mov    $0x7,%ecx
  5.   401160:	89 ca                	mov    %ecx,%edx
  6.   401162:	2b 10                	sub    (%rax),%edx
  7.   401164:	89 10                	mov    %edx,(%rax)
  9.   401166:	48 83 c0 04          	add    $0x4,%rax
  10.   40116a:	48 39 f0             	cmp    %rsi,%rax
  11.   40116d:	75 f1                	jne    401160 <phase_6+0x6c>

第四段：还是包含了很多的循环，注意到401195是循环的出口。rsi用于rsp的访存，并且按4递增，可以将其看做是循环变量i。代码中包含了一个硬编码0x6032d0，查看内存发现是包含了node信息，每个node16B：

从内存结构可以看出，从node的地址往后偏移8个字节就是next指针的位置，也就对应着mov 0x8(%rdx),%rdx。根据前文可知，array中存放了1 2 3 4 5 6，因此带入两个特殊值就能明白该函数的功能。

  • 当array[i] = 1。从40119d可知，此时会跳转到401183，直接将链表的首地址存到了(rsp+20)[i]处，这里需要注意(%rsp,%rsi,2)中2的含义，单位是32bit（4B）

  • 当array[i] = 3。会跳转到401176，eax初始值1，ecx为3，rdx的初始值为0x6032d0。对应的代码为：

    1. do {
    2.     rdx = rdx->next;
    3.     eax += 1;
    4. }while(eax <= ecx);

    当循环结束时，rdx的值刚好是第3个节点的地址，然后将它存储到(rsp+20)[i]处。

因此这一部分代码个作用就是将节点的地址按照输入的数组的被7减之后的顺序存到rsp+20处，查看栈rsp+20处的内容：

输入的数字为1 2 3 4 5 6，变换后为6 5 4 3 2 1，刚好是把节点的地址倒过来

  1.   40116f:	be 00 00 00 00       	mov    $0x0,%esi
  2.   401174:	eb 21                	jmp    401197 <phase_6+0xa3>
  4.   401176:	48 8b 52 08          	mov    0x8(%rdx),%rdx
  5.   40117a:	83 c0 01             	add    $0x1,%eax
  6.   40117d:	39 c8                	cmp    %ecx,%eax
  7.   40117f:	75 f5                	jne    401176 <phase_6+0x82>
  8.   401181:	eb 05                	jmp    401188 <phase_6+0x94>
  10.   401183:	ba d0 32 60 00       	mov    $0x6032d0,%edx
  11.   401188:	48 89 54 74 20       	mov    %rdx,0x20(%rsp,%rsi,2)
  13.   40118d:	48 83 c6 04          	add    $0x4,%rsi
  14.   401191:	48 83 fe 18          	cmp    $0x18,%rsi
  15.   401195:	74 14                	je     4011ab <phase_6+0xb7> # 循环出口
  17.   401197:	8b 0c 34             	mov    (%rsp,%rsi,1),%ecx
  18.   40119a:	83 f9 01             	cmp    $0x1,%ecx
  19.   40119d:	7e e4                	jle    401183 <phase_6+0x8f>
  21.   40119f:	b8 01 00 00 00       	mov    $0x1,%eax
  22.   4011a4:	ba d0 32 60 00       	mov    $0x6032d0,%edx
  23.   4011a9:	eb cb                	jmp    401176 <phase_6+0x82>

第五段：

将rsp+20上的数组记作addr[0],addr[1],..., addr[5]

rbx-->addr[0], rax--> addr[1]的地址，rsi--> addr[6]的地址，充当循环的边界

rbx--> rcx

(rax)就是addr[1]--> rdx

rdx--> mem[rcx+0x8]， rcx是addr[0]，也就是将rdx赋值给地址为addr[0]的链表节点的next指针

rdx-->rcx，循环后rdx取下一个值

结束时rdx为addr[5]，也就是链表的最后一个节点，只需要将其next指针设置为0

因此第五段是在重新排列链表

  1.   # 初始化
  2.   4011ab:	48 8b 5c 24 20       	mov    0x20(%rsp),%rbx # head
  3.   4011b0:	48 8d 44 24 28       	lea    0x28(%rsp),%rax # head.next
  4.   4011b5:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi # end
  5.   4011ba:	48 89 d9             	mov    %rbx,%rcx
  7.   # 主体
  8.   4011bd:	48 8b 10             	mov    (%rax),%rdx
  9.   4011c0:	48 89 51 08          	mov    %rdx,0x8(%rcx)
  11.   # 循环条件判断
  12.   4011c4:	48 83 c0 08          	add    $0x8,%rax
  13.   4011c8:	48 39 f0             	cmp    %rsi,%rax
  14.   4011cb:	74 05                	je     4011d2 <phase_6+0xde>
  16.   4011cd:	48 89 d1             	mov    %rdx,%rcx
  17.   4011d0:	eb eb                	jmp    4011bd <phase_6+0xc9>
  19.   4011d2:	48 c7 42 08 00 00 00 	movq   $0x0,0x8(%rdx)

第六段：

一个链表的取value的过程，比较相邻的两个节点的value，要降序排列

原链表的节点为 14c 0a8 39c 2b3 1dd 1bb

降序排列的下标应该是3 4 5 6 1 2，变换前的应该是4 3 2 1 6 5


  2.   4011d9:	00
  3.   4011da:	bd 05 00 00 00       	mov    $0x5,%ebp
  4.   4011df:	48 8b 43 08          	mov    0x8(%rbx),%rax #rbx就是头结点的地址，偏移8就是next指针
  5.   4011e3:	8b 00                	mov    (%rax),%eax # next的value存到eax中
  6.   4011e5:	39 03                	cmp    %eax,(%rbx) # 比较next.value和value
  7.   4011e7:	7d 05                	jge    4011ee <phase_6+0xfa> # value >=next.value跳转，也就意味着要降序排列
  8.   4011e9:	e8 4c 02 00 00       	callq  40143a <explode_bomb>
  9.   4011ee:	48 8b 5b 08          	mov    0x8(%rbx),%rbx
  11.   4011f2:	83 ed 01             	sub    $0x1,%ebp
  12.   4011f5:	75 e8                	jne    4011df <phase_6+0xeb> # 循环6次
  14.   4011f7:	48 83 c4 50          	add    $0x50,%rsp
  15.   4011fb:	5b                   	pop    %rbx
  16.   4011fc:	5d                   	pop    %rbp
  17.   4011fd:	41 5c                	pop    %r12
  18.   4011ff:	41 5d                	pop    %r13
  19.   401201:	41 5e                	pop    %r14
  20.   401203:	c3                   	retq

csapp lab2 拆炸弹的更多相关文章

  1. ACM_Jack拆炸弹（深搜）

    Jack拆炸弹 Time Limit: 2000/1000ms (Java/Others) Problem Description: 在一个由n*n个格子组成的监狱里被恐怖份子安置了一个定时炸弹.其中 ...

  2. csapp lab2 bomb 二进制炸弹《深入理解计算机系统》

    bomb炸弹实验 首先对bomb这个文件进行反汇编,得到一个1000+的汇编程序,看的头大. phase_1: 0000000000400ef0 <phase_1>: 400ef0: 48 ...

  3. CSAPP Lab2: Binary Bomb

    著名的CSAPP实验:二进制炸弹 就是通过gdb和反汇编猜测程序意图,共有6关和一个隐藏关卡 只有输入正确的字符串才能过关,否则会程序会bomb终止运行 隐藏关卡需要输入特定字符串方会开启 实验材料下 ...

  4. IDA Pro 在CSAPP lab2中的使用

    在做lab2的时候,偶然的情况下,发现了IDA pro这样一个反汇编工具,总的来说对于lab2这样的小实验读懂代码的大体功能是有作用的,但对于想要具体明白某一条指令的执行过程,又显得不足,到最后还是需 ...

  5. CSAPP lab2 二进制拆弹 binary bombs phase_6

    给出对应于7个阶段的7篇博客 phase_1  https://www.cnblogs.com/wkfvawl/p/10632044.htmlphase_2  https://www.cnblogs. ...

  6. CSAPP lab2 二进制拆弹 binary bombs phase_5

    给出对应于7个阶段的7篇博客 phase_1  https://www.cnblogs.com/wkfvawl/p/10632044.htmlphase_2  https://www.cnblogs. ...

  7. CSAPP lab2 二进制拆弹 binary bombs phase_4

    给出对应于7个阶段的7篇博客 phase_1  https://www.cnblogs.com/wkfvawl/p/10632044.htmlphase_2  https://www.cnblogs. ...

  8. CSAPP lab2 二进制拆弹 binary bombs phase_3

    给出对应于7个阶段的7篇博客 phase_1  https://www.cnblogs.com/wkfvawl/p/10632044.htmlphase_2  https://www.cnblogs. ...

  9. CSAPP lab2 二进制拆弹 binary bombs phase_2

    给出对应于7个阶段的7篇博客 phase_1  https://www.cnblogs.com/wkfvawl/p/10632044.htmlphase_2  https://www.cnblogs. ...

随机推荐

  1. outlook2007邮件里的图片显示不出来

    outlook2007邮件里的图片显示不出来,这是为啥? 以图片为附件的形式进行传送吧,这样在收件箱里就能在线看图片了,不用担心看不到图片

  2. SQL：查询Mysql表结构

    背景:有时需要做数据字典,其中最重要的就是表结构.经整理,编写SQL如下: 代码: 1 -- drop TABLE `cfg_data_dict` ; 2 CREATE TABLE `cfg_data ...

  3. Jenkins安装部署使用图文详解（非常详细）

    前言 最近公司需要弄一套自动化运维部署,于是抽空学习了一下,用了两天左右完成Jenkins的安装部署和各种项目的配置化,于是整理一下进行分享. 介绍 Jenkins是一个独立的开源软件项目,是基于Ja ...

  4. mysql导入文件 日期时间报错：[Err] 1067 - Invalid default value for 'active_time'

    报错原因意思是说:mysql5.7版本中有了一个STRICT mode(严格模式),而在此模式下默认是不允许设置日期时间的值为全0值的,所以想要  解决这个问题,就需要修改sql_mode的值. 修改 ...

  5. c(++)变长参数之整形（非字符串类型类似）

    0.序言 变长参数,接触的第一个可变长参数函数是 printf   , 然后是 scanf   .他们的原型如下: printf: _Check_return_opt_ _CRT_STDIO_INLI ...

  6. 【九度OJ】题目1109：连通图 解题报告

    [九度OJ]题目1109:连通图 解题报告 标签(空格分隔): 九度OJ 原题地址:http://ac.jobdu.com/problem.php?pid=1109 题目描述: 给定一个无向图和其中的 ...

  7. 【LeetCode】49. Group Anagrams 解题报告（Python & Java & C++）

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 排序+hash 日期 题目地址:https://le ...

  8. python学习第五天：python基础（string、list、tuple）

    首先,什么是sequence(序列)操作? 字符串的特性被称为sequence(序列) H o w a r e y o u ? 就好像存储在一个个连续的单元格里面,每个单元格存储一个字符,每个字符就是 ...

  9. Codeforces 450C：Jzzhu and Chocolate（贪心）

    C. Jzzhu and Chocolate time limit per test: 1 seconds memory limit per test: 256 megabytes input: st ...

  10. POJ 3126：Prime Path（素数+BFS）

    The ministers of the cabinet were quite upset by the message from the Chief of Security stating that ...