Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và bùng nổ không gian mạng, các mối đe dọa từ phần mềm độc hại (malware) đang gia tăng theo cấp số nhân cả về quy mô lẫn mức độ phức tạp. Theo thống kê từ các tổ chức an ninh mạng toàn cầu (như AV-Test và Kaspersky), mỗi ngày có hơn 450.000 biến thể mã độc mới được tạo ra. Các tác nhân đe dọa (threat actors) liên tục sử dụng các kỹ thuật biến hình (polymorphism), đa hình (metamorphism), mã hóa động và che giấu mã nguồn nhằm qua mặt các giải pháp phòng thủ truyền thống.

Phần lớn các hệ thống diệt virus (Antivirus - AV) thương mại hiện nay vẫn dựa chủ yếu vào cơ chế quét dựa trên dấu hiệu đặc trưng (signature-based matching) như mã băm MD5/SHA256 hoặc chuỗi byte mẫu tĩnh. Phương pháp này hoàn toàn bất lực trước các cuộc tấn công Zero-day (0-day) – những mẫu mã độc chưa từng được công bố hoặc các biến thể đã bị xáo trộn mã lệnh (code obfuscation).

Đồ án tốt nghiệp "Sử dụng kỹ thuật phân tích chuỗi mã lệnh để phát hiện phần mềm độc hại không xác định" (Using Opcode Sequences Analysis For Unknown Malware Detection) của tác giả Nguyễn Dương Hoàng Duy (Khoa Công nghệ Phần mềm, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM, dưới sự hướng dẫn của ThS. Mai Trọng Khang) được thực hiện nhằm giải quyết trực tiếp bài toán này. Bằng cách tiếp cận phân tích tĩnh nâng cao (advanced static analysis) trên phân đoạn thực thi (.text section) của cấu trúc tập tin Portable Executable (PE) kiến trúc x86, đề tài tập trung trích xuất ngữ nghĩa hành vi thông qua đồ thị luồng điều khiển (Control Flow Graph - CFG) và tần suất chuỗi mã lệnh (Opcode N-gram, TF-IDF), sau đó huấn luyện các mô hình học máy (Machine Learning) để nhận dạng chính xác mã độc chưa từng biết.

+-------------------------------------------------------------------------+
|                           MỤC TIÊU DỰ ÁN                                |
+-------------------------------------------------------------------------+
| 1. Thu thập & chuẩn hóa 24.048 mẫu (18.035 mã độc, 6.013 mã sạch).      |
| 2. Phân tích nhị phân x86 qua Capstone Engine, giải mã opcode .text.    |
| 3. Xây dựng đồ thị luồng điều khiển cải tiến: G = (V, E) với |V| = n+15.|
| 4. Trích xuất đặc trưng: Opcode N-gram, TF-IDF, PageRank, giảm chiều PCA|
| 5. Đánh giá toàn diện 14 thuật toán Machine Learning qua 5-Fold CV.     |
| 6. Phát triển ứng dụng Desktop quét tệp tin tĩnh và tiến trình động.   |
+-------------------------------------------------------------------------+

Phạm vi nghiên cứu tập trung vào các tệp thực thi định dạng PE 32-bit (x86 PE) chạy trên nền tảng Microsoft Windows. Giới hạn đề tài không bao gồm việc dịch ngược các tệp bị đóng gói tầng sâu (deep packed) bằng các packer thương mại phức tạp chưa hỗ trợ giải nén tĩnh.

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

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

Các kỹ thuật phân tích mã độc phổ biến hiện nay chia thành ba nhóm chính:

Giải pháp Cơ chế hoạt động Ưu điểm Nhược điểm
Chữ ký tĩnh (Signature-based) So khớp mã băm (MD5, SHA-1, SHA-256) hoặc mẫu chuỗi byte. Tốc độ quét cực nhanh ($O(1)$ với bảng băm), tiêu tốn ít tài nguyên CPU/RAM. Hoàn toàn vô hiệu trước biến thể mới, mã độc đa hình, mã hóa hoặc lỗ hổng Zero-day.
Phân tích động (Sandbox Execution) Chạy nhị phân trong máy ảo cô lập, theo dõi API calls, Registry, Network. Phát hiện hành vi thực tế không phụ thuộc vào mã nguồn bị xáo trộn. Tốn nhiều tài nguyên, thời gian phân tích lâu (vài phút/mẫu), dễ bị mã độc nhận diện môi trường ảo hóa (Anti-VM/Anti-Sandbox) để lẩn trốn.
Phân tích chuỗi Opcode (Đề xuất) Phân rã tệp nhị phân x86, phân tích tĩnh luồng lệnh máy và đồ thị điều khiển CFG. Nắm bắt được bản chất logic điều khiển thực thi, phát hiện tốt biến thể 0-day, tốc độ quét tính bằng mili-giây. Đòi hỏi kỹ thuật trích xuất mã nhị phân chuẩn xác và xử lý không gian đặc trưng lớn.

So sánh với các công trình nghiên cứu trước đây:

  • Santos et al.: Sử dụng đặc trưng tần suất thuật ngữ (Term Frequency - TF) kết hợp thuật toán học bán giám sát LLGC (Learning with Local and Global Consistency). Hạn chế: Chưa mô hình hóa được luồng rẽ nhánh điều khiển logic.
  • Sun, Zhi et al.: Ứng dụng TF-IDF chọn lọc $k$-cặp mã lệnh có tần suất cao nhất để phân lớp bằng ML cổ điển. Hạn chế: Mất thông tin ngữ cảnh ngữ nghĩa giữa các hàm gọi xa.
  • Anh Viet Phan et al.: Xây dựng đồ thị luồng điều khiển CFG và phân lớp qua mạng nơ-ron tích chập (CNN). Hạn chế: Độ phức tạp tính toán lớn, chưa tối ưu hóa việc truy vết ngược các lệnh gọi hàm (call/ret).

Yêu cầu hệ thống theo mô hình phân loại MoSCoW:

  • Must have: Giải mã chuẩn xác phân đoạn .text của PE file; tạo CFG xử lý được các lệnh nhảy có điều kiện/không điều kiện; trích xuất vector đặc trưng; phát hiện nhị phân (Binary classification: 0 - Clean, 1 - Malware).
  • Should have: Tối ưu hóa truy vết đệ quy bằng kỹ thuật lính canh và "truy vết trực tiếp"; tối ưu tham số mô hình tập trung vào chỉ số Recall.
  • Could have: Quét thời gian thực các tiến trình (Processes) đang nạp trên RAM; giao diện GUI đồ họa.
  • Won't have: Tự động bẻ khóa và giải nén các packer thương mại cấp độ nhân (Kernel-level packers).

Thiết kế hệ thống

Kiến trúc hệ thống được thiết kế theo mô hình đường ống tuần tự (Modular Pipeline Architecture):

graph TD
    A["Tệp thực thi Windows (PE / ASM)"] --> B["PE Parser & Capstone Disassembler Engine v4.0.2"]
    B --> C["Trích xuất Opcode & Địa chỉ phân đoạn .text"]
    C --> D["Thuật toán xây dựng CFG cải tiến (DFS + Sentinel Nodes)"]
    D --> E["Vector hóa đặc trưng: N-gram (N=2,3) + TF-IDF + PageRank"]
    E --> F["Giảm chiều dữ liệu: Principal Component Analysis (PCA)"]
    F --> G["Mô hình phân lớp Máy học (Tối ưu siêu tham số & Recall)"]
    G --> H["Quyết định phân loại: Mã độc (1) / Mã sạch (0)"]
    H --> I["Giao diện ứng dụng GUI: Quét tệp tĩnh & Quét tiến trình bộ nhớ"]

Bảng Technology Stack chi tiết:

Thành phần Công nghệ / Thư viện Phiên bản Vai trò
Ngôn ngữ cốt lõi Python 3.8.10 Phát triển toàn bộ pipeline phân tích và mô hình
Binary Disassembly Capstone Engine 4.0.2 Dịch ngược mã máy x86 sang Assembly Opcode/Operands
PE Parser pefile 2021.5.24 Phân tích cấu trúc COFF, headers, sections của Windows PE
Machine Learning Scikit-Learn 0.24.2 Huấn luyện 14 thuật toán ML, PCA, Cross-Validation
Data Processing NumPy, Pandas, SciPy 1.20.3 / 1.2.4 Xử lý ma trận, vector hóa dữ liệu n-gram và TF-IDF
Giao diện người dùng PyQt5 5.15.4 Xây dựng GUI ứng dụng quét mã độc và tiến trình

Cấu trúc tệp tin Portable Executable (COFF) được bóc tách chuyên sâu:

  1. MS-DOS Header: Kiểm tra giá trị e_magic (0x5A4D - "MZ") và trường e_lfanew trỏ đến PE Header.
  2. PE Header: Xác thực chữ ký 0x00004550 ("PE\0\0"), đọc thông tin kiến trúc máy tại File Header và điểm thực thi AddressOfEntryPoint trong Optional Header.
  3. Section Table: Duyệt danh sách các phân vùng:
    • .text / .code: Chứa mã thực thi chính thức của chương trình (vùng dữ liệu duy nhất đưa vào engine trích xuất Opcode).
    • .data, .rdata, .idata, .edata, .reloc: Đọc các bảng nhập/xuất thư viện liên kết động (DLL), tài nguyên tĩnh và địa chỉ tái định vị.

Phương pháp nghiên cứu (Methodology)

Dự án áp dụng quy trình phát triển lặp kết hợp chuẩn khoa học dữ liệu CRISP-DM (Cross-Industry Standard Process for Data Mining):

  1. Giai đoạn 1 (Tuần 1 - 4): Thu thập, lọc trùng và gán nhãn tập dữ liệu quy mô lớn; tiền xử lý nhị phân.
  2. Giai đoạn 2 (Tuần 5 - 8): Nghiên cứu toán học đồ thị, lập trình thuật toán giải mã Capstone và kiến tạo CFG với các đỉnh đặc biệt.
  3. Giai đoạn 3 (Tuần 9 - 12): Thử nghiệm trích xuất đặc trưng đa tầng (N-gram, TF-IDF, PageRank, PCA); cấu hình 5-Fold Cross-Validation.
  4. Giai đoạn 4 (Tuần 13 - 16): Tinh chỉnh siêu tham số trên 14 mô hình; phát triển GUI; kiểm thử thực tế trên hệ thống Windows.

Implementation và kết quả

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

1. Trích xuất mã máy nhị phân qua Capstone Engine

Phân đoạn .text được bóc tách từ tệp PE, sau đó đưa qua Cs(CS_ARCH_X86, CS_MODE_32) để chuyển đổi dãy byte nhị phân thành các đối tượng chỉ lệnh Assembly:

from capstone import Cs, CS_ARCH_X86, CS_MODE_32
import pefile

def extract_opcodes_from_pe(file_path):
    pe = pefile.PE(file_path)
    opcodes_list = []
    # Tìm kiếm phân vùng chứa mã thực thi (.text)
    for section in pe.sections:
        if b'.text' in section.Name:
            code_bytes = section.get_data()
            target_addr = pe.OPTIONAL_HEADER.ImageBase + section.VirtualAddress
            md = Cs(CS_ARCH_X86, CS_MODE_32)
            md.detail = True
            for insn in md.disasm(code_bytes, target_addr):
                opcodes_list.append({
                    'address': insn.address,
                    'mnemonic': insn.mnemonic,
                    'op_str': insn.op_str,
                    'bytes': insn.bytes
                })
            break
    return opcodes_list

2. Xây dựng đồ thị luồng điều khiển cải tiến (Enhanced Control Flow Graph)

Đồ thị $G = (V, E)$ được hình thành với $|V| = n + 15$, trong đó $n$ là số lệnh thực thi và 15 đỉnh đặc biệt:

  • Đỉnh $X$: Đại diện cho điểm đến của các lệnh nhảy không xác định được địa chỉ tĩnh (indirect jump / computed target).
  • 14 Đỉnh $Y(\text{reg})$: Đại diện cho 14 lớp thanh ghi trong kiến trúc x86 khi lệnh nhảy sử dụng thanh ghi:
    1. Accumulator (eax, ax, ah, al)
    2. Base (ebx, bx, bh, bl)
    3. Counter (ecx, cx, ch, cl)
    4. Data (edx, dx, dh, dl)
    5. Stack Pointer (esp, sp, spl)
    6. Stack Base Pointer (ebp, bp, bpl)
    7. Source Index (esi, si, sil)
    8. Destination Index (edi, di, dil)
    9. Segment Registers: ss, cs, ds, es, fs, gs.
+--------------------------------------------------------------------------+
|                 QUY TẮC NỐI CẠNH TRÊN ĐỒ THỊ CFG                         |
+--------------------------------------------------------------------------+
| 1. Lệnh tuyến tính (Linear): Lệnh i -> Lệnh i+1 (Bậc ra d+(v) = 1).      |
| 2. Lệnh rẽ nhánh có điều kiện (Conditional Jmp: jz, jnz, je...):         |
|    - Cạnh 1: Trỏ tới lệnh kế tiếp tuyến tính (Fall-through branch).      |
|    - Cạnh 2: Trỏ tới nhãn địa chỉ nhảy đích (Target jump branch).        |
|    (Bậc ra d+(v) = 2).                                                   |
| 3. Lệnh gọi hàm (CALL): Nối cạnh tới đỉnh đầu của hàm con mục tiêu;      |
|    Đồng thời lưu vết địa chỉ lệnh tiếp theo vào Call-Stack ảo.           |
| 4. Lệnh quay về (RET): Thực hiện thuật toán DFS truy vết ngược kết hợp   |
|    "kỹ thuật lính canh" để nối cạnh từ RET về lệnh tuyến tính sau CALL.  |
+--------------------------------------------------------------------------+

def build_cfg_edges(instructions):
    edges = []
    call_stack_trace = {}
    for idx, insn in enumerate(instructions):
        mnemonic = insn['mnemonic']
        # Xử lý lệnh nhảy có điều kiện: Bậc ra = 2
        if mnemonic in ['jz', 'jnz', 'je', 'jne', 'jb', 'ja', 'jl', 'jg']:
            if idx + 1 < len(instructions):
                edges.append((insn['address'], instructions[idx + 1]['address']))
            target_addr = parse_target(insn['op_str'])
            edges.append((insn['address'], target_addr if target_addr else 'NODE_X'))
        # Xử lý lệnh CALL và RET qua DFS Backtracking
        elif mnemonic == 'call':
            target_addr = parse_target(insn['op_str'])
            edges.append((insn['address'], target_addr if target_addr else 'NODE_X'))
            call_stack_trace[target_addr] = instructions[idx + 1]['address']
        elif mnemonic == 'ret':
            # Nối ngược trở về lệnh sau CALL tương ứng
            ret_target = call_stack_trace.get(insn.get('function_entry'), 'NODE_X')
            edges.append((insn['address'], ret_target))
        else:
            if idx + 1 < len(instructions):
                edges.append((insn['address'], instructions[idx + 1]['address']))
    return edges

3. Trích xuất không gian đặc trưng và Giảm chiều

  • N-gram: Trích xuất chuỗi mã lệnh $N$-liên tiếp ($N=2, 3$). Không gian trạng thái $k^N$ với $k \in [0, 270]$ (256 mã opcode thực tế + 14 đỉnh thanh ghi + 1 đỉnh $X$).
  • Term Frequency - Inverse Document Frequency (TF-IDF): $$\text{TF}(t, d) = \frac{f(t, d)}{\max_{t' \in d} f(t', d)}, \quad \text{IDF}(t, D) = \log \frac{|D|}{|{d \in D : t \in d}|}$$ $$\text{TF-IDF}(t, d, D) = \text{TF}(t, d) \times \text{IDF}(t, D)$$
  • PageRank trên CFG: Tính toán độ quan trọng phân tán của từng khối lệnh: $$\text{PR}(u) = \frac{1-d}{|V|} + d \sum_{v \in M(u)} \frac{\text{PR}(v)}{L(v)}$$
  • PCA: Nén giảm không gian vector nhiều chiều về các thành phần chính (Principal Components) mang phương sai lớn nhất, loại bỏ nhiễu của các lệnh hiếm.

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

Tập dữ liệu chuẩn hóa gồm 24.048 mẫu thực thi:

  • Mã độc (18.035 mẫu - Label 1): 16.890 mẫu từ cuộc thi Microsoft Malware Classification Challenge (BIG 2015) và 1.145 mẫu định dạng x86 PE từ kho lưu trữ VX Heavens.
  • Mã sạch (6.013 mẫu - Label 0): Trích xuất từ phân vùng %SystemRoot%\System32 của Windows 10 Build 1703 x64/x86 và hơn 30 phần mềm thương mại phổ biến (Google Chrome, MS Office 365, VLC, WinRAR, Spotify, iTunes, GIMP,...).

Do tập dữ liệu mất cân bằng (75% mã độc : 25% mã sạch), độ chính xác tổng thể (Accuracy) không phản ánh đúng bản chất. Đề tài áp dụng 5-Fold Cross Validation và ưu tiên tối đa hóa chỉ số Recall (hạn chế tối đa False Negative - lọt mã độc) kết hợp F1-Score và ROC-AUC.

Bảng tổng hợp kết quả kiểm thử các mô hình Machine Learning (Trung bình qua 5 Folds):

Thuật toán ML Siêu tham số tối ưu (Hyperparameters) Precision Recall F1-Score Mean ROC-AUC
K-Nearest Neighbor (KNN) n_neighbors=2, metric='euclidean', weights='uniform' 0.942 0.968 0.955 0.96
Linear SVM C=10.0, kernel='linear' 0.925 0.931 0.928 0.94
RBF SVM C=100.0, kernel='rbf', gamma='scale' 0.968 0.982 0.975 0.98
Logistic Regression C=100, solver='liblinear', penalty='l2' 0.884 0.921 0.902 0.92
Multi-layer Perceptron (MLP) hidden_layer_sizes=(7,), activation='relu', max_iter=500 0.971 0.979 0.975 0.98
Gaussian Naive Bayes var_smoothing=1e-08 0.812 0.895 0.851 0.88
Linear Discriminant Analysis solver='svd' 0.865 0.890 0.877 0.90
Decision Tree (DT) max_depth=50, min_samples_split=2 0.912 0.924 0.918 0.93
Random Forest (RF) n_estimators=100, max_depth=None, min_samples_split=2 0.960 0.974 0.967 0.97
Extra Trees n_estimators=150, max_depth=None 0.958 0.972 0.965 0.97
AdaBoost learning_rate=0.1, n_estimators=100 0.905 0.938 0.921 0.94
Gradient Boosting learning_rate=0.1, loss='deviance', n_estimators=100 0.938 0.955 0.946 0.96

Phân tích kết quả:

  • RBF SVM và Neural Network (Multi-layer Perceptron) đạt hiệu năng cao nhất với Mean ROC-AUC đạt 0.98, chỉ số Recall đạt 98.2%, kiểm soát sai số phân loại nhầm mã độc thành mã sạch ở mức cực thấp.
  • Các mô hình Ensemble Tree (Random Forest, Extra Trees) thể hiện tính ổn định cao, tốc độ huấn luyện nhanh gấp 4 lần so với SVM trên tập dữ liệu lớn.

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

  1. Kiến trúc CFG mở rộng với 15 đỉnh đặc biệt:
    • Giải quyết triệt để vấn đề "đứt gãy luồng điều khiển" khi nhị phân gặp các lệnh rẽ nhánh qua thanh ghi hoặc địa chỉ không xác định bằng cách thêm nút $X$ và 14 nút phân lớp thanh ghi $Y(\text{reg})$.
    • Đảm bảo tính toàn vẹn ngữ nghĩa của luồng thực thi trong môi trường phân tích tĩnh.
  2. Kỹ thuật DFS Backtracking kết hợp lính canh & Truy vết trực tiếp:
    • Khôi phục chính xác ngữ cảnh ghép cặp giữa lệnh call và ret.
    • Giảm độ phức tạp thuật toán duyệt đồ thị từ $O(|V| \cdot |E|)$ xuống mức xấp xỉ tuyến tính $O(|V| + |E|)$, cho phép xử lý các nhị phân dung lượng lớn trong thời gian dưới 1,2 giây.
  3. Mô hình kết hợp đa tầng đặc trưng (Multi-tiered Feature Engineering):
    • Kết hợp cấu trúc hình học đồ thị (PageRank trên CFG) cùng phân bố tần suất văn bản (Opcode N-gram + TF-IDF), tạo ra vector biểu diễn có tính phân tách tuyến tính cao.
  4. Bộ kiểm thử thực nghiệm quy mô lớn:
    • Khảo sát độc lập và toàn diện trên 14 thuật toán máy học với 24.048 mẫu thực tế, cung cấp bộ tham số chuẩn hóa cho các nghiên cứu tiếp theo về phân tích tĩnh mã độc tại Việt Nam.

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

Tình huống ứng dụng thực tế

  • Tích hợp cổng quét Endpoint Protection / EDR: Triển khai như một module phân tích tĩnh tiền xử lý (pre-execution filter), sàng lọc các tệp thực thi tải về trước khi cấp quyền chạy.
  • Hệ thống SOC / SIEM Triage: Hỗ trợ chuyên viên phân tích an ninh mạng phân loại sơ bộ hàng ngàn mẫu nhị phân đáng ngờ mỗi ngày với thời gian dưới 1 giây/mẫu.
  • Kiểm soát bảo mật chuỗi cung ứng phần mềm (CI/CD Pipeline): Quét tự động các tệp .exe, .dll sinh ra từ quá trình build phần mềm để phát hiện việc bị chèn mã độc lén lút (Supply chain poisoning).

Hướng dẫn triển khai và Cấu hình hệ thống

+--------------------------------------------------------------------------+
|                       YÊU CẦU PHẦN CỨNG & PHẦN MỀM                       |
+--------------------------------------------------------------------------+
| - Hệ điều hành: Windows 10/11 (32-bit/64-bit) hoặc Ubuntu Linux 20.04 LTS|
| - Phần cứng tối thiểu: CPU Intel Core i3 (2.0 GHz), 4GB RAM, 2GB Disk    |
| - Phần cứng khuyến nghị: CPU Intel Core i7 / AMD Ryzen 7, 16GB RAM       |
| - Môi trường: Python 3.8+, Scikit-Learn 0.24+, Capstone 4.0+, PyQt5      |
+--------------------------------------------------------------------------+

# 1. Khởi tạo môi trường ảo và cài đặt thư viện phụ thuộc
python -m venv venv
source venv/bin/activate  # Trên Windows: venv\Scripts\activate
pip install capstone==4.0.2 pefile==2021.5.24 scikit-learn==0.24.2 PyQt5==5.15.4 pandas numpy

# 2. Khởi chạy ứng dụng quét mã độc
python app_scanner_gui.py

Ứng dụng cung cấp 2 chế độ quét trực quan:

  1. Quét tệp tin tĩnh (File Scanner): Chọn tệp thực thi bất kỳ (.exe, .dll, .ocx, .sys), hệ thống sẽ phân tách .text, trích xuất opcode, tính toán ma trận đặc trưng và hiển thị tỷ lệ xác suất độc hại.
  2. Quét tiến trình bộ nhớ (Live Process Scanner): Liệt kê danh sách các Process ID (PID) đang chạy trên hệ điều hành, đọc bộ nhớ phân đoạn thực thi và cảnh báo ngay lập tức các tiến trình độc hại ngầm.

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

Hạn chế kỹ thuật

  • Mã độc bị nén/đóng gói phức tạp (Heavy Packed/Obfuscated): Các phần mềm sử dụng công cụ nén (UPX, Themida, VMProtect) làm xáo trộn hoàn toàn phân vùng .text, khiến disassembly tĩnh không thể trích xuất opcode nguyên bản nếu không thực hiện unpack trước.
  • Phân tích hàm liên kết động: Các tệp nhị phân sử dụng kỹ thuật nạp thư viện động (LoadLibraryA, GetProcAddress) gây khó khăn cho việc dựng đồ thị CFG chính xác ở mức tĩnh.
  • Giới hạn kiến trúc: Hệ thống mới hỗ trợ sâu kiến trúc x86 32-bit, chưa bao quát toàn diện x86-64 (AMD64) và ARM.

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

  • Tích hợp module tự động giải nén (Auto Unpacking Engine) dựa trên bộ giả lập mã lệnh (CPU Emulation như Unicorn Engine) để trích xuất payload sạch từ bộ nhớ.
  • Nghiên cứu ứng dụng Mạng nơ-ron đồ thị (Graph Neural Networks - GNN / Graph Convolutional Networks) trực tiếp trên cấu trúc CFG thay vì chuyển đổi qua vector trung gian PCA.
  • Mở rộng tập mẫu sang định dạng PE 64-bit và ELF (Linux Malware).

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

  • Sinh viên / Học viên ngành An toàn thông tin, Kỹ thuật phần mềm: Nắm vững tài liệu thực hành chi tiết về phân tích ngược nhị phân PE COFF, giải mã Capstone Engine và ứng dụng toán học đồ thị trong Machine Learning.
  • Kỹ sư phát triển phần mềm & Chuyên viên An ninh mạng: Sở hữu mã nguồn mẫu hoàn chỉnh về pipeline xử lý dữ liệu nhị phân tốc độ cao và kỹ thuật tối ưu hóa thuật toán duyệt đồ thị CFG.
  • Doanh nghiệp & Tổ chức CNTT: Tiếp cận giải pháp phát hiện mã độc Zero-day với chi phí vận hành $0 (Open-source stack), khả năng tích hợp linh hoạt vào hệ thống giám sát sẵn có.
  • Cộng đồng nghiên cứu (Researchers): Cung cấp kết quả đánh giá thực nghiệm định lượng giữa 14 thuật toán máy học trên tập dữ liệu chuẩn 24.048 mẫu.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai giải pháp là gì?

Hệ thống yêu cầu môi trường Python 3.8 trở lên, bộ nhớ RAM tối thiểu 4GB (khuyến nghị 8GB khi huấn luyện lại mô hình với tập mẫu lớn), CPU x86/x64 hỗ trợ tập lệnh ảo hóa và các thư viện capstone, pefile, scikit-learn. Ứng dụng tương thích hoàn toàn trên Windows 10/11 và các bản phân phối Linux.

2. Giới hạn xử lý của hệ thống khi gặp tệp bị nén mã nguồn (Packed PE)?

Nếu tệp PE bị nén bởi UPX tiêu chuẩn, hệ thống có thể tích hợp lệnh xả nén tĩnh upx -d trước khi quét. Đối với các custom packer hoặc mã độc mã hóa đa tầng, hệ thống sẽ nhận diện phân đoạn .text có độ đo entropy cao bất thường và khuyến nghị chuyển sang môi trường phân tích động (Dynamic Sandbox).

3. Hệ thống tích hợp vào quy trình CI/CD hoặc Antivirus sẵn có như thế nào?

Module trích xuất và phân loại được đóng gói dưới dạng thư viện Python độc lập (malware_detector_core.py) với API chuẩn predict(file_path) -> dict(is_malware=bool, confidence=float). Có thể dễ dàng nhúng vào các hook kiểm tra tự động của GitLab CI, GitHub Actions hoặc Jenkins.

4. Chi phí vận hành và bảo trì mô hình định kỳ ra sao?

Giải pháp xây dựng 100% trên các công nghệ mã nguồn mở (Open-source), loại bỏ chi phí bản quyền thương mại. Để duy trì độ chính xác trước các biến thể mới, khuyến nghị định kỳ 3 tháng nạp thêm các mẫu mã độc mới phát sinh và thực hiện lại bước fine-tuning mô hình (mất khoảng 15-30 phút tính toán trên CPU thông thường).

5. Tại sao mô hình chọn tối ưu chỉ số Recall thay vì Accuracy tổng quát?

Trong an ninh mạng, chi phí của việc bỏ lọt một mã độc nguy hiểm (False Negative - Type II Error) gây hậu quả nghiêm trọng hơn rất nhiều so với việc cảnh báo nhầm một tệp tin an toàn (False Positive - Type I Error). Do đó, ngưỡng quyết định phân lớp được tinh chỉnh để đạt Recall tối đa ($\ge 98%$).

Kết luận

Khóa luận tốt nghiệp của tác giả Nguyễn Dương Hoàng Duy đã giải quyết thành công bài toán nhận diện phần mềm độc hại chưa xác định thông qua việc kết hợp kỹ thuật phân tích tĩnh chuỗi mã lệnh và học máy nâng cao. Với đồ thị luồng điều khiển CFG cải tiến xử lý triệt để các rẽ nhánh phức tạp cùng pipeline đặc trưng đa tầng (N-gram, TF-IDF, PageRank, PCA), mô hình RBF SVM và Multi-layer Perceptron đã đạt được hiệu năng ấn tượng với Mean ROC-AUC 0.98 và Recall 98.2% trên tập dữ liệu 24.048 mẫu.

Sản phẩm ứng dụng GUI đi kèm chứng minh tính khả thi cao trong việc ứng dụng thực tiễn, đóng góp một công cụ hữu hiệu cho công tác bảo vệ không gian mạng và phát hiện sớm các mối đe dọa Zero-day nguy hiểm.