main_arena 结构

main_arena 是 glibc 中堆管理器的核心数据结构，你可以把它理解为堆内存的总指挥部。

main_arena 的基本概念：

1
2
// glibc 源码中
static struct malloc_state main_arena;  // 全局变量，主分配区

main_arena 是一个全局变量，类型是 struct malloc_state。它存储了堆管理器运行所需的所有元数据，包括 bins 链表（fastbin、smallbin、largebin、unsorted bin）的头指针 ，top chunk 的位置等。

由于main_arena 是 libc.so 的一个全局变量，它在 libc 中的偏移是固定的。因此使用 main_arena 泄露 libc_base 也是一种常见的攻击手法。

main_arena 通常在 __malloc_hook 的高地址 0x10 处

1
2
3
4
main_arena = __malloc_hook + 0x10

# 所以很多 exp 先泄露 __malloc_hook，再计算 main_arena
main_arena_addr = libc.sym['__malloc_hook'] + 0x10

main_arena 的内部结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// glibc 2.32 malloc/malloc.c

struct malloc_state
{
    /* 第一部分：锁和标志位 */
    __libc_lock_define (, mutex);       // 0x00: 4 字节 (但通常占用 0x4)
    int flags;                          // 0x04: 4 字节
    int have_fastchunks;                // 0x08: 4 字节

    /* 第二部分：fastbins 数组 */
    mfastbinptr fastbinsY[NFASTBINS];   // 0x0C: NFASTBINS=10, 每个8字节=80字节
    // 但实际从 0x10 开始对齐

    /* 第三部分：特殊指针 */
    mchunkptr top;                      // 0x60: top chunk 指针
    mchunkptr last_remainder;           // 0x68: 拆分后剩余 chunk 指针

    /* 第四部分：bins 数组 */
    mchunkptr bins[NBINS * 2 - 2];     // 0x70: 254 个指针 = 2032 字节
    // NBINS = 128, 2*128-2 = 254

    /* 第五部分：bitmap */
    unsigned int binmap[BINMAPSIZE];    // 0x860: BINMAPSIZE=4, 16 字节

    /* 第六部分：链表和统计 */
    struct malloc_state *next;          // 0x870: 指向下一个 arena
    struct malloc_state *next_free;     // 0x878: 空闲链表

    INTERNAL_SIZE_T attached_threads;   // 0x880
    INTERNAL_SIZE_T system_mem;         // 0x888
    INTERNAL_SIZE_T max_system_mem;     // 0x890
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
main_arena 基址 (例如: 0x7f1234567b80)
│
├─ 0x00 ~ 0x03: mutex (__libc_lock_define)
│    ┌──────────────────────────────┐
│    │ mutex (int)                  │  0x00
│    ├──────────────────────────────┤
│    │ flags (int)                  │  0x04
│    ├──────────────────────────────┤
│    │ have_fastchunks (int)        │  0x08
│    ├──────────────────────────────┤
│    │ padding / alignment          │  0x0C
│    ├──────────────────────────────┤
│    │ fastbinsY[0]  (0x20)         │  0x10
│    │ fastbinsY[1]  (0x30)         │  0x18
│    │ fastbinsY[2]  (0x40)         │  0x20
│    │ fastbinsY[3]  (0x50)         │  0x28
│    │ fastbinsY[4]  (0x60)         │  0x30
│    │ fastbinsY[5]  (0x70)         │  0x38
│    │ fastbinsY[6]  (0x80)         │  0x40
│    │ fastbinsY[7]  (0x88)         │  0x48  (注意: 0x88在64位下与0x80同大小)
│    │ fastbinsY[8]  (0xA0)         │  0x50
│    │ fastbinsY[9]  (0xB0?)        │  0x58  (最大 fastbin)
│    ├──────────────────────────────┤
│    │ top chunk 指针               │  0x60
│    ├──────────────────────────────┤
│    │ last_remainder 指针          │  0x68
│    └──────────────────────────────┘
│
├─ 0x70: bins[] 数组开始 (这里是关键!)
│
│    ┌──────────────────────────────┐
│    │ bins[0]  (fd of unsorted)    │  0x70  ← unsorted bin 头节点的 fd
│    │ bins[1]  (bk of unsorted)    │  0x78  ← unsorted bin 头节点的 bk
│    ├──────────────────────────────┤  bin 1: unsorted bin -> main_arena + 0x80
│    │ bins[2]  (smallbin 0 fd)     │  0x80
│    │ bins[3]  (smallbin 0 bk)     │  0x88
│    ├──────────────────────────────┤  bin 2: smallbin 0 (0x20 大小)
│    │ bins[4]  (smallbin 1 fd)     │  0x90
│    │ bins[5]  (smallbin 1 bk)     │  0x98
│    ├──────────────────────────────┤  bin 3: smallbin 1 (0x30 大小)
│    │ ...                          │
│    │ 共 62 个 small bin           │  每个 bin 占 2 个指针 (16 字节)
│    │ bin 2 ~ bin 63               │
│    ├──────────────────────────────┤
│    │ bins[124] (smallbin 61 fd)   │  0x450
│    │ bins[125] (smallbin 61 bk)   │  0x458
│    ├──────────────────────────────┤  bin 63: smallbin 61 (最大 smallbin, 0x3F0?)
│    │ bins[126] (LARGEBIN 0 fd)    │  0x460  ← 第一个 large bin 头的 fd!
│    │ bins[127] (LARGEBIN 0 bk)    │  0x468  ← 第一个 large bin 头的 bk!
│    ├──────────────────────────────┤  bin 64: large bin 0
│    │ bins[128] (large bin 1 fd)   │  0x470
│    │ bins[129] (large bin 1 bk)   │  0x478
│    ├──────────────────────────────┤  bin 65: large bin 1
│    │ ...                          │
│    │ 共 63 个 large bin           │
│    │ bin 64 ~ bin 126             │
│    ├──────────────────────────────┤
│    │ bins[248] (large bin 61 fd)  │  0x830
│    │ bins[249] (large bin 61 bk)  │  0x838
│    ├──────────────────────────────┤  bin 125: large bin 61
│    │ bins[250] (large bin 62 fd)  │  0x840
│    │ bins[251] (large bin 62 bk)  │  0x848
│    ├──────────────────────────────┤  bin 126: large bin 62 (最大)
│    │ bins[252] (???)              │  0x850  ← 这是 bins[126*2-2] 到 bins[126*2-1-2]
│    │ bins[253] (???)              │  0x858  ← 即 bins[250] 和 bins[251]
│    └──────────────────────────────┘  实际 bins 数量: NBINS*2-2 = 254
│                                        索引范围: bins[0] ~ bins[253]
│
├─ 0x860: binmap[] 开始
│    ┌──────────────────────────────┐
│    │ binmap[0]                    │  0x860
│    │ binmap[1]                    │  0x864
│    │ binmap[2]                    │  0x868
│    │ binmap[3]                    │  0x86C
│    ├──────────────────────────────┤
│    │ padding?                     │  0x870
│    ├──────────────────────────────┤
│    │ *next                        │  0x878  (实际可能对齐到 0x878)
│    ├──────────────────────────────┤
│    │ *next_free                   │  0x880
│    ├──────────────────────────────┤
│    │ attached_threads             │  0x888
│    ├──────────────────────────────┤
│    │ system_mem                   │  0x890
│    ├──────────────────────────────┤
│    │ max_system_mem               │  0x898
│    └──────────────────────────────┘
│
└─ 0x8A0: main_arena 结构体结束

main_arena 关键偏移速查：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# 基于 glibc 2.32 x86_64

main_arena_offsets = {
    # 基础信息
    "mutex":              0x00,   # int
    "flags":              0x04,   # int
    "have_fastchunks":    0x08,   # int
    
    # fastbins (10 个，每个 8 字节)
    "fastbinsY[0]":       0x10,   # 大小 0x20
    "fastbinsY[1]":       0x18,   # 大小 0x30
    "fastbinsY[2]":       0x20,   # 大小 0x40
    "fastbinsY[3]":       0x28,   # 大小 0x50
    "fastbinsY[4]":       0x30,   # 大小 0x60
    "fastbinsY[5]":       0x38,   # 大小 0x70
    "fastbinsY[6]":       0x40,   # 大小 0x80
    "fastbinsY[7]":       0x48,   # 大小 0x88
    "fastbinsY[8]":       0x50,   # 大小 0xA0
    "fastbinsY[9]":       0x58,   # 大小 0xB0
    
    # 特殊指针
    "top":                0x60,   # top chunk 指针
    "last_remainder":     0x68,   # 最后剩余 chunk 指针
    
    # bins 数组起始
    "bins_start":         0x70,   # bins[0] = unsorted bin fd
    
    # 各 bin 的起始 (bin N = bins[N*2-2] 和 bins[N*2-1])
    "bin_1_unsorted":     0x70,   # unsorted bin (bin[0], bin[1])
    "bin_2_small_0x20":   0x80,   # smallbin 0
    "bin_3_small_0x30":   0x90,   # smallbin 1
    # ... small bins 每 0x10 递增，直到 bin 63
    "bin_64_large_0":     0x460,  # 第一个 large bin
    "bin_65_large_1":     0x470,  # 第二个 large bin
    # ... large bins 每 0x10 递增，直到 bin 126
    
    # 尾部
    "binmap":             0x860,  # binmap[0..3]
    "next":               0x870,  # 下一个 arena
    "next_free":          0x878,  # 空闲 arena 链表
    "attached_threads":   0x880,  # 附加线程数
    "system_mem":         0x888,  # 系统内存
    "max_system_mem":     0x890,  # 最大系统内存
}
1
2
3
4
5
6
7
8

偏移	                  glibc 2.23	glibc 2.27	glibc 2.31	glibc 2.32	glibc 2.35
fastbins    	          0x10	        0x10	    0x10	    0x10	    0x10
top	                      0x60          0x60	    0x60	    0x60	    0x60
bins 起始	      		  0x68/0x70	    0x70	    0x70	    0x70	    0x70
large bin      	  		  0x458/0x460	0x460	    0x460	    0x460	    0x460
__malloc_hook → main_arena+0x10         +0x10	    +0x10	   +0x10	    (已移除)

更新: 2026-04-27 09:07:01
原文: https://www.yuque.com/idcm/wnemg9/pkwcn2laubfihq67