CSAPP实验——BombLab

最新推荐文章于 2023-08-26 03:57:37 发布

C__C_

最新推荐文章于 2023-08-26 03:57:37 发布

阅读量1.2k

点赞数 6

分类专栏： CSAPP 文章标签： c++ 数据结构

本文链接：https://blog.csdn.net/C__C_/article/details/110954153

版权

本文详细记录了CSAPP实验中的BombLab过程，包括每个phase的解决策略。从phase_1到phase_6，逐一分析了程序的汇编代码，理解其逻辑并找到正确输入。实验涉及字符串比较、数字计算、循环、跳转表、递归函数、字符串截取、链表和二叉树操作。通过这个实验，作者深化了对反汇编指令和数据结构的理解，同时也认识到解决问题时的耐心和细心的重要性。

摘要由CSDN通过智能技术生成

CSAPP — BombLab

Bomb Lab

实验任务

是“拆炸弹”。所谓炸弹，其实就是一个二进制的可执行文件，分为六个阶段每个阶段要求输入一个字符串。如果字符串输入错误，系统就会输出 BOOM!!!。

实验目的

通过观察用汇编语言描述的程序行为来猜测符合条件的字符串，加深对汇编程序以及计算机运行流程的理解以及各类数据结构在内存和机器级层面如何体现。

实验准备

相关命令

反汇编指令
objdump -d [objfile]
GDB基本命令
break [function_name] or *[address]
在某个函数或某条指令处下断点。
continue
继续调试。
x /[Length][Format] [Address expression]
以给定的参数查看内存中的内容。
AT&T 汇编指令
常用的主要是移动指令、比较指令和跳转指令，从网上或者课件里都能找到。

更多命令可以查看官网的GDB命令参考。

准备工作

首先通过bomb.c文件可以大致看出整个程序的执行流程。

/* Do all sorts of secret stuff that makes the bomb harder to defuse. */
    initialize_bomb();

    printf("Welcome to my fiendish little bomb. You have 6 phases with\n");
    printf("which to blow yourself up. Have a nice day!\n");

    /* Hmm...  Six phases must be more secure than one phase! */
    input = read_line();             /* Get input                   */
    phase_1(input);                  /* Run the phase               */
    phase_defused();                 /* Drat!  They figured it out!
				      * Let me know how they did it. */
    printf("Phase 1 defused. How about the next one?\n");

    /* The second phase is harder.  No one will ever figure out
     * how to defuse this... */
    input = read_line();
    phase_2(input);
    phase_defused();
    printf("That's number 2.  Keep going!\n");

mian函数

main函数主要的部分，可以看到程序分为6个phase，每一个phase都需要输入一行字符串，然后对应调用 phase_n()函数进行判断是否触发炸弹。

通过objdump -d bomb > bomb.txt反汇编得到相应的汇编程序，根据汇编程序来得到正确的字符串输入。

拆除炸弹

phase_1

代码

0000000000400ee0 <phase_1>:
  400ee0:	48 83 ec 08          	sub    $0x8,%rsp
  400ee4:	be 00 24 40 00       	mov    $0x402400,%esi
  400ee9:	e8 4a 04 00 00       	callq  401338 <strings_not_equal>
  400eee:	85 c0                	test   %eax,%eax
  400ef0:	74 05                	je     400ef7 <phase_1+0x17>
  400ef2:	e8 43 05 00 00       	callq  40143a <explode_bomb>
  400ef7:	48 83 c4 08          	add    $0x8,%rsp
  400efb:	c3                   	retq

方法
通过主函数的汇编程序，知道我们输入的字符串存放在%rdi内；
在0x400ee9处调用了strings_not_equal(%rdi,%rsi)函数，在此之前将地址0x402400移入%esi内；
使用命令gdb bomb开始调试程序，在phase_1和explode_bomb函数处设置断点。

输入字符串为 one!

观察%rdi内的内容验证是否储存着我们输入的字符串。
在这里插入图片描述
通过分析，可以知道phase_1只是简单的将输入字符串与%rsi内的内容即0x402400地址处的字符串进行比较，如果相等则拆弹成功。

因此正确字符串为Border relations with Canada have never been better.。重新运行后输入正确字符串通过phase_1。

phase_2

代码

0000000000400efc <phase_2>:
  400efc:	55                   	push   %rbp
  400efd:	53                   	push   %rbx
  400efe:	48 83 ec 28          	sub    $0x28,%rsp
  400f02:	48 89 e6             	mov    %rsp,%rsi
  400f05:	e8 52 05 00 00       	callq  40145c <read_six_numbers>
  400f0a:	83 3c 24 01          	cmpl   $0x1,(%rsp)
  400f0e:	74 20                	je     400f30 <phase_2+0x34>
  400f10:	e8 25 05 00 00       	callq  40143a <explode_bomb>
  400f15:	eb 19                	jmp    400f30 <phase_2+0x34>
  400f17:	8b 43 fc             	mov    -0x4(%rbx),%eax
  400f1a:	01 c0                	add    %eax,%eax
  400f1c:	39 03                	cmp    %eax,(%rbx)
  400f1e:	74 05                	je     400f25 <phase_2+0x29>
  400f20:	e8 15 05 00 00       	callq  40143a <explode_bomb>
  400f25:	48 83 c3 04          	add    $0x4,%rbx
  400f29:	48 39 eb             	cmp    %rbp,%rbx
  400f2c:	75 e9                	jne    400f17 <phase_2+0x1b>
  400f2e:	eb 0c                	jmp    400f3c <phase_2+0x40>
  400f30:	48 8d 5c 24 04       	lea    0x4(%rsp),%rbx
  400f35:	48 8d 6c 24 18       	lea    0x18(%rsp),%rbp
  400f3a:	eb db                	jmp    400f17 <phase_2+0x1b>
  400f3c:	48 83 c4 28          	add    $0x28,%rsp
  400f40:	5b                   	pop    %rbx
  400f41:	5d                   	pop    %rbp
  400f42:	c3                   	retq

%rsp	%rsp+0x4	%rsp+0x8	%rsp+0xc	%rsp+0x10	rsp+0x14	%rbp=rsp+0x18
Number[0]	Number[1]	Number[2]	Number[3]	Number[4]	Number[5]	Edge

数组中元素储存位置

方法
系统大体流程

400f05:	e8 52 05 00 00       	callq  40145c <read_six_numbers>   ;调用read_six_numbers函数
400f0a:	83 3c 24 01          	cmpl   $0x1,(%rsp) ;比较：rsp寄存器内的内容和1
400f0e:	74 20                	je     400f30 <phase_2+0x34>  ;相等，则跳转到0x400f30处

400f30:	48 8d 5c 24 04       	lea    0x4(%rsp),%rbx ;将rsp+4的地址传给rbx
400f35:	48 8d 6c 24 18       	lea    0x18(%rsp),%rbp ;rsp+24的地址传给rbp
400f3a:	eb db                	jmp    400f17 <phase_2+0x1b> ;跳转到0x400f17

400f17:	8b 43 fc             	mov    -0x4(%rbx),%eax ;将rbx-4地址处的内容传给eax  也就是将rsp的内容传给eax
400f1a:	01 c0                	add    %eax,%eax ;乘2
400f1c:	39 03                	cmp    %eax,(%rbx) ;比较eax内容和rbx地址下的内容
400f1e:	74 05                	je     400f25 <phase_2+0x29> ;相等跳转到0x400f25处

400f25:	48 83 c3 04          	add    $0x4,%rbx ;rbx+4,既地址加4
400f29:	48 39 eb             	cmp    %rbp,%rbx ;比较rbp和rbx两个地址，rbp(=rsp+24)相当与循环哨兵，每循环一次后rbx+4
400f2c:	75 e9                	jne    400f17 <phase_2+0x1b>  ;若不相等则跳转到0x400f17
400f2e:	eb 0c                	jmp    400f3c <phase_2+0x40>  ;若相等，则跳转到0x400f3c

400f3c:	48 83 c4 28          	add    $0x28,%rsp
400f40:	5b                   	pop    %rbx
400f41:	5d                   	pop    %rbp
400f42:	c3                   	retq

因此总的系统流程就是将(%rsp)=1作为数组的第一个元素，然后后一个元素是前一个元素的2倍，数组一共有6个元素，因此循环哨兵设置为rbp=rsp+24。所以正确答案为：
phase_2 正确答案

phase_3

代码

0000000000400f43 <phase_3>:
  400f43:	48 83 ec 18          	sub    $0x18,%rsp
  400f47:	48 8d 4c 24 0c       	lea    0xc(%rsp),%rcx
  400f4c:	48 8d 54 24 08       	lea    0x8(%rsp),%rdx
  400f51:	be cf 25 40 00       	mov    $0x4025cf,%esi
  400f56:	b8 00 00 00 00       	mov    $0x0,%eax
  400f5b:	e8 90 fc ff ff       	callq  400bf0 <__isoc99_sscanf@plt>
  400f60:	83 f8 01             	cmp    $0x1,%eax
  400f63:	7f 05                	jg     400f6a <phase_3+0x27>
  400f65:	e8 d0 04 00 00       	callq  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),%eax
  400f75:	ff 24 c5 70 24 40 00 	jmpq   *0x402470(,%rax,8)
  400f7c:	b8 cf 00 00 00       	mov    $0xcf,%eax
  400f81:	eb 3b                	jmp    400fbe <phase_3+0x7b>
  400f83:	b8 c3 02 00 00       	mov    $0x2c3,%eax
  400f88:	eb 34                	jmp    400fbe <phase_3+0x7b>
  400f8a:	b8 00 01 00 00       	mov    $0x100,%eax
  400f8f:	eb 2d                	jmp    400fbe <phase_3+0x7b>
  400f91:	b8 85 01 00 00       	mov    $0x185,%eax
  400f96:	eb 26                	jmp    400fbe <phase_3+0x7b>
  400f98:	b8 ce 00 00 00       	mov    $0xce,%eax
  400f9d:	eb 1f                	jmp    400fbe <phase_3+0x7b>
  400f9f:	b8 aa 02 00 00       	mov    $0x2aa,%eax
  400fa4:	eb 18                	jmp    400fbe <phase_3+0x7b>
  400fa6:	b8 47 01 00 00       	mov    $0x147,%eax
  400fab:	eb 11                	jmp    400fbe <phase_3+0x7b>
  400fad:	e8 88 04 00 00       	callq  40143a <explode_bomb>
  400fb2:	b8 00 00 00 00       	mov    $0x0,%eax
  400fb7:	eb 05                	jmp    400fbe <phase_3+0x7b>
  400fb9:	b8 37 01 00 00       	mov    $0x137,%eax
  400fbe:	3b 44 24 0c          	cmp    0xc(%rsp),%eax
  400fc2:	74 05                	je     400fc9 <phase_3+0x86>
  400fc4:	e8 71 04 00 00       	callq  40143a <explode_bomb>
  400fc9:	48 83 c4 18          	add    $0x18,%rsp
  400fcd:	c3                   	retq

方法
首先观察到程序调用了sscanf函数来获取我们的输入，观察寄存器%esi或0x4025cf处的内容
显示结果是"%d，%d"，即从我们的输入中获取两个int型数。然后判断sscanf函数的返回值，如果小于等于1，则触发炸弹，否则继续。
从后文分析可以看出这两个数分别存储在 rsp+8和rsp+0xc 处。
继续分析代码

400f60:	83 f8 01             	cmp    $0x1,%eax              ;比较sscanf返回值
400f63:	7f 05                	jg     400f6a <phase_3+0x27>  ;大于1则跳转到0x400f6a

400f6a:	83 7c 24 08 07       	cmpl   $0x7,0x8(%rsp)         ;比较rsp+8处值和7
400f6f:	77 3c                	ja     400fad <phase_3+0x6a>

最低0.47元/天解锁文章

C__C_

关注

6
点赞
踩
11

收藏

觉得还不错? 一键收藏
1
评论
CSAPP实验——BombLab

CSAPP的第二个实验BombLab：实验目的主要是通过观察用汇编语言描述的程序行为来猜测符合条件的字符串，加深对汇编程序以及计算机运行流程的理解以及各类数据结构在内存和机器级层面如何体现。
复制链接

扫一扫