IDA Pro - 使用IDA Pro逆向C++程序

原文地址：Reversing C++ programs with IDA pro and Hex-rays

简介

在假期期间，我花了很多时间学习和逆向用C++写的程序。这是我第一次学习C++逆向，并且只使用IDA进行分析，感觉难度还是比较大的。

这是你用Hex-ways分析一个有意思的函数时看到的东西

v81 = 9;
v63 = *(_DWORD *)(v62 + 88);
if ( v63 )
{
   v64 = *(int (__cdecl **)(_DWORD, _DWORD, _DWORD,
   _DWORD, _DWORD))(v63 + 24);
   if ( v64 )
     v62 = v64(v62, v1, *(_DWORD *)(v3 + 16), *(_DWORD
     *)(v3 + 40), bstrString);
}

我们的任务是添加一些符号名称、分辨出类等，让hex-rays能够有足够的信息给出我们一个可靠、易于理解的输出

padding = *Dst;
if ( padding < 4 )
  return -1;
buffer_skip_bytes(this2->decrypted_input_buffer, 5u);
buffer_skip_end(this2->decrypted_input_buffer, padding);
if ( this2->encrypt_in != null )
{
  if ( this2->compression_in != null )
  {
    buffer_reinit(this2->compression_buffer_in);
    packet_decompress(this2,
      this2->decrypted_input_buffer,
      this2->compression_buffer_in);
    buffer_reinit(this2->decrypted_input_buffer);
    avail_len = buffer_avail_bytes(this2->compression_buffer_in);
    ptr = buffer_get_data_ptr(this2->compression_buffer_in);
    buffer_add_data_and_alloc(this2->decrypted_input_buffer, ptr, avail_len);
  }
}
packet_type = buffer_get_u8(this2->decrypted_input_buffer);
*len = buffer_avail_bytes(this2->decrypted_input_buffer);
this2->packet_len = 0;
return packet_type;

当然hex-rays不会自己命名这些变量名，你需要理解这些代码，至少给这些类一个合适的名字能帮你分析代码。

这里我的所有例子都是用visual studio或者Gnu C++编译的，这两个编译器的结果是相似，即使他们在某些语法上并不兼容。如果自己的编译器遇到问题，自己改下代码吧。

C++程序的结构

这里我就不介绍OOP编程的知识了，你也应该已经知道了。我们只从整体看下OOP是如何工作的和实现的。

Class = data structure + code (methods).

类的数据结构只能在源码里看到，函数则会显示在你的反汇编器里。

Object = memory allocation + data + virtual functions.

对象是一个类的一个实例，你可以在IDA里看到它。一个对象需要内存，所以你会看到调用new()或者栈分配内存，调用构造函数或者析构函数。你也会看到访问成员变量（成员对象），调用虚函数。

虚函数很蠢，如果不下断点运行程序，你很难知道哪些代码会被执行。

成员函数简单点，他们就像C语言里的结构。并且IDA有非常顺手的工具声明结构，hex-rays能在反汇编过程中很好的用到这些结构信息。

接下来我们将回到具体的问题上来。

对象的创建

int __cdecl sub_80486E4()
{
  void *v0; // ebx@1
  v0 = (void *)operator new(8);
  sub_8048846(v0);
  (**(void (__cdecl ***)(void *))v0)(v0);
  if ( v0 )
    (*(void (__cdecl **)(void *))(*(_DWORD *)v0 + 8))(v0);
  return 0;
}

这是一个我用G++编译的小程序的反汇编结果，我们能看到new(8)，意思是这个对象大小为8bytes，而不是我们有一个8bytes大小的变量。

函数sub_8048846在调用new()之后立刻被调用，并把new()产生的指针作为参数，这肯定就是构造函数了。

下一个函数就有点让人头大了，它在调用v0之前对v0做了两次解引用。这是一个虚函数调用。

所有的多态对象在他们变量中都有一个特殊的指针，被称作vtable。这个表包含了所有虚函数的地址，所以C++程序在需要的时候能够调用他们。在多种编译器中，我测试出vtable总是一个对象的第一个元素，总是待在相同的位置，即使是在子类中。（这也许对多继承不合适，我没有测试过）。

让我们开始用IDA进行分析：

重命名符号名称

点击一个名字，然后按n，就会弹出修改名字的窗口，你可以把它改成一个有意义的名字。目前我们还不知道这个类在做什么，所以我建议把这个类命名成“class1”，直到我们理解了这个类在做些什么。在我们完成分析class1之前我们很可能会遇到其他类，所以我建议遇到他们的时候只改下这些类的名字。

int __cdecl main()
{
  void *v0; // ebx@1
  v0 = (void *)operator new(8);
  class1::ctor(v0);
  (**(void (__cdecl ***)(void *))v0)(v0);
  if ( v0 )
    (*(void (__cdecl **)(void *))(*(_DWORD *)v0 + 8))(v0);
  return 0;
}

创建结构

IDA的结构（structures）窗口非常有用。按shitf + f9能够调出来。我建议你把它拖出来放到IDA窗口的右边（IDA的QT版能这么做），然后你就能同时看到反汇编窗口和结构窗口。

按Insert键并创建一个新的结构“class1”。我们已经知道这个结构是8bytes长，按d键增加变量，直到我们有两个dd变量。重命名第一个变量为“vtable”，然后就变成下面的样子了。

接下里我们添加函数的类型信息，右键v0，选择Convert to struct * ，选择class1。此外，按y，然后输入“ class1 * ”也能得到一样的结果。

创建一个新的长度为12bytes的结构并把它命名成“class1_vtable”。现在我们并不知道vtable有多大，但改结构的大小很容易。点击class1结构里的vtable，按y，把它的类型改成“class1_vtable *”。按F5刷新下伪代码的窗口，结果如下：

我们可以把方法命名成"method1"到“method3”。method3当然就是析构函数。根据编程约定和所使用的编译器，第一个函数经常是析构函数，但这里有一个反例。现在我们分析下构造函数。

分析构造函数

int __cdecl class1::ctor(void *a1)
{
  sub_80487B8(a1);
  *(_DWORD *)a1 = &off_8048A38;
  return puts("B::B()");
}

你可以先把a1的类型改一下。puts()调用证实了这个是构造函数，我们甚至能了解到这个类叫“B”。

sub_80487B8() 在构造函数里被直接调用，这个函数也许是class1的经函数，但也可能是父类的构造函数。

off_8048A38是class1的vtable，到这里你已经能知道vtable的大小了（只需要看vtable附近有Xref的数据的数量）和一个class1虚函数的列表。你可以把他们命名成“ class1_mXX”，但需要注意的是其中的一些函数可能与其他类共享。

更改这个vtable的类型信息也是没有问题的。但我不推荐这么做，因为你会丢掉IDA的经典窗口，并且这样做也提供不了任何你在经典窗口里看不到的东西。

构造函数里的奇怪调用：

int __cdecl sub_80487B8(int a1)
{
  int result; // eax@1
  *(_DWORD *)a1 = &off_8048A50;
  puts("A::A()");
  result = a1;
  *(_DWORD *)(a1 + 4) = 42;
  return result;
}

构造函数里的sub_80487b8() 函数是同样类型的函数：一个虚函数表 指针放到了vtable成员里，puts()调用告诉我们我们在另外一个构造函数里。

不要把参数a1的类型改成class1，因为我我们已经不在class1里了。我们找到了一个新的类，把它命名成class2。这个类class1的父类。我们做下和class1一样的工作。他们之间的区别仅仅是我们不知道class2成员的具体大小。这里有两种方法找到它：

1. 看对class2 ::ctor的xref，如果我们能找到一个对它的直接调用，例如一个对class2的实例化，我们就能知道class2成员函数的大小。
2. 看vtable里的函数，尝试找出被访问过的最高的成员。

在我们这种情况下，class2 ::ctor访问了最开始的4个字节之后的4个字节。因为class2的子类class1是8个字节长，所以class2的大小也是8个字节。

为所有的子类做同样的操作，从父类到子类给这些虚函数进行命名。

对析构函数的研究

Let’s go back to our main function. We can see that the last call, before our v0 object becomes a memory leak, is a call to the third virtual method of class2. Let’s study it.

if ( v0 )
  ((void (__cdecl *)(class1 *))
    v0->vtable->method_3)(v0);

void __cdecl class1::m3(class1 *a1)
{
  class1::m2(a1);
  operator delete(a1);
}

void __cdecl class1::m2(class1 *a1)
{
  a1->vtable = (class1_vtable *)&class1__vtable;
  puts("B::~B()");
  class2::m2((class2 *)a1);
}

void __cdecl class2::m2(class2 *a1)
{
  a1->vtable = (class2_vtable *)&class2__vtable;
  puts("A::~A()");
}

我们可以看到， class1::m3是一个析构函数，调用了class1::m2这一class1的主要析构函数。这个析构函数通过设置vtable为class1确保我们在class1的上下文。然后调用了class2的析构函数，这个析构函数也把vtable设置为class2的上下文。这种方法被用来遍历整个类的继承树，因为继承树的所有类的虚析构函数都要被调用。

这些映射是怎么回事，为什么两个结构里定义了一样的变量？

在用C表示OOP的过程中，我们遇到了和你一样的问题：有时候某些变量在所有的继承树里都会出现。下面是我避免变量重复定义的方法：

对每一个类，定义一个classXX_members, classXX_vtable, classXX结构

classXX 包含

+++ vtable (typed to classXX_vtable *)

+++ classXX-1_members (members of the superclass)

+++ classXX_members, if any

classXX_vtable contains

+++classXX-1_vtable

+++classXX’s vptrs, if any

理想情况下，你应该从父类开始到子类结束，直到你分析到一个没有子类的类位置。在这个例子里，下面使我们的解决办法：

00000000 class1          struc ; (sizeof=0x8)
00000000 vtable          dd ?                    ; offset
00000004 class2_members  class2_members ?
00000008 class1          ends
00000008
00000000 ; ----------------------------------------------00000000
00000000 class1_members  struc ; (sizeof=0x0)
00000000 class1_members  ends
00000000
00000000 ; ----------------------------------------------00000000
00000000 class1_vtable   struc ; (sizeof=0xC)
00000000 class2_vtable   class2_vtable ?
0000000C class1_vtable   ends
0000000C
00000000 ; ----------------------------------------------00000000
00000000 class2          struc ; (sizeof=0x8)
00000000 vtable          dd ?                    ; offset
00000004 members         class2_members ?
00000008 class2          ends
00000008
00000000 ; ----------------------------------------------00000000
00000000 class2_vtable   struc ; (sizeof=0xC)
00000000 method_1        dd ?                    ; offset
00000004 dtor            dd ?                    ; offset
00000008 delete          dd ?                    ; offset
0000000C class2_vtable   ends
0000000C
00000000 ; ----------------------------------------------00000000
00000000 class2_members  struc ; (sizeof=0x4)
00000000 field_0         dd ?
00000004 class2_members  ends
00000004

int __cdecl main()
{
  class1 *v0; // ebx@1
  v0 = (class1 *)operator new(8);
  class1::ctor(v0);
  ((void (__cdecl *)(class1 *)) v0->vtable->class2_vtable.method_1)(v0);
  if ( v0 )
    ((void (__cdecl *)(class1 *)) v0->vtable->class2_vtable.delete)(v0);
  return 0;
}

int __cdecl class1::ctor(class1 *a1)
{
  class2::ctor((class2 *)a1);
  a1->vtable = (class1_vtable *)&class1__vtable;
  return puts("B::B()");
}

class2 *__cdecl class2::ctor(class2 *a1)
{
  class2 *result; // eax@1
  a1->vtable = (class2_vtable *)&class2__vtable;
  puts("A::A()");
  result = a1;
  a1->members.field_0 = 42;
  return result;
}

总结

1. 当你找到一个新的类时，对其进行命名，在分析出这个类的有意义的名字前分析出整个继承树。
2. 从父类开始分析到子类。
3. 先查看构造函数和析构函数，找到对new()和静态方法的调用。
4. 同一个类的函数在编译过的文件里一般彼此相邻。而相关的类（继承关系）可能彼此之间离得很远。有时候构造函数会在子类的构造函数里内联，甚至在实例化的地方出现。
5. 如果你想在逆向继承关系比较复杂的结构时，使用“结构包含结构”的技巧只需要命名一次变量。
6. 尽管使用hex-rays的类型系统，它非常强大。
7. 纯虚类很让人头大，你可以发现几个类有相似的vtable，但却通常没有代码，要注意他们。

本文中用到的代码

#include <iostream>
#include <stdio.h>

class A {
  public:
   A(){
    printf("A::A()\n");
    id = 42;
   }
   virtual void a(){
     printf("Virtual A::a()\n");
   }
   virtual ~A(){
     printf("A::~A()\n");
   }
   private:
    int id;
};

class B : public A {
  public:
    B(){
      printf("B::B()\n");
    }
    virtual ~B(){
      printf("B::~B()\n");
    }
    virtual void a(){
      printf("Virtual B::a()\n");
      A::a();
    }
};

int main(){
  A *b = new(B);
  b->a();
  delete(b);
  return 0;
}

为了方便我直接把二进制文件后缀改成jpg了，下载下来把文件后缀去掉就OK了

编译之后的二进制文件：