软件逆向分析作业 on 远楒

【武大软件逆向课程/第四周】加减乘除运算的逆向特征

Sat, 15 Mar 2025 06:27:52 +0000

汇编语言预备知识

指令简介与总览

汇编指令	指令格式	功能	备注
lea	`lea reg, addr`	主要用于将一个内存地址加载到寄存器中，而不是将该地址处的数据加载到寄存器。	如在`printf`函数中，将格式字符串的地址加载到指定寄存器中供`printf`函数读取。
inc	`inc reg`	寄存器自增1	变量加一
mov	`mov reg, imm`	将立即数赋值到寄存器中	`imm`意为立即数(immediate number)
imul	指令格式见详解	用于执行带符号整数乘法。	它可以接受一个、两个或三个操作数，具体取决于你想要执行的乘法类型。
mul	`mul source`	用于执行无符号整数乘法。	`mul` 指令只接受一个操作数，这个操作数可以是寄存器或内存地址。根据操作数的大小（8位、16位、32位或64位），乘积会被存储在特定的寄存器组合中。
shl/shr	`shl/shr dest, cnt`	逻辑左/右移	`shr`用于将寄存器或内存中的二进制数值向右移动指定的位数。这个操作会将每个位都向右移动，并在左侧补0。对于无符号数来说，这相当于除以2的幂次；而对于有符号数，它仅当被移位的数据视为无符号时有效，因为逻辑右移不会复制符号位。
sar	`sar dest, count`	算术左/右移	`sar`指令用于将指定的二进制数按算术右移的方式移动指定的位数。算术右移是指在右移时，最高位（符号位）保持不变，低位移出，高位补上符号位的值。这通常用于有符号数的除以2的幂次操作。
cdq	`cdq`	将32位寄存器`eax`中的有符号数符号扩展为64位，结果存储在由`edx:eax`组成的64位寄存器中	它会把`eax`的第31位（符号位）复制到`edx`的每一位。如果`eax`的符号位是0（即正数），则`edx`会被设置为0；如果符号位是1（即负数），则`edx`会被设置为全1。通常在执行32位有符号除法（如`idiv`指令）之前使用，以确保被除数的符号位正确扩展到高位寄存器，从而保证除法运算的正确性。
cqo	`cqo`	将64位寄存器`rax`中的有符号数符号扩展为128位，结果存储在由`rdx:rax`组成的128位寄存器中	它会把`rax`的第63位（符号位）复制到`rdx`的每一位。如果`rax`的符号位是0，则`rdx`被设置为0；如果符号位是1，则`rdx`被设置为全1。在64位模式下，通常在执行64位有符号除法之前使用，确保被除数的符号位正确扩展到高位寄存器。

imul - 带符号整数乘法

一个操作数

imul src

这种形式假设隐含的目标操作数是累加器（对于16位操作为AX，对于32位操作为EAX，对于64位操作为RAX）。该指令将累加器与source相乘，并将结果存储回累加器和其对应的双倍宽度寄存器（即对于16位操作为DX:AX，对于32位操作为EDX:EAX，对于64位操作为RDX:RAX）。

两个操作数

imul dest, source

这种形式将source与dest相乘，并将结果存储在dest中。dest可以是一个寄存器或内存位置，而source可以是一个寄存器、内存位置或立即数。注意，结果被截断到目标操作数的大小。

三个操作数

imul dest, source1, source2

这种形式将source1与source2相乘，并将结果存储在dest中。source1和source2可以是寄存器、内存位置或立即数，但dest必须是寄存器。结果同样被截断到目标操作数的大小。

mul - 无符号整数乘法

mul的功能

MUL是一个单操作数指令，它隐式地使用AL（8位）、AX（16位）、EAX（32位）或RAX（64位）作为其中一个乘数，具体取决于操作数的大小和处理器模式。

对于字节乘法（8位），结果被存储在AX寄存器中；对于字乘法（16位），结果被存储在DX:AX寄存器对中；对于双字乘法（32位），结果被存储在EDX:EAX寄存器对中；对于四字乘法（64位），结果被存储在RDX:RAX寄存器对中。

mul的示例

; 8 
mov al, 0x05       ; AL = 5
mov bl, 0x03       ; BL = 3
mul bl             ; AX := AL * BL
; AL = 5 * 3 = 15 (0x0F), AH = 0

; 16
mov ax, 0x0123     ; AX = 291
mov bx, 0x0004     ; BX = 4
mul bx             ; DX:AX := AX * BX
; AX = 291 * 4 = 1164 (0x048C), DX = 0

; 32
mov eax, 0x12345678 ; EAX = 305419896
mov ebx, 0x00000002 ; EBX = 2
mul ebx             ; EDX:EAX := EAX * EBX
; EAX = 305419896 * 2 = 610839792 (0x2468ACF0), EDX = 0

scanf与printf函数

scanf会使用多个寄存器：rcx，rdx，r8等等，均存储输入项的地址，其中rcx为格式化字符串的地址。 printf使用的寄存器与scanf类似。

逆向分析程序1

使用IDA打开reverse_basic.exe，反汇编结果如下：

; int __fastcall main(int argc, const char **argv, const char **envp)
main proc near

var_18= dword ptr -18h
var_14= dword ptr -14h
var_10= qword ptr -10h
arg_0= qword ptr  8
arg_8= qword ptr  10h
arg_10= qword ptr  18h

; __unwind { // __GSHandlerCheck
mov     [rsp+arg_0], rbx
mov     [rsp+arg_8], rbp
mov     [rsp+arg_10], rsi
push    rdi
sub     rsp, 30h
mov     rax, cs:__security_cookie
xor     rax, rsp
mov     [rsp+38h+var_10], rax
lea     r8, [rsp+38h+var_18]
lea     rdx, [rsp+38h+var_14]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080
mov     ecx, [rsp+38h+var_18]
mov     eax, 38E38E39h
add     ecx, [rsp+38h+var_14]
imul    r8d, ecx, 7
lea     rcx, Format     ; "%d\n"
lea     ebx, ds:0[r8*8]
lea     edi, [rbx+rbx*8]
mul     edi
mov     esi, edx
mov     edx, r8d
shr     esi, 1
mov     ebp, esi
shr     ebp, 3
call    sub_140001020
mov     edx, ebx
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     edx, edi
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     edx, esi
lea     rcx, aU         ; "%u\n"
call    sub_140001020
mov     edx, ebp
lea     rcx, aU         ; "%u\n"
call    sub_140001020
mov     eax, 24924925h
lea     rcx, aU         ; "%u\n"
mul     ebp
sub     ebp, edx
shr     ebp, 1
add     edx, ebp
shr     edx, 2
call    sub_140001020
xor     eax, eax
mov     rcx, [rsp+38h+var_10]
xor     rcx, rsp        ; StackCookie
call    __security_check_cookie
mov     rbx, [rsp+38h+arg_0]
mov     rbp, [rsp+38h+arg_8]
mov     rsi, [rsp+38h+arg_10]
add     rsp, 30h
pop     rdi
retn
; } // starts at 1400010E0
main endp

可以发现该程序的结构大致是，进行一些运算之后，集中打印运算结果。其中sub_140001020即为prinf函数，sub_140001080为scanf函数。

lea     r8, [rsp+38h+var_18]
lea     rdx, [rsp+38h+var_14]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080

因此此程序会读取两个四字节数据写入var_14和var_18。

mov     ecx, [rsp+38h+var_18]
mov     eax, 38E38E39h
add     ecx, [rsp+38h+var_14]
imul    r8d, ecx, 7

分析接下来的指令，程序将读取的两个数相加之后乘以7，将结果存到r8d中。

lea     rcx, Format     ; "%d\n"
lea     ebx, ds:0[r8*8]
lea     edi, [rbx+rbx*8]
mul     edi
mov     esi, edx
mov     edx, r8d
shr     esi, 1
mov     ebp, esi
shr     ebp, 3
call    sub_140001020

lea ebx, ds:0[r8*8]通过地址计算的方式计算了r8 * 8的值存入ebx中，然后类似地计算rbx * 9存入edi中。

然后经过其他无关运算后，调用printf将r8d(乘以7的结果)打印出来（先将r8d赋给edx）。

mov     edx, ebx
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     edx, edi
lea     rcx, Format     ; "%d\n"
call    sub_140001020

这一段打印出ebx和edi。

mov     edx, esi
lea     rcx, aU         ; "%u\n"
call    sub_140001020
mov     edx, ebp
lea     rcx, aU         ; "%u\n"
call    sub_140001020

根据这两个打印可以知道，在上面的运算中，esi和ebp被存入了运算结果，让我们再次分析上面被我们忽视的部分指令：

mov     eax, 38E38E39h
...
lea     rcx, Format     ; "%d\n"
lea     ebx, ds:0[r8*8]
lea     edi, [rbx+rbx*8]
mul     edi
mov     esi, edx
mov     edx, r8d
shr     esi, 1
mov     ebp, esi
shr     ebp, 3
call    sub_140001020

mul edi的作用：会计算edi * eax，将结果存入edx: eax中，eax被赋值为38E38E39h，是编译器将除以9运算进行优化使用的魔数。因此esi为edi / 9。然后将esi存入ebp后右移3位。

mov     eax, 24924925h
lea     rcx, aU         ; "%u\n"
mul     ebp
sub     ebp, edx
shr     ebp, 1
add     edx, ebp
shr     edx, 2
call    sub_140001020

24924925h是除以7的魔数，因此这里计算ebp除以7后打印出来。

综上，我们可以复原这个可执行文件的原c文件：

#include <stdio.h>

int main(int argc, char *argv[]) {
    int a, b, c;
    scanf("%d %d", a, b);
    c = a + b;
    int n1 = c * 7;
    int n2 = n1 * 8;
    int n3 = n2 * 9;
    unsigned int n4 = n3 / 9;
    unsigned int n5 = n4 / 8;
    unsigned int n6 = n5 / 7;
    
    printf("%d\n", n1);
    printf("%d\n", n2);
    printf("%d\n", n3);
    printf("%u\n", n4);
    printf("%u\n", n5);
    printf("%u\n", n6);
    
    return 0;
}

逆向分析程序2

; int __fastcall main(int argc, const char **argv, const char **envp)
main proc near

var_18= dword ptr -18h
var_14= dword ptr -14h
var_10= qword ptr -10h
arg_0= qword ptr  8

; __unwind { // __GSHandlerCheck
mov     [rsp+arg_0], rbx
push    rdi
sub     rsp, 30h
mov     rax, cs:__security_cookie
xor     rax, rsp
mov     [rsp+38h+var_10], rax
lea     r8, [rsp+38h+var_14]
lea     rdx, [rsp+38h+var_18]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080
mov     eax, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
mov     edi, [rsp+38h+var_18]
lea     ebx, [rdi+rax]
imul    edi, eax
lea     edx, [rdi+rbx]
call    sub_140001020
mov     eax, 66666667h
imul    [rsp+38h+var_18]
sar     edx, 1
mov     ecx, edx
shr     ecx, 1Fh
add     edx, ecx
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     r8d, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
lea     edx, [r8+r8*4]
call    sub_140001020
sub     ebx, [rsp+38h+var_18]
lea     rcx, Format     ; "%d\n"
mov     edx, ebx
call    sub_140001020
mov     eax, edi
lea     rcx, Format     ; "%d\n"
cdq
idiv    [rsp+38h+var_14]
mov     edx, eax
call    sub_140001020
xor     eax, eax
mov     rcx, [rsp+38h+var_10]
xor     rcx, rsp        ; StackCookie
call    __security_check_cookie
mov     rbx, [rsp+38h+arg_0]
add     rsp, 30h
pop     rdi
retn
; } // starts at 1400010E0
main endp

lea     r8, [rsp+38h+var_14]
lea     rdx, [rsp+38h+var_18]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080

容易知道，这里使用scanf函数读入两个数据存入var_18， var_14中。

mov     eax, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
mov     edi, [rsp+38h+var_18]
lea     ebx, [rdi+rax]
imul    edi, eax
lea     edx, [rdi+rbx]
call    sub_140001020

这段首先将var_14和var_18分别存入eax和edi中。计算ebx = rdi + rax，计算edi = edi * eax，计算edx = rdi + rbx。即为计算edx = var_14 + var_18 + var_14 * var_18然后打印出来。

mov     eax, 66666667h
imul    [rsp+38h+var_18]
sar     edx, 1
mov     ecx, edx
shr     ecx, 1Fh
add     edx, ecx
lea     rcx, Format     ; "%d\n"
call    sub_140001020

这里是使用魔数66666667h优化除法运算。实际上计算的是var_18 / 5。

mov     r8d, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
lea     edx, [r8+r8*4]
call    sub_140001020

容易知道这里计算的是var_14 * 5，使用var_14 * 4 + var_14优化。

sub     ebx, [rsp+38h+var_18]
lea     rcx, Format     ; "%d\n"
mov     edx, ebx
call    sub_140001020
mov     eax, edi
lea     rcx, Format     ; "%d\n"
cdq
idiv    [rsp+38h+var_14]
mov     edx, eax
call    sub_140001020

ebx在之前存储着var_18 + var_14的结果，因此这里计算ebx - var_18后打印。

edi存储着var_18 * var_14的结果，这里计算var_18 * var14 / var_14后打印。

源码：

#include <stdio.h>

int main() {
    int var_18, var_14;
    scanf("%d %d", &var_18, var_14);
    int a = var_18 + var_14;
    int b = var_18 * var_14;
    
    printf("%d\n", a + b);
    printf("%d\n", var_18 / 5);
    printf("%d\n", var_14 * 5);
    printf("%d\n", a - var_18);
    printf("%d\n", b / var_14);
    
    return 0;
}

【武大软件逆向课程/第一周】扫雷逆向分析批量插旗及机器指令表.exe文件字体更换

Wed, 19 Feb 2025 17:43:52 +0800

作业目标

逆向分析扫雷程序winmine.exe，并编写程序对其进行批量插旗
更换机器指令表.exe内的显示字体

扫雷

定位绘制雷区的代码位置

使用Ollydbg打开winmin.exe。

在当前模块中右键->查找->当前模块中的名称（标签），在弹出的窗口中寻找名称为Bitblt的函数。这里可以直接右键->在每个参考上设置断点，但是我的Ollydbg会报错。因此采用后续的方法。

选中Bitblt项后，按回车键Enter，在弹出的窗口中再次按回车Enter。

执行上述操作后弹出的窗口即为Bitblt的源码，在源码首行按F2或者右键设置断点。

设置断点后按F9或功能按钮运行程序，程序会暂停在断点处。此时按Ctrl + F9或者功能按钮执行到返回，程序会运行到函数Bitblt调用处的下一行。

观察上下文程序可以发现是类似于一个循环的结构，其中esi寄存器为循环变量。

定位雷区数据地址

在这一节内需要观察不同操作下内存区域的变化。

在Ollydbg中可以通过单击任意数据来刷新数据窗口中的内容。

如果想要重新绘制扫雷窗口，需要最小化后恢复窗口。

观察内存读取部分，代码中只有两句可能是对于数组的读取。分别为：

mov    al, byte ptr [ebx+esi]
push   dword ptr [eax*4+1005A20]

这里可以记录一下Bitblt调用处的地址1002706，然后取消所有断点重新运行程序，将游戏切换到高级模式，随机点击一个地块。这里为了便于定位雷区数据位置，我们多次开局点击地块，直到仅连锁翻开一个地块（这样对雷区数据的影响较小，数据特征更明显）。

然后将在数据窗口中右键->转到->表达式或者按Ctrl + G，输入内存读取部分的常量地址1005A20跳转到该地址。观察数据窗口内该地址处的数据。

发现并不符合雷区数据的特征（至少应该出现大量相同的两种数据）。实际上作为绘制雷区的函数，对数组下标的访问应该具有循环变量，也就是esi寄存器应该参与内存地址的计算，而这条指令并不符合。

因此选择下面的指令来寻找雷区数据所在的内存地址。

mov    al, byte ptr [ebx+esi]

在这条指令上打断点后最小化扫雷窗口，再恢复窗口，查看ebx寄存器的值，发现是内存地址1005360，在数据窗口中跟踪该地址。

该地址处的内存数据如下。可以大致推测，未翻开的雷区和未翻开的空白对应数据为0x0F或0x8F。

再次重开游戏，翻开第一个地块以定位数据区域首个元素的位置，如下图所示。

对比可知1005361为首的地址存放雷区数据。

分析地块状态对应的内存值

非雷区地块

从上一节的最后一个图可以得知，翻开的2地块对应的内存值为0x42。推测翻开的n对应的内存值为0x4n。

翻开相邻地块进行验证，可知推测成立，同时也得知未翻开的非雷区对应的内存值为0x0F。

雷区地块

再次观察内存区域，在9个地块后，有一个地块的内存值为不同的0x8F，翻开该地块后再次观察内存区域变化。

可知未翻开的雷为0x8F，翻开的雷为0x8A，踩中的雷为0xCC。

插旗地块与存疑地块

重开游戏并刷新数据窗口。在任意0x8E和0x0F对应的地块上右键以插旗后，刷新数据窗口，观察对应数据变化。扫雷游戏中还有一种标记，在插旗的地块上再次右键可以变为问号地块，这里称为存疑地块，与本次任务并不相关，但是这里还是给出其对应的内存值。

观察上图可知，插旗地块的0x?F被替换为0x?E，存疑地块的0x?F被替换为0x?D。

至此，所有地块状态对应的内存值均被我们分析出来。

简单总结一下，地块状态对应的内存值如下：

地块状态	内存值	地块状态	内存值
未翻开的空地	0x0F	插旗的空地	0x0E
翻开的空地	0x4n(n为要显示的数字)	存疑的空地	0x0D
未翻开的地雷	0x8F	插旗的地雷	0x8E
翻开的地雷	0x8A	存疑的地雷	0x8D
踩中的地雷	0xCC

此外，按Ctrl + ↓调整数据窗口首列数据从0x01偏移开始展示，可以发现在高级模式下30 * 16的布局下，每30个地块的数据后都有两个0x10，用于标注此行结束，在后面编写程序时，应当注意处理这个间隔区域。

编写程序以批量插旗地雷

程序如下：

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <tlhelp32.h>

#define GET_OFFSET(ROW, COL) ((ROW) * 32 + (COL))

void print_sign(BYTE val) {
    if (val == 0x0F || val == 0x8F) {
        printf("--");
    } else if (val == 0x0E || val == 0x8E) {
        printf("||");
    } else if (val == 0x0D || val == 0x8D) {
        printf("??");
    } else if (val == 0x40) {
        printf("..");
    } else if (val == 0x8A) {
        printf("**");
    } else if (val == 0xCC) {
        printf("XX");
    } else if (val == 0x10) {
    } else {
        printf("%01X", val & 0x0F);
        printf("%01X", val & 0x0F);
    }
    printf(" ");
}

int main() {
    DWORD pid = 0;          // Target process ID
    HANDLE hProcess = NULL;
    LPVOID targetAddress = (LPVOID)0x1005361; // Target memory address
    BYTE readBuffer[512] = {0};
    // BYTE writeData[4] = {0xAA, 0xBB, 0xCC, 0xDD}; // Example data to write
    SIZE_T bytesRead = 0;
    // SIZE_T bytesWritten = 0;

    // Create a snapshot of all processes
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("Failed to create process snapshot, error code: %d\n", GetLastError());
        return 1;
    }

    PROCESSENTRY32 pe = {sizeof(PROCESSENTRY32)};
    if (Process32First(hSnapshot, &pe)) {
        do {
            if (_tcsicmp(pe.szExeFile, _T("winmine.exe")) == 0) {
                pid = pe.th32ProcessID;
                printf("Process found: winmine.exe, PID: %u\n", pid);
                break;
            }
        } while (Process32Next(hSnapshot, &pe));
    } else {
        printf("Failed to retrieve process information, error code: %d\n", GetLastError());
    }

    CloseHandle(hSnapshot);

    if (pid == 0) {
        printf("Process winmine.exe not found\n");
        return 1;
    }

    // Open the target process with required permissions for memory operations
    hProcess = OpenProcess(
        PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
        FALSE,
        pid
    );

    if (hProcess == NULL) {
        printf("Failed to open process, error code: %d\n", GetLastError());
        return 1;
    }

    // Read memory content
    if (!ReadProcessMemory(
        hProcess,
        targetAddress,
        readBuffer,
        sizeof(readBuffer),
        &bytesRead
    )) {
        printf("Failed to read memory, error code: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }
    printf("Read %d bytes of data:\n", bytesRead);
    for (int i = 0; i < 16; i++) {
        for (int j = 0; j < 32; j++) {
            print_sign(readBuffer[GET_OFFSET(i, j)]);
        }
        printf("\n");
    }


    printf("Start flaging all the mines..\n");
    // Write to memory
    int count = 0;
    for (int i = 0; i < 16; i++) {
        for (int j = 0; j < 32; j++) {
            BYTE flag_mine = 0x8E;
            if (readBuffer[GET_OFFSET(i, j)] == 0x8F) {
                WriteProcessMemory(
                    hProcess,
                    targetAddress + GET_OFFSET(i, j),
                    &flag_mine,
                    sizeof(flag_mine),
                    NULL
                );
                count++;
            }
        }
    }
    printf("Finish! the count of mines: %d\n", count);

    CloseHandle(hProcess);
    // system("pause");
    return 0;
}

这段程序将会在打印雷区当前状态后，将所有0x8F修改为0x8E，即将所有的未翻开的地雷插上旗子，用户应当在新一局游戏内翻开任意地块后运行此程序，然后最小化再恢复窗口以重新绘制雷区。

打印当前状态过程中，未翻开的所有地块将记为--，插旗地块记为||，翻开的空地记为..，翻开的数字地块记为该数字，翻开的地雷记为**，踩中的地雷记为XX。

实验结果

运行结果如下图所示：

刷新窗口后成功插旗。

降低雷数为20后重新运行，便于验证结果正确性，手动翻开所有未插旗地块，中间笑脸图标带上墨镜（表示游戏胜利），可见结果正确。

更换机器指令表.exe显示字体

定位控制字体显示的WinAPI

使用Ollydbg打开机器指令表.exe。

在API文档及网络资料中查询其内涉及的API。

API名称	功能
GetModuleHandle	检索指定模块的模块句柄。模块必须已由调用进程加载。
GetCommandLine	检索当前进程的命令行字符串。
ExitProcess	结束调用进程及其所有线程。
GetSystemMetrics	用于获取关于显示器、鼠标、键盘等系统参数的信息。

观察发现在程序有效的程序段中涉及的三个WinAPI均与字体显示无关。还剩下一个call 004031，推测其很可能控制字体的显示。其上的四个push可能包含参数，尝试修改为push 0D 观察程序变化。修改两个push后运行程序并无明显变化。可见这两个参数并不控制该程序的字体显示。

在call 00401031处设断点并单步步入，依次检索遇见的到的WinAPI功能。

API名称	功能
CreateWindowEx	用于创建一个窗口（包括各种控件如按钮、文本框等）。
SetWindowLong	更改指定窗口的属性。该函数还将指定偏移量处的32位(长)值设置为额外的窗口内存。
GetStockObject	用于获取预定义的图形对象（如画笔、画刷和字体）的句柄。

其中GetStockObject涉及字体的显示，在4010C6处调用，其上一条指令push 0B很可能控制字体的显示。

将push 0B修改为push 0E后继续运行程序，可见字体明显发生变化。

将修改保存到文件

选中被修改的指令，在指令窗口中右键->复制到可执行文件->选择，在弹出的新窗口中选中被修改的指令，右键->保存文件。将新可执行文件命名为机器指令表2.exe。

双击运行修改前后的机器指令表，对比两者的字体差异。