CSAPP六个重要实验lab2

CSAPP lab2 哈哈~ 不愧是“美国进口的六级*”！爽歪歪的“升级打怪” 我把实验材料都上传到下面这个link了，0分下载(良心啊~) http://download.csdn.net/detail/u011368821/7892649 再一个实验指导说明供大家下载： http://download.csdn.net/detail/u011

CSAPP && lab2

哈哈~ 不愧是“美国进口的六级*”！爽歪歪的“升级打怪”

我把实验材料都上传到下面这个link了，0分下载(良心啊~)

http://download.csdn.net/detail/u011368821/7892649

再一个实验指导说明供大家下载：

http://download.csdn.net/detail/u011368821/7892677

对于Phase_1的分析:

0000000000400ef0 :
 400ef0:	48 83 ec 08 	sub $0x8,%rsp
 400ef4:	be 18 1b 40 00 	mov $0x401b18,%esi
 400ef9:	e8 10 04 00 00 	callq 40130e 
 400efe:	85 c0 	test %eax,%eax
 400f00:	74 05 	je 400f07 
 400f02:	e8 dc 07 00 00 	callq 4016e3 
 400f07:	48 83 c4 08 	add $0x8,%rsp
 400f0b:	c3 	retq 

注意到这句指令.

400ef4:be 18 1b 40 00 mov $0x401b18,%esi

ESI/EDI 分别叫做"源/目标索引寄存器"(source/destination index),因为在很多字符串操作指令中

就是要培养的对寄存器很敏感的能力.上面mov $0x401b18,%esi之后立马callq string_not_equal.这是在bomb爆炸之前.我们看看string_not_equal 里面能找到什么线索

000000000040130e :
 40130e:	41 54 	push %r12
 401310:	55 	push %rbp
 401311:	53 	push %rbx
 401312:	48 89 fb 	mov %rdi,%rbx
 401315:	48 89 f5 	mov %rsi,%rbp
 401318:	e8 d4 ff ff ff 	callq 4012f1 
 40131d:	41 89 c4 	mov %eax,%r12d
 401320:	48 89 ef 	mov %rbp,%rdi
 401323:	e8 c9 ff ff ff 	callq 4012f1 
 401328:	ba 01 00 00 00 	mov $0x1,%edx
 40132d:	41 39 c4 	cmp %eax,%r12d
 401330:	75 3e 	jne 401370 

 ... ...

 401369:	eb 05 	jmp 401370 
 40136b:	ba 01 00 00 00 	mov $0x1,%edx
 401370:	89 d0 	mov %edx,%eax
 401372:	5b 	pop %rbx
 401373:	5d 	pop %rbp
 401374:	41 5c 	pop %r12
 401376:	c3 	retq 

我们可以看到这里有连个string_length. 注意到之前的%rdi 和%rsi 分别被mov到%rbx和%rbp中

%rdi记录的是第一个参数的地址，于是当第一次调用直接第一个参数(指针)指向的字符串,

经过

mov %rsi %rbp

mov %rbp %rdi

这样第二次传入string_length的参数就变成了string_not_equal的第二个参数(指针),

string_length 对这两个不同指针指向的字符串进行计算，返回它们的长度值，如果不一致，返回1,如果一致返回0(关于返回值的情况这里的汇编不足以解释，还要分析所有的string_not_equal反汇编才会知道)

phase_1中

callq 40130e
test %eax,%eax

string_not_equal结束后立即test %eax %eax(text 指令的作用是对寄存器& bit and)

je 如果上一个test指令的结果是0就跳转，否者不跳转

这里如果返回值是0就跳转到了

add $0x8,%rsp
retq

正确返回弹栈了。

上面唧唧歪歪说了这么一对铺垫就一个目的，推理出

400ef4:be 18 1b 40 00 mov $0x401b18,%esi

涉及的这个0x401b18是不寻常的，它指向一个字符串，而我们输入的字符串必须和这个指针指向的字符串完全相同才能不触发bomb否者触发BOMB

那就看看0x401b18这里究竟都藏了什么！

gdb debug去

Science isn't about why, it's about why not?

输入0x401b18 指向的字符串即可过了phase 1 : -)

对于Phase_2的分析:

main函数部分截选

 400e30:	e8 bb 00 00 00 	callq 400ef0 
 400e35:	e8 f2 09 00 00 	callq 40182c 
 400e3a:	bf 08 1a 40 00 	mov $0x401a08,%edi
 400e3f:	e8 ac fc ff ff 	callq 400af0 
 400e44:	e8 fe 08 00 00 	callq 401747 
 400e49:	48 89 c7 	mov %rax,%rdi
 400e4c:	e8 bb 00 00 00 	callq 400f0c 

我们可以看到搞定了phase_1这里又要进入pahse_2鸟~
这里又有个指令

mov $0x401a08,%edi

0x401a08这个地址装着是一个普通的提示字符串不必在意(测试过了)

看看pahse_2

0000000000400f0c :
 400f0c:	55 	push %rbp
 400f0d:	53 	push %rbx
 400f0e:	48 83 ec 28 	sub $0x28,%rsp
 400f12:	48 89 e6 	mov %rsp,%rsi
 400f15:	e8 eb 07 00 00 	callq 401705 
 400f1a:	83 3c 24 01 	cmpl $0x1,(%rsp)
 400f1e:	74 25 	je 400f45 
 400f20:	e8 be 07 00 00 	callq 4016e3 
 400f25:	eb 1e 	jmp 400f45 
 400f27:	83 c3 01 	add $0x1,%ebx
 400f2a:	89 d8 	mov %ebx,%eax
 400f2c:	0f af 45 fc 	imul -0x4(%rbp),%eax
 400f30:	39 45 00 	cmp %eax,0x0(%rbp)
 400f33:	74 05 	je 400f3a 
 400f35:	e8 a9 07 00 00 	callq 4016e3 
 400f3a:	48 83 c5 04 	add $0x4,%rbp
 400f3e:	83 fb 06 	cmp $0x6,%ebx
 400f41:	75 e4 	jne 400f27 
 400f43:	eb 0c 	jmp 400f51 
 400f45:	48 8d 6c 24 04 	lea 0x4(%rsp),%rbp
 400f4a:	bb 01 00 00 00 	mov $0x1,%ebx
 400f4f:	eb d6 	jmp 400f27 
 400f51:	48 83 c4 28 	add $0x28,%rsp
 400f55:	5b 	pop %rbx
 400f56:	5d 	pop %rbp
 400f57:	c3 	retq 

核心语句

imul -0x4(%rbp),%eax
cmp %eax,0x0(%rbp) //如果比较结果是0,就跳转，否则BOMB
je 400f3a
callq 4016e3

既然如此，那就看看前面什么东东影响%eax 和%rbp的取值

callq 401705

cmpl $0x1,(%rsp)

je 400f45
callq 4016e3

这里很明显,读入的6个数字被存放在从rsp指向的地址开始向上的位置。

首先比较第一个输入的数(%rsp)和1是否相等，如果是则跳转到400f45标记的位置，否者callq explode_bomb，爆炸

那么可以确定，第一个输入的数字必须是1,接着我们跳转到 400f45 的位置看看会发生什么

400f45:	48 8d 6c 24 04 	lea 0x4(%rsp),%rbp
 400f4a:	bb 01 00 00 00 	mov $0x1,%ebx
 400f4f:	eb d6 	jmp 400f27 

这里lea把rsp寄存器指向的指针+4,然后赋值给rbp，并把%edx寄存器初始化为1

最后跳转到400f27的位置

400f27:	83 c3 01 	add $0x1,%ebx
 400f2a:	89 d8 	mov %ebx,%eax
 400f2c:	0f af 45 fc 	imul -0x4(%rbp),%eax
 400f30:	39 45 00 	cmp %eax,0x0(%rbp)
 400f33:	74 05 	je 400f3a 
 400f35:	e8 a9 07 00 00 	callq 4016e3 
 400f3a:	48 83 c5 04 	add $0x4,%rbp
 400f3e:	83 fb 06 	cmp $0x6,%ebx
 400f41:	75 e4 	jne 400f27 

此时add 把ebx 增 1,然后赋值给%eax，即数值2.

把-0x4(%rbp)即第一个输入的数字，imul 乘以%eax的值，然后赋值给%eax,即 %eax = 1*2

cmp把此时的%eax 和当前输入0x0(%rbp),此时为第二个输入数字，比较。如果相同就跳转到400f3a的位置，否者callq explode_bomb爆炸. 由此我们可以知道，第二个输入的数字必须是2.

如果第二个数字输入的是2,接着add 把%rbp +4, 接着cmp 比较%ebx(此时为2)和0x6比较，不相等就跳转到400f27,

于是我们又回到了400f27的位置，有点汇编经验的人一看就可以发现，这里其实是一个循环. %ebx每次+1, 循环6次。

 400f2c:	0f af 45 fc 	imul -0x4(%rbp),%eax
 400f30:	39 45 00 	cmp %eax,0x0(%rbp)

每次都把%eax和前一个输入数字相乘，赋值给%eax，并和当前数字0x0(%rbp)比较。

这样一步步按照汇编语句构造的循环，执行下去，可以发现要想不bomb，输入应该是

1 2 6 24 120 720

OK~ 搞定，phase_2。

对于Phase_3的分析:

当我们搞定phase_2之后，phase_3来了~

400e4c:	e8 bb 00 00 00 	callq 400f0c 
 400e51:	e8 d6 09 00 00 	callq 40182c 
 400e56:	bf 67 19 40 00 	mov $0x401967,%edi
 400e5b:	e8 90 fc ff ff 	callq 400af0 
 400e60:	e8 e2 08 00 00 	callq 401747 
 400e65:	48 89 c7 	mov %rax,%rdi
 400e68:	e8 eb 00 00 00 	callq 400f58 
 400e6d:	e8 ba 09 00 00 	callq 40182c 

phase_3:

0000000000400f58 :
 400f58:	48 83 ec 18 	sub $0x18,%rsp
 400f5c:	4c 8d 44 24 08 	lea 0x8(%rsp),%r8 //把%rsp指向的地址+0x8 赋值给%rcx ，以下的lea操作同理
 400f61:	48 8d 4c 24 07 	lea 0x7(%rsp),%rcx
 400f66:	48 8d 54 24 0c 	lea 0xc(%rsp),%rdx
 400f6b:	be 6e 1b 40 00 	mov $0x401b6e,%esi //把0x401b6赋值给%esi ,注意esi是字符串相关寄存器，我们看看这个地址里面是什么
 400f70:	b8 00 00 00 00 	mov $0x0,%eax
 400f75:	e8 86 fc ff ff 	callq 400c00 <__isoc99_sscanf@plt>
 400f7a:	83 f8 02 	cmp $0x2,%eax
 400f7d:	7f 05 	jg 400f84 
 400f7f:	e8 5f 07 00 00 	callq 4016e3 
 400f84:	83 7c 24 0c 07 	cmpl $0x7,0xc(%rsp) //比较0xc(%rsp)处的值和7比较，如果大于7,ja跳转，接着bomb，于是我们知道0xc(%rsp)处的值要在(0~7)
 400f89:	0f 87 fc 00 00 00 	ja 40108b 
 400f8f:	8b 44 24 0c 	mov 0xc(%rsp),%eax
 400f93:	ff 24 c5 80 1b 40 00 	jmpq *0x401b80(,%rax,8)
 400f9a:	b8 6a 00 00 00 	mov $0x6a,%eax //把0x6a赋值给%eax，这里很重要，每一个witch分支的这里都不一样，而且第二个输入参数和这个有关系
 400f9f:	81 7c 24 08 40 02 00 	cmpl $0x240,0x8(%rsp) //把0x8(%rsp)的值和0x240比较，如果不相等，bomb，相等就正常跳转到 401095
 400fa6:	00 
 400fa7:	0f 84 e8 00 00 00 	je 401095 
 400fad:	e8 31 07 00 00 	callq 4016e3 
 400fb2:	b8 6a 00 00 00 	mov $0x6a,%eax
 400fb7:	e9 d9 00 00 00 	jmpq 401095 
 400fbc:	b8 66 00 00 00 	mov $0x66,%eax
 400fc1:	81 7c 24 08 bc 03 00 	cmpl $0x3bc,0x8(%rsp)
 400fc8:	00 
 400fc9:	0f 84 c6 00 00 00 	je 401095 
 400fcf:	e8 0f 07 00 00 	callq 4016e3 
 400fd4:	b8 66 00 00 00 	mov $0x66,%eax
 400fd9:	e9 b7 00 00 00 	jmpq 401095 
 400fde:	b8 6a 00 00 00 	mov $0x6a,%eax
 400fe3:	81 7c 24 08 2a 02 00 	cmpl $0x22a,0x8(%rsp)
 400fea:	00 
 400feb:	0f 84 a4 00 00 00 	je 401095 
 400ff1:	e8 ed 06 00 00 	callq 4016e3 
 400ff6:	b8 6a 00 00 00 	mov $0x6a,%eax
 400ffb:	e9 95 00 00 00 	jmpq 401095 
 401000:	b8 76 00 00 00 	mov $0x76,%eax
 401005:	81 7c 24 08 c9 00 00 	cmpl $0xc9,0x8(%rsp)
 40100c:	00 
 40100d:	0f 84 82 00 00 00 	je 401095 
 401013:	e8 cb 06 00 00 	callq 4016e3 
 401018:	b8 76 00 00 00 	mov $0x76,%eax
 40101d:	eb 76 	jmp 401095 
 40101f:	b8 62 00 00 00 	mov $0x62,%eax
 401024:	81 7c 24 08 07 01 00 	cmpl $0x107,0x8(%rsp)
 40102b:	00 
 40102c:	74 67 	je 401095 
 40102e:	e8 b0 06 00 00 	callq 4016e3 
 401033:	b8 62 00 00 00 	mov $0x62,%eax
 401038:	eb 5b 	jmp 401095 
 40103a:	b8 69 00 00 00 	mov $0x69,%eax
 40103f:	81 7c 24 08 3b 03 00 	cmpl $0x33b,0x8(%rsp)
 401046:	00 
 401047:	74 4c 	je 401095 
 401049:	e8 95 06 00 00 	callq 4016e3 
 40104e:	b8 69 00 00 00 	mov $0x69,%eax
 401053:	eb 40 	jmp 401095 
 401055:	b8 71 00 00 00 	mov $0x71,%eax
 40105a:	81 7c 24 08 c6 00 00 	cmpl $0xc6,0x8(%rsp)
 401061:	00 
 401062:	74 31 	je 401095 
 401064:	e8 7a 06 00 00 	callq 4016e3 
 401069:	b8 71 00 00 00 	mov $0x71,%eax
 40106e:	eb 25 	jmp 401095 
 401070:	b8 77 00 00 00 	mov $0x77,%eax
 401075:	81 7c 24 08 74 01 00 	cmpl $0x174,0x8(%rsp)
 40107c:	00 
 40107d:	74 16 	je 401095 
 40107f:	e8 5f 06 00 00 	callq 4016e3 
 401084:	b8 77 00 00 00 	mov $0x77,%eax
 401089:	eb 0a 	jmp 401095 
 40108b:	e8 53 06 00 00 	callq 4016e3 
 401090:	b8 68 00 00 00 	mov $0x68,%eax
 401095:	3a 44 24 07 	cmp 0x7(%rsp),%al //把0x7(%rsp)和 %al(%eax低字节)比较，相等就跳转，否者，bomb
 401099:	74 05 	je 4010a0 
 40109b:	e8 43 06 00 00 	callq 4016e3 
 4010a0:	48 83 c4 18 	add $0x18,%rsp
 4010a4:	c3 	retq 

注意到开头这里

mov $0x401b6e,%esi

把0x401b6赋值给%esi ,注意esi是字符串相关寄存器，我们看看这个地址里面是什么

我们发现是一个格式化输入说明字符串

于是我们就知道我们应该输入什么类型的数据了

400f75: callq 400c00 <__isoc99_sscanf@plt>
400f7a: cmp $0x2,%eax
400f7d: jg 400f84
400f7f: callq 4016e3
400f84: cmpl $0x7,0xc(%rsp)

可以发现，sscanf的返回值放在%eax里，如果输入的数据大于2个(即最少是3个)，就跳转到400f84,否则explode_bomb

根据前面的格式化字符串我们可以注意到

输入三个数据即正常跳转

这里又有个跳转语句

 400f93:	ff 24 c5 80 1b 40 00 	jmpq *0x401b80(,%rax,8)
 400f9a:	b8 6a 00 00 00 	mov $0x6a,%eax

我们看看 *0x401b80处是什么东东

是一个数，0x400f9a，这个是指令mov $0x6a,%eax 的代码段标记地址

如果%rax是0，就直接跳转到0x400f9a 否则0x400f9a + %rax * 8

这里是典型的witch 语句的汇编形式...如果不明白就去看CSAPP第三章

上面给出的phase_3汇编部分注释我已经写的很清楚了~

 400f5c:	4c 8d 44 24 08 	lea 0x8(%rsp),%r8 //把%rsp指向的地址+0x8 赋值给%rcx ，以下的lea操作同理
 400f61:	48 8d 4c 24 07 	lea 0x7(%rsp),%rcx
 400f66:	48 8d 54 24 0c 	lea 0xc(%rsp),%rdx

这里可以推知phase_3一开始就保存了0x8(%rsp),0x7(%rsp),0xc(%rsp)三处的值，这三处肯定要被接下来的程序重写利用.

而分析偏移量0x8 0x7 0xc，以及格式化字符串参数入栈顺序可知，0xc(%rsp)储存第一个参数，0x7(%rsp)储存第二个参数，0x8(%rsp)储存第三个参数.

提示: printf("%d %d",a,b); 参数是b先入栈，然后是a

综合以上分析,输入

0 j 576

即可过关

这里我偷一下懒第一个选择了0

实际上第一个数据可以是0~7内的任意数字，这也会导致跳转至不同的分支，而影响第二个第三个参数的输入情况。

以0 作为第一个输入参数的例子，

 400f9a:	b8 6a 00 00 00 	mov $0x6a,%eax 

 401095:	3a 44 24 07 	cmp 0x7(%rsp),%al 

以上两个指令将被执行，我们可以知道0x7(%rsp)第二个输入的参数应当为0x6a对应的ascii码字符，于是这里应当输入 j

第三个参数的确定是在

 400f9f:	81 7c 24 08 40 02 00 	cmpl $0x240,0x8(%rsp) //把0x8(%rsp)的值和0x240比较，如果不相等，bomb，相等就正常跳转到 401095
 400fa6:	00 
 400fa7:	0f 84 e8 00 00 00 	je 401095 

于是第三个参数必须为0x240，否则bomb，这里是%d的读入，于是转化为相应的十进制数为576.

OK, Phase_3 搞定 halfway there!

对于Phase_4的分析:

注意到phase_4会调用到func4

00000000004010a5 :
 4010a5:	53 	push %rbx
 4010a6:	89 fb 	mov %edi,%ebx
 4010a8:	b8 01 00 00 00 	mov $0x1,%eax
 4010ad:	83 ff 01 	cmp $0x1,%edi
 4010b0:	7e 0b 	jle 4010bd 
 4010b2:	8d 7f ff 	lea -0x1(%rdi),%edi
 4010b5:	e8 eb ff ff ff 	callq 4010a5 
 4010ba:	0f af c3 	imul %ebx,%eax
 4010bd:	5b 	pop %rbx
 4010be:	c3 	retq 

00000000004010bf :
 4010bf:	48 83 ec 18 	sub $0x18,%rsp
 4010c3:	48 8d 54 24 0c 	lea 0xc(%rsp),%rdx
 4010c8:	be 74 1b 40 00 	mov $0x401b74,%esi
 4010cd:	b8 00 00 00 00 	mov $0x0,%eax
 4010d2:	e8 29 fb ff ff 	callq 400c00 <__isoc99_sscanf@plt>
 4010d7:	83 f8 01 	cmp $0x1,%eax
 4010da:	75 07 	jne 4010e3 
 4010dc:	83 7c 24 0c 00 	cmpl $0x0,0xc(%rsp)
 4010e1:	7f 05 	jg 4010e8 
 4010e3:	e8 fb 05 00 00 	callq 4016e3 
 4010e8:	8b 7c 24 0c 	mov 0xc(%rsp),%edi
 4010ec:	e8 b4 ff ff ff 	callq 4010a5 
 4010f1:	3d 00 5f 37 00 	cmp $0x375f00,%eax
 4010f6:	74 05 	je 4010fd 
 4010f8:	e8 e6 05 00 00 	callq 4016e3 
 4010fd:	48 83 c4 18 	add $0x18,%rsp
 401101:	c3 	retq 

进过前面三个*的“轰炸”，这里我不想在过细致的分析，就是一步步跟着汇编看就是了

主题就是phase_4要求根据格式化字符串“%d”输入一个数字，这个数字传入func做递归乘法，相当于传入参数的阶乘.

最后

 4010f1:	3d 00 5f 37 00 	cmp $0x375f00,%eax

返回值和0x375f00比较，如果不相等就bomb，于是我们必须找到阶乘等于0x375f00的数字.

的方法嘛.写个阶乘的C 函数去测试，什么输入参数的阶乘是0x375f00

#include 

int main()
{
	int ans = 1;
	int tmp = 1;

	for(tmp = 1;ans != 0x375f00;tmp++)
	{
	ans *= tmp;
	}

	printf("%d \n",tmp-1);

	return 0;
}

呵呵，原来是10.

对于Phase_5的分析:

0000000000401102 :
 401102:	53 	push %rbx
 401103:	48 89 fb 	mov %rdi,%rbx
 401106:	e8 e6 01 00 00 	callq 4012f1 
 40110b:	83 f8 06 	cmp $0x6,%eax //输入字符串的长度必须是6,否则bomb
 40110e:	74 05 	je 401115 
 401110:	e8 ce 05 00 00 	callq 4016e3 
 401115:	b8 00 00 00 00 	mov $0x0,%eax // 把%eax %edx 寄存器赋值为0
 40111a:	ba 00 00 00 00 	mov $0x0,%edx
 40111f:	0f b6 0c 03 	movzbl (%rbx,%rax,1),%ecx //%rbx + %rax*1 赋值给%ecx
 401123:	83 e1 0f 	and $0xf,%ecx //取%ecx低4位赋值给%ecx
 401126:	03 14 8d c0 1b 40 00 	add 0x401bc0(,%rcx,4),%edx
 40112d:	48 83 c0 01 	add $0x1,%rax
 401131:	48 83 f8 06 	cmp $0x6,%rax
 401135:	75 e8 	jne 40111f 
 401137:	83 fa 3e 	cmp $0x3e,%edx
 40113a:	74 05 	je 401141 
 40113c:	e8 a2 05 00 00 	callq 4016e3 
 401141:	5b 	pop %rbx
 401142:	c3 	retq 

值得注意的是

 401126:	03 14 8d c0 1b 40 00 	add 0x401bc0(,%rcx,4),%edx

这里又有个很特殊的地址0x401bc0

我尝试打印这里的数据，怀疑这里很可能是个数组

对于phase_5,概括性的说，就是输入6个ascii字符，然后这6个字符的低4位对应这个数组的index，然后对应数字累加要等于0x3e,即62

这里我的想法是62 = 2+2+10+16+16+16

对应的偏移量是001555

我们查看ascii码表可以发现，恰巧数字字符00155符合要求，于是输入00155

对于Phase_6的分析:

最后一关了！

0000000000401143 :
 401143:	48 89 f8 	mov %rdi,%rax
 401146:	4c 8b 47 08 	mov 0x8(%rdi),%r8
 40114a:	48 c7 47 08 00 00 00 	movq $0x0,0x8(%rdi)
 401151:	00 
 401152:	4d 85 c0 	test %r8,%r8
 401155:	75 48 	jne 40119f 
 401157:	f3 c3 	repz retq 
 401159:	48 89 d1 	mov %rdx,%rcx
 40115c:	48 8b 51 08 	mov 0x8(%rcx),%rdx
 401160:	48 85 d2 	test %rdx,%rdx
 401163:	74 09 	je 40116e 
 401165:	39 32 	cmp %esi,(%rdx)
 401167:	7f f0 	jg 401159 
 401169:	48 89 d6 	mov %rdx,%rsi
 40116c:	eb 03 	jmp 401171 
 40116e:	48 89 d6 	mov %rdx,%rsi
 401171:	48 39 ce 	cmp %rcx,%rsi
 401174:	74 06 	je 40117c 
 401176:	4c 89 41 08 	mov %r8,0x8(%rcx)
 40117a:	eb 13 	jmp 40118f 
 40117c:	4c 89 c0 	mov %r8,%rax
 40117f:	eb 0e 	jmp 40118f 
 401181:	48 89 c2 	mov %rax,%rdx
 401184:	4c 89 c0 	mov %r8,%rax
 401187:	eb 06 	jmp 40118f 
 401189:	48 89 c2 	mov %rax,%rdx
 40118c:	4c 89 c0 	mov %r8,%rax
 40118f:	49 8b 48 08 	mov 0x8(%r8),%rcx
 401193:	49 89 50 08 	mov %rdx,0x8(%r8)
 401197:	48 85 c9 	test %rcx,%rcx
 40119a:	74 14 	je 4011b0 
 40119c:	49 89 c8 	mov %rcx,%r8
 40119f:	48 85 c0 	test %rax,%rax
 4011a2:	74 dd 	je 401181 
 4011a4:	41 8b 30 	mov (%r8),%esi
 4011a7:	39 30 	cmp %esi,(%rax)
 4011a9:	7e de 	jle 401189 
 4011ab:	48 89 c1 	mov %rax,%rcx
 4011ae:	eb ac 	jmp 40115c 
 4011b0:	f3 c3 	repz retq 

00000000004011b2 :
 4011b2:	48 83 ec 08 	sub $0x8,%rsp
 4011b6:	ba 0a 00 00 00 	mov $0xa,%edx
 4011bb:	be 00 00 00 00 	mov $0x0,%esi
 4011c0:	e8 1b fa ff ff 	callq 400be0 
 4011c5:	89 05 55 21 20 00 	mov %eax,0x202155(%rip) # 603320 
 4011cb:	bf 20 33 60 00 	mov $0x603320,%edi
 4011d0:	e8 6e ff ff ff 	callq 401143 
 4011d5:	48 8b 40 08 	mov 0x8(%rax),%rax
 4011d9:	8b 0d 41 21 20 00 	mov 0x202141(%rip),%ecx # 603320 
 4011df:	39 08 	cmp %ecx,(%rax)
 4011e1:	74 05 	je 4011e8 
 4011e3:	e8 fb 04 00 00 	callq 4016e3 
 4011e8:	48 83 c4 08 	add $0x8,%rsp
 4011ec:	c3 	retq 

这步不要陷入到func6了，逐步的去gdb stepi nexti 调试就是了. 具体的调试方法不讲了

值得一提的就是这里

 4011c5:	89 05 55 21 20 00 	mov %eax,0x202155(%rip) # 603320 
 
 4011d9:	8b 0d 41 21 20 00 	mov 0x202141(%rip),%ecx # 603320 

这里0x202155(%rip) 0x202141(%rip)都是指向同一个地址，这个地址储存着输入数据

cmp %ecx,(%rax)

最后这里比较的时候，直接gdb查看%rax指向的地址存的什么东东,

打印出来

826！于是我们就应该输入826

其实应该还有个彩蛋——secrete phase

我目前~没心思看了，过两天继续更新

*****************************************************************************************************************************

参考资料——向所有前辈致敬, sharing，step together! open source！

逆向工程——二进制*(CSAPP Project)

http://www.cnblogs.com/remlostime/archive/2011/05/21/2052708.html

bomb lab （《深入理解计算机系统》lab2）Stone

http://blog.csdn.net/u013648407/article/details/24845129

CSAPP:二进制*实验 lycos的六度空间

http://blog.csdn.net/caoxu1987728/article/details/6056947

最后感谢

UNIVERSITY OF WASHINGTON

呵呵，国内的某些大学学着点别人的风度.

***************************************************************************************************************************