Linux堆溢出漏洞利用之off by one

技术研究
Created At :
Count:2.2k Views 👀 :
  1. 前言
    1. off-by-one 漏洞原理
    2. off-by-one的分类
    3. off-by-one 利用思路
    4. 达成漏洞利用的条件
    5. 达成漏洞利用的具体操作
  2. 简单例子

前言

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

off-by-one 漏洞原理

off-by-one 是指单字节缓冲区溢出，这种漏洞的产生往往与边界验证不严和字符串操作有关，当然也不排除写入的 size 正好就只多了一个字节的情况。其中边界验证不严通常包括

  • 使用循环语句向堆块中写入数据时，循环的次数设置错误（这在 C 语言初学者中很常见）导致多写入了一个字节。
  • 字符串操作不合适

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

off-by-one的分类

off-by-one总共可以分为两种利用方式

chunk overlapping

off-by-one overwrite allocated

off-by-one overwrite freed

off-by-one null byte

unlink

off-by-one small bin

off-by-one large bin

这种划分的依据是基于利用的思路不同。

第一种的利用的核心思路主要是为了进行chunk overlapping,而第二种的利用思路则是想要触发unlink。

off-by-one 利用思路

  1. 溢出字节为可控制任意字节：通过修改大小造成块结构之间出现重叠，从而泄露其他块数据，或是覆盖其他块数据。也可使用 NULL 字节溢出的方法
  2. 溢出字节为 NULL 字节：在 size 为 0x100 的时候，溢出 NULL 字节可以使得 prev_in_use 位被清，这样前块会被认为是 free 块。（1） 这时可以选择使用 unlink 方法（见 unlink 部分）进行处理。
  3. （2） 另外，这时 prev_size 域就会启用，就可以伪造 prev_size ，从而造成块之间发生重叠。此方法的关键在于 unlink 的时候没有检查按照 prev_size 找到的块的大小与prev_size 是否一致。

最新版本代码中，已加入针对 2 中后一种方法的 check ，但是在 2.28 及之前版本并没有该 check 。

达成漏洞利用的条件

off-by-one并不是全都可以达到利用的目的的。首先就要求堆必须以要求的size+0x4字节（x86）的大小进行分配。如果不满足这个条件那么就无法覆盖到inuse位了。

这个是由于堆的字节对齐机制造成的，简单的说堆块是以8字节进行对齐的（x64为16字节）。如果malloc(1024)，那么实际会分配1024+8=1032字节，这一点很好理解。

但是如果是malloc(1020)呢，1020+8=1028字节，而1028不满足8字节对齐，那么实际只会分配1020+4=1024字节，多出的4个字节由下一块的prev_size提供空间。

达成漏洞利用的具体操作

off-by-one overwrite allocated

![](Linux堆溢出漏洞利用之off by one/3.png)

A是发生有off-by-one的堆块，其中B和C是allocated状态的块。而且C是我们的攻击目标块。

我们的目标是能够读写块C，那么就应该去构造出这样的内存布局。然后通过off-by-one去改写块B的size域（注意要保证inuse域的值为1，否则会触发unlink导致crash）以实现把C块给整个包含进来。通过把B给free掉，然后再allocated一个大于B+C的块就可以返回B的地址，并且可以读写块C了。

具体的操作是：

  1. 构成图示的内存布局

  2. off-by-one改写B块的size域(增加大小以包含C，inuse位保持1)

  3. free掉B块

  4. malloc一个B+C大小的块

  5. 通过返回的地址即可对C任意读写

注意，必须要把C块整个包含进来，否则free时会触发check，导致抛出错误。因为ptmalloc实现时的验证逻辑是当前块的下一块的inuse必须为1，否则在free时会触发异常，这一点本来是为了防止块被double free而做的限制，却给我们伪造堆块造成了障碍。

off-by-one overwrite freed

在这种情况下堆块布局依然是这样的

![](Linux堆溢出漏洞利用之off by one/3.png)

A是发生有off-by-one的堆块，其中B是free状态的块,C是allocated块。而且C是我们的攻击目标块。

我们的目标是能够读写块C，那么就应该去构造出这样的内存布局。然后通过off-by-one去改写块B的size域（注意要保证inuse域的值为1）以实现把C块给整个包含进来。但是这种情况下的B是free状态的,通过增大B块包含C块，然后再allocated一个B+C尺寸的堆块就可以返回B的地址，并且可以读写块C了。

具体的操作是：

  1. 构成图示的内存布局

  2. off-by-one改写B块的size域(增加大小以包含C，inuse位保持1)

  3. malloc一个B+C大小的块

  4. 通过返回的地址即可对C任意读写

off-by-one null byte

这种情况就与上面两种有所不同了，在这种情况下溢出的这个字节是一个’\x00’字节。这种off-by-one可能是最为常见的，因为诸如:

1
2
3
4
5
6
buf=malloc(124);

if(strlen(str==124))
{
 strcpy(buf,str);
}

就会产生这种null byte off-by-one，即拷贝一个字符串到一个同样长的缓冲区时，并未考虑到NULL字节 相比于前两种，这种利用方式就显得更复杂，而且对内存布局的要求也更高了。

首先内存布局需要三个块

![](Linux堆溢出漏洞利用之off by one/3.png)

其中A,B,C都是allocated块，A块发生了null byte off-by-one,覆盖了B块的inuse位，使B块伪造为空。然后在分配两个稍小的块b1、b2，根据ptmalloc的实现，这两个较小块（不能是fastbin）会分配在B块中。然后只要释放掉b1，再释放掉C，就会引发从原B块到C的合并。那么只要重新分配原B大小的chunk，就会重新得到b2。在这个例子中，b2是我们要进行读写的目标堆块。最后的堆块布局如下所示：

![](Linux堆溢出漏洞利用之off by one/4.png)

布局堆块结构如ABC所示

  1. off-by-one覆盖B，目的是覆盖掉B的inuse位

  2. free B

  3. malloc b1,malloc b2

  4. free C

  5. free b1

  6. malloc B

  7. overlapping b2

这种利用方式成功的原因有两点:

通过prev_chunk()宏查找前块时没有对size域进行验证

当B块的size域被伪造后，下一块的pre_size域无法得到更新。

简单例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdlib.h>
#include <string.h>
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;
}

我们自己编写的 my_gets 函数导致了一个 off-by-one 漏洞，原因是 for 循环的边界没有控制好导致写入多执行了一次，这也被称为栅栏错误

ptr数组大小为16 我们写入了17

两次malloc

我们来调试一下

![](Linux堆溢出漏洞利用之off by one/1.png)

两个malloc

![](Linux堆溢出漏洞利用之off by one/2.png)

上图是我们输入了 17个A， 可以看到数据发生了溢出覆盖到了下一个堆块的 prev_size 域

还有一种是字符串相关

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

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 的发生。 strlen 是我们很熟悉的计算 ascii 字符串长度的函数，这个函数在计算字符串长度时是不把结束符 ‘\x00’ 计算在内的，但是 strcpy 在复制字符串时会拷贝结束符 ‘\x00’ 。这就导致了我们向chunk1中写入了25个字节，我们使用gdb进行调试可以看到这一点。

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 1204342476@qq.com

💰

©2016-2023 answer77

Built with Hexo and 3-hexo theme

×

Help us with donation