Large Bin Attack

2021-09-18

Large Bin

chunk size>0x400(0x40个机器字长)
large bin链表的个数为63个，被分为6组。每个bin里的chunk大小不用相等，但是在一定范围内。这也导致了LB chunk 与其他chunk的些许不同。
LIFO双链表

LB Chunk

被释放进Large Bin中的chunk，除了以前经常见到的prev_size、size、fd、bk之外，还具有fd_nextsize和bk_nextsize:

fd_nextsize，bk_nextsize：只有chunk可先的时候才使用，不过用于较大的chunk（large chunk）
fd_nextsize指向前一个与当前chunk大小不同的第一个空闲块，不包含bin的头指针
bk_nextsize指向后一个与当前chunk大小不同的第一个空闲块，不包含bin的头指针
一般空闲的large chunk在fd的遍历顺序中，按照由大到小的顺序排列。这样可以避免在寻找合适chunk时挨个遍历

LB管理机制

我们通过一个样例直观感受一下large bin的管理机制

#include <stdio.h>
#include <stdlib.h>

int count = 0;

char* mymalloc(int size)
{
	char *ptr = malloc(size - 0x10);
	char *gap = malloc(0x10);
	printf("No.%d===>%p\n",++count,ptr - 0x10);
	return ptr;
}
int main()
{
	char *ptr0 = mymalloc(0x400);
	char *ptr1 = mymalloc(0x410);
	char *ptr2 = mymalloc(0x420);
	char *ptr3 = mymalloc(0x430);
	char *ptr4 = mymalloc(0x400);
	char *ptr5 = mymalloc(0x410);
	char *ptr6 = mymalloc(0x420);
	char *ptr7 = mymalloc(0x430);

	free(ptr2); 
	free(ptr3); 
	free(ptr0); 
	free(ptr1); 
	free(ptr7); 
	free(ptr6); 
	free(ptr5); 
	free(ptr4); 
	malloc(0x440); //trigger that sort largebin from unsorted bin to largebins
	return 0;
}

调试一下

No.1===>0x602000
No.2===>0x602830
No.3===>0x602c60
No.4===>0x6030a0
No.5===>0x6034f0
No.6===>0x603910
No.7===>0x603d40
No.8===>0x604180

pwndbg> largebins
0x400 [corrupted]
FD: 0x6030a0 —▸ 0x604180 —▸ 0x602c60 —▸ 0x603d40 —▸ 0x602830 ◂— ...
BK: 0x6034f0 —▸ 0x602000 —▸ 0x603910 —▸ 0x602830 —▸ 0x603d40 ◂— ...
#看一眼chunk4的结构
pwndbg> chunkinfo 0x6030a0
==================================
            Chunk info            
==================================
Status :  Freed 
Unlinkable : True
Result of unlink :
       FD->bk (*0x604198) = BK (0x6030a0 -> 0x7ffff7dd1f68) 
       BK->fd (*0x7ffff7dd1f78) = FD (0x6030a0 -> 0x604180) 
Freeable : false -> Double free chunkaddr(0x6030a0) inused bit is not seted )
prev_size : 0x0                  
size : 0x430                  
prev_inused : 1                    
is_mmap : 0                    
non_mainarea : 0                     
fd : 0x604180                  
bk : 0x7ffff7dd1f68                  
fd_nextsize : 0x602c60  
bk_nextsize : 0x602000

也就是说其结构是

图中从左往右的chunk直接都由fd链接，反之则由bk链接

可以看到对于相同大小的堆块，先释放的堆块为堆头；对于不同的堆块，大的在前

Manners of attack

总的来说存在两种攻击方式：

在申请largebin的过程中，伪造largebin的bk_nextsize，实现非预期内存申请。
在largebin插入的过程中，伪造largebin的bk_nextsize以及bk，实现任意地址写堆地址。

Principle

非预期地址申请

申请largebin大小的chunk时是从最小的开始找起的，也就是通过bk_nextsize反向遍历双链表

if ((victim = first (bin)) != bin &&(unsigned long) (victim->size) >= (unsigned long) (nb)) 
//判断链表的第一个结点，即最大的chunk是否大于要申请的size
{
	victim = victim->bk_nextsize; 
	while (((unsigned long) (size = chunksize (victim)) <(unsigned long) (nb))) 
//从最小的chunk开始，反向遍历 chunk size链表，直到找到第一个大于等于所需chunk大小的chunk退出循环
		victim = victim->bk_nextsize;  //漏洞点，伪造bk_nextsize

	if (victim != last (bin) && victim->size == victim->fd->size) 
//申请的chunk对应的chunk存在多个结点，则申请相应堆头的下个结点，不申请堆头。
        victim = victim->fd;
	remainder_size = size - nb;
	unlink (av, victim, bck, fwd); //largebin unlink 操作
	... 
	return p;
}

fake bk_nextsize ==> 非预期地址
构造好数据使得非预期地址通过unlink的检查
申请出非预期地址

绕过unlink的检查：伪造的内存空间将fd与bk按照smallbinunlink的利用方式设置，而将bk_nextsize和fd_nextsize设置成0，这样就不会对这两个字段进行操作了。

条件能够修改free LB chunk

效果申请出非预期地址

任意地址写堆地址

从UB取出chunk到LB时，

...//将largebin从unsorted bin中取下
unsorted_chunks(av)->bk = bck;
bck->fd = unsorted_chunks (av);
...
//否则这个chunk将会成为堆头，`bk_nextsize`和`fd_nextsize`将被置位
      victim->fd_nextsize = fwd;
      victim->bk_nextsize = fwd->bk_nextsize; 
//由于fwd->bk_nextsize可控，因此victim->bk_nextsize可控
      fwd->bk_nextsize = victim;
      victim->bk_nextsize->fd_nextsize = victim; 
//victim->bk_nextsize可控，因此实现了往任意地址写victim的能力 1*
    }
  bck = fwd->bk; //由于fwd->bk可控，因此bck可控
...
mark_bin (av, victim_index);
//设置fd与bk完成插入
victim->bk = bck; 
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim; //bck可控，因此实现了往任意地址写victim的能力 2*
...
}

很明显有两个漏洞点，都可以向任意地址写入victim地址（堆地址），类似于UB attack，我们可以覆盖global_max_fast，从而进行fastbin attack