虚函数表与虚表钩子

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

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

我们假设有这么一个类

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字节。

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

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

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; }
};

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

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

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; }

};

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

这里就实现了多态

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

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的虚函数表

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

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/

我们知道虚函数表了，那么我们有种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函数。

时间： 2024-11-23 11:01:38

虚函数表与虚表钩子的相关文章

类虚函数表原理实现分析（当我们将虚表地址[n]中的函数替换，那么虚函数的实现就由我们来控制了）

原理分析 当调用一个虚函数时, 编译器生成的代码会调用 虚表地址[0](param1, param2)这样的函数. 已经不是在调用函数名了. 当我们将虚表地址[n]中的函数实现改为另外的函数, 虚函数的实现就由我们来控制了. 实验 根据虚表原理, 实验一下修改自己程序的虚函数表项地址. 使编译器生成的代码执行一个虚函数A时, 执行的是我们自己定义的非虚函数B. 知识点 * 使用union赋值, 绕过编译器函数与变量强转赋值的限制 * 类成员函数指针的执行 * 修改和恢复自己的代码段属性 * 虚函

C++学习 - 虚表,虚函数,虚函数表指针学习笔记

虚函数 虚函数就是用virtual来修饰的函数.虚函数是实现C++多态的基础. 虚表 每个类都会为自己类的虚函数创建一个表,来存放类内部的虚函数成员. 虚函数表指针 每个类在构造函数里面进行虚表和虚表指针的初始化. 下面看一段代码: // // main.cpp // VirtualTable // // Created by Alps on 15/4/14. // Copyright (c) 2015年 chen. All rights reserved. // #include <iostr

C++ 虚函数表解析

转自陈浩的博客 前言 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有"多种形态",这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 关于虚函数的使用方法,我在这里不做过多的阐述.大家可以看看相关的C++的书籍.在这篇文章中,我只想从虚函数的实现

C++虚函数表剖析

关键词:虚函数.虚表,虚表指针,动态绑定,多态 一.概述 为了实现C++的多态,C++使用了一种动态绑定的技术. 这个技术的核心是虚函数表(下文简称虚表).本文介绍虚函数表是怎样实现动态绑定的. 二.类的虚表 每一个包括了虚函数的类都包括一个虚表. 我们知道,当一个类(A)继承还有一个类(B)时.类A会继承类B的函数的调用权.所以假设一个基类包括了虚函数,那么其继承类也可调用这些虚函数,换句话说,一个类继承了包括虚函数的基类.那么这个类也拥有自己的虚表. 我们来看下面的代码. 类A包括虚函数vf

C++ 虚函数表解析（转）

转自:http://blog.csdn.net/haoel 前言 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有"多种形态",这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 关于虚函数的使用方法,我在这里不做过多的阐述.大家可以看看相关的C

C++中3种多态实现机制之虚函数表

上期我们简单的讲解了利用RTTI来实现多肽,这期我们就来聊聊利用虚函数的方法来实现多肽. 1.什么是虚函数 在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数,用法格式为:virtual 函数返回类型 函数名(参数表) {函数体}:,实现多态性,通过指向派生类的基类指针或引用,访问派生类中同名覆盖成员函数 2.实现多肽的条件 简单的说就是:基类的指针或引用指向子类对象,当子类中成员函数和基类成员函数:函数名相同,参数列表相同,返回值相同,并且基类该函数为虚函数时,基类

C++之：虚函数表

一.文章来由 虚函数表究竟存放在哪里? 二.概念 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有"多种形态",这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 对C++ 了解的人都应该知道虚函数(Virtual Function)是通过一张虚

c++ 虚函数表

转自 http://blog.csdn.net/haoel/article/details/1948051/ C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有"多种形态",这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 关于虚函数的使用方法,

C++入门学习——虚函数表介绍

多态 多态是指使用相同的函数名来访问函数不同的实现方法,可以简单概括为"一种接口,多种方法". C++支持编译时多态(也叫静态多态)和运行时多态(也叫动态多态),运算符重载和函数重载就是编译时多态,而派生类和虚函数实现运行时多态. 静态多态与动态多态的实质区别就是函数地址是早绑定还是晚绑定.如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态多态(编译时多态),就是说地址是早绑定的.而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定,是