虚函数逆向分析

最新推荐文章于 2024-01-23 19:49:43 发布
最新推荐文章于 2024-01-23 19:49:43 发布
阅读量186 收藏 1
点赞数
原文链接：http://www.cnblogs.com/nothx/p/8537334.html
版权

[背景]

       虚函数表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中分配了指向这个表的指针的内存，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得尤为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

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

 

 

无继承时虚函数表

 1 编写demo：
 2 #include <iostream>
 3 using namespace std;
 4  
 5 class base_class
 6 {
 7 private:
 8 int m_base;
 9 public:
10 virtual void v_func1()
11 {
12 cout << "This is base_class's v_func1()" << endl;
13 }
14 virtual void v_func2()
15 {
16 cout << "This is base_class's v_func2()" << endl;
17 }
18 virtual void v_func3()
19 {
20 cout << "This is base_class's v_func3()" << endl;
21 }
22 };

OD载入逆向分析

构造函数

我们查看一下虚表指针

内存中应该为：

 

 

 

 

 

虚表单一继承：

 1 改写demo
 2 class base_class
 3 {
 4 public:
 5 virtual void v_func1()
 6 {
 7 cout << "This is base_class's v_func1()" << endl;
 8 }
 9 virtual void v_func2()
10 {
11 cout << "This is base_class's v_func2()" << endl;
12 }
13 virtual void v_func3()
14 {
15 cout << "This is base_class's v_func3()" << endl;
16 }
17 };
18 class dev_class : public base_class
19 {
20 public:
21 virtual void v_func4()
22 {
23 cout << "This is dev_class's v_func4()" << endl;
24 }
25 virtual void v_func5()
26 {
27 cout << "This is dev_class's v_func5()" << endl;
28 }
29 };

构造函数逆向如下

基类构造函数改写指针

此时虚表

 

在派生类中又改写了虚函数指针

此时虚表

在内存中的布局应该为：

 

在改写虚表指针的时候，按照父类-子类的顺序存放在虚表中

 

重写父类虚函数继承

 1 我们改写demo：
 2 class base_class
 3 {
 4 public:
 5 virtual void v_func1()
 6 {
 7 cout << "This is base_class's v_func1()" << endl;
 8 }
 9 virtual void v_func2()
10 {
11 cout << "This is base_class's v_func2()" << endl;
12 }
13 virtual void v_func3()
14 {
15 cout << "This is base_class's v_func3()" << endl;
16 }
17 };
18 class dev_class : public base_class
19 {
20 public:
21 virtual void v_func3()
22 {
23 cout << "This is dev_class's v_func4()" << endl;
24 }
25 virtual void v_func4()
26 {
27 cout << "This is dev_class's v_func5()" << endl;
28 }
29 };

OD载入分析构造函数

我们按照上述方法打印虚表

在构造基类的时候

在派生类修改虚表指针后

可以很清楚的发现，在第三个虚函数地址被派生类修改

内存中布局应该是这样

 

 

 

多重继承下的虚函数表_子类没有改写父类

 1 我们改写demo
 2  
 3 class base_class_A
 4 {
 5 public:
 6 virtual void v_func1()
 7 {
 8 cout << "This is base_class_A's v_func1()" << endl;
 9 }
10 virtual void v_func2()
11 {
12 cout << "This is base_class_A's v_func2()" << endl;
13 }
14 
15 };
16 class base_class_B
17 {
18 public:
19 virtual void v_func3()
20 {
21 cout << "This is base_class_B's v_func1()" << endl;
22 }
23 virtual void v_func4()
24 {
25 cout << "This is base_class_B's v_func2()" << endl;
26 }
27 };
28 class dev_class : public base_class_A,base_class_B
29 {
30 public:
31 virtual void v_func5()
32 {
33 cout << "This is dev_class`s v_func" << endl;
34 }
35 
36 };

OD载入分析构造函数

Base_a 虚表

Base_b

Dev:

修改虚表指针

和

通过分析我们可以发现当多重继承中会存在多张虚表

内存中的布局应该为：

 

 

多重继承下的虚函数表_子类改写父类

 1 我们改写demo
 2 class base_class_A
 3 {
 4 public:
 5 virtual void v_func1()
 6 {
 7 cout << "This is base_class_A's v_func1()" << endl;
 8 }
 9 virtual void v_func2()
10 {
11 cout << "This is base_class_A's v_func2()" << endl;
12 }
13 
14 };
15 class base_class_B
16 {
17 public:
18 virtual void v_func3()
19 {
20 cout << "This is base_class_B's v_func1()" << endl;
21 }
22 virtual void v_func4()
23 {
24 cout << "This is base_class_B's v_func2()" << endl;
25 }
26 };
27 class dev_class : public base_class_A,base_class_B
28 {
29 public:
30 virtual void v_func1()
31 {
32 cout << "This is dev_class`s v_func1" << endl;
33 }
34 virtual void v_func3()
35 {
36 cout << "This is dev_class`s v_func3" << endl;
37 }
38 virtual void v_fun5()
39 {
40 cout << "This is dev_class`s v_func5" << endl;
41 }
42 
43 };

虚表为

内存中的布局为

 

我们稍微修改下我们的demo

加入成员变量：

 1 class root 
 2 {
 3 private:
 4 int m_r1;
 5 int m_r2;
 6 public:
 7 root()
 8 {
 9 m_r1 = 1;
10 m_r2 = 2;
11 }
12 ~root(){};
13 virtual void v_funr()
14 {
15 cout << "This is root" << endl;
16 }
17  
18 
19 };
20 class base_class_A : public root
21 {
22 private:
23 int m_a;
24  
25 public:
26 base_class_A()
27 {
28 m_a = 3;
29 }
30 ~base_class_A(){};
31 virtual void v_func1()
32 {
33 cout << "This is base_class_A's v_func1()" << endl;
34 }
35 virtual void v_func2()
36 {
37 cout << "This is base_class_A's v_func2()" << endl;
38 }
39 
40 };
41 class base_class_B : public root
42 {
43 private: 
44 int m_b ;
45  
46 public:
47 base_class_B()
48 {
49 m_b = 4;
50 }
51 ~base_class_B(){};
52 void v_func3()
53 {
54 cout << "This is base_class_B's v_func1()" << endl;
55 }
56 void v_func4()
57 {
58 cout << "This is base_class_B's v_func2()" << endl;
59 }
60 };
61  
62 class dev_class : public base_class_A,base_class_B
63 {
64 private: 
65 int m_a;
66 int m_b;
67 int m_c;
68 public:
69 dev_class();
70 ~dev_class(){};
71 virtual void v_func1()
72 {
73 cout << "This is dev_class`s v_func1" << endl;
74 }
75 virtual void v_func3()
76 {
77 cout << "This is dev_class`s v_func3" << endl;
78 }
79 virtual void v_fun5()
80 {
81 cout << "This is dev_class`s v_func5" << endl;
82 }
83 
84 };
85  
86  dev_class :: dev_class():m_a(1),m_b(2),m_c(3)
87 {
88  
89 }

加入成员变量

我们看下最开始的基类root的构造

虚表为

 

 

虚拟多重继承

 1 Demo：
 2 class root 
 3 {
 4 private:
 5 int m_r1;
 6 int m_r2;
 7 public:
 8 root()
 9 {
10 m_r1 = 1;
11 m_r2 = 2;
12 }
13 ~root(){};
14 virtual void v_funr()
15 {
16 cout << "This is root" << endl;
17 }
18  
19  
20 };
21 class base_class : virtual public root
22 {
23 private:
24 int m_a;
25 int m_b;
26  
27 public:
28 base_class()
29 {
30 m_a = 3;
31 m_b = 4;
32 }
33 ~base_class(){};
34 virtual void v_funr()
35 {
36 cout << "This is base_class_A's v_funcr()" << endl;
37 }
38 virtual void v_func1()
39 {
40 cout << "This is base_class_A's v_func1()" << endl;
41 }
42 virtual void v_func2()
43 {
44 cout << "This is base_class_A's v_func2()" << endl;
45 }
46  
47 };
48  
49 class dev_class :virtual public base_class
50 {
51 private: 
52 int m_a;
53 int m_b;
54 int m_c;
55 public:
56 dev_class();
57 ~dev_class(){};
58 virtual void v_funr()
59 {
60 cout << "This is dev_class's v_funcr()" << endl;
61 }
62 virtual void v_func1()
63 {
64 cout << "This is dev_class`s v_func1" << endl;
65 }
66 virtual void v_func3()
67 {
68 cout << "This is dev_class`s v_func3" << endl;
69 }
70 virtual void v_fun5()
71 {
72 cout << "This is dev_class`s v_func5" << endl;
73 }
74  
75 };
76 dev_class :: dev_class():m_a(1),m_b(2),m_c(3)
77 {
78  
79 }

Dev_class的时候

此时[eax+0x4]和[eax+0x2c]存放的不再为虚表指针，而是一个偏转

我们可以查看下地址

在root构造时，

00A22BA7    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]
00A22BAA    C700 90DCA200   mov dword ptr ds:[eax],offset vft.base_class::`vftable'
00A22BB0    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]
00A22BB3    8B48 04         mov ecx,dword ptr ds:[eax+0x4]                                          ; 得到偏转表地址
00A22BB6    8B51 04         mov edx,dword ptr ds:[ecx+0x4]                                          ; 得到偏移地址
00A22BB9    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]
00A22BBC    C74410 04 A0DCA>mov dword ptr ds:[eax+edx+0x4],offset vft.base_class::`vftable'         ; 通过偏转地址计算得到虚基类指针并修改
00A22BC4    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]
00A22BC7    8B48 04         mov ecx,dword ptr ds:[eax+0x4]
00A22BCA    8B51 04         mov edx,dword ptr ds:[ecx+0x4]
00A22BCD    83EA 10         sub edx,0x10                                                            ; 减去类大小得到相对长度
00A22BD0    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]
00A22BD3    8B48 04         mov ecx,dword ptr ds:[eax+0x4]                                          ; 得到偏移表地址
00A22BD6    8B41 04         mov eax,dword ptr ds:[ecx+0x4]                                          ; 得到偏移
00A22BD9    8B4D F8         mov ecx,dword ptr ss:[ebp-0x8]
00A22BDC    891401          mov dword ptr ds:[ecx+eax],edx                                          ; 将偏移大小存放在虚基类前
00A22BDF    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]
00A22BE2    C740 08 0300000>mov dword ptr ds:[eax+0x8],0x3
00A22BE9    8B45 F8         mov eax,dword ptr ss:[ebp-0x8]

可以发现刚刚分析 出来的偏转地址均指向 虚基类（root）的虚表指针

而FFFFFFFC则为-4，指向偏转表的前一个DWORD地址

我们继续看base类的构造

通过偏移，使子类可以很容易访问到虚基类，进而对虚基类指针进行改写

00FE2C8C    837D 08 00      cmp dword ptr ss:[ebp+0x8],0x0                                          ; 判断虚基类
00FE2C90    74 51           je Xvft.00FE2CE3
00FE2C92    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2C95    C740 04 58DDFE0>mov dword ptr ds:[eax+0x4],offset vft.dev_class::`vbtable'              ; 偏转表
00FE2C9C    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2C9F    C740 2C 68DDFE0>mov dword ptr ds:[eax+0x2C],offset vft.dev_class::`vbtable'             ; 偏转表
00FE2CA6    8B4D EC         mov ecx,dword ptr ss:[ebp-0x14]
00FE2CA9    83C1 18         add ecx,0x18                                                            ; 得到虚基类指针
00FE2CAC    E8 5FE7FFFF     call vft.00FE1410
00FE2CB1    C745 FC 0000000>mov dword ptr ss:[ebp-0x4],0x0
00FE2CB8    8B85 20FFFFFF   mov eax,dword ptr ss:[ebp-0xE0]
00FE2CBE    83C8 01         or eax,0x1
00FE2CC1    8985 20FFFFFF   mov dword ptr ss:[ebp-0xE0],eax                                         ; 虚基类已经构造
00FE2CC7    6A 00           push 0x0
00FE2CC9    8B4D EC         mov ecx,dword ptr ss:[ebp-0x14]
00FE2CCC    83C1 28         add ecx,0x28
00FE2CCF    E8 BFE6FFFF     call vft.00FE1393                                                       ; base构造
00FE2CD4    8B85 20FFFFFF   mov eax,dword ptr ss:[ebp-0xE0]
00FE2CDA    83C8 02         or eax,0x2
00FE2CDD    8985 20FFFFFF   mov dword ptr ss:[ebp-0xE0],eax
00FE2CE3    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2CE6    C700 30DDFE00   mov dword ptr ds:[eax],offset vft.dev_class::`vftable'                  ; dev的虚表指针（指向fun3,fun5）
00FE2CEC    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2CEF    8B48 04         mov ecx,dword ptr ds:[eax+0x4]
00FE2CF2    8B51 04         mov edx,dword ptr ds:[ecx+0x4]                                          ; 得到偏移
00FE2CF5    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2CF8    C74410 04 40DDF>mov dword ptr ds:[eax+edx+0x4],offset vft.dev_class::`vftable'          ; 通过偏移访问到虚基类并修改
00FE2D00    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D03    8B48 04         mov ecx,dword ptr ds:[eax+0x4]
00FE2D06    8B51 08         mov edx,dword ptr ds:[ecx+0x8]                                          ; 取到base类偏移
00FE2D09    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]                                         ; 得到基址
00FE2D0C    C74410 04 4CDDF>mov dword ptr ds:[eax+edx+0x4],offset vft.dev_class::`vftable'          ; 修改base类虚表指针
00FE2D14    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D17    8B48 04         mov ecx,dword ptr ds:[eax+0x4]
00FE2D1A    8B51 04         mov edx,dword ptr ds:[ecx+0x4]                                          ; 得到长度
00FE2D1D    83EA 14         sub edx,0x14                                                            ; 减去类大小
00FE2D20    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D23    8B48 04         mov ecx,dword ptr ds:[eax+0x4]
00FE2D26    8B41 04         mov eax,dword ptr ds:[ecx+0x4]
00FE2D29    8B4D EC         mov ecx,dword ptr ss:[ebp-0x14]
00FE2D2C    891401          mov dword ptr ds:[ecx+eax],edx                                          ; 将偏移存放在虚基类前
00FE2D2F    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D32    8B48 04         mov ecx,dword ptr ds:[eax+0x4]
00FE2D35    8B51 08         mov edx,dword ptr ds:[ecx+0x8]
00FE2D38    83EA 24         sub edx,0x24
00FE2D3B    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]                                         ; 得到基址
00FE2D3E    8B48 04         mov ecx,dword ptr ds:[eax+0x4]                                          ; 偏转表
00FE2D41    8B41 08         mov eax,dword ptr ds:[ecx+0x8]                                          ; 偏移大小
00FE2D44    8B4D EC         mov ecx,dword ptr ss:[ebp-0x14]                                         ; 基址
00FE2D47    891401          mov dword ptr ds:[ecx+eax],edx                                          ; 将相对偏移存放在base前
00FE2D4A    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D4D    C740 08 0100000>mov dword ptr ds:[eax+0x8],0x1                                          ; m_a = 1
00FE2D54    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D57    C740 0C 0200000>mov dword ptr ds:[eax+0xC],0x2                                          ; m_b = 2
00FE2D5E    8B45 EC         mov eax,dword ptr ss:[ebp-0x14]
00FE2D61    C740 10 0300000>mov dword ptr ds:[eax+0x10],0x3                                         ; m_c = 3

最终虚表为

在虚表中我们发现

而我们在funcr时发现有这样的结构

在dev.func1也有这样的结构

我们现在总结在内存中，虚拟继承结构如下：

 

结论：

在分析虚函数，当存在多重继承（虚拟继承中有虚函数）情况下，虚表的结构会发生变化，将会多出一个偏转表，通过对偏移地址的操作进而去访问和改写父类虚表指针。而其在内存中的结构也与普通继承有些不同（考虑跟编译器有关！）。

 

*转载请注明来自游戏安全实验室（GSLAB.QQ.COM）

转载于:https://www.cnblogs.com/nothx/p/8537334.html

weixin_30915951
关注
C++-继承-单继承-虚函数-内存结构分析-汇编分析-逆向分析（一）
插件开发
11-11 551
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型级别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态“。对于使用者而言，意思就是将复杂的子类，按照父类统一的函数接口来进行访问。
d3d透视逆向篇：第7课 虚表和虚函数分析
mutashizhe的博客
12-11 680
课程不能继续了，这里基础比较差的朋友，自己补充下知识。 了解：类、继承、虚函数、纯虚函数、虚表 逆向学习目的：分析虚表和虚函数地址 #include "pch.h" #include <iostream> #include "windows.h" using namespace std; class Animal { private: int height=0x8888; int...
从逆向分析角度看C++虚函数
个人技术博客
07-28 6096
从逆向分析角度，粗略地分析了虚拟表的结构，本人才疏学浅，有误之处，望各位指正
逆向虚函数
程序员人生
09-27 665
 对象结构体  虚函数表    xxxxx    0x800Jmp sub_xxxxxx xxxxx       xxxxx  0x800 0x250Jmp sub_xxxxxx xxxxx 0x800x250   ObjectAD0x20 0x80        虚函数表存在了.rdata节区...
C++逆向分析--虚函数（多态的前置）
最新发布
qq_30528603的博客
01-23 2405
真正调用的其实是call eax这句汇编代码，我们看到他的硬编码是FF D0。说明他是个间接调用。将this指针的第一项放入eax，又将eax的第一项复制给edx，此时将this指针给ecx（如果是linux平台g++编译this指针是赋值给rdi的 _x64情况下）最后将edx的第一项赋值给eax。我们先来看一个例子，这次试验用的是windows平台下的VS编译器不同编译器的细节是不一样的原理大差不差。现在我们知道虚函数，如果是通过对象去调用，和普通成员方法没什么区别，但是如果通过指针或者引用去调用。
函数逆向分析
05-12 159
函数逆向分析 作者：ONDragon 环境:Windows 7 VC6.0。 一、 函数源码 __cdecl int CTestPlus(int a,int b,int c) { return a + b + c; } __stdcall int STestPlus(int a,int b,int c) { re...
c++虚函数逆向分析
Night May Say
11-22 1994
虚函数表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中分配了指向这个表的指针的内存，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得尤为重要了，它就像一个地图一样，指明了实际所应该调用的函数。 虚函数表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实
x86逆向 - 虚函数1
08-04
在x86逆向工程中，虚函数是一个关键的概念，特别是在处理C++对象和类时。...这种技术在逆向分析复杂的类层次结构和动态行为时非常有用。理解虚函数和虚表的工作原理对于深入剖析C++程序的内部运作至关重要。
逆向分析c++虚函数指针和虚函数表及其内存结构
&Ψ的博客
11-23 1380
1. 环境和工具 Ubuntu 18.04.4 LTS g++ 7.5.0 objdump 静态反汇编 gdb + peda插件 动态调试 2. 从一个程序说起 #include <iostream> class AA { public: virtual void print() {std::cout << "AA" <<std::endl;} }; class BB { public: virtual void print() {std::cou
逆向之虚函数执行分析
菜鸟-传奇
04-26 189
逆向之虚函数执行分析 同名函数调用 函数重复定义： 　　在C++中，同一类中是不能定义两个名字相同、参数个数和类型都相同的函数的，否则就是“重复定义” 不同层次的函数调用: 　　在类的继承层次结构中在不同的层次中可以出现名字相同、参数个数和类型都相同而功能不同的函数。编译系统按照同名覆盖的原则决定调用的对象。 虚函数 虚函数的定义： 　　虚函数的作用是允许在派生类中重新定义与基类同名...
【C++逆向】虚表（Virtual table）逆向 | 安卓so虚函数逆向
Juruo@Security
01-14 812
【C++逆向】虚表（Virtual table）逆向 | 安卓so虚函数逆向
C++ 虚函数表解析
koozxcv的博客
01-18 391
出处：http://blog.csdn.net/haoel/article/details/1948051  C++ 虚函数表解析 前言   C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变
《C++反汇编与逆向分析技术揭秘》之11——虚函数
weixin_30633949的博客
12-19 114
虚函数的机制 当类中定义有虚函数时，编译器会将该类中所有虚函数的首地址保存在一张地址表中，这张表被称为虚函数地址表。编译器还会在类中添加一个虚表指针。 举例： CVirtual类的构造函数中没有进行任何操作，但是我们来看构造函数内部，还是有一个赋初值的操作： 这个地址指向的是一个数组： 这些数组中的内容就是虚函数的指针： 值得注意的是，如果没有虚...
【黑客免杀攻防】读书笔记14 - 面向对象逆向-虚函数、MFC逆向
weixin_30312659的博客
04-16 162
虚函数存在是为了克服类型域解决方案的缺陷，以使程序员可以在基类里声明一些能够在各个派生类里重新定义的函数。 1 识别简单的虚函数 代码示例： #include "stdafx.h" #include <Windows.h> class CObj { public: CObj():m_Obj_1(0xAAAAAAAA),m_Obj_2(0xBBBB) { ...
【逆向】从逆向角度看C++
weixin_49816179的博客
01-02 1960
从逆向角度观察C++，了解程序执行时的内部机理。
Microsoft Visual C++ 逆向第二部分:类、方法和RTTI
u013043103的博客
08-09 1234
Microsoft Visual c++是Win32使用最广泛的编译器，所以Win32逆向工作者熟悉其内部工作方式是很重要的。能够识别编译器生成的粘合代码有助于快速将注意力集中在程序员编写的实际代码上。它还有助于恢复项目的高层结构。在这篇由2部分组成的文章的第二部分(请参阅:第一部分:异常处理)中，我将介绍如何在MSVC中实现c++机制，包括类布局、虚函数、RTTI。假如您熟悉基本的c++和汇编语言。 基本类布局 为了说明下面的内容，让我们思考这个简单的例子: class A { ...
逆向基础（三）--- IDA中的虚函数
热门推荐
移动（IoT）安全
07-20 1万+
这片文章（C++中的多态及实现原理（虚函数））阐述了多态的使用以及利用虚函数实现多态的原理，主要是从正向侧说明。我们在逆向过程中也会经常遇到虚函数的使用，在逆向中，在IDA中，虚函数又是什么样子的呢？ 本文实例代码： /* C++多态测试实例 */ #include <string> #include <iostream> using namespace std; //基类 class Base { public: virtual void vfunc1() {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值