linux程序逆向ida,IDA Pro - 使用IDA Pro逆向C++程序

简介

在假期期间，我花了很多时间学习和逆向用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成员的具体大小。这里有两种方法找到它：

看对class2 ::ctor的xref，如果我们能找到一个对它的直接调用，例如一个对class2的实例化，我们就能知道class2成员函数的大小。

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

}

总结

当你找到一个新的类时，对其进行命名，在分析出这个类的有意义的名字前分析出整个继承树。

从父类开始分析到子类。

先查看构造函数和析构函数，找到对new()和静态方法的调用。

同一个类的函数在编译过的文件里一般彼此相邻。而相关的类(继承关系)可能彼此之间离得很远。有时候构造函数会在子类的构造函数里内联，甚至在实例化的地方出现。

如果你想在逆向继承关系比较复杂的结构时，使用“结构包含结构”的技巧只需要命名一次变量。

尽管使用hex-rays的类型系统，它非常强大。

纯虚类很让人头大，你可以发现几个类有相似的vtable，但却通常没有代码，要注意他们。

本文中用到的代码

#include

#include

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了

编译之后的二进制文件：