C++逆向基础与正向比较——Virtual关键字、虚函数表以及动态绑定的实现

拼搏现实的明天。 2023-02-18 03:29 13阅读 0赞

### 一. 简单介绍一下 ###

添加Virtual后会多出四个字节，位于结构体的首地址。这个指针是虚函数表指针(vptr / 虚表指针)，指向了虚函数表的开始位置；对虚函数表头继续寻址，就可以得到虚函数指针了。可以看出，结构体首地址的指针为三级指针。

在vptr指向的位置维护了一个数组，即虚函数表，里面保存了当前类内所有虚函数的地址。

这里找来一张图可以参考一下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70][]

### 二. 使用指针调用虚函数 ###

使用指针来调用一下函数：

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    using namespace std;
    
    class A {
    public:
    	virtual void func() {
    		cout << 111 << endl;
    	}
    };
    int main(int argc, char* argv[])
    {
    	A a;
    	((void(*)(void))**(int ***)&a)();
    
    	system("pause");
    	return 0;
    }

来看一下内存数据：都是取的窗口左上方四个四个字节的数据。在下一个窗口的搜索栏就可以看到利用这个地址进行搜索。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70 3][]

然而最后用地址直接调用函数出现断错误，单步跟了一下地址没有变化，应该是编译器认为这是一个野指针不允许这样调用吧。

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    using namespace std;
    
    class A {
    public:
    	virtual void func() {
    		cout << 111 << endl;
    	}
    };
    int main(int argc, char* argv[])
    {
    	A a;
    	(*(void(*)(void))**(int ***)&a)();
    	(*(void(*)(void))0x00049de9)();
    	// e9 9d 04 00
    	system("pause");
    	return 0;
    }

### 三. 有继承关系时的虚函数表 ###

1. 下面是一个明显的**多继承**，Sub分别继承了Base1和Base2。类有多继承时就会创建父类个数的虚函数表。下列代码使用数组的当时遍历了这两张表。另外，编译器将子类Sub的虚函数放在了第一章表内。

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    using namespace std;
    struct Base1
    {
    public:
    	virtual void Fn_1()
    	{
    		printf("Base1:Fn_1...\n");
    	}
    	virtual void Fn_2()
    	{
    		printf("Base1:Fn_2...\n");
    	}
    };
    struct Base2
    {
    public:
    	virtual void Fn_3()
    	{
    		printf("Base2:Fn_3...\n");
    	}
    	virtual void Fn_4()
    	{
    		printf("Base2:Fn_4...\n");
    	}
    };
    struct Sub :Base1, Base2
    {
    public:
    	virtual void Fn_5()
    	{
    		printf("Sub:Fn_5...\n");
    	}
    	virtual void Fn_6()
    	{
    		printf("Sub:Fn_6...\n");
    	}
    };
    
    
    int main(int argc, char *argv[])
    {
    	Sub s;
    	for (int j = 0; j < 2; j++) {
    		for (int i = 0; i < 4; i++) {
    			if (j > 0 && i > 1) break;
    			((void(*)()) (((int ***)&s)[j][i])) ();
    		}
    	}
    
    	//((void(*)())*(*(int ***)&s + i)) ();
    	//((void(*)()) (((int ***)&s)[1] [0])) ();
    	//((void(*)()) (((int ***)&s)[1] [0])) ();
    
    
    	system("pause");
    	return 0;
    }

2. 还有就是多继承有覆盖的情况，编译器会将父类虚函数表里的指针替换为子类函数指针，如果子类还有子类，继续替换即可。

而子类的虚函数还是会放在第一个虚函数表中。

### 四. 利用虚函数实现多态 ###

C++有动态绑定(前期绑定)和静态绑定(运行时绑定)之分，即编译期确定地址和运行时确定地址。成员变量和普通函数就是编译期绑定地址，而加了virtual的函数就是运行时绑定地址。

因为此类函数只有在运行时通过调用对象的this指针来确定需要调用的函数，进而根据调用对象的虚函数表来找到调用函数的地址。

1. 通过下面的代码就可以看出：成员变量和普通函数是编译期绑定地址，而加了virtual的函数就是运行时绑定地址。

**虚析构函数：**在编程时，将父类析构函数定义为虚函数那么在使用父类指针指向子类对象时，子类就可以重写父类的虚函数。

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    using namespace std;
    class Base
    {
    public:
    	int x;
    public:
    	Base()
    	{
    		x = 100;
    	}
    	void Function_1()
    	{
    		printf("Base:Function_1...\n");
    	}
    	virtual void Function_2()
    	{
    		printf("Base:Function_2...virtual\n");
    	}
    };
    class Sub :public Base
    {
    public:
    	int x;
    public:
    	Sub()
    	{
    		x = 200;
    	}
    	void Function_1()
    	{
    		printf("Sub:Function_1...\n");
    	}
    	virtual void Function_2()
    	{
    		printf("Sub:Function_2...virtual\n");
    	}
    };
    
    int main(int argc, char* argv[])
    {
    	Base b;
    	Base *pb = &b;
    	int n = pb->x;
    	printf("%x\n", n);
    
    	pb->Function_1();		
    	pb->Function_2();
    
    	system("pause");
    	return 0;
    }

2. 通过下面的反汇编代码来看动态绑定。

Call：有直接调用和间接调用之分。直接Call + 地址；间接Call + \[地址\]

E8：直接；FF：间接

virtual函数使用的是FF调用。

0040D9E3 8B 4D F0             mov         ecx,dword ptr [ebp-10h]							
    	0040D9E6 8B 11                mov         edx,dword ptr [ecx]							
    	0040D9E8 8B F4                mov         esi,esp							
    	0040D9EA 8B 4D F0             mov         ecx,dword ptr [ebp-10h]							
    	0040D9ED FF 12                call        dword ptr [edx]

第一行ecx保存的就是this指针也就是虚函数表的地址；

\[ecx\]相当于做了一次寻址操作，将虚函数表的地址赋值给edx；

call 调用 edx寻址后的地址，也就是函数地址了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200616023117330.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200616010638424.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200616010654750.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200616010701778.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlbGxvX015RHJlYW0=,size_16,color_FFFFFF,t_70