Assembly, Disassembly và Decompilation#

Ba khái niệm hay bị lẫn vào nhau:

• Assembly — dạng human-readable của machine code, mỗi dòng gần như tương ứng 1-1 với một lệnh CPU. Mỗi kiến trúc (x86, ARM, MIPS) có cú pháp assembly riêng, nhưng nguyên lý nền tảng thì giống nhau.
• Disassembly — quá trình ngược: một disassembler (IDA Pro, Ghidra…) phân tích machine code nhị phân rồi dựng lại thành assembly kèm mnemonic/operand đầy đủ.
• Decompilation — đi xa hơn nữa: cố gắng biến assembly trở lại thành mã nguồn bậc cao (C/C++). Khác với disassembly, decompilation không bao giờ khôi phục hoàn hảo được mã gốc — vì tên biến, comment, định nghĩa kiểu dữ liệu đã mất vĩnh viễn trong lúc compile, cộng thêm compiler optimization làm biến dạng logic gốc. Decompiler chỉ cho ra một bản xấp xỉ “best-effort”, nhưng cực kỳ hữu ích để suy luận ở mức trừu tượng cao hơn thay vì đọc từng dòng assembly.

Pipeline đầy đủ (và chiều ngược lại khi làm RE):

Biên dịch:  Source Code (.c) → Compiler → .ASM (intermediate) → Assembler → .OBJ → Linker → .EXE Binary
Reverse:    .EXE Binary → Disassembler → Assembly Listing → Decompiler → Pseudo-Source Code (xấp xỉ)

Data Types#

x86 làm việc với các đơn vị dữ liệu kích thước cố định, tương ứng kiểu dữ liệu Windows API và C:

x86 Registers#

EAX (32-bit)
 └── AX (16-bit, nửa thấp của EAX)
      ├── AH (8-bit cao của AX)
      └── AL (8-bit thấp của AX)

Instruction Basics#

MOV#

MOV đích, nguồn — copy giá trị từ nguồn sang đích, không hề thay đổi giá trị nguồn. Đây là lệnh xuất hiện nhiều nhất trong bất kỳ đoạn disassembly nào vì phần lớn logic chương trình xoay quanh việc di chuyển dữ liệu.

mov eax, 0FFh        ; EAX = 0xFF
mov ebx, eax          ; EBX = EAX (EAX không đổi)

NOP#

NOP — không làm gì, chỉ nhảy sang lệnh kế tiếp. Về mặt chức năng tương đương xchg eax, eax (tự hoán đổi một thanh ghi với chính nó). Mã hóa chỉ 1 byte (0x90) nên rất tiện để ghi đè lệnh không mong muốn hoặc lấp khoảng trống khi patch/debug.

Hacking Assembly với IDA#

IDA cho phép tự viết/sửa assembly ngay trong database đang debug. Quy trình cơ bản: mở IDA database, nhấn Continue (F9) để chạy, rồi dùng 4 panel chính:

• Disassembly — xem lệnh dạng tuyến tính hoặc graph
• Registers — xem/sửa giá trị thanh ghi
• Memory — xem/sửa bộ nhớ dạng hex
• Stack — quan sát trạng thái stack

Muốn tự “viết” một lệnh assembly: chọn địa chỉ đích → Edit → Patch Program → Assemble → gõ lệnh muốn chèn. Các phím debug hay dùng: Step Over (F8) chạy qua 1 lệnh mà không nhảy vào hàm con, Step Into (F7) nhảy hẳn vào trong hàm được gọi, Add Breakpoint (F2), và Set IP (chuột phải) để ép EIP nhảy tới địa chỉ khác (chính là kỹ thuật “forcing execution” ở Chapter 6).

Arithmetic Instructions#

ADD (cộng), SUB (trừ), INC (+1), DEC (-1) — đích phải là thanh ghi hoặc bộ nhớ, không thể là immediate. Cả 4 lệnh đều cập nhật EFLAGS sau khi chạy.

Bitwise Instructions#

7 lệnh thao tác ở cấp bit: XOR, AND, OR (phép logic trên 2 toán hạng), SHL/SHR (dịch bit trái/phải, phần trống được lấp bằng 0 — dữ liệu bị dịch ra ngoài sẽ mất), và ROL/ROR (xoay bit trái/phải — bit bị đẩy ra một đầu sẽ vòng lại đầu kia thay vì mất đi). Phân biệt rõ shift (mất dữ liệu) và rotate (không mất) là điểm hay bị nhầm.

Accessing Memory#

CPU bắt buộc phải biết đọc/ghi bao nhiêu byte mỗi lần truy cập bộ nhớ — xác định theo 2 cách:

1. Suy luận ngầm — nếu một operand là thanh ghi, kích thước thanh ghi đó quyết định luôn kích thước truy cập (mov [402000h], ebx không cần ghi rõ vì EBX đã là 4 byte).
2. Khai báo tường minh — dùng directive kích thước: byte ptr, word ptr, dword ptr khi không có thanh ghi nào gợi ý sẵn kích thước (ví dụ mov dword ptr [402000h], 0).

mov eax, [402000h]        ; đọc 4 byte (vì đích là EAX)
mov ax, [402000h]          ; chỉ đọc 2 byte (vì đích là AX)
mov dword ptr [402000h], 0  ; phải khai báo rõ vì nguồn là immediate, không tự suy luận được

Memory Operands — công thức tính địa chỉ#

Địa chỉ hiệu dụng (effective address) được tính từ tối đa 3 thành phần:

Effective Address = Base + Index × Scale + Displacement

• Base — thanh ghi chứa địa chỉ gốc
• Index × Scale — một thanh ghi index nhân với hệ số scale (1, 2, 4 hoặc 8) — đúng kích thước 1 phần tử mảng
• Displacement — hằng số offset cố định (có thể âm)

[ebp+8]              ; base = EBP, displacement = 8
[esp+ebx*4+8]         ; base = ESP, index = EBX, scale = 4, displacement = 8

Pattern index*scale chính là lý do vì sao công thức này gắn liền với việc duyệt mảng (sẽ nói kỹ hơn ở Chapter 7).

LEA (Load Effective Address)#

LEA đích, [biểu thức] — khác hẳn các lệnh khác: nó không hề đọc bộ nhớ, chỉ tính toán giá trị của biểu thức trong ngoặc vuông như một phép tính thuần túy rồi ghi kết quả (một địa chỉ, hoặc đơn giản là một con số) vào đích. Ngoặc vuông ở đây chỉ mang tính ký hiệu, không phải lệnh truy cập bộ nhớ thật.

Hai công dụng chính:

1. Tính offset — về bản chất tương đương toán tử & (lấy địa chỉ) trong C
2. Compiler tối ưu — thay cả chuỗi lệnh cộng/nhân bằng đúng 1 lệnh LEA duy nhất

lea eax, [ebx+8]         ; EAX = EBX + 8 (không đọc bộ nhớ)
lea eax, [ebx*4+5]        ; EAX = EBX*4 + 5
lea eax, [ecx+ebx*4+5]     ; EAX = ECX + EBX*4 + 5

Nhìn thấy LEA trong disassembly, đừng vội nghĩ “đang lấy địa chỉ của biến gì đó” — rất nhiều khi nó chỉ đơn giản là một phép ADD/MUL được compiler viết dưới dạng khác.

Đây là nền tảng bắt buộc phải nắm trước khi đọc bất kỳ đoạn disassembly nào. Chapter tiếp theo mình sẽ ghi về Stack — khái niệm cũng nền tảng không kém.