逆向基础（三）--- IDA中的虚函数

已于 2023-01-20 12:13:26 修改
阅读量1.2w 收藏 2
点赞数 1
分类专栏： 逆向 文章标签： c++ 反汇编
于 2020-07-20 16:15:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49364644/article/details/107464891
版权

这片文章（C++中的多态及实现原理（虚函数））阐述了多态的使用以及利用虚函数实现多态的原理，主要是从正向侧说明。我们在逆向过程中也会经常遇到虚函数的使用，在逆向中，在IDA中，虚函数又是什么样子的呢？

本文实例代码：

/*
C++多态测试实例
*/

#include <string>
#include <iostream>
using namespace std;

//基类
class Base {
public:
    virtual void vfunc1()
    {
        printf("Base::vfunc1\r\n");
    }
    virtual void vfunc2()
    {
        printf("Base::vfunc2\r\n");
    }
    virtual void vfunc3()
    {
        printf("Base::vfunc3\r\n");
    }
    virtual void vfunc4()
    {
        printf("Base::vfunc4\r\n");
    }
    void func1()
    {
        printf("Base::func1\r\n");
    }
    void func2()
    {
        printf("Base::func2\r\n");
    }
public:
    int m_data1, m_data2;
};
//无虚函数的基类
class BaseWithoutV {
public:
     void vfunc1()
    {
        printf("BaseWithoutV::vfunc1\r\n");
    }
     void vfunc2()
    {
        printf("BaseWithoutV::vfunc2\r\n");
    }
     void vfunc3()
    {
        printf("BaseWithoutV::vfunc3\r\n");
    }
     void vfunc4()
    {
        printf("BaseWithoutV::vfunc4\r\n");
    }
    void func1()
    {
        printf("BaseWithoutV::func1\r\n");
    }
    void func2()
    {
        printf("BaseWithoutV::func2\r\n");
    }
private:
    int m_data1, m_data2;
};

//派生类A
class A: public Base {
public:
    virtual void vfunc1()
    {
        printf("A::vfunc1\r\n");
    }
    void func1(int a)
    {
        printf("A::func1 with %d\r\n",a);
    }
    void func1()
    {
        printf("A::func1\r\n");
    }
private:
    int m_data3;
};
//派生类B
class B : public Base {
public:
    virtual void vfunc1()
    {
        printf("B::vfunc1\r\n");
    }
    virtual void vfunc3()
    {
        printf("B::vfunc3\r\n");
    }
    void func2()
    {
        printf("B::func2\r\n");
    }
private:
    int m_data1, m_data4;
};


int main()
{
    //动态联编调用，实现动态多态
    A object_a;          
    B object_b;      

    Base* p = &object_a;    //隐式向下转换基类指针p 指向类A对象object_a
    p->vfunc1();           //基类指针指向对象A，调用A类虚函数vfunc1

    p = &object_b;          //隐式向下转换基类指针p 指向类B对象object_b
    p->vfunc3();           //基类指针指向对象B，调用B类虚函数vfunc3

    system("pause");
}

IDA中虚函数的构造函数

我们知道编译器处理虚函数的方法是：给每一个对象添加一个隐藏的成员—虚函数表指针，该指针指向一个虚函数表。编译器必须要保证虚函数表的指针存在于对象实例中最前面的位置。
来看实例中派生类B的构造，从反汇编可以看出构造过程，派生类B的构造首先进行基类构造，然后才进行派生类B的构造。
有关函数调用，参数传递，引用等可以参考：逆向基础（二）— 函数调用过程完整分析，这里就不注解了。

text:00411830 ; B *__thiscall B::B(B *__hidden this)
.text:00411830 ??0B@@QAE@XZ    proc near               ; CODE XREF: B::B(void)↑j
.text:00411830
.text:00411830 var_CC          = byte ptr -0CCh
.text:00411830 var_8           = dword ptr -8
.text:00411830
.text:00411830                 push    ebp
.text:00411831                 mov     ebp, esp
.text:00411833                 sub     esp, 0CCh
.text:00411839                 push    ebx
.text:0041183A                 push    esi
.text:0041183B                 push    edi
.text:0041183C                 push    ecx
.text:0041183D                 lea     edi, [ebp+var_CC]
.text:00411843                 mov     ecx, 33h
.text:00411848                 mov     eax, 0CCCCCCCCh
.text:0041184D                 rep stosd
.text:0041184F                 pop     ecx
.text:00411850                 mov     [ebp+var_8], ecx
.text:00411853                 mov     ecx, [ebp+var_8] ; this
.text:00411856                 call    j_??0Base@@QAE@XZ ; 基类构造
.text:0041185B                 mov     eax, [ebp+var_8]
.text:0041185E                 mov     dword ptr [eax], offset ??_7B@@6B@ ; ClassB的虚函数表覆盖了上面存放的基类虚函数表
.text:00411864                 mov     eax, [ebp+var_8]
.text:00411867                 pop     edi
.text:00411868                 pop     esi
.text:00411869                 pop     ebx
.text:0041186A                 add     esp, 0CCh
.text:00411870                 cmp     ebp, esp
.text:00411872                 call    j___RTC_CheckEsp
.text:00411877                 mov     esp, ebp
.text:00411879                 pop     ebp
.text:0041187A                 retn

ClassB的虚函数表如下：
.rdata:00417BC4 ; const B::`vftable’
.rdata:00417BC4 ??7B@@6B@ dd offset j?vfunc1@B@@UAEXXZ
.rdata:00417BC4 ; DATA XREF: B::B(void)+2E↑o
.rdata:00417BC4 ; B::vfunc1(void)
.rdata:00417BC8 dd offset j_?vfunc2@Base@@UAEXXZ ; Base::vfunc2(void)
.rdata:00417BCC dd offset j_?vfunc3@B@@UAEXXZ ; B::vfunc3(void)
.rdata:00417BD0 dd offset j_?vfunc4@Base@@UAEXXZ ; Base::vfunc4(void)
构造完成，this指针内存情况如下图
在这里插入图片描述

IDA中虚函数的调用

截取mian中的关键反汇编代码，调用过程详见注释说明

.text:00E61DAE                 mov     eax, ___security_cookie
.text:00E61DB3                 xor     eax, ebp
.text:00E61DB5                 mov     [ebp+var_4], eax
.text:00E61DB8                 mov     ecx, offset unk_E6C027
.text:00E61DBD                 call    j_@__CheckForDebuggerJustMyCode@4 ; __CheckForDebuggerJustMyCode(x)
.text:00E61DC2                 lea     ecx, [ebp+var_18] ; ClassA的this，thiscall 使用ecx传输this指针
.text:00E61DC5                 call    j_??0A@@QAE@XZ  ; ClassA的构造函数
.text:00E61DCA                 lea     ecx, [ebp+var_34] ; ClassB的this
.text:00E61DCD                 call    j_??0B@@QAE@XZ  ; ClassB的构造函数
.text:00E61DD2                 lea     eax, [ebp+var_18] ; ClassA的this
.text:00E61DD5                 mov     [ebp+var_40], eax
.text:00E61DD8                 mov     eax, [ebp+var_40]
.text:00E61DDB                 mov     edx, [eax]      ; 从ClassA的this中获取虚函数表存放到edx中
.text:00E61DDD                 mov     esi, esp
.text:00E61DDF                 mov     ecx, [ebp+var_40]
.text:00E61DE2                 mov     eax, [edx]      ; 从ClassA虚函数表中索引虚函数vfunc1()
.text:00E61DE4                 call    eax             ; 虚函数调用 A::vfunc1()
.text:00E61DE6                 cmp     esi, esp
.text:00E61DE8                 call    j___RTC_CheckEsp
.text:00E61DED                 lea     eax, [ebp+var_34] ; ClassB的this
.text:00E61DF0                 mov     [ebp+var_40], eax
.text:00E61DF3                 mov     eax, [ebp+var_40]
.text:00E61DF6                 mov     edx, [eax]      ; 从ClassB的this中获取虚函数表存放到edx中
.text:00E61DF8                 mov     esi, esp
.text:00E61DFA                 mov     ecx, [ebp+var_40]
.text:00E61DFD                 mov     eax, [edx+8]    ; 从ClassB虚函数表中索引虚函数vfunc3(),注意+8对应第三个虚函数
.text:00E61E00                 call    eax             ; 虚函数调用 B::vfunc3()
.text:00E61E02                 cmp     esi, esp
.text:00E61E04                 call    j___RTC_CheckEsp

IDA中整个调用流程如下图：
虚函数的调用过程
ClassB中的虚函数调用同ClassA，需要注意的是这里
ClassB虚函数调用当派生类中如果没有重写虚函数时，这时候调用没有重写的虚函数，直接调用该派生类继承的基类对应的虚函数。如下图ClassB中没有重写vfunc2()，在ClassB的虚函数表中存放的是基类vfunc2()。
未重写的虚函数

okay哥
关注
专栏目录
反汇编工具IDA使用详解（使用IDA查看二进制文件的汇编代码以及使用IDA分析崩溃问题实例分享）
dvlinker的技术专栏
10-07 6万+
本文详细介绍一下IDA反汇编工具，介绍如何使用IDA反汇编工具查看二进制文件的汇编代码，并分享一个使用IDA排查程序崩溃的实例。
IDA逆向代码 --- 结构体分析与建立
生命不息 折腾不止
10-11 1862
结构体的创建首先要确定结构体的大小，主要是通过数据的使用来确定结构体的大小； IDA中结构体成员一般出现在：类初始化的地方（XX.dll）； 根据成员的多少，我们创建结构体的大小，注意虚表vt占4个字节；一般有三个地方有助于我们创建结构体：初始化函数成员列表、memcpy函数的使用、memset函数的使用、数据库字段； 在memcpy的参数中的size，结构体大小起码为size； 在...
IDA逆向技巧(持续更新)
热门推荐
生命不息 折腾不止
09-02 2万+
读者如果发现错误，请指正。 IDA的逆向分析水平就是一个逆向工程师的水平；7.1 IDA与OD的联合使用 一般使用OD下断点，找到关键代码位置，然后使用IDA静态看流程。 需要注意的是IDA需要与OD基地址对齐，这样才方便在IDA中查找代码位置，具体方式如下： Edit ---> Segment ----- Rebase Program : 设置基地址； 在WINdbg中基地址...
OD和IDA载入程序时地址不一致解决方法
最新发布
qq_46415382的博客
09-20 275
再看一下OD和IDA的第一行代码的地址是否相同，发现还有点不一样（这里我也不知道是为什么），IDA的比OD多0x1000,既然如此那我们把IDA的Image base改成0x2FE90000。最后的解决办法就是把OD的反汇编窗口，就是显示在你屏幕上占地最大的那个模块，把它拉到最上面，查看第一行的地址，我的这个程序是2FE91000。在OD里面想要跳转到0x3000AFA0的地址去，g一下显示没有这个地址。这个时候就是一样的了，再来尝试跳转地址试试。一样的了，现在调试代码就方便多了。
12.IDA-虚函数和虚表
hgy413的专栏
01-26 5607
vtable编译器会为每一个包含虚函数的类（或通过继承得到的子类）生成一个表，其中包含指向类中每一个虚函数的指针，这样的表就叫做虚表（vtable）__vfptr每个包含虚函数的类对象都获得__vfptr指针，并且是对象的第一个数据成员 编译器必须要保证虚函数表的指针存在于对象实例中最前面的位置 在计算对象的总大小时，也必须考虑到虚表指针。比如new，传递给new的大小值不仅包括类（以及任何超类
虚函数表（转）
小时候挺菜的博客
09-01 232
C++通过继承（inheritance）和虚函数（virtual function）来实现多态性。所谓多态，简单地说就是，将基类的指针或引用绑定到子类的实例，然后通过基类的指针或引用调用实际子类的成员函数（虚函数）。本文将介绍单继承、多重继承下虚函数的实现机制。 转自 http://songlee24.github.io/2014/09/02/cpp-virtual-table/    神奕
C++中虚函数、虚指针和虚表详解
bob的博客
09-28 5480
关于虚函数的背景知识 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 存在虚函数的类都有一个一维的虚函数表叫做虚表。每一个类的对象都有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 多态性是一个接口多种实现，是面向对象的核心。分为编译多态性和运行多态性。 运行多态用虚函数来实现，结合动态绑定。 纯虚函数是虚函数再加上=0。并且该函数只有声明，没有实现。 抽象类是指包括至少一个纯虚函数的类。 详细原理： 编译器在编译的时候，发现Base类中有虚函数，此时编译器
逆向反汇编--- 虚函数特征识别与虚表的建立
生命不息 折腾不止
03-08 1008
一、虚函数重要性 虚函数是面向对象的重要组成部分，是多态的基础，如果定义了虚函数但是没有定义构造函数，编译器必须提供默认的构造函数（因为必须要初始化虚表指针）； 二、虚函数特性与识别 虚表指针一定是在对象的首地址的前4个字节（固定的，且4字节，这一点很重要），虚表指针指向的虚函数表的首地址，虚函数作为成员函数使用； 对于开发者来说，虚表和虚表指针都是隐藏的； 如果类没有虚函数，构造的时候不...
ida_medigate:Medigate插件，用于C ++逆向工程和其他实用程序
05-10
使其如此困难的主要原因是虚函数。 与已编译的C代码相反，没有清晰的代码流。 人们可能花太多时间试图理解下一个虚拟函数是什么，而不是像在已编译的C代码中那样仅看到函数。 当人们研究一种虚拟功能时，他或她...
[网络安全自学篇] 五.IDA反汇编工具初识及逆向工程解密实战
杨秀璋的专栏
08-08 2万+
这是作者的系列网络安全自学教程，主要是关于网安工具和实践操作的在线笔记，特分享出来与博友共勉，希望您们喜欢，一起进步。上一篇文章分享了实验吧CFT实战的题目，涉及WEB渗透和隐写术常见题型，包括“这是什么”、“天网管理系统”、“忘记密码”、“false”、“天下武功唯快不破”和“隐写术之水果、小苹果”；这一篇文章将详细讲解IDA Pro反汇编工具的基础用法，并简单讲解一个EXE逆向工程解密实战方法。希望对入门的博友有帮助，大神请飘过，谢谢各位看官！
虚函数和虚函数表
vanturman的博客
11-19 548
复习下虚函数和虚函数表的知识 一、虚析构函数的必要性 我们常将一个基类的析构函数定义为虚函数，这样可以防止可能的内存泄漏，其中要点有以下几点： 1） 什么情况下会造成可能的内存泄漏？  当父类的析构函数不为虚函数，此时有一个父类的指针指向了子类对象，尝试释放掉这个指针所  占的内存，就可能造成内存的泄漏  我们先建两个类出来，其中myChild公有继承了myFather class m...
最深层了解虚表 ida
he702477275的专栏
12-09 1192
今天面试被人问了：虚表模型。一听见模型，这俩字，我就一下子就蒙了。像我这种不爱看书的人，回答这种问题，真不是那么容易啊。也不知道，面试管要问什么。 以下是，我在底层对虚表的理解。    class A { int nA; virtual void a() { }; virtual int bb() { return 0; }; public: ~A(
虚函数的识别2
BiCai2的博客
09-14 375
1.虚函数调用过程：void ShowSpeak(CPerson * pPerson) pPerson->ShowSpeak(); 00407CFE 8B 45 08 mov eax,dword ptr [pPerson] 00407D01 8B 10 mov edx,dword ptr [eax]
浅谈多态中的虚函数和虚表
no_name_sky的博客
02-16 431
需要实现多态必不可少的就是虚函数，类的成员函数前加virtual关键字，这个成员函数就是虚函数；例如： class T { public: virtual void fun() { cout<<"fun()"<<endl; } int _t; };在不加virtual的情况下：sizeof(T)的大小为4; 加了vitual变成虚函数之后：sizeof(T)的大小为8；
03_IDA逆向分析
blind cat
01-28 462
IDA逆向分析-插件demo http://hex-rays.com/products/ida/support/idapython_docs idapython的文档 IDA插件的编写 plugins 目录下进行实例化 python 目录下面进行具体功能的编写 在IDA的plugins目录下创建 listFuncPlugin.py文件 # -*- coding:utf-8 -*- import idautils import idaapi import idc from datetime impor
查看ida中的函数调用
yellow的博客
02-06 2万+
在一个样本中想要查看一个函数调用了那些函数，有2个办法： 1、View->Open subviews->Function calls 显示出函数调用窗口，如下： 显示的很详细，而且不冗余。 2、点击按钮Display graph of xrefs from current identifier(从当前标识符绘制交叉引用图)，下图： 这个方法显示的内容有时候会很多，冗余量大，
ida调试技巧-通过修改eip寄存器的值强制运行程序中存在但未被调用的函数
这个博主不懒，但Ta什么也没写~（私信互关24小时必回）
04-25 584
ctf逆向分析过程中有一类情况是程序中有某个函数未被调用，但其中存在一些重要信息（例如flag）且需要运行（即动态调试）后才可以获取到因为主函数的进程中从未调用，因此单纯的调试无论如何也无法进入该函数eip寄存器故而修改eip寄存器的值可以让cpu直接执行某函数参考本篇->
逆向虚函数
Jiangkai.net
10-05 321
   对象结构体     虚函数表         xxxxx         0x800 Jmp sub_xxxxxx   xxxxx  
ida 逆向代码 --- 双精度浮点型jumpout
08-01
IDA逆向代码是指对二进制程序进行逆向分析和修改的过程。双精度浮点型jumpout是指在逆向代码过程中遇到的一个跳转指令，该指令可以根据双精度浮点数的值来进行跳转。 在IDA逆向代码中，双精度浮点型jumpout的实现方式通常是通过比较双精度浮点寄存器的值，并根据比较结果跳转到指定的地址。具体实现步骤如下： 1. 首先，使用IDA打开二进制程序，并进行逆向分析，找到双精度浮点型jumpout指令的位置。 2. 在跳转指令之前，通常会使用一条或多条指令将双精度浮点数的值加载到浮点寄存器中。 3. 找到进行比较的指令，该指令通常会使用浮点寄存器中的值与另一个双精度浮点数进行比较。比较操作可以是大于、小于、等于等。 4. 根据比较结果，使用条件跳转指令进行跳转。如果比较结果符合条件，则跳转到目标地址；否则，继续执行下一条指令。 5. 如果跳转成功，程序将会执行目标地址处的指令，否则继续执行下一条指令。 通过以上步骤，我们可以实现双精度浮点型jumpout的功能。在IDA逆向代码中，我们可以根据这个跳转指令的地址和执行条件，来分析和修改程序的行为。这在逆向工程中是非常有用的，可以帮助我们理解和改进二进制程序的逻辑。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值