1. Use-After-Free Là Gì?

Use-After-Free (UAF) là lớp lỗ hổng xảy ra khi một chương trình tiếp tục sử dụng một vùng bộ nhớ (dangling pointer) sau khi vùng nhớ đó đã được giải phóng. Đây là lỗi quản lý bộ nhớ thuộc họ memory corruption và được phân loại theo CWE-416.

Về mặt nguyên lý, lỗi xảy ra khi lập trình viên giải phóng một khối heap (free(ptr)) nhưng không đặt con trỏ về NULL. Về sau, khi chương trình vô tình đọc hoặc ghi qua con trỏ đó, hành vi là undefined behavior — và kẻ tấn công có thể lợi dụng điều này để kiểm soát luồng thực thi.

2. Cơ Chế Quản Lý Bộ Nhớ Heap

Để hiểu UAF, cần nắm vững cách allocator quản lý heap. Các allocator hiện đại như ptmalloc2 (glibc), jemalloc (Firefox, FreeBSD) hay tcmalloc (Google) đều tổ chức bộ nhớ theo cấu trúc chunk.

Cấu trúc chunk trong ptmalloc2

/* Cấu trúc malloc_chunk trong glibc/malloc/malloc.c */
struct malloc_chunk {
  INTERNAL_SIZE_T  mchunk_prev_size;  /* kích thước chunk trước (nếu free) */
  INTERNAL_SIZE_T  mchunk_size;       /* kích thước chunk hiện tại + flags */
  struct malloc_chunk *fd;           /* forward pointer (chỉ khi free) */
  struct malloc_chunk *bk;           /* backward pointer (chỉ khi free) */
  /* ... dữ liệu người dùng ... */
};

Khi free() được gọi, chunk được đưa vào freelist (tcache, fastbin, smallbin…). Khi gọi malloc() tiếp theo với kích thước phù hợp, allocator có thể tái sử dụng chính chunk đó — đây là nền tảng của kỹ thuật khai thác.

3. Vòng Đời Lỗ Hổng UAF

Một lỗ hổng UAF điển hình diễn ra qua 3 bước:

1. Allocation: Đối tượng A được cấp phát trên heap. Con trỏ ptr trỏ vào đó.
2. Free: Đối tượng A bị giải phóng (free(ptr)), nhưng ptr không được đặt về NULL. ptr trở thành dangling pointer.
3. Use: Chương trình truy cập ptr thêm một lần nữa — đây là lỗi. Nếu kẻ tấn công đã kịp đặt dữ liệu của mình vào vùng bộ nhớ đó, họ kiểm soát hành vi của chương trình.

4. Kỹ Thuật Khai Thác

4.1 Heap Spraying & Grooming

Kẻ tấn công thực hiện heap grooming — tạo ra hàng loạt allocation có kích thước chính xác để sau khi victim object được free, allocation tiếp theo của attacker chắc chắn rơi vào đúng chunk đó. Trong môi trường trình duyệt, JavaScript được dùng để tạo các ArrayBuffer hoặc object có kích thước tùy ý.

/* Victim code (lỗi) */
Object *obj = malloc(64);   // Allocation
free(obj);                    // Giải phóng — obj thành dangling ptr
/* ... sau nhiều hàm gọi ... */
obj->method();               // UAF: gọi qua dangling pointer ← lỗi

/* Attacker code */
char *spray = malloc(64);   // Chiếm đúng chunk vừa freed
memcpy(spray, fake_vtable, 64); // Ghi vtable giả
// Khi victim gọi obj->method(), thực thi fake_vtable[0]

4.2 Type Confusion qua UAF

Trong các ngôn ngữ hướng đối tượng như C++, đối tượng lưu trữ một con trỏ vtable ở đầu bộ nhớ. Khi attacker ghi đè vtable pointer bằng dữ liệu của mình, mọi lời gọi virtual function đều chuyển hướng sang địa chỉ attacker kiểm soát — đây là PC hijacking (Program Counter hijacking).

4.3 UAF trong Kernel Space

UAF trong nhân hệ điều hành đặc biệt nguy hiểm vì attacker có thể leo thang đặc quyền (privilege escalation). Ví dụ điển hình: lỗ hổng cr_ref overflow qua kqueueex syscall — khi kernel counter bị tràn số (integer overflow 32-bit), struct được giải phóng sớm trong khi vẫn còn reference, dẫn đến UAF. Khai thác thành công cho phép ghi vào vùng nhớ kernel read-only thông qua các primitive như pipe-based R/W hay IPv6 socket primitives.

5. Ví Dụ Thực Tế — Các CVE Nổi Bật

6. Biện Pháp Phòng Thủ Hiện Đại

6.1 Phòng thủ ở cấp độ ngôn ngữ

Cách hiệu quả nhất để ngăn UAF là sử dụng ngôn ngữ memory-safe. Rust với hệ thống ownership và borrow checker loại bỏ toàn bộ lớp lỗi UAF tại compile time — con trỏ không bao giờ tồn tại lâu hơn dữ liệu nó trỏ đến.

// Borrow checker ngăn UAF tại compile time
fn main() {
    let s = String::from("hello");
    let r = &s;          // borrow
    drop(s);             // ERROR: cannot move s while r borrows it
    println!("{}", r);  // compile error — UAF bị chặn hoàn toàn
}

6.2 Phòng thủ ở cấp độ Allocator

• PartitionAlloc (Chrome): cô lập heap theo kiểu đối tượng, ngăn type confusion sau UAF.
• Delayed Reuse / Quarantine: chunk được free sẽ bị giữ trong quarantine một thời gian trước khi tái sử dụng — làm giảm cửa sổ khai thác.
• Pointer Authentication Code (PAC) trên ARMv8.3: ký mã hóa các con trỏ, phát hiện dangling pointer bị giả mạo.

6.3 Phòng thủ ở cấp độ OS/Kernel

• SMEP / SMAP (x86): ngăn kernel thực thi hoặc truy cập bộ nhớ user-space trực tiếp.
• Kernel Address Space Layout Randomization (KASLR): ngẫu nhiên hóa địa chỉ kernel, làm khó địa chỉ hóa gadget.
• CFI (Control Flow Integrity): kiểm tra tính hợp lệ của mọi lời gọi hàm gián tiếp — ngăn vtable hijacking.

6.4 Công cụ phát hiện tự động

7. Kết Luận

Use-After-Free là minh chứng rõ ràng cho cái giá của quản lý bộ nhớ thủ công. Dù các mitigation hiện đại đã làm tăng đáng kể chi phí khai thác, lớp lỗ hổng này vẫn xuất hiện đều đặn trong các CVE nghiêm trọng — đặc biệt trong các codebase C/C++ lớn như nhân OS, trình duyệt và runtime.

Xu hướng ngành đang dịch chuyển theo hai hướng song song: memory-safe languages (Rust, Go, Swift) cho code mới và hardened allocators + hardware mitigation (PAC, MTE trên ARM) cho legacy codebase. Nghiên cứu về lớp lỗ hổng này vẫn còn rất nhiều giá trị học thuật, đặc biệt trong lĩnh vực phân tích tĩnh, fuzzing và formal verification.