嵌入式学习资源——突破C++的虚拟指针－C++程序的缓冲区溢出攻击

backend注：本文来自Phrack56期的《SMASHING C++ VPTRS》。正如大多数国外黑客的文章，技术原理及应用都讲得比较详细，但所提供的源代码似乎总是会存在不大不小的问题。这也许是因为他们觉得应该让读者自己去研究和调试，以更好地掌握这些技术。或许以后我也会这样做。；）

测试环境：

　　操作系统：Red Hat 6.1 (i386)
　　内核版本：Kernel 2.2.14
　　内核补丁：None　　　　　　　 Non-executable stack patch (by Solar Design)
　　C++编译器：gcc
　　

---[[ 前言 ]]--------------------------------------

　　到目前为止，我所掌握的缓冲区溢出程序都是针对C编程语言的。虽然C语言编程在UNIX系统中几乎无处不在，但越来越多的C++程序也开始出现了。对于大多数情况，C语言的溢出技术对于C++语言也是适用的，但C++的面向对象的特性也导致了新的缓冲区溢出技术。下面以x86 Linux系统和C++ GNU编译器为平台进行分析。

---[[ 基础－－简单的C++程序 ]]--------------------------------------

　　我不愿在这里浪费时间讲解太多的C++语言基础。如果你对C++或面向对象编程技术一无所知，请先找本这方面的书籍看看。在继续往下看之前，请确认你已经掌握或了解以下C++术语：
　　
　　1、Class（类）
　　2、Object（对象）
　　3、Method（方法）
　　4、Virtual（虚拟）
　　5、Inherit（继承）
　　6、Derivative（派生）

　　接着，把下面的两个程序看完，确认你了解每条语句的含义和作用：
　　
// bo1.cpp
// C++基础程序

#include
#include

class MyClass
{
　　private:
　　　　char Buffer[32];
　　public:
　　　　void SetBuffer(char *String)
　　　　{
　　　　　　strcpy(Buffer, String);
　　　　}
　　　　void PrintBuffer()
　　　　{
　　　　　　printf("%s\n", Buffer);
　　　　}
};

void main()
{
　　 MyClass Object;

　　 Object.SetBuffer("string");
　　 Object.PrintBuffer();
}

===========================================================

// bo2.cpp
// 有缓冲区溢出漏洞的常见C++程序

#include
#include

class BaseClass
{
　　private:
　　　　char Buffer[32];
　　public:
　　　　void SetBuffer(char *String)
　　　　{
　　　　　　strcpy(Buffer,String);　// 存在缓冲区溢出漏洞
　　　　}
　　　　virtual void PrintBuffer()
　　　　{
　　　　　　printf("%s\n",Buffer);
　　　　}
};

class MyClass1:public BaseClass
{
　　public:
　　　　void PrintBuffer()
　　　　{
　　　　　　printf("MyClass1: ");
　　　　　　BaseClass::PrintBuffer();
　　　　}
};

class MyClass2:public BaseClass
{
　　public:
　　　　void PrintBuffer()
　　　　{
　　　　　　printf("MyClass2: ");
　　　　　　BaseClass::PrintBuffer();
　　　　}
};

void main()
{
　　BaseClass *Object[2];

　　Object[0] = new MyClass1;
　　Object[1] = new MyClass2;

　　Object[0]->SetBuffer("string1");
　　Object[1]->SetBuffer("string2");
　　Object[0]->PrintBuffer();
　　Object[1]->PrintBuffer();
}

　　以下是bo2.cpp编译后的运行结果：

[backend@isbase test]> ./bo2
MyClass1: string1
MyClass2: string2
[backend@isbase test]>

　　再一次提醒，在继续往下看时，确信你读懂了上面的程序，特别是对象虚拟（virtual）方法PrintBuffer()。与SetBuffer()方法不同，PrintBuffer方法必须在基类BaseClass的派生类MyClass1和MyClass2中声明并实现。这使得SetBuffer与PrintBuffer方法在运行时的处理会有所不同。

　我们知道，虚拟方法与非虚拟方法的一个不同之处是，非虚拟方法的调用是在编译时确定（通常称为“静态绑定”），而虚拟方法的调用却是在程序时确定的（通常称为“动态绑定”）。下面以上例中的BaseClass基类及其派生类为例，对动态绑定的机制做一些解释。

　　编译器在编译时首先检查BaseClass基类的声明。在本例，编译器首先为私有变量Buffer（字符串型）保留32个字节，接着为非虚拟方法SetBuffer()计算并指定相应的调用地址（静态绑定处理），最后在检查到虚拟方法PrintBuffer()时，将做动态绑定处理，即在类中分配4个字节用以存放该虚拟方法的指针。结构如下：

　　　　BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBVVVV

说明： B 变量Buffer占用。
　　　 V 虚拟方法指针占用。

　　这个指针通常被称为“VPTR”（Virtual Pointer），它指向一个“VTABLE”结构中的函数入口之一。每一个类都有一个VTABLE。如下图所示：

Object[0]: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBVVVV
　　　　　　　　　　　　　　　　　　　　　 =+==
　　　　　　　　　　　　|
　　　　 +------------------------------+
　　　　 |
　　　　 +--> VTABLE_MyClass1: IIIIIIIIIIIIPPPP

Object[1]: BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBWWWW
　　　　　　　　　　　　　　　　　　　　　 =+==
　　　　　　　　　　　　|
　　　　 +------------------------------+
　　　　 |
　　　　 +--> VTABLE_MyClass2: IIIIIIIIIIIIQQQQ

说明： B 变量Buffer占用。
　　　 V 指向VTABLE_MyClass1的VPTR指针占用。
　　　 W 指向VTABLE_MyClass2的VPTR指针占用。
　　　 I 其它用途的数据
　　　 P MyClass1对象实例的PrintBuffer()方法的地址指针。
　　　 Q MyClass2对象实例的PrintBuffer()方法的地址指针。

　　我们可以发现，VPTR位于进程内存中Buffer变量之后。即当调用危险的strcpy()函数时有可能覆盖VPTR的内容！
　　
　　根据rix的研究测试，对于Windows平台上的Visual C++ 6.0，VPTR位于对象的起始位置，因此这里提到的技术无法产生作用。这点与GNU C++有很大的不同。

---[[ 剖析VPTR ]]--------------------------------------

　　在Linux下当然是使用GDB来分析了：

[backend@isbase test]> gcc -o bo2 bo2.cpp
[backend@isbase test]> gdb bo2
GNU gdb 4.18
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.　Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux"...
(gdb) disassemble main
Dump of assembler code for function main:
0x8049400

:　　　 push　 %ebp
0x8049401 :　　 mov　　%esp,%ebp
0x8049403 :　　 sub　　$0x8,%esp
0x8049406 :　　 push　 %edi
0x8049407 :　　 push　 %esi
0x8049408 :　　 push　 %ebx
0x8049409 :　　 push　 $0x24
0x804940b :　　call　 0x804b580 <__builtin_new>
0x8049410 :　　add　　$0x4,%esp
0x8049413 :　　mov　　%eax,%eax
0x8049415 :　　mov　　%eax,%ebx
0x8049417 :　　push　 %ebx
0x8049418 :　　call　 0x804c90c <__8MyClass1>

0x804941d :　　add　　$0x4,%esp
0x8049420 :　　mov　　%eax,%esi
0x8049422 :　　jmp　　0x8049430
0x8049424 :　　call　 0x8049c3c <__throw>
0x8049429 :　　lea　　0x0(%esi,1),%esi
0x8049430 :　　mov　　%esi,0xfffffff8(%ebp)
0x8049433 :　　push　 $0x24
0x8049435 :　　call　 0x804b580 <__builtin_new>
0x804943a :　　add　　$0x4,%esp
0x804943d :　　mov　　%eax,%eax
0x804943f :　　mov　　%eax,%esi
0x8049441 :　　push　 %esi
0x8049442 :　　call　 0x804c8ec <__8MyClass2>
0x8049447 :　　add　　$0x4,%esp
0x804944a :　　mov　　%eax,%edi
0x804944c :　　jmp　　0x8049455
0x804944e :　　mov　　%esi,%esi
0x8049450 :　　call　 0x8049c3c <__throw>
0x8049455 :　　mov　　%edi,0xfffffffc(%ebp)
0x8049458 :　　push　 $0x804cda2
0x804945d :　　mov　　0xfffffff8(%ebp),%eax
0x8049460 :　　push　 %eax
0x8049461 :　　call　 0x804c930
0x8049466 :　 add　　$0x8,%esp
0x8049469 :　 push　 $0x804cdaa
---Type to continue, or q to quit---
0x804946e :　 mov　　0xfffffffc(%ebp),%eax
0x8049471 :　 push　 %eax
0x8049472 :　 call　 0x804c930
0x8049477 :　 add　　$0x8,%esp
0x804947a :　 mov　　0xfffffff8(%ebp),%edx
0x804947d :　 mov　　0x20(%edx),%eax
0x8049480 :　 add　　$0x8,%eax
0x8049483 :　 mov　　0xfffffff8(%ebp),%edx
0x8049486 :　 push　 %edx
0x8049487 :　 mov　　(%eax),%edi
0x8049489 :　 call　 *%edi
0x804948b :　 add　　$0x4,%esp
0x804948e :　 mov　　0xfffffffc(%ebp),%edx
0x8049491 :　 mov　　0x20(%edx),%eax
0x8049494 :　 add　　$0x8,%eax
0x8049497 :　 mov　　0xfffffffc(%ebp),%edx
0x804949a :　 push　 %edx
0x804949b :　 mov　　(%eax),%edi
0x804949d :　 call　 *%edi
0x804949f :　 add　　$0x4,%esp
0x80494a2 :　 xor　　%eax,%eax
0x80494a4 :　 jmp　　0x80494d0
0x80494a6 :　 jmp　　0x80494d0
0x80494a8 :　 push　 %ebx
0x80494a9 :　 call　 0x804b4f0 <__builtin_delete>
0x80494ae :　 add　　$0x4,%esp
0x80494b1 :　 jmp　　0x8049424

0x80494b6 :　 push　 %esi
0x80494b7 :　 call　 0x804b4f0 <__builtin_delete>
0x80494bc :　 add　　$0x4,%esp
0x80494bf :　 jmp　　0x8049450
0x80494c1 :　 jmp　　0x80494c8
0x80494c3 :　 call　 0x8049c3c <__throw>
0x80494c8 :　 call　 0x8049fc0
0x80494cd :　 lea　　0x0(%esi),%esi
0x80494d0 :　 lea　　0xffffffec(%ebp),%esp
0x80494d3 :　 pop　　%ebx
0x80494d4 :　 pop　　%esi
0x80494d5 :　 pop　　%edi
---Type to continue, or q to quit---
0x80494d6 :　 leave　
0x80494d7 :　 ret　　
0x80494d8 :　 nop　　
0x80494d9 :　 nop　　
0x80494da :　 nop　　
0x80494db :　 nop　　
0x80494dc :　 nop　　
0x80494dd :　 nop　　
0x80494de :　 nop　　
0x80494df :　 nop　　
End of assembler dump.
(gdb)

　　以下是对该程序汇编代码的解释：

0x8049400

:　　　 push　 %ebp
0x8049401 :　　 mov　　%esp,%ebp
0x8049403 :　　 sub　　$0x8,%esp
0x8049406 :　　 push　 %edi
0x8049407 :　　 push　 %esi
0x8049408 :　　 push　 %ebx

　　构建堆栈。为Object[]数组保留8个字节（即两个4字节指针地址），则Object[0]的指针存放在0xfffffff8(%ebp)，Object[1]的指针存放在0fffffffc(%ebp)。接着保存寄存器。

0x8049409 :　　 push　 $0x24
0x804940b :　　call　 0x804b580 <__builtin_new>
0x8049410 :　　add　　$0x4,%esp

　　首先调用__builtin_new，在堆（heap）中分配0x24（36字节）给Object[0]，并将其首地址保存到EAX寄存器中。这36字节中前32字节是Buffer变量的，后4字节由VPTR占用。

0x8049413 :　　mov　　%eax,%eax
0x8049415 :　　mov　　%eax,%ebx
0x8049417 :　　push　 %ebx
0x8049418 :　　call　 0x804c90c <__8MyClass1>
0x804941d :　　add　　$0x4,%esp

　　将对象的首地址压栈，然后调用__8MyClass1函数。这其实是MyClass1对象的构造函数（constructor）。

(gdb) disassemble __8MyClass1
Dump of assembler code for function __8MyClass1:
0x804c90c <__8MyClass1>:　　　　push　 %ebp
0x804c90d <__8MyClass1+1>:　　　mov　　%esp,%ebp
0x804c90f <__8MyClass1+3>:　　　push　 %ebx
0x804c910 <__8MyClass1+4>:　　　mov　　0x8(%ebp),%ebx

　　寄存器EBX现在存放着指向分配的36个字节的指针（在C++语言中，称之为"This"指针）。

0x804c913 <__8MyClass1+7>:　　　push　 %ebx
0x804c914 <__8MyClass1+8>:　　　call　 0x804c958 <__9BaseClass>
0x804c919 <__8MyClass1+13>:　　 add　　$0x4,%esp

　　首先调用基类BaseClass的构造函数。

(gdb) disassemble __9BaseClass
Dump of assembler code for function __9BaseClass:
0x804c958 <__9BaseClass>:　　　 push　 %ebp
0x804c959 <__9BaseClass+1>:　　 mov　　%esp,%ebp
0x804c95b <__9BaseClass+3>:　　 mov　　0x8(%ebp),%edx

　　寄存器EDX现在存放着指向分配的36个字节的指针（"This"指针）。

0x804c95e <__9BaseClass+6>:　　 movl　 $0x804e01c,0x20(%edx)

　　将0x804e01c存放到EDX+0x20（=EDX+32）。让我们看看该0x804e01c地址内存数据：

(gdb) x 0x804e01c
0x804e01c <__vt_9BaseClass>:　　0x00000000

　　可以看到这个存放到EDX+0x20（即该对象的VPTR位置）的地址是基类BaseClass的VTABLE地址。
　　现在回到MyClass1对象的构造函数：

0x804c91c <__8MyClass1+16>:　　 movl　 $0x804e010,0x20(%ebx)

　　将0x804e010存放到EBX+0x20（即VPTR）。同样让我们看看该0x804e010地址内存数据：

(gdb) x 0x804e010
0x804e010 <__vt_8MyClass1>:　　 0x00000000

　　现在，我们知道VPTR被改写了，再在它的内容是MyClass1对象的VTABLE地址。当返回到main()函数时寄存器EAX中存放着该对象在内存中的指针。

0x8049420 :　　mov　　%eax,%esi
0x8049422 :　　jmp　　0x8049430
0x8049424 :　　call　 0x8049c3c <__throw>
0x8049429 :　　lea　　0x0(%esi,1),%esi
0x8049430 :　　mov　　%esi,0xfffffff8(%ebp)

　　将得到的地址指针赋予Object[0]。然后程序对Object[1]进行同样的处理，只不过返回的地址不同罢了。在经过以上对象初始化处理后，将执行以下指令：

0x8049458 :　　push　 $0x804cda2
0x804945d :　　mov　　0xfffffff8(%ebp),%eax
0x8049460 :　　push　 %eax

　　将0x804cda2和Object[0]的值压栈。观察一下0x804cda2的内容：

(gdb) x/s 0x804cda2
0x804cda2 <_IO_stdin_used+30>:　 "string1"

　　可知该地址存放了将要通过基类BaseClass的SetBuffer函数拷贝到Buffer中的字符串"string1"。

0x8049461 :　　call　 0x804c930
0x8049466 :　 add　　$0x8,%esp

　　调用基类BaseClass的SetBuffer()方法。注意到这种SetBuffer方法的调用是“静态绑定”（因为它不是虚拟方法）。对Object[1]的处理也是一样的。

　　为了验证这两个对象在运行时都被正确地初始化，我们将要设置如下断点：

0x8049410: 获得第一个对象的地址。
0x804943a: 获得第二个对象的地址。
0x804947a: 检验对象的初始化是否正确。

(gdb) break *0x8049410
Breakpoint 1 at 0x8049410
(gdb) break *0x804943a
Breakpoint 2 at 0x804943a
(gdb) break *0x804947a
Breakpoint 3 at 0x804947a

　　现在运行这个程序：

St

相关文章

供应链合同管理解决方案：从需求梳理到上线运维

二手交易合同管理解决方案：从需求梳理到上线运维

财税代理合同管理解决方案：从需求梳理到上线运维

母婴亲子合同管理解决方案：从需求梳理到上线运维

智能制造合同管理解决方案：从需求梳理到上线运维

美业门店合同管理解决方案：从需求梳理到上线运维

法律咨询合同管理解决方案：从需求梳理到上线运维

制造业合同管理解决方案：从需求梳理到上线运维

源码分类

热门源码

最新资讯

联系我们