OD-IDA应用-分析C++常量-字符串-指针-对象-虚函数

OD一些常用的功能？？

设置软件断点：F2

运行程序：F9

单步步入：F7

单步步过：F8

运行到光标处：F4

如果说我们分析的时候，在反汇编窗口中看到一个地址，想查看这个位置的内存：

右键》数据窗口中跟随

如果说想在反汇编窗口查看一个代码：

右键》反汇编窗口中跟随

如果说我们想搜索指令：

右键-查找-命令

搜索所有字符串：

可以使用OD的中文搜索引擎插件，是一个快速便捷的查看字符串的方式。需要处于所在的模块当中，再去搜索

断点：软件断点：F2 在B窗口中可以看到所有的软件断点，方便的禁用和启用断点

硬件断点

在代码段上右键，可以设置硬件执行

在数据段上右键，可以设置硬件访问和硬件写入。

我们可以在：调试》硬件断点中看到我们设置过的硬件断点。

内存断点：

用的时候并不太多

可以设置:读写执行

条件断点：

消息断点：

必须将目标位置事先指定为回调函数的原型：

之后在此位置点击右键，就可以设置消息断点：使得程序可以在触发某一种消息的时候中断下来。

查看堆栈：

[ebp-8] 局部变量的区域

[ebp-4] 局部变量的区域

[ebp] 上一个函数的

ebp [ebp+4] 返回地址

[ebp+8] 第一个参数

有两个重要的用处：

1 分析参数与局部变量

2 能够查看到调用关系，回溯出整个的调用链。

通常分析程序的一般步骤：

1 运行一下程序，找到我们感兴趣的功能，然后搜集信息

a. 编译环境是否加壳了

b. 有哪些关键字符串

c. 可能调用的什么函数

d. 使用了哪些DLL

e. 如果有关键dll，可以分析关键dll中的字符串函数名等等信息

2 猜测了关键函数，关键字符串，使用了什么库之后，有对应的一些方法

1 搜索关键字符串

2 在关键函数上下断点运行程序栈回溯

IDA的一些常见功能：

切换代码视图和图形视图：空格

想要重命名：n 将常量设置

enum: m

识别一个位置为结构体：atl+q

分析VC++程序：

#define SIZE  100                   
const int g_nCount = 1000; 
enum eData { 
    enum_TYPE_1 = 1,  
    enum_TYPE_2 = 2,   
    enum_TYPE_3 = 3 };
struct sData {  
    int n;   
    float fNum; 
    char chA; };
int main() 
{    
    bool bRet = true;  // 布尔常量
    const int nCount = SIZE;             // 宏常量 
    const char* szHello = "Hello 15PB";  // 字符串常量 
    const eData data = enum_TYPE_1;      // 枚举常量 
    const float  fNum = 1.5;                 // 浮点
    常量     
        const sData stc = { 
        1,
        2.0,
        '1' 
    };   // 结构体常量    
    return 0; 
}

这是一个结构体，要把这3个合成一个结构体的操作如下：

1.Structurs 视图

2.按下Ins按钮跳出

3.按d添加成员及更改db类型，只能更改最后一个成员

4.选择结构体首成员位置ALT+Q选择自己定义的结构体。

5.成功之后显示

如何将一个数组显示为浮点数：

分析字符串：

#include <iostream>
#include <iostream>
#include <afx.h> 
int main()
{
    char szStr[100] = { "szStr[100] Hello 15PB" };     wchar_t szWchar[100] = L"szWchar Hello 15PB";     char szHello[] = "szHello[] Hello 15PB";
    std::string strHello = "string Hello 15PB";
    CString csString = "CString Hello 15PB";
    return 0;
}

char*是4个字节4个字节分开传到栈里，再用memcopy

总结：字符串都是放在rdata段中，指令是使用字符串的地址。分析 STL中的string对象

我们应该能够识别出可能是thiscall的函数。

在调用函数的时候，传递ecx是传递对象的地址。

分析CString的信息

CString只有一个字段。

指针和引用：

int main()
{
    int n = 15;
    int* pData = &n;     int &m = n;
    return 0;
}

指针和引用在汇编层面来看，没有任何区别：

关于全局对象和局部对象调用：

成员函数

静态函数

友元函数的行为

class CObjA
{ 
public:
    CObjA() {
        m_Num1 = 1;
        m_Num2 = 2;
        printf("CObjA::CObjA
");     }
    ~CObjA(){
        printf("CObjA::~CObjA
");     };

    void Print() {
        printf("Print %d %d
", m_Num1, m_Num2);     }

    static void Print1() {
        printf("static Print1
");     }

    friend void Print2();

private:
    int m_Num1;     int m_Num2; 
};

void Print2() {
    printf("friend Print2
"); }

CObjA g_obj; //本身会生成一个函数，用于调用构造函数

int main()
{
    CObjA obj;
    g_obj.Print();
    obj.Print();
    obj.Print1();
    Print2();
    // 函数末尾 调用析构函数     return 0;
}

总结：

全局对象调用成员函数，ecx是通过mov指令得到的对象地址局部对象调用成员函数，ecx是通过lea指令得到的对象地址静态函数和友元函数都和普通函数的调用是一致的。

虚函数的调用：

class CObjA
{ 
public:
    CObjA();
    ~CObjA();
    virtual void Print() {
        printf("CObjA::Print %d %d
", mNum1, mNum2);     }
    virtual void Print1() {
        printf("CObjA::Print1
");
    } 
private:
    int mNum1;
    int mNum2;
};

CObjA::CObjA()
{
    mNum1 = 1;     mNum2 = 2; 
}
CObjA::~CObjA()
{
}

void hook() {
    printf("虚函数表 Hook
"); }

int main()
{
    CObjA objA;
    CObjA* pObj = &objA;     pObj‐>Print();

    // 修改虚表中的函数地址
    // 1. 获取虚函数表地址
    PDWORD dwVTableAddr = *(DWORD**)pObj;
    // 2. 修改内存属性
    DWORD dwOldProtect;
    VirtualProtect(dwVTableAddr, 4, PAGE_READWRITE,&dwOldProtect);     // 3. 修改函数地址
    *dwVTableAddr = (DWORD)hook;
    // 4. 恢复内存属性
    VirtualProtect(dwVTableAddr, 4, dwOldProtect, &dwOldProtect);     // 
    pObj‐>Print();
    return 0;
}