虚函数表与虚表钩子

最新推荐文章于 2023-11-27 16:23:37 发布
最新推荐文章于 2023-11-27 16:23:37 发布
阅读量157 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/aliflycoris/p/5400813.html
版权

0x01、前言

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

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

 

0x02、实例分析

　　 我们假设有这么一个类,有三个虚函数

class Base1 {
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);

    Base b;
    Fun pFun = NULL;
 
    // cout << "虚函数指针的地址：" << (int*)(&b) << endl;  解两次&b保存着指向虚表的指针
    cout << "虚函数表地址：" << (int*)*(int*)(&b) << endl;

    pFun = (Fun)*((int*)*(int*)(&b)+0);  // Base::f()
 　 pFun();
    pFun = (Fun)*((int*)*(int*)(&b)+1);  // Base::g()
　　 pFun();
    pFun = (Fun)*((int*)*(int*)(&b)+2);  // Base::h()    
 　 pFun();

　　而结果也是很明显的

 

　　而虚函数的存储位置我们可以通过这张图来了解

　　&b就是虚函数表的地址，按声明顺序保存着虚函数的地址。最后一个点表示结束，对于不同编译器这个值是不同的。

　　我们看看虚表的内存

　　我们可以看到前12个字节分别保存着0030104b、00301186、0030122b就是我们上图调用函数的地址，就是声明的虚函数地址，而后面则是保存着我们函数输出的字符串。

　　我们试试64位下

 

　　我们可以看到只是地址变成8字节了，我们把上面的int变成DWORD64就行，虚表中保存的地址为8字节。

　　我们分为以下4种继承情况分析虚表

　1.一般继承（无虚函数覆盖）

 

　　我们的子类对父类的虚函数不加以实现，子类加入自己的虚函数

class Derive1:public Base1
{
public:
    virtual void f1() { cout << "Derive::f1" << endl; }
    virtual void g1() { cout << "Derive::g1" << endl; }
    virtual void h1() { cout << "Derive::h1" << endl; }
};

　　那我们的虚函数表就变成这样了，子类实现的虚函数会放在父类虚函数表后面

 

　　2.一般继承（有虚函数覆盖）

class Son1:public Base1
{
public:
    void f() { cout << "Son::f" << endl; }          //对父类的实现
    virtual void g1() { cout << "Son::g1" << endl; }
    virtual void h1() { cout << "Son::h1" << endl; }

};

 

　　当我们的子类对父类中虚函数覆盖时，我们子类中实现的函数地址就会覆盖虚函数表中父类原来虚函数的地址

　　这里就实现了多态

 

　　3.多重继承（无虚函数覆盖）

class Derive : public Base1, public Base2, public Base3 
{
public:
    virtual void f1() { cout << "Derive::f1" << endl; }
    virtual void g1() { cout << "Derive::g1" << endl; }
};

 

　　在子类的虚函数表是下面这样的

　　我们遍历这个虚表

    Derive d;
    int** pVtab = (int**)&d;

    //Base1's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
    pFun = (Fun)pVtab[0][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
    pFun = (Fun)pVtab[0][1];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
    pFun = (Fun)pVtab[0][2];
    pFun();

    //Derive's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
    pFun = (Fun)pVtab[0][3];
    pFun();

    
    pFun = (Fun)pVtab[0][4];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[0][5];
    cout<<pFun<<endl;


    //Base2's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    pFun = (Fun)pVtab[1][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    pFun = (Fun)pVtab[1][1];
    pFun();

    pFun = (Fun)pVtab[1][2];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[1][3];
    cout<<pFun<<endl;



    //Base3's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    pFun = (Fun)pVtab[2][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    pFun = (Fun)pVtab[2][1];
    pFun();

    pFun = (Fun)pVtab[2][2];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[2][3];
    cout<<pFun<<endl;

　　得到遍历的结果

 

 　　我们&d的地址

　　可以看到有三个地址，分别对应着三个虚函数表

　　我们的实现中，第一个地址保存着第一个父类Base1中的三个虚函数，还有自己实现的两个虚函数，一共是5个，第六个2d6e7552截止。

　　第二个地址003f7848和第三个地址003f7834分别对应着Base2，Base3的虚函数表

　　4.多重继承（有虚函数覆盖）

class Derive : public Base1, public Base2, public Base3 
{
public:
    void f1() { cout << "Derive::f" << endl; }
    virtual void g1() { cout << "Derive::g1" << endl; }
};

　　我们可以看到，对于三个虚函数表，子类的实现将其都覆盖了 ，继续用上面那个例子遍历，不过子类的虚函数实现只有一个所以pFun = (Fun)pVtab[0][4];就是虚函数表中的结束的地址，不能在遍历，不然会崩溃

 

　　可以看到三个虚表中的第一个成员都被子类实现，并且都更新到虚表中。

　　下面是完整测试代码

// VirtualTable.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <iostream>
using namespace std;
#include <Windows.h>

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

};

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

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


class Derive : public Base1, public Base2, public Base3 
{
public:
    void f() { cout << "Derive::f" << endl; }
    virtual void g1() { cout << "Derive::g1" << endl; }
};
class Son:public Base1
{
public:
    virtual void f1() { cout << "Son::f1" << endl; }
    virtual void g1() { cout << "Son::g1" << endl; }
    virtual void h1() { cout << "Son::h1" << endl; }

};
class Son1:public Base1
{
public:
    void f() { cout << "Son::f" << endl; }
    virtual void g1() { cout << "Son::g1" << endl; }
    virtual void h1() { cout << "Son::h1" << endl; }

};

typedef void(*Fun)(void);

int main()
{
    Fun pFun = NULL;
    /*
    //遍历父类虚函数表
    Base1 b;
    //cout << "虚函数表地址：" << (int*)(&b) << endl;
    cout << "虚函数表地址:" << (DWORD64*)*(DWORD64*)(&b) << endl;

    pFun = (Fun)*((DWORD64*)*(DWORD64*)(&b)+0);  // Base::f()
    cout<<"Base f Address:"<<pFun<<endl;
    pFun();
    pFun =(Fun)*((DWORD64*)*(DWORD64*)(&b)+1);  // Base::g()
    cout<<"Base g Address:"<<pFun<<endl;
    pFun();
    pFun =(Fun)*((DWORD64*)*(DWORD64*)(&b)+2);  // Base::h()   
    cout<<"Base h Address:"<<pFun<<endl;
    pFun();
    */
    /*
    //一般继承 无覆盖
    //遍历子类虚函数表
    Son son;
    cout<<"子类虚函数表地址: "<<(int*)*(int*)&(son)<<endl;
    pFun  = (Fun)*((int*)*(int*)&(son)+0);
    cout<<"Base f Address:"<<pFun<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+1);
    cout<<"Base g Address:"<<pFun<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+2);
    cout<<"Base h Address:"<<pFun<<endl;
    pFun();

    pFun  = (Fun)*((int*)*(int*)&(son)+3);
    cout<<"son f Address:"<<pFun<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+4);
    cout<<"son g Address:"<<pFun<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+5);
    cout<<"son h Address:"<<pFun<<endl;
    pFun();
    */
    /*
    一般继承  实现覆盖
    Son1 son;
    cout<<"子类虚函数表地址: "<<(int*)*(int*)&(son)<<endl;
    pFun  = (Fun)*((int*)*(int*)&(son)+0);
    cout<<"son f Address:"<<pFun<<"我覆盖了啦啦啦"<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+1);
    cout<<"Base g Address:"<<pFun<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+2);
    cout<<"Base h Address:"<<pFun<<endl;
    pFun();

    pFun  = (Fun)*((int*)*(int*)&(son)+3);
    cout<<"son g Address:"<<pFun<<endl;
    pFun();
    pFun  = (Fun)*((int*)*(int*)&(son)+4);
    cout<<"son h Address:"<<pFun<<endl;
    pFun();
    */

    /*多重继承   无覆盖
    Derive d;
    int** pVtab = (int**)&d;

    //Base1's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
    pFun = (Fun)pVtab[0][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
    pFun = (Fun)pVtab[0][1];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
    pFun = (Fun)pVtab[0][2];
    pFun();

    //Derive's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
    pFun = (Fun)pVtab[0][3];
    pFun();

    
    pFun = (Fun)pVtab[0][4];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[0][5];
    cout<<pFun<<endl;


    //Base2's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    pFun = (Fun)pVtab[1][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    pFun = (Fun)pVtab[1][1];
    pFun();

    pFun = (Fun)pVtab[1][2];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[1][3];
    cout<<pFun<<endl;



    //Base3's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    pFun = (Fun)pVtab[2][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    pFun = (Fun)pVtab[2][1];
    pFun();

    pFun = (Fun)pVtab[2][2];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[2][3];
    cout<<pFun<<endl;
    */


    /*多重继承   有覆盖*/
    Derive d;
    int** pVtab = (int**)&d;

    //Base1's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
    pFun = (Fun)pVtab[0][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
    pFun = (Fun)pVtab[0][1];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
    pFun = (Fun)pVtab[0][2];
    pFun();

    //Derive's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
    pFun = (Fun)pVtab[0][3];
    pFun();


    //The tail of the vtable
    pFun = (Fun)pVtab[0][4];
    cout<<pFun<<endl;


    //Base2's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    pFun = (Fun)pVtab[1][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    pFun = (Fun)pVtab[1][1];
    pFun();

    pFun = (Fun)pVtab[1][2];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[1][3];
    cout<<pFun<<endl;



    //Base3's vtable
    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    pFun = (Fun)pVtab[2][0];
    pFun();

    //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    pFun = (Fun)pVtab[2][1];
    pFun();

    pFun = (Fun)pVtab[2][2];
    pFun();

    //The tail of the vtable
    pFun = (Fun)pVtab[2][3];
    cout<<pFun<<endl;
    
    return 0;
}

　　参考：http://blog.csdn.net/haoel/article/details/1948051/

 

0x03、简单虚表钩子

　　我们知道虚函数表了，那么我们有种Hook叫做虚表钩子，替换对象中虚表的函数地址，走进我们的函数，然后在实现完成之后调用原来函数

　　代码如下

// COMHook.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
using namespace std;
#include <windows.h>

typedef void(*Fun)(void);
Fun FuncAddres;
class A
{
public:
    int a ;
    int b ;
    A(){}
    ~A(){}

    virtual void f1(){ printf("Founction f1 called\n"); }

    virtual void f2(){ printf("Founction f2 called\n"); }

    virtual void f3(){ printf("Founction f3 called\n"); }
private:
    int n;
}; 
class B :public A
{
public:
    void f1();
    void f2();
    void f3();
};
void B::f1()
{
    printf("Hello f1\r\n");
}
void B::f2()
{
    printf("Hello f2\r\n");
}
void B::f3()
{
    printf("Hello f3\r\n");
}



void myfunc()
{
    cout<<"我是大坏蛋"<<endl;
    FuncAddres();
}
int _tmain(int argc, _TCHAR* argv[])
{
    
    B* b = new B;
    
    long** pplVrtable= (long**)(b);    //取得虚函数表的指针
    cout<<"My Func Address : "<<myfunc<<endl;

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ::GetCurrentProcessId());
    MEMORY_BASIC_INFORMATION mbi = {0};
    if (VirtualQueryEx(hProcess, (LPVOID)(*pplVrtable), &mbi, sizeof(mbi)) != sizeof(mbi))
        return 0;

    DWORD dwOldProtect = 0;
    if(!::VirtualProtectEx(hProcess, mbi.BaseAddress, 4, PAGE_EXECUTE_READWRITE, &dwOldProtect)) 
        return 0;

    FuncAddres = (Fun)*(int*)*pplVrtable;//保存原来的函数地址
    *(int*)*pplVrtable =(long)myfunc;//(LONG)pplVrtable[0][1];//将虚函数表的指针指向虚函数表第二个值。



    DWORD dwTemp = 0;
    ::VirtualProtectEx(hProcess, mbi.BaseAddress, 4, dwOldProtect, &dwTemp);
    CloseHandle(hProcess);

    b->f1();
    b->f2();
    b->f3();

    delete b;
    return 0;
}

 　　需要注意的是在测试的时候 B b;这样申明之后，虽然改了内存中虚表地址，但是不会调用我们的myfunc函数。只有B*b = new B;这样生成替换之后才能走进我们的myfunc函数。

转载于:https://www.cnblogs.com/aliflycoris/p/5400813.html

weixin_30429201
关注
C++虚表的hook
godzhe的博客
06-05 2209
c++类实例中.第一个成员是一个指向virtual Routine的函数地址表,类似于ssdt表.类中调用虚函数的时候，会在虚函数表中查找相应的虚函数代码执行地址. 下面一段代码调用虚函数的反汇编代码 00291B54  |.  6A 0F         push 0xF 00291B56  |.  6A 0A         push 0xA 00291B58  |.  8B4
VirtualTable(虚函数表)Hook
南宫封清的博客
05-03 1124
HOOK HOOK是用来获取，更改程序执行时的某些数据，或者用于更改程序执行流程的一种技术 INLINE HOOK 直接修改函数的代码 虚函数表的HOOK 在c++中虚函数的继承会生成一个虚函数表，来确定父类指针指向子类对象时所需要调用的具体的方法，用以实现多态。那么可不可以像静态方法一样直接调用类中的虚函数呢，答案是可行的 虚函数表在内存中的分布 大致原理如下： 实验 ...
C++ 虚函数表 Hook
lk_HIT的博客
07-11 625
当C++类中函数虚函数时，为了实现多态，C++类最开始地方会包含一个指针，该指针指向虚函数表，当我们修改这虚函数表里地址就达到了实现虚函数表Hook的目的。 代码如下： #include "VTblHook.h" #include <iostream> #include <Windows.h> class MyBase { public: MyBase(int a,int b):m_ia(a),m_ib(b){ } virtual void __cdecl Te
详解虚函数的实现过程之菱形继承（5）
寻梦&之璐
12-18 3733
大家看到标题，会不会菱形继承的虚表会不会是重复的呢？祖父类的虚表会不会在子类会不会是两份相同呢？那么我们一起来探索一下吧，冲冲冲！！ 首先我们来分析一下： 它一共定义了四个类，分别为CFurniture，CSofa，CBed和CSofaBed。CFurniture为祖父类，从CFurniture类中派生了两个子类：CSofa与CBed，它们在继承时使用了virtual的方式，即虚继承。 接下来我们来看看CSofaBed的对象的内存结构图 那么这些数据都有什么含义呢？如下所示： 看了一下，大概能看懂
虚函数HOOK
FlowShell的专栏
08-16 1898
看来一些资料，觉得这篇写的比较好，做此笔记。 栗子如下： #pragma once #include using namespace std; class A { public: int iVal1; int iVal2; virtual void print1() { cout<<"iVal1(A) = "<<iVal1<<endl; } virtual void
虚表注入源码
12-28
虚表注入的核心在于利用程序的虚函数表（Virtual Function Table，VFT或VTBL）来改变对象的行为。 虚函数表是C++中的一个特性，它允许类的实例通过指针调用虚方法，即使这些方法在派生类中被重写。每个对象都有一个...
WINDOWS钩子与API截获和替换Win32 API的开发包HookAPI源码1.62版
02-23
- **VTable Hooking**：对于COM对象，可以通过修改虚函数表实现API截获。 3. **HookAPI1.62核心功能** - **动态API Hook**：在程序运行时，动态地替换API函数。 - **静态API Hook**：编译时就将API函数替换为...
几个apihook钩子的经典例子，不要错过哟！.zip
03-28
- **VAT（Virtual Address Table）Hook**：对于导出的虚拟函数，可以修改虚函数表来实现钩子。 3. **经典例子解析** - **API Hooking Revealed** 这可能是一份关于API Hooking的深入教程，涵盖了各种钩子技术的...
API-Hook.zip_api hook_hook_hook api_钩子
09-24
4. **VTable Hook**：对于使用虚函数的类，可以通过修改对象的虚函数表（VTable）来实现Hook。这在处理面向对象的API时特别有用。 5. **Detouring**：Detouring技术，如Microsoft的Detours库，允许开发者在不修改...
apihook钩子程序例子，简单的实现过程，学习用.zip
03-28
5. **VTable Hook**：对于面向对象编程，可以修改类的虚函数表(VTable)来实现对成员函数的Hook。 在"apihijack.cpp"和"apihijack.h"中，我们可能看到关于如何定位目标函数地址、修改IAT以及创建和安装钩子的代码。...
简单的虚表Hook
qq_39708161的博客
02-06 599
最近在学习C++虚函数表的Hook,这里简单上传一个小例子,是64位32位通用的 // ConsoleApplication1.cpp : 定义控制台应用程序的入口点。 // #include #include /// 虚表指针的地址 /// fake函数地址 /// 欲Hook函数的引索 /// 保存原函数地址 BOOL HookVT(IN PVOID __vfptr, IN
Hook技术第二讲，之虚表HOOK
qq_34573534的博客
12-26 1299
一、认识虚表指针以及虚表 讲解之前我们要认识一下类在内存中的表现形式，以及认识虚表指针。 1.首先我们知道，当类中有虚函数的时候，则会生成虚表指针，虚表指针指向了虚表，虚表中保存的则是当前类中所有虚函数的函数地址。 内存结构图： 　　 第一个是类的内存结构，第二个是虚表。 那么我们就有想法了，当我们调用虚函数的时候，会通过虚表指针，找到虚表，而后找到虚函数地址 那么现在我们是否可以将...
虚函数Hook代码
ab7936573的专栏
03-25 991
作为备记,直接上代码. #include //更改地址跳转表 long ExChangeJumpTable(void* vfptr,int index,void* Value){ //虚表函数地址 void * functionJmpAddr = ((void**)vfptr)[index]; //E9 xx xx xx xx unsigned char *codeAddr = (u
修改虚函数中部分函数和HOOK虚函数
yu_sn0w的博客
11-13 200
class CTestVirtual { public: virtual void FunA() { std::cout << "FuncA " << m_iNum << std::endl; } virtual void FunB() { std::cout << "Fun...
hook虚表,快速获取怪物动向,boss技能
最新发布
任鸟飞2217777779的博客
11-27 740
我们把虚表中的虚函数地址修改成我们自己的函数地址,执行完我们的代码,我们再调用他原来的真正的虚函数
C++——Hook教程[1]：虚函数表（VMT）Hook
PP的秘密基地
12-07 4982
前言 虚函数表（VMT）Hook，又叫指针重定向，是一种常见的Hook技术，在游戏外挂程序中最常见。例如，使用VMTHook在Direct3D / OpenGL引擎游戏里实现内置叠加层。 虚函数表（VMT） 本文中VMT就代指虚函数表。 虚函数表是C++实现多态的一种方式。 每一个有虚函数的类（或有虚函数类的派生类）都有一个VMT，VMT本质上就是一个函数指针数组，通常位于对象内存布局的开头或结尾。每当C++类声明虚(virtual)函数时，编译器都会增加一个条目到VMT中。 例如，在x86系统上使用V
C++虚函数及虚函数表解析
weixin_34353714的博客
07-11 148
原文链接：http://www.keepsimply.org/2012/07/11/cpp-vtable/ 作者：独酌逸醉 时间：2012.07.11 声明： 　　本文内容由自互联网资源（见参考资料）、个人的一些 C++ 学习感悟、个人实践整理而成。文章仅以技术学习和交流为目的。如果您发现了文中的错误，或者您有的不同的见解，可以给我留言或者给我发邮件,我们共同探 讨。如果您觉得我...
C++浅析——虚表和虚表Hook
weixin_30451709的博客
08-08 309
为了探究虚表的今生前世，先来一段测试代码 虚函数类： 1 class CTest 2 { 3 public: 4 int m_nData; 5 6 virtual void PrintData() 7 { 8 printf("Data = 0x%x\n", m_nData); ...
Hook技术：虚表hook及虚函数的调用过程详解(附源码)
weixin_43742894的博客
05-08 2315
偶然间看到一篇帖子讲述的是虚表Hook，之前没有接触过，兴趣多致，进行学习和实践，将个人感悟与代码分享出来。 什么是虚表hook？ 首先我们应该要先了解什么是虚表？ 虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。 在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。 我们调...
C++虚函数表深度解析与应用
"C++类对象关于虚函数表详解" C++中的虚函数是实现多态性的重要机制，它允许我们通过基类指针调用派生类重写的成员函数，从而实现动态绑定或运行时多态。虚函数的实现依赖于虚函数表（Virtual Table，简称V-Table）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值