Giới thiệu dự án

Sự bùng nổ của các cuộc tấn công mạng sử dụng mã độc thực thi dạng Portable Executable (PE) đang đặt ra thách thức nghiêm trọng cho các hệ thống an ninh thông tin hiện đại. Theo báo cáo The State of Ransomware 2023 từ Sophos, số lượng các cuộc tấn công mã độc tống tiền toàn cầu đã tăng hơn 10% so với năm 2022, với 43% các tổ chức doanh nghiệp vừa và nhỏ (SMB) trở thành nạn nhân trực tiếp, chịu mức chi phí khôi phục và tiền chuộc trung bình lên đến hàng triệu USD. Đồng thời, báo cáo Global Threat Landscape Report 2023 của Fortinet ghi nhận hoạt động của mạng máy tính ma (Botnet) tăng 27%, chủ yếu khai thác các lỗ hổng thiết bị đầu cuối và biến đổi cấu trúc nhị phân để lẩn tránh sự phát hiện.

+-------------------------------------------------------------------------------+
|                             CẢNH QUAN MỐI ĐE DỌA PE                           |
+------------------------------------+------------------------------------------+
| Ransomware Attacks (Sophos 2023)   | +10% tăng trưởng, 43% doanh nghiệp SMB bị |
|                                    | ảnh hưởng trực tiếp                      |
+------------------------------------+------------------------------------------+
| Hoạt động Botnet (Fortinet 2023)   | +27% tăng trưởng, liên tục biến đổi kỹ   |
|                                    | thuật lẩn tránh                          |
+------------------------------------+------------------------------------------+
| Cơ chế trốn tránh phổ biến         | Packing đa tầng, Process Hollowing,      |
|                                    | DLL Injection, Memory-only Execution     |
+------------------------------------+------------------------------------------+

Vấn đề thực tiễn (Problem Statement)

Các kỹ thuật phát hiện truyền thống chủ yếu dựa trên tập luật chữ ký tĩnh (Signature-based Detection) hoặc trích xuất đặc trưng hình thái từ tệp tĩnh (Static PE Header Analysis). Tuy nhiên, các dòng mã độc hiện đại dễ dàng vượt qua các lớp phòng thủ này nhờ vào các kỹ thuật tinh vi:

  • Mã hóa đa tầng và Packing (UPX, Themida, VMProtect): Che giấu hoàn toàn chuỗi mã máy (Opcode), bảng địa chỉ nhập khẩu (Import Address Table - IAT) và các hàm API quan trọng khi tệp nằm trên đĩa cứng.
  • Thực thi trong bộ nhớ (In-memory Execution & Fileless Malware): Sử dụng các kỹ thuật như Process Hollowing, Dynamic Forking, DLL Injection để nạp và thực thi trực tiếp payload độc hại trong không gian địa chỉ ảo của các tiến trình hệ thống hợp lệ (svchost.exe, explorer.exe).
  • Biến thể liên tục (Polymorphism/Metamorphism): Tự động thay đổi mã băm (Hash) và cấu trúc PE header mà không làm thay đổi hành vi phá hoại gốc.

Mục tiêu nghiên cứu (Project Objectives)

Đề tài "Phát hiện phần mềm độc hại PE bằng cách sử dụng Mạng thần kinh đồ thị và Pháp chứng bộ nhớ" do Kỹ sư Lê Thanh Duẫn thực hiện dưới sự hướng dẫn của TS. Nguyễn Tấn Cẩm và ThS. Nghi Hoàng Khoa tại Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM (2024), tập trung giải quyết triệt để bài toán trên thông qua các mục tiêu cụ thể:

  1. Xây dựng quy trình trích xuất dấu vết pháp chứng bộ nhớ (Memory Forensics): Phân tích hình ảnh bộ nhớ động (Memory Dump) bằng framework Volatility 3, bóc tách cấu trúc các tiến trình thực thi, không gian bộ nhớ ảo (VAD - Virtual Address Descriptor), và cây phân cấp tiến trình đang hoạt động.
  2. Mô hình hóa dữ liệu tiến trình thành đồ thị cấu trúc (Graph Representation Learning): Chuyển đổi các thực thể tiến trình, module nạp động (DLLs), luồng thực thi (Threads) và mối quan hệ tương tác (Parent-Child, Memory Injection, Handle Reference) thành biểu đồ đồ thị không thuần nhất (Attributed Graph).
  3. Thiết kế và huấn luyện mô hình Mạng thần kinh đồ thị (Graph Neural Networks - GNN): Triển khai các kiến trúc GNN tiên tiến (Graph Convolutional Networks - GCN, GraphSAGE, Graph Attention Networks - GAT) nhằm học biểu diễn ngữ nghĩa và cấu trúc topo của tiến trình độc hại.
  4. Đánh giá và kiểm thử thực nghiệm: Đo lường hiệu năng mô hình trên tập dữ liệu thực nghiệm gồm các mẫu mã độc thực tế (Trojan, Ransomware, Botnet, Backdoor) với các tiêu chí khắt khe: Accuracy, Precision, Recall, F1-Score và Inference Latency.

Phương pháp tiếp cận và Giả thuyết nghiên cứu

Phương pháp đề xuất kết hợp sức mạnh phân tích thời gian thực của Pháp chứng bộ nhớ và khả năng suy diễn cấu trúc phi tuyến tính của Mạng thần kinh đồ thị. Khi mã độc PE thực thi, dù được đóng gói hay mã hóa tinh vi đến đâu trên đĩa, toàn bộ payload đều bắt buộc phải giải mã và ánh xạ vào bộ nhớ RAM (PAGE_EXECUTE_READWRITE). Bằng cách trích xuất bộ nhớ thời điểm thực thi và chuyển hóa thành đồ thị tương tác, GNN có thể nắm bắt các mẫu liên kết bất thường mà các mô hình học máy truyền thống không thể nhận diện.

Phạm vi và Giới hạn (Scope & Limitations)

  • Phạm vi: Tập trung vào các tệp thực thi định dạng Portable Executable (PE 32-bit và 64-bit) hoạt động trên các phiên bản hệ điều hành Microsoft Windows 10/11 và Windows Server.
  • Giới hạn kỹ thuật: Dữ liệu đầu vào yêu cầu tập tin ảnh chụp bộ nhớ hoàn chỉnh (Memory Dump dạng .raw, .dmp, .vmem). Nghiên cứu không đi sâu vào việc phân tích gói tin mạng cấp thấp hoặc dịch ngược mã nguồn ở tầng assembly.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Trước khi xây dựng giải pháp kết hợp GNN và Memory Forensics, các phương pháp phát hiện mã độc hiện nay được phân tích và đánh giá toàn diện:

Phương pháp Nguyên lý hoạt động Ưu điểm Nhược điểm / Lỗ hổng
Chữ ký tĩnh & Hash (YARA, Antivirus truyền thống) So khớp mã băm SHA256/MD5 hoặc các chuỗi byte tĩnh cố định. Tốc độ quét cực nhanh ($<10\text{ms}$), chi phí tính toán thấp. Hoàn toàn vô hiệu trước mã độc đa hình, packing hoặc fileless malware.
Phân tích đặc trưng PE Header tĩnh (Machine Learning) Trích xuất các trường từ DOS Header, PE File Header, Optional Header (ImageBase, AddressOfEntryPoint, Entropy). Độ chính xác cao trên mã độc chưa bị pack ($>95%$). Tỷ lệ cảnh báo sai (False Positive) cao khi gặp trình đóng gói hợp pháp; không nắm được hành vi runtime.
Đồ thị luồng điều khiển tĩnh (Static CFG/FCG + GNN) Dịch ngược mã nhị phân thành Control Flow Graph hoặc Function Call Graph rồi đưa vào DGCNN/GAT. Nắm bắt được cấu trúc luận lý của chương trình. Tốn kém chi phí dịch ngược (Disassembly); dễ bị đánh lừa bởi kỹ thuật làm rối mã (Obfuscation) và Dead Code Insertion.
GNN kết hợp Memory Forensics (Giải pháp đề xuất) Bóc tách đối tượng EPROCESS, VAD, DLL từ RAM Dump và mô hình hóa thành Đồ thị tương tác tiến trình. Bắt trọn payload đã giải mã trong RAM; phát hiện chính xác Process Injection và Rootkit ẩn. Cần thu thập ảnh chụp bộ nhớ; tài nguyên trích xuất đồ thị ban đầu đòi hỏi cấu hình xử lý phù hợp.

Phân tích yêu cầu chức năng (MoSCoW Prioritization)

  • Must Have (Bắt buộc):
    • Trích xuất danh sách tiến trình ẩn và tiến trình bị unhook từ Memory Dump thông qua cấu trúc EPROCESS và kỹ thuật quét psscan.
    • Trích xuất thông tin chi tiết các Section, VAD tags, quyền bộ nhớ (PAGE_EXECUTE_READWRITE) của từng tiến trình.
    • Xây dựng ma trận kề (Adjacency Matrix) và ma trận đặc trưng nút (Node Feature Matrix).
    • Phân loại nhị phân (Benign vs Malicious) với độ chính xác $\ge 98%$.
  • Should Have (Nên có):
    • Tích hợp kiểm tra tự động qua API VirusTotal nhằm gán nhãn tập dữ liệu mẫu.
    • Hỗ trợ xuất biểu đồ đồ thị trực quan (Graph Visualization).
  • Could Have (Có thể có):
    • Mở rộng phân loại đa lớp (Multi-class Classification: Ransomware, Trojan, Backdoor, Worm).
  • Won't Have (Chưa thực hiện trong giai đoạn này):
    • Khả năng can thiệp trực tiếp vào Kernel để cô lập tiến trình độc hại theo thời gian thực (Active Remediation).

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế thành một quy trình khép kín gồm 4 tầng xử lý chính:

graph TD
    A[Image Bộ nhớ: Memory Dump .raw / .vmem] --> B[Tầng Pháp chứng Bộ nhớ: Volatility 3 Engine]
    B --> B1[Trích xuất Tiến trình: windows.psscan]
    B --> B2[Trích xuất VAD & Quyền Bộ nhớ: windows.vadinfo]
    B --> B3[Trích xuất DLL & Module: windows.dlllist]
    B --> B4[Phát hiện Vùng nhớ Độc hại: windows.malfind]
    
    B1 & B2 & B3 & B4 --> C[Tầng Xây dựng Đồ thị: Graph Construction Engine]
    C --> C1[Trích xuất Đặc trưng Đỉnh: Node Feature Extractor]
    C --> C2[Tạo Cạnh & Ma trận Kề: Topology Builder]
    
    C1 & C2 --> D[Biểu diễn Đồ thị: PyTorch Geometric Data Object]
    D --> E[Tầng Mô hình GNN: GNN Inference Architecture]
    E --> E1[Graph Convolutional / GraphSAGE Layers]
    E1 --> E2[Global Pooling: Mean + Max Pooling]
    E2 --> E3[Multi-Layer Perceptron: Softmax Output]
    
    E3 --> F[Kết quả: Benign / Malicious Classification & Forensics Report]

Technology Stack và Phiên bản chi tiết

  • Ngôn ngữ lập trình: Python 3.10.12
  • Framework Pháp chứng bộ nhớ: Volatility 3 v2.5.0
  • Deep Learning Framework: PyTorch v2.1.0 (hỗ trợ CUDA 11.8)
  • Graph Neural Network Library: PyTorch Geometric (PyG) v2.4.0
  • Xử lý đồ thị & Cấu trúc dữ liệu: NetworkX v3.1, NumPy v1.24.3, Pandas v2.1.1
  • Phân tích tệp PE tĩnh: pefile v2023.2.7
  • Môi trường huấn luyện & Đánh giá: NVIDIA Tesla T4 GPU (Google Colab Pro), 16GB VRAM, 32GB System RAM.

Cấu trúc Đặc trưng Đỉnh (Node Feature Schema)

Mỗi tiến trình hoặc module nhị phân trong không gian bộ nhớ được biểu diễn thành một nút $v \in \mathcal{V}$ với vector đặc trưng 32 chiều $\mathbf{x}_v \in \mathbb{R}^{32}$:

  1. PID / PPID Relative Ratio (1 dim)
  2. ImageBase Address Offset (1 dim)
  3. VirtualSize & SizeOfRawData Log-scale (2 dim)
  4. Tỷ lệ phân mảnh bộ nhớ và Entropy của VAD (4 dim)
  5. Cờ quyền bộ nhớ thực thi (PAGE_EXECUTE_READWRITE, PAGE_NOACCESS) (8 dim)
  6. Số lượng Handle trỏ tới Mutex, Thread, File, Registry Key (8 dim)
  7. Điểm số bất thường từ plugin malfind (Hex injection, unlinked memory) (4 dim)
  8. Các đặc trưng cấu trúc PE cơ bản trích xuất từ header giải nạp trong RAM (4 dim)

Phương pháp luận (Methodology)

Quy trình nghiên cứu áp dụng phương pháp luận chuẩn khoa học dữ liệu kết hợp an toàn thông tin:

+-------------------------------------------------------------------------------+
|                       LỘ TRÌNH THỰC HIỆN DỰ ÁN                                |
+---------------+---------------------------------------------------------------+
| Giai đoạn 1   | Thu thập mẫu mã độc PE và tạo lập môi trường Sandbox cô lập.   |
| (Tuần 1 - 3)  | Thực thi mã độc và trích xuất Memory Dump (.raw).             |
+---------------+---------------------------------------------------------------+
| Giai đoạn 2   | Xây dựng module tự động hóa Volatility 3 CLI/Library.         |
| (Tuần 4 - 6)  | Parse cấu trúc EPROCESS, VAD, Thread Injection.                |
+---------------+---------------------------------------------------------------+
| Giai đoạn 3   | Xây dựng pipeline ánh xạ dữ liệu bộ nhớ sang đồ thị PyG.       |
| (Tuần 7 - 9)  | Thiết kế kiến trúc Message Passing GNN.                       |
+---------------+---------------------------------------------------------------+
| Giai đoạn 4   | Huấn luyện mô hình, tinh chỉnh siêu tham số (Hyperparameters). |
| (Tuần 10 - 12)| Đánh giá thực nghiệm chéo và hoàn thiện báo cáo khoa học.     |
+---------------+---------------------------------------------------------------+

Quản trị rủi ro và Đảm bảo an toàn (Risk Assessment)

  • Nguy cơ lây nhiễm mã độc: Toàn bộ quá trình thực thi mã độc lấy mẫu memory dump được cô lập hoàn toàn trên máy ảo VMware Workstation Pro với card mạng Host-Only, cấu hình Deep Freeze và Snapshot phục hồi tức thì.
  • Rủi ro mất cân bằng dữ liệu (Class Imbalance): Áp dụng kỹ thuật Focal Loss kết hợp phân tầng dữ liệu (Stratified K-Fold Cross Validation, $k=5$) để tránh thiên kiến phân loại cho lớp chiếm đa số.

Implementation và kết quả

Quá trình phát triển và Thuật toán cốt lõi

1. Module Trích xuất Pháp chứng Bộ nhớ (Volatility 3 Integration)

Đoạn mã sau thực hiện trích xuất tiến trình và các vùng nhớ nghi vấn từ Memory Dump bằng thư viện Volatility 3:

import os
import sys
from volatility3.framework import contexts, automagic
from volatility3.framework import plugins
from volatility3.plugins.windows import psscan, malfind, vadinfo

class MemoryGraphExtractor:
    """Trích xuất tiến trình và cấu trúc bộ nhớ phục vụ tạo đồ thị GNN."""
    def __init__(self, memory_dump_path: str):
        self.memory_path = memory_dump_path
        self.ctx = contexts.Context()
        self.ctx.config['automagic.LayerStacker.single_location'] = f"file://{os.path.abspath(memory_dump_path)}"
        self.automagics = automagic.available(self.ctx)
        
    def extract_process_nodes(self) -> dict:
        """Quét cấu trúc EPROCESS thông qua windows.psscan để tìm tiến trình ẩn."""
        plugin = psscan.PsScan(self.ctx, config_path="plugins.psscan")
        constructed = automagic.choose_automagic(self.automagics, plugin)
        constructed(self.ctx, plugin.config_path, plugin, None)
        
        process_tree = {}
        for row in plugin.run():
            pid = int(row[0])
            ppid = int(row[1])
            image_name = str(row[2])
            offset = hex(row[3])
            threads_count = int(row[4])
            
            process_tree[pid] = {
                "ppid": ppid,
                "name": image_name,
                "offset": offset,
                "threads": threads_count,
                "has_injected_code": False,
                "vad_entropy": 0.0
            }
        return process_tree

    def analyze_malfind_anomalies(self, process_tree: dict) -> dict:
        """Phát hiện các vùng nhớ thực thi không gắn file (Injected Code)."""
        plugin = malfind.Malfind(self.ctx, config_path="plugins.malfind")
        constructed = automagic.choose_automagic(self.automagics, plugin)
        constructed(self.ctx, plugin.config_path, plugin, None)
        
        for row in plugin.run():
            pid = int(row[0])
            protection = str(row[3])
            if pid in process_tree and "EXECUTE_READWRITE" in protection:
                process_tree[pid]["has_injected_code"] = True
        return process_tree

2. Kiến trúc Mạng thần kinh đồ thị (GNN Architecture)

Mô hình sử dụng mạng tích chập đồ thị GraphSAGE (Graph Sample and Aggregate) nhằm tổng hợp thông tin từ láng giềng theo công thức:

$$\mathbf{h}_v^{(k)} = \sigma \left( \mathbf{W}^{(k)} \cdot \text{CONCAT}\left(\mathbf{h}_v^{(k-1)}, \text{AGG}\left(\left{\mathbf{h}_u^{(k-1)}, \forall u \in \mathcal{N}(v)\right}\right)\right) \right)$$

Trong đó:

  • $\mathbf{h}_v^{(k)}$ là vector biểu diễn của nút tiến trình $v$ tại tầng lặp thứ $k$.
  • $\mathcal{N}(v)$ là tập hợp các nút láng giềng (tiến trình cha/con, DLL liên kết).
  • $\text{AGG}(\cdot)$ là hàm tổng hợp trung bình (Mean Aggregator).
  • $\mathbf{W}^{(k)}$ là ma trận trọng số huấn luyện được của tầng $k$.
  • $\sigma(\cdot)$ là hàm kích hoạt phi tuyến tính ReLU (Rectified Linear Unit).
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import SAGEConv, global_mean_pool, global_max_pool

class MalwareGNNClassifier(nn.Module):
    def __init__(self, in_features: int = 32, hidden_dim: int = 64, num_classes: int = 2):
        super(MalwareGNNClassifier, self).__init__()
        # Lớp lan truyền tin nhắn đồ thị thứ nhất
        self.conv1 = SAGEConv(in_features, hidden_dim, aggregator='mean')
        # Lớp lan truyền tin nhắn đồ thị thứ hai
        self.conv2 = SAGEConv(hidden_dim, hidden_dim, aggregator='mean')
        
        # Batch Normalization & Dropout chống Overfitting
        self.bn1 = nn.BatchNorm1d(hidden_dim)
        self.bn2 = nn.BatchNorm1d(hidden_dim)
        self.dropout = nn.Dropout(p=0.3)
        
        # Tầng Fully-Connected (MLP) cho bài toán phân loại đồ thị
        self.fc1 = nn.Linear(hidden_dim * 2, 32)
        self.fc2 = nn.Linear(32, num_classes)

    def forward(self, x, edge_index, batch):
        # 1. Message Passing Layer 1
        h = self.conv1(x, edge_index)
        h = self.bn1(h)
        h = F.relu(h)
        h = self.dropout(h)
        
        # 2. Message Passing Layer 2
        h = self.conv2(h, edge_index)
        h = self.bn2(h)
        h = F.relu(h)
        
        # 3. Global Graph Readout Pooling (Kết hợp Mean và Max Pooling)
        h_mean = global_mean_pool(h, batch)
        h_max = global_max_pool(h, batch)
        h_graph = torch.cat([h_mean, h_max], dim=1)
        
        # 4. Dense Classifier Output
        out = F.relu(self.fc1(h_graph))
        out = self.dropout(out)
        logits = self.fc2(out)
        return F.log_softmax(logits, dim=-1)

Kiểm thử và Đánh giá thực nghiệm

Mô hình được huấn luyện và đánh giá trên tập dữ liệu gồm 4.250 mẫu Memory Dumps (2.125 mẫu mã độc thực tế gồm Ransomware, Trojan, Botnet, Infostealer và 2.125 mẫu lành tính thu thập trong điều kiện người dùng văn phòng và lập trình). Dữ liệu được chia theo tỷ lệ 70% Training, 15% Validation và 15% Testing.

+-------------------------------------------------------------------------------+
|                       KẾT QUẢ HUẤN LUYỆN VÀ ĐÁNH GIÁ GNN                      |
+-------------------+-----------------+--------------------+--------------------+
| Kiến trúc Mô hình | Độ chính xác    | Precision          | Recall             |
|                   | (Accuracy)      |                    |                    |
+-------------------+-----------------+--------------------+--------------------+
| Baseline (GCN)    | 96.45%          | 95.80%             | 97.10%             |
| GraphSAGE         | 98.92%          | 98.75%             | 99.10%             |
| GAT (Attention)   | 98.40%          | 98.15%             | 98.65%             |
+-------------------+-----------------+--------------------+--------------------+

Ma trận nhầm lẫn (Confusion Matrix trên 638 mẫu Test Set)

  • True Positives (TP): 316 (Mã độc nhận diện chính xác là Mã độc)
  • True Negatives (TN): 315 (Lành tính nhận diện chính xác là Lành tính)
  • False Positives (FP): 4 (Lành tính bị báo nhầm thành Mã độc)
  • False Negatives (FN): 3 (Mã độc bị bỏ sót)
  • F1-Score tổng thể: 98.92%
  • Độ phức tạp tính toán (Inference Latency): 148ms trung bình cho mỗi Memory Graph.
                  DỰ ĐOÁN: BENIGN        DỰ ĐOÁN: MALICIOUS
THỰC TẾ: BENIGN       315 (TN)                  4 (FP)
THỰC TẾ: MALWARE        3 (FN)                316 (TP)

Đổi mới và đóng góp

  1. Hợp nhất Pháp chứng Bộ nhớ động và Biểu diễn Đồ thị học sâu: Khác với các nghiên cứu trước đây chỉ áp dụng GNN trên đồ thị luồng điều khiển tĩnh (Static CFG) dễ bị vô hiệu hóa khi tệp bị mã hóa hoặc nén (Pack), nghiên cứu này phân tích trạng thái thực thi thực tế trong RAM. Mọi kỹ thuật lẩn tránh đều bị bộc lộ khi chương trình giải mã mã máy để thực thi.
  2. Kỹ thuật trích xuất cấu trúc quan hệ Đa tầng (Multi-layer Relationship): Mô hình không chỉ xét riêng lẻ từng tiến trình mà liên kết các mối quan hệ: Tiến trình cha - con (PPID - PID), Luồng bị tiêm mã (Injected Threads), và Vùng nhớ ẩn không thuộc file ánh xạ trên đĩa (Unlinked VAD Nodes).
  3. Hiệu năng vượt trội so với các công trình công bố trước đây:
Tiêu chí so sánh Nghiên cứu PE Header ML (Nguyễn et al.) Nghiên cứu MAGIC (DGCNN CFG) Giải pháp Memory-GNN (Khóa luận này)
Nguồn dữ liệu PE File Header trên đĩa Static Binary Disassembly Volatile Memory RAM Dump
Khả năng chống Packing Kém (Dễ bị bypass) Trung bình (Bị làm rối mã) Rất cao (Bắt tại thời điểm chạy)
Phát hiện Fileless Malware Không thể Không thể Hoàn toàn khả thi
Độ chính xác (Accuracy) 99.71% (Chỉ trên tệp chưa pack) 94.20% 98.92% (Bao gồm 100% mẫu đã pack)
Thời gian trích xuất $<50\text{ms}$ $15-45\text{s}$ (Disassembly) 2.5s - 5s (Volatility Plugin)

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng trong thực tế (Real-world Use Cases)

  • Trung tâm điều hành an ninh mạng (SOC / Incident Response): Khi phát hiện hành vi bất thường trên máy trạm hoặc máy chủ, hệ thống tự động kích hoạt tạo snapshot bộ nhớ và đẩy vào pipeline GNN để xác định chính xác tiến trình độc hại trong vòng dưới 3 phút.
  • Hệ thống phân tích mã độc tự động (Automated Malware Sandbox): Nâng cấp các Sandbox truyền thống (Cuckoo Sandbox, CAPE) bằng cách tích hợp module chụp và phân tích RAM đồ thị sau khi cho mẫu thực thi 60 giây.
  • Điều tra số (Digital Forensics & Triage): Giúp chuyên gia điều tra nhanh chóng lọc ra các bằng chứng số có giá trị pháp lý cao từ các vụ tấn công có chủ đích (APT).

Kiến trúc triển khai hạ tầng (Deployment Architecture)

[Máy trạm/Endpoint] ---> [WinPmem / LiME Agent] ---> [RAM Dump Snapshot]
                                                           |
                                                           v
[FastAPI Backend Gateway] <------------------ [Storage Server / S3 Bucket]
         |
         +---> [Volatility 3 Parser Worker (Celery/Redis)]
         |                 |
         |                 v
         +---> [PyTorch Geometric Inference Engine (T4 GPU)]
                           |
                           v
         +---> [SIEM / EDR Alert / Dashboard Visualizer]

Phân tích hiệu quả kinh tế (Cost-Benefit & ROI Analysis)

  • Giảm thời gian phản ứng (MTTR - Mean Time to Respond): Rút ngắn thời gian phân tích thủ công từ 4 giờ làm việc của một Chuyên gia phân tích mã độc xuống còn dưới 5 phút tự động hóa.
  • Ước tính ROI: Tiết kiệm khoảng 65% chi phí vận hành đội ngũ SOC Tier-2/Tier-3 và giảm thiểu nguy cơ rò rỉ dữ liệu doanh nghiệp do mã độc nằm vùng (Dwell Time).

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Kích thước tệp Memory Dump: Dung lượng ảnh chụp RAM lớn (từ 4GB đến 32GB) dẫn đến thời gian tải và phân tích cấu trúc ban đầu của Volatility 3 còn chiếm nhiều I/O đĩa cứng.
  • Kỹ thuật tấn công can thiệp trực tiếp Kernel (DKOM): Các mã độc Rootkit tinh vi can thiệp sửa đổi trực tiếp cấu trúc danh sách liên kết kép ActiveProcessLinks của Windows Kernel có thể làm ẩn tiến trình khỏi bảng quét thông thường nếu không kết hợp quét sâu địa chỉ pool.

Hướng phát triển trong tương lai

  1. Tích hợp Mạng Đồ thị Biến đổi Dị thể (Heterogeneous Graph Transformers - HGT): Nâng cao khả năng phân loại đa kiểu nút và đa kiểu cạnh (Process, File, Registry, Network Socket).
  2. Hỗ trợ Triển khai Thời gian thực (Live Memory Streaming): Sử dụng driver kernel nhẹ để theo dõi đồ thị tương tác bộ nhớ theo luồng thời gian thực mà không cần chụp toàn bộ file dump tĩnh.
  3. Phân loại họ mã độc chi tiết (Fine-grained Family Classification): Mở rộng bộ phân loại nhận diện chính xác các họ mã độc cụ thể như LockBit 3.0, Cobalt Strike Beacon, RedLine Stealer.

Đối tượng hưởng lợi

+-------------------------------------------------------------------------------+
|                           ĐỐI TƯỢNG HƯỞNG LỢI                                 |
+---------------------+---------------------------------------------------------+
| Sinh viên & Người   | Nguồn tài liệu học tập toàn diện về Pháp chứng bộ nhớ,  |
| tự học              | cấu trúc Windows PE và kỹ thuật ứng dụng GNN thực chiến.|
+---------------------+---------------------------------------------------------+
| Kỹ sư An toàn thông | Kiến trúc mã nguồn mẫu kết hợp Volatility 3 và PyTorch  |
| tin / DevSecOps     | Geometric tối ưu sẵn sàng tích hợp vào EDR/SIEM.        |
+---------------------+---------------------------------------------------------+
| Doanh nghiệp &      | Giải pháp tự động hóa phát hiện mã độc ẩn sâu trong     |
| Tổ chức SOC         | RAM, giảm thiểu chi phí và thời gian điều tra sự cố.    |
+---------------------+---------------------------------------------------------+
| Nhà nghiên cứu      | Cung cấp cơ sở lý thuyết và phương pháp luận mới về     |
| (Researchers)       | Graph Representation Learning trên dữ liệu bộ nhớ động. |
+---------------------+---------------------------------------------------------+

Câu hỏi thường gặp

1. Yêu cầu phần cứng và phần mềm tối thiểu để triển khai giải pháp là gì?

Hệ thống yêu cầu máy chủ chạy hệ điều hành Ubuntu 22.04 LTS hoặc Windows Server 2022, CPU tối thiểu 8 Cores (Intel Xeon hoặc AMD EPYC), 32GB RAM, ổ cứng SSD NVMe để đảm bảo tốc độ đọc/ghi ảnh chụp bộ nhớ, và 01 GPU NVIDIA (tối thiểu 8GB VRAM như RTX 3060 hoặc Tesla T4) phục vụ tính toán song song ma trận GNN.

2. Mô hình có khả năng mở rộng (Scalability) khi xử lý hàng trăm máy trạm đồng thời không?

Hoàn toàn có thể mở rộng thông qua kiến trúc hướng vi dịch vụ (Microservices). Module Volatility Parser và GNN Inference có thể đóng gói thành các Docker Container độc lập, quản lý bằng Kubernetes (K8s) và điều phối tải thông qua hàng đợi Celery / RabbitMQ.

3. Làm thế nào để tích hợp giải pháp này với hệ thống SIEM (Splunk, Elastic SIEM, Wazuh)?

Giải pháp hỗ trợ xuất kết quả dưới dạng chuẩn JSON hoặc Syslog CEF (Common Event Format). Khi GNN phát hiện tiến trình độc hại, hệ thống tự động gửi Webhook API tới SIEM với đầy đủ thông tin: PID, Đường dẫn file gốc, Offset bộ nhớ, Mức độ tin cậy (Confidence Score) và Danh sách các DLL bị tiêm mã.

4. Tần suất cập nhật và huấn luyện lại mô hình (Retraining) như thế nào?

Khuyến nghị thiết lập chu kỳ huấn luyện lại mô hình (Active Learning) mỗi quý một lần hoặc khi xuất hiện các kỹ thuật tấn công In-memory mới (MITRE ATT&CK T1055). Pipeline có thể tự động thu thập các mẫu Memory Dump mới gán nhãn để cập nhật trọng số mô hình.

5. Chi phí đầu tư và thời gian hoàn vốn (ROI) ước tính trong bao lâu?

Do sử dụng hoàn toàn các công nghệ mã nguồn mở (Volatility 3, PyTorch, Linux), chi phí phần mềm là $0. Doanh nghiệp chỉ cần đầu tư hạ tầng máy chủ GPU (khoảng $2.000 - $4.000). Thời gian hoàn vốn ước tính đạt được trong vòng 4 đến 6 tháng nhờ cắt giảm thời gian xử lý sự cố thủ công và ngăn chặn kịp thời các đợt mã hóa dữ liệu quy mô lớn.

Kết luận

Khóa luận tốt nghiệp của Kỹ sư Lê Thanh Duẫn đã giải quyết thành công một trong những bài toán phức tạp và cấp thiết nhất của ngành An toàn Thông tin hiện đại: Phát hiện các biến thể phần mềm độc hại PE tinh vi, bị che giấu hoặc thực thi trực tiếp trong bộ nhớ RAM. Bằng sự kết hợp đột phá giữa kỹ thuật Pháp chứng bộ nhớ (Memory Forensics với Volatility 3) và Mạng thần kinh đồ thị (Graph Neural Networks với GraphSAGE), nghiên cứu đã chứng minh tính khả thi và hiệu năng vượt trội với độ chính xác đạt 98.92% và thời gian phản hồi ở mức mili-giây.

Công trình không chỉ mang giá trị học thuật cao trong việc áp dụng mô hình học sâu cấu trúc đồ thị vào dữ liệu nhị phân động, mà còn mở ra tiềm năng thương mại hóa và ứng dụng thực tiễn to lớn cho các trung tâm SOC và giải pháp an ninh điểm cuối. Đây là minh chứng rõ nét cho năng lực nghiên cứu ứng dụng chuyên sâu của sinh viên và giảng viên Khoa Mạng máy tính và Truyền thông, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM.