Giới thiệu dự án

Trong bối cảnh an ninh mạng toàn cầu diễn biến phức tạp, các cuộc tấn công bằng mã độc (malware) trên hệ điều hành Windows không ngừng gia tăng cả về quy mô lẫn mức độ tinh vi. Điển hình như cuộc tấn công ransomware toàn cầu WannaCry (2017) đã làm tê liệt các cơ sở y tế và hạ tầng doanh nghiệp tại hơn 150 quốc gia, cho thấy thiệt hại thảm khốc của mã độc tống tiền thế hệ mới. Các kỹ thuật che giấu hiện đại như làm rối mã (obfuscation), đóng gói mã (packing), đa hình (polymorphic), biến hình (metamorphic) cùng các cơ chế chống dịch ngược (anti-debugging) và né tránh môi trường ảo (anti-sandbox) đang vô hiệu hóa dần các giải pháp phòng thủ dựa trên chữ ký truyền thống.

Vấn đề cốt lõi đặt ra là các phương pháp phân tích đơn lẻ bộc lộ nhiều điểm yếu chí tử:

  • Phân tích tĩnh (Static Analysis): Xử lý nhanh trong thời gian thực nhưng hoàn toàn bất lực trước mã độc bị mã hóa, nén hoặc rối mã.
  • Phân tích động (Dynamic Analysis): Bắt được hành vi thực thi nhưng tốn tài nguyên tính toán, độ trễ cao và dễ bị đánh lừa bởi mã độc có cơ chế phát hiện máy ảo (anti-analysis).
  • Các giải pháp áp dụng Xử lý ngôn ngữ tự nhiên (NLP) hiện hành: Phần lớn chỉ tập trung vào một thuộc tính đơn lẻ (hoặc chỉ chuỗi ký tự printable strings, hoặc chỉ chuỗi API calls, hoặc chỉ mã lệnh Opcode), làm mất đi mối tương quan ngữ nghĩa đa chiều giữa mã nguồn tĩnh và hành vi động.

Đồ án khóa luận tốt nghiệp "Một hướng tiếp cận đa thể thức cho phát hiện mã độc Windows sử dụng phân tích lai và kỹ thuật xử lý ngôn ngữ tự nhiên" do sinh viên Lâm Thiệu An và Nguyễn Quang Huy thực hiện dưới sự hướng dẫn của ThS. Đỗ Thị Thu Hiề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-HCM, 2024) được nghiên cứu nhằm giải quyết triệt để bài toán này.

                  +----------------------------------------------+
                  |         Tập tin Windows PE thực thi          |
                  +----------------------+-----------------------+
                                         |
                   +---------------------+---------------------+
                   |                                           |
       [ PHÂN TÍCH TĨNH ]                              [ PHÂN TÍCH ĐỘNG ]
       (Capstone Disassembler)                         (Cuckoo Sandbox VM)
       +-----------+-----------+                       +-----------+-----------+
       |                       |                       |                       |
   [ Strings ]             [ Opcode ]             [ API Sequence ]     [ Network pcap ]
       |                       |                       |                       |
   (Text Clean)          (EntryPt Filter)       (Arith-Prog Purify)       (3-grams)
       |                       |                       |                       |
  (Keras Embed)        (Word2Vec CBOW)           (Keras Embed)          (Word2Vec CBOW)
       |                       |                       |                       |
  [ 1D-CNN Branch ]     [ Bi-LSTM Branch ]     [ 1D-CNN+LSTM Branch ]  [ 1D-CNN Branch ]
       +-----------------------+-----------+-----------+-----------------------+
                                           |
                              [ CONCATENATE LAYER ]
                                           |
                              [ DENSE CLASSIFIER ]
                                           |
                   +-----------------------+-----------------------+
                   |                                               |
         [ Phân loại Nhị phân ]                          [ Phân loại Đa nhãn ]
         (Lành tính vs Độc hại)             (Benign, Trojan, Virus, Worm, Backdoor)

Mục tiêu dự án

  1. Xây dựng quy trình phân tích lai (Hybrid Analysis): Tự động hóa việc trích xuất đồng thời 4 luồng dữ liệu mang đặc tính "ngôn ngữ" từ tập tin Portable Executable (PE): chuỗi ký tự (Strings), chuỗi mã lệnh thực thi (Opcode), chuỗi lời gọi hàm hệ thống (API Calls) và luồng gói tin mạng (Network Traffic pcap).
  2. Thiết kế thuật toán tiền xử lý chuyên sâu: Triệt tiêu nhiễu dữ liệu chuỗi ký tự bằng cơ chế lọc phân bố tần suất 2 chiều (ngưỡng 30%) và loại bỏ chuỗi API lặp tuần hoàn/cấp số cộng gây tràn bộ đệm.
  3. Mô hình hóa dữ liệu dạng ngôn ngữ: Chuyển đổi các đặc trưng phi cấu trúc thành biểu diễn không gian vector ngữ nghĩa bằng kỹ thuật Word2Vec (CBOW) và Tokenization/Embedding tối ưu.
  4. Kiến trúc mô hình học sâu đa thể thức (Multimodal Deep Learning): Xây dựng mạng nơ-ron đa nhánh song song kết hợp 1D Convolutional Neural Network (1D-CNN) và Bidirectional Long Short-Term Memory (Bi-LSTM), hợp nhất thông qua Concatenate Layer để phân loại chính xác.
  5. Thực nghiệm toàn diện: Đánh giá hiệu năng trên cả 2 tác vụ: Phân loại nhị phân (Binary Classification) và Phân loại đa lớp họ mã độc (Multiclass Classification: Benign, Trojan, Virus, Worm, Backdoor).

Phạm vi và giới hạn

  • Hệ điều hành mục tiêu: Môi trường Microsoft Windows x86/x64, định dạng tệp thực thi PE (.exe, .dll).
  • Hạ tầng phân tích động: Cuckoo Sandbox 2.0.7 cô lập trên nền tảng máy ảo VirtualBox chạy Windows 7 Professional SP1 x64.
  • Tập mẫu: 7.596 mẫu dữ liệu thực tế gán nhãn đa lớp chuẩn xác thông qua dịch vụ VirusTotal API và nguồn mở VirusShare kết hợp PE Malware Machine Learning Dataset.

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

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

Phương pháp Ưu điểm Nhược điểm Khả năng vượt qua Obfuscation/Anti-VM
Phân tích tĩnh truyền thống Thời gian xử lý mili-giây, không cần chạy file, an toàn tuyệt đối. Không nhận diện được payload đã mã hóa/pack; phụ thuộc mẫu chữ ký có sẵn. Kém (Dễ bị bypass bởi Packers, Crypters).
Phân tích động độc lập Ghi nhận chính xác hành vi thực tế; giải mã được payload trong bộ nhớ. Tốn nhiều tài nguyên, độ trễ cao (30-120s/file); dễ bị vô hiệu bởi mã độc kiểm tra môi trường ảo. Trung bình (Dễ bị vô hiệu bởi Anti-Sandbox/Anti-Debug).
NLP đơn thể thức (Single-modal NLP) Nắm bắt được ngữ cảnh tuần tự của mã lệnh hoặc lời gọi API. Góc nhìn hạn chế; nếu thuộc tính duy nhất bị làm mờ hoặc ẩn giấu, mô hình suy giảm độ chính xác nghiêm trọng. Trung bình (Phụ thuộc vào loại đặc trưng được chọn).
Giải pháp đề xuất: Phân tích lai Đa thể thức Tận dụng toàn diện 4 góc nhìn: Cấu trúc tĩnh + Mã máy + Hành vi hệ thống + Giao tiếp mạng. Bù trừ khuyết điểm giữa các luồng dữ liệu. Cần xây dựng pipeline thu thập và tiền xử lý dữ liệu phức tạp. Rất cao (Kháng đa hình, phát hiện mẫu Zero-day).

Ma trận ưu tiên yêu cầu hệ thống (MoSCoW)

  • Must-have: Trích xuất tự động Opcode từ AddressOfEntryPoint, làm sạch API sequence khử cấp số cộng, mô hình trích chọn n-gram cho dữ liệu pcap, mạng nơ-ron đa nhánh song song.
  • Should-have: Gán nhãn tự động chuẩn hóa qua VirusTotal API đa động cơ bảo mật, cơ chế post-padding cân bằng kích thước vector chuỗi.
  • Could-have: Hỗ trợ giao diện dòng lệnh (CLI) tích hợp trực tiếp vào hệ thống SIEM/SOC.
  • Won't-have (giai đoạn này): Phân tích can thiệp bộ nhớ sâu kernel-mode hypervisor trực tiếp.

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm 3 phân hệ độc lập: Phân hệ Phân tích & Trích xuất (Analysis Pipeline), Phân hệ Xử lý ngôn ngữ & Nhúng đặc trưng (NLP Preprocessing), và Phân hệ Phân loại Đa thể thức (Multimodal Classifier Network).

                      KIẾN TRÚC MẠNG ĐA THỂ THỨC (MULTIMODAL DEEP LEARNING)

+-----------------------+ +-----------------------+ +-----------------------+ +-----------------------+
|  Tokenized String     | |  Tokenized API Seq    | |  Tokenized Opcode     | |  Tokenized Network    |
|  Vector (L=maxlen)    | |  Vector (L=1000)      | |  Vector (L=maxlen)    | |  Byte 3-grams         |
+-----------+-----------+ +-----------+-----------+ +-----------+-----------+ +-----------+-----------+
            |                         |                         |                         |
+-----------v-----------+ +-----------v-----------+ +-----------v-----------+ +-----------v-----------+
| Keras Embedding Layer | | Keras Embedding Layer | | Word2Vec Embedding    | | Word2Vec Embedding    |
| (dim=256)             | | (dim=256)             | | (dim=100, window=5)   | | (dim=128, window=1)   |
+-----------+-----------+ +-----------+-----------+ +-----------+-----------+ +-----------+-----------+
            |                         |                         |                         |
+-----------v-----------+ +-----------v-----------+ +-----------v-----------+ +-----------v-----------+
| 1D-CNN (128 filters,  | | 1D-CNN (128 filters,  | | LSTM Layer            | | 1D-CNN (128 filters,  |
|  kernel=5, ReLU)      | |  kernel=8, ReLU)      | | (units=128, tanh)     | |  kernel=8, ReLU)      |
+-----------+-----------+ +-----------+-----------+ +-----------+-----------+ +-----------+-----------+
            |                         |                         |                         |
+-----------v-----------+ +-----------v-----------+ +-----------v-----------+ +-----------v-----------+
| 1D-CNN (64 filters,   | | 1D-CNN (64 filters,   | | LSTM Layer            | | MaxPooling1D (pool=5) |
|  kernel=5, ReLU)      | |  kernel=8, ReLU)      | | (units=128, tanh)     | +-----------+-----------+
+-----------+-----------+ +-----------+-----------+ +-----------+-----------+             |
            |                         |                         |             +-----------v-----------+
+-----------v-----------+ +-----------v-----------+             |             | 1D-CNN (64 filters,   |
| GlobalMaxPooling1D    | | MaxPooling1D (pool=5) |             |             |  kernel=4, ReLU)      |
+-----------+-----------+ +-----------+-----------+             |             +-----------+-----------+
            |                         |                         |                         |
            |             +-----------v-----------+             |             +-----------v-----------+
            |             | LSTM (units=32, tanh) |             |             | 1D-CNN (32 filters,   |
            |             +-----------+-----------+             |             |  kernel=2, ReLU)      |
            |                         |                         |             +-----------+-----------+
            |             +-----------v-----------+             |                         |
            |             | GlobalMaxPooling1D    |             |             +-----------v-----------+
            |             +-----------+-----------+             |             | GlobalMaxPooling1D    |
            |                         |                         |             +-----------+-----------+
            |                         |                         |                         |
            +-------------------------+------------+------------+-------------------------+
                                                   |
                                     +-------------v-------------+
                                     |    CONCATENATE LAYER      |
                                     +-------------+-------------+
                                                   |
                                     +-------------v-------------+
                                     | Dense / Softmax Layer     |
                                     | (Classification Output)   |
                                     +---------------------------+

Technology Stack và phiên bản kỹ thuật

  • Ngôn ngữ thực thi chính: Python 3.8+
  • Disassembler tĩnh: Capstone Engine 4.0.2 / PEfile 2023.2.7
  • Nền tảng Sandbox phân tích động: Cuckoo Sandbox 2.0.7 (REST API client)
  • Trích xuất phân tích mạng: Dpkt 1.9.8 (Packet Parsing)
  • NLP & Deep Learning Frameworks: TensorFlow 2.12.0 / Keras 2.12.0, Gensim 4.3.1 (Word2Vec)
  • Hệ điều hành Host & Guest: Ubuntu 18.04 LTS (Analysis Server), Windows 7 SP1 x64 (Guest Target)
  • Phần cứng huấn luyện: 4 vCPUs Intel Xeon 2.20GHz, 29GB RAM, GPU NVIDIA Tesla P100 16GB VRAM

Implementation và kết quả

Development Process

1. Thuật toán trích xuất Opcode bắt đầu từ EntryPoint

Để khắc phục tình trạng các phần mềm độc hại đổi tên section .text nhằm đánh lừa disassembler, hệ thống truy xuất trực tiếp AddressOfEntryPoint trong OptionalHeader, cộng với ImageBase để tính toán virtual offset chính xác trước khi đưa qua engine Capstone:

import pefile
from capstone import Cs, CS_ARCH_X86, CS_MODE_32

def extract_opcodes_from_entrypoint(pe_path: str, max_opcodes: int = 5000) -> str:
    pe = pefile.PE(pe_path)
    entry_point = pe.OPTIONAL_HEADER.AddressOfEntryPoint
    image_base = pe.OPTIONAL_HEADER.ImageBase
    
    # Xác định Section chứa Entry Point
    target_section = None
    for section in pe.sections:
        v_addr = section.VirtualAddress
        v_size = section.Misc_VirtualSize
        if v_addr <= entry_point < v_addr + v_size:
            target_section = section
            break
            
    if not target_section:
        return ""
        
    offset = entry_point - target_section.VirtualAddress
    code_data = target_section.get_data()[offset:]
    
    # Khởi tạo Capstone Disassembler x86 (32-bit / 64-bit compatible)
    md = Cs(CS_ARCH_X86, CS_MODE_32)
    ignored_directives = {'dd', 'db', 'align', 'dw', 'dq'}
    opcodes = []
    
    for insn in md.disasm(code_data, image_base + entry_point):
        mnemonic = insn.mnemonic.lower()
        if mnemonic not in ignored_directives:
            opcodes.append(mnemonic)
        if len(opcodes) >= max_opcodes:
            break
            
    return " ".join(opcodes)

2. Thuật toán loại bỏ chuỗi API gây nhiễu có tính chất cấp số cộng

Nhiều dòng mã độc chủ động gọi lặp vô tận các API rác nhằm làm tràn bộ đệm phân tích. Thuật toán PURIFY_API_SEQUENCE phát hiện và cô lập các dãy API lặp lại tuần hoàn theo cấp số cộng vị trí:

def purify_api_sequence(in_api_seq: list) -> list:
    """
    Thuật toán loại bỏ chuỗi API con nhiễu có tính chất cấp số cộng
    Độ phức tạp tối đa: O(n^2), tinh chỉnh trên chuỗi API độ dài N <= 1000
    """
    i = 0
    while i < len(in_api_seq):
        br_flag = 0
        target_api = in_api_seq[i]
        
        # Lưu trữ tất cả vị trí xuất hiện của target_api
        positions = [j for j, api in enumerate(in_api_seq) if api == target_api]
        
        j = 0
        while j < len(positions):
            for n in range(len(positions) - j, 2, -1):
                if j + n < len(positions):
                    # Kiểm tra tính chất cấp số cộng của các vị trí xuất hiện
                    step = positions[j + 1] - positions[j]
                    is_arithmetic = all(
                        positions[j + k] - positions[j + k - 1] == step 
                        for k in range(2, n)
                    )
                    
                    if is_arithmetic:
                        # Trích xuất và kiểm tra xem chuỗi con có thực sự lặp lại giống nhau không
                        sub_seq = in_api_seq[positions[j] : positions[j + n] + 1]
                        is_noisy = all(
                            sub_seq[k + step : k + 2 * step] == sub_seq[k : k + step]
                            for k in range(0, len(sub_seq) - 2 * step + 1, step)
                        )
                        if is_noisy:
                            # Cắt bỏ phần dư thừa gây nhiễu, chỉ giữ lại một đại diện
                            in_api_seq = (
                                in_api_seq[: positions[j]] + 
                                in_api_seq[positions[j + n - 1] + 1 :]
                            )
                            i = 0
                            br_flag = 1
                            break
            if br_flag == 1:
                break
            j += 1
        i += 1
    return in_api_seq

3. Xử lý gói tin mạng pcap thành Byte n-grams (3-grams)

Toàn bộ byte payloads trong tập tin pcap được đọc tuần tự bằng dpkt, phân rã thành các chuỗi 3-grams độc bản và nhúng vector qua Word2Vec CBOW:

import dpkt

def extract_pcap_3grams(pcap_path: str) -> list:
    ngrams = set()
    with open(pcap_path, 'rb') as f:
        pcap = dpkt.pcap.Reader(f)
        for ts, buf in pcap:
            # Chuyển đổi byte thô sang hex token
            hex_stream = [f"{byte:02x}" for byte in buf]
            if len(hex_stream) >= 3:
                for k in range(len(hex_stream) - 2):
                    gram = f"{hex_stream[k]}_{hex_stream[k+1]}_{hex_stream[k+2]}"
                    ngrams.add(gram)
    return list(ngrams)

Testing và Validation

Quá trình tinh chỉnh siêu tham số (Hyperparameter Tuning) thực nghiệm trên hơn 18.000 tập tin đã xác lập các giá trị tối ưu:

  1. Tỉ lệ lọc từ điển chuỗi ký tự (String Filtering Threshold): Ngưỡng loại bỏ 30% tần suất cao giúp triệt tiêu hoàn toàn các chuỗi tiêu chuẩn xuất hiện ở cả file sạch lẫn file độc (this program cannot be run in dos mode), giữ lại các chuỗi đặc trưng hành vi độc (URL độc, tên file payload, registry keys).
  2. Ngưỡng độ dài chuỗi API ($N$): Thực nghiệm phân tích biến thiên $N \in [500, 2000]$. Kết quả cho thấy tại $N = 1000$, mô hình đạt độ chính xác cao nhất (97.8% so với 95.2% ở $N=500$ và 96.5% ở $N=2000$), đồng thời giảm thời gian thực thi thuật toán làm sạch đi 68.4%.
  3. Kích thước mạng n-gram cho dữ liệu pcap: Thử nghiệm $n \in {2, 3, 4, 5}$ chỉ ra $n = 3$ (3-grams) đạt Accuracy đỉnh 87.4% trên nhánh network độc lập.
+-----------------------------------------------------------------------------------+
|                        KẾT QUẢ ĐÁNH GIÁ TRÊN CÁC MÔ HÌNH THÀNH PHẦN               |
+--------------------------+---------------+--------------+------------+------------+
| Mô hình thành phần       | Accuracy (%)  | Precision(%) | Recall (%) | F1-Score(%)|
+--------------------------+---------------+--------------+------------+------------+
| Nhánh Network (pcap)     | 87.40         | 86.80        | 87.10      | 86.95      |
| Nhánh Opcode (tĩnh)      | 93.80         | 93.50        | 94.10      | 93.80      |
| Nhánh String (tĩnh)      | 95.20         | 94.90        | 95.50      | 95.20      |
| Nhánh API Call (động)    | 97.80         | 97.60        | 98.00      | 97.80      |
| MÔ HÌNH ĐA THỂ THỨC GỘP  | **99.15**     | **99.05**    | **99.20**  | **99.12**  |
+--------------------------+---------------+--------------+------------+------------+

Kết quả đạt được

Hệ thống phân loại đa lớp trên 7.596 mẫu thực tế đạt độ chính xác vượt trội giữa các họ mã độc phức tạp:

+-----------------------------------------------------------------------------------+
|               KẾT QUẢ PHÂN LOẠI ĐA LỚP (MULTICLASS CLASSIFICATION)                |
+--------------------+---------------+--------------+------------+------------------+
| Loại mã độc / Label| Precision (%) | Recall (%)   | F1-Score(%)| Mẫu kiểm thử     |
+--------------------+---------------+--------------+------------+------------------+
| Benign (Lành tính) | 99.40         | 99.20        | 99.30      | 2.500            |
| Trojan             | 98.60         | 98.40        | 98.50      | 1.850            |
| Virus              | 98.90         | 99.10        | 99.00      | 1.200            |
| Worm               | 98.20         | 98.50        | 98.35      | 1.100            |
| Backdoor           | 97.80         | 97.30        | 97.55      | 946              |
| TRUNG BÌNH CHUNG   | **98.58**     | **98.50**    | **98.54**  | **7.596 Mẫu**    |
+--------------------+---------------+--------------+------------+------------------+

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

Các cải tiến kỹ thuật nổi bật

  1. Cơ chế biểu diễn hợp nhất 4 luồng ngôn ngữ: Đề xuất cách tiếp cận đa thể thức đầu tiên xử lý đồng thời cả String, Opcode, API Sequence và Network pcap dưới dạng ngôn ngữ tự nhiên, nắm bắt trọn vẹn dấu vết tĩnh và hành vi động.
  2. Thuật toán thanh lọc API Sequence cấp số cộng (Algorithm 1): Triệt tiêu hoàn toàn kỹ thuật tấn công làm mù sandbox (Sandbox Blindness/Stalling) bằng vòng lặp API rác, giảm độ phức tạp không gian vector mà không làm mất dấu vết chuỗi hành vi độc thực tế.
  3. Trích xuất Opcode độc lập cấu trúc section: Cơ chế định vị AddressOfEntryPoint giúp vượt qua các thủ thuật làm rối bảng Section Header (.text obfuscation/renaming) trong các file PE bị pack/crypt.
  4. Chuẩn hóa Byte-level Packet NLP: Xử lý luồng lưu lượng mạng thô dạng 3-grams nhúng Word2Vec, loại bỏ phụ thuộc vào các trường thống kê lưu lượng (Flow-based) vốn dễ bị làm giả.

So sánh với các nghiên cứu tiền nhiệm

+-----------------------+---------------------+-------------------+---------------------+-------------------------+
| Tiêu chí so sánh      | Mimura & Ito (2020) | Tran & Sato (2021)| Renjie Lu (2021)    | ĐỀ TÀI ĐA THỂ THỨC (2024)|
+-----------------------+---------------------+-------------------+---------------------+-------------------------+
| Thuộc tính đầu vào    | Chỉ Printable String| Chỉ API Sequences | Chỉ Opcode Disasm   | 4 Luồng: String, Opcode,|
|                       |                     |                   |                     | API Call, Network pcap  |
+-----------------------+---------------------+-------------------+---------------------+-------------------------+
| Hướng phân tích       | Phân tích Tĩnh      | Phân tích Động    | Phân tích Tĩnh      | Phân tích Lai (Hybrid)  |
+-----------------------+---------------------+-------------------+---------------------+-------------------------+
| Xử lý chống né tránh  | Không có            | Lọc chuỗi cơ bản  | Bỏ qua directive    | Khử cấp số cộng API,    |
| (Anti-evasion)        |                     |                   |                     | Lọc tần suất 30% 2 chiều|
+-----------------------+---------------------+-------------------+---------------------+-------------------------+
| Độ chính xác (Binary) | 90.20%              | 96.40%            | 94.80% (AUC: 0.94)  | **99.15% (AUC: 0.99)**  |
+-----------------------+---------------------+-------------------+---------------------+-------------------------+
| Phân loại Đa họ mã độc| Không hỗ trợ        | 92.10%            | Không hỗ trợ        | **98.58% F1-Score**     |
+-----------------------+---------------------+-------------------+---------------------+-------------------------+

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

Kịch bản ứng dụng trong thực tế

  • Hệ thống giám sát an ninh tập trung (SOC/SIEM Pipeline): Hoạt động như một Gateway phân tích chuyên sâu cấp độ 2 (Tier-2 Malware Analysis Engine), tiếp nhận các file thực thi bị gắn cờ nghi vấn từ Endpoint Detection and Response (EDR).
  • Cổng phân tích tệp tin tự động cho dịch vụ Email Gateway / File Storage: Quét và phân loại mã độc tự động, bóc tách chính xác các biến thể ransomware, backdoor ẩn giấu.
                          KIẾN TRÚC TRIỂN KHAI DOANH NGHIỆP

  +------------------+         +------------------+         +------------------+
  |  EDR / Firewall  |         |  Email Gateway   |         | Web Portal Upload|
  +--------+---------+         +--------+---------+         +--------+---------+
           |                            |                            |
           +--------------------+       |       +--------------------+
                                |       |       |
                         +------v-------v-------v------+
                         |   API Gateway & LoadBalancer|
                         |      (Nginx / FastAPI)      |
                         +--------------+--------------+
                                        |
                 +----------------------+----------------------+
                 |                                             |
     +-----------v-----------+                     +-----------v-----------+
     | Static Pre-Filter Node|                     | Cuckoo Sandbox Cluster|
     | (Strings, PE Opcodes) |                     | (Dynamic API & pcap)  |
     +-----------+-----------+                     +-----------+-----------+
                 |                                             |
                 +----------------------+----------------------+
                                        |
                         +--------------v--------------+
                         |  Worker Celery Queue (Redis)|
                         +--------------+--------------+
                                        |
                         +--------------v--------------+
                         | Multimodal Inference Engine |
                         | (TensorFlow Serving / GPU)  |
                         +--------------+--------------+
                                        |
                 +----------------------+----------------------+
                 |                                             |
     +-----------v-----------+                     +-----------v-----------+
     | SOC SIEM / SOAR Alert |                     | Threat Intel Database |
     | (Block IP, Quarantine)|                     | (Elasticsearch/Kibana)|
     +-----------------------+                     +-----------------------+

Yêu cầu triển khai hệ thống (System Requirements)

  • Môi trường Host: Linux Ubuntu Server 20.04 / 22.04 LTS x64.
  • Tài nguyên phần cứng: Tối thiểu 8 CPU Cores, 32GB RAM, 200GB SSD (đáp ứng lưu trữ snapshot máy ảo và pcap), GPU NVIDIA (khuyến nghị từ RTX 3060 12GB hoặc Tesla T4 trở lên để inference thời gian thực).
  • Phần mềm ảo hóa: KVM/QEMU hoặc VirtualBox 6.1+ tích hợp module Cuckoo REST API server.

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

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

  • Độ trễ phân tích động: Quá trình chạy sandbox tự động tốn từ 30-60 giây cho mỗi mẫu để thu thập đủ chuỗi API và lưu lượng mạng pcap, tạo nút thắt cổ chai khi tiếp nhận lượng lớn tập tin đồng thời.
  • Kỹ thuật chống máy ảo bậc cao: Một số dòng mã độc APT sử dụng cơ chế phát hiện tương tác chuột của người dùng (human interaction timing) hoặc kiểm tra tập lệnh CPU hypervisor chuyên sâu có thể tạm dừng hành vi để qua mặt Cuckoo Sandbox.
  • Tập dữ liệu đa nhãn: Chưa mở rộng bao phủ toàn bộ các nhóm mã độc đặc biệt như Ransomware chuyên biệt, Spyware và Rootkit do số lượng mẫu sạch/chuẩn nhãn còn hạn chế.

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

  • Tích hợp mô hình Transformer / BERT for Assembly: Nghiên cứu áp dụng kiến trúc kiến trúc ngôn ngữ lớn dạng mã máy (như MalBERT, CodeBERT) thay thế cho Word2Vec/LSTM thuần túy để tăng khả năng đọc hiểu ngữ cảnh chuỗi opcode dài.
  • Ứng dụng Đồ thị luồng điều khiển (Control Flow Graph - CFG) với Graph Neural Networks (GNN): Kết hợp cấu trúc đồ thị luồng điều khiển hàm vào mạng đa thể thức.
  • Tối ưu hóa Sandbox thời gian thực: Ứng dụng công nghệ memory introspection không độ trễ (như DRAKVUF) trên nền tảng Hypervisor để trích xuất API call tức thì mà không cần cài agent trong guest OS.

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

+-------------------+---------------------------------------------------------+------------------------------------------+
| Nhóm đối tượng    | Lợi ích kỹ thuật trực tiếp                              | Giá trị định lượng                       |
+-------------------+---------------------------------------------------------+------------------------------------------+
| Sinh viên CNTT /  | Nguồn tài liệu mẫu hoàn chỉnh về ứng dụng NLP trong     | Tiếp cận pipeline xử lý đa thể thức      |
| An toàn thông tin | phân tích mã độc; phương pháp nghiên cứu học sâu chuẩn. | chuẩn mực, 100% mã nguồn thực nghiệm.   |
+-------------------+---------------------------------------------------------+------------------------------------------+
| Kỹ sư bảo mật /   | Bộ khung tham chiếu để xây dựng engine phân tích lai;   | Tăng độ phát hiện mã độc lên 99.15%,     |
| SOC Analysts      | thuật toán khử nhiễu API sequence có thể tích hợp ngay. | giảm 68.4% dữ liệu rác trong sandbox.    |
+-------------------+---------------------------------------------------------+------------------------------------------+
| Doanh nghiệp /    | Cơ sở phát triển giải pháp EDR thế hệ mới; tiết kiệm    | Giảm thiểu tổn thất do mã độc tống tiền, |
| Tổ chức tài chính | chi phí bản quyền giải pháp bảo mật đắt đỏ từ nước ngoài| giảm 90% thời gian phân loại thủ công.   |
+-------------------+---------------------------------------------------------+------------------------------------------+
| Nhà nghiên cứu    | Đặt nền móng học thuật cho việc biểu diễn mã máy và lưu | Tăng chỉ số F1-Score đa lớp lên 98.54%,  |
| chuyên sâu        | lượng mạng như các token ngôn ngữ tự nhiên.             | vượt trội các giải pháp đơn lẻ 3-8%.     |
+-------------------+---------------------------------------------------------+------------------------------------------+

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

1. Cần cấu hình hạ tầng như thế nào để triển khai hệ thống trong môi trường sản xuất?

Để vận hành hệ thống tự động, doanh nghiệp cần thiết lập cụm máy chủ Linux Ubuntu 20.04/22.04 LTS cấu hình tối thiểu 8 Core CPU, 32GB RAM cùng GPU NVIDIA (T4 hoặc RTX 3080/4080) phục vụ suy luận mạng nơ-ron đa thể thức. Máy chủ phân tích động cần cấu hình các máy ảo Windows 7/10 được cài đặt sẵn môi trường phần mềm phụ trợ (Adobe Reader, Java Runtime, MS Office) nhằm kích hoạt tối đa hành vi của mã độc khi chạy ngầm.

2. Thuật toán loại bỏ chuỗi API cấp số cộng hoạt động thế nào khi gặp mã độc đa luồng (Multi-threading)?

Khi mã độc thực thi đa luồng, Cuckoo Sandbox sẽ hook và gom các lời gọi API kèm định danh thread_id. Trước khi áp dụng thuật toán purify_api_sequence, hệ thống nhóm các API theo từng luồng thực thi riêng biệt để xử lý khử cấp số cộng độc lập, sau đó mới hợp nhất lại theo dấu thời gian (timestamp). Điều này đảm bảo không làm đảo lộn thứ tự hành vi giữa các luồng.

3. Hệ thống có khả năng tích hợp vào hạ tầng SIEM/SOC có sẵn không?

Hoàn toàn khả thi. Toàn bộ pipeline phân tích và mạng nơ-ron suy luận được đóng gói thành các microservices RESTful API (FastAPI/Docker). Khi EDR hoặc Firewall phát hiện file PE đáng ngờ, file sẽ được tự động gửi qua webhook tới API Gateway, hệ thống thực thi phân tích lai và trả về kết quả phân loại định dạng JSON (kèm nhãn, xác suất phần trăm, và danh sách IoC trích xuất) chỉ trong thời gian ngắn.

4. Chi phí duy trì và cập nhật mô hình học sâu định kỳ ra sao?

Mô hình học sâu đa thể thức có khả năng tổng quát hóa rất cao nhờ nắm bắt ngữ nghĩa thay vì chữ ký tĩnh. Tuy nhiên, để đối phó với các chiến dịch tấn công mới, hệ thống nên được huấn luyện tái tinh chỉnh (fine-tuning) định kỳ hàng tháng. Với tập dữ liệu bổ sung khoảng 2.000 - 5.000 mẫu mới, thời gian huấn luyện lại trên GPU P100/T4 chỉ mất từ 2-4 giờ tính toán, không phát sinh thêm chi phí phần cứng lớn.

5. Tại sao mô hình chọn Word2Vec CBOW thay vì các mô hình Transformer phức tạp hơn?

Trong xử lý Opcode và Byte 3-grams mạng, tập từ vựng (vocabulary) mang tính cục bộ cao và cấu trúc có tính tuần hoàn trực tiếp. Word2Vec dạng Continuous Bag-of-Words (CBOW) mang lại sự cân bằng hoàn hảo giữa chất lượng vector ngữ nghĩa và tốc độ huấn luyện/suy luận (nhanh hơn Transformer gấp 10-15 lần), đảm bảo hệ thống có thể phân tích thời gian thực với lượng tài nguyên vừa phải.

Kết luận

Đồ án khóa luận tốt nghiệp của sinh viên Lâm Thiệu An và Nguyễn Quang Huy đã giải quyết xuất sắc bài toán phát hiện và phân loại mã độc Windows thông qua cách tiếp cận đa thể thức mang tính đột phá. Bằng việc kết hợp hài hòa giữa phân tích lai (tĩnh và động) với các kỹ thuật Xử lý ngôn ngữ tự nhiên (NLP) tiên tiến, nghiên cứu đã vượt qua những giới hạn cố hữu của các phương pháp phân tích đơn thuộc tính truyền thống.

Các đóng góp cốt lõi của công trình:

  • Độ chính xác vượt trội: Đạt tỷ lệ phân loại nhị phân 99.15% và F1-Score phân loại đa họ mã độc 98.54% trên tập dữ liệu thực tế.
  • Đổi mới phương pháp luận: Chuẩn hóa toàn bộ 4 luồng dữ liệu (String, Opcode, API Sequence, Network pcap) về không gian vector ngôn ngữ ngữ nghĩa.
  • Tính thực tiễn cao: Xây dựng thành công quy trình tiền xử lý, thuật toán khử nhiễu API tuần hoàn và kiến trúc mạng nơ-ron đa nhánh song song có khả năng áp dụng trực tiếp vào các hệ thống SOC/EDR doanh nghiệp.

Đây là nền tảng vững chắc mở ra hướng đi mới cho các hệ thống an ninh mạng thông minh trong kỷ nguyên đối đầu với các mối đe dọa mã độc tinh vi và biến thể liên tục.