Giới thiệu dự án

Sự bùng nổ của các biến thể phần mềm độc hại (malware) thế hệ mới cùng các cuộc tấn công zero-day đang đặt ra thách thức nghiêm trọng cho hạ tầng an ninh mạng toàn cầu. Theo báo cáo từ các tổ chức bảo mật quốc tế, mỗi ngày có hơn 450.000 mẫu mã độc và chương trình không mong muốn (PUA) mới được ghi nhận. Các phương pháp phát hiện truyền thống dựa trên chữ ký nhị phân (signature-based), giá trị băm (MD5/SHA256) hay luật tĩnh (YARA rules) đã bộc lộ sự bất lực trước kỹ thuật làm mờ mã nguồn (obfuscation), mã hóa payload và đa hình (polymorphism).

Học máy (Machine Learning - ML) và Học sâu (Deep Learning - DL) nổi lên như giải pháp tối ưu cho phép phân loại và nhận diện mã độc thông qua việc học các đặc trưng hành vi và cấu trúc tệp. Tuy nhiên, các hệ thống phát hiện mã độc dựa trên ML lại đối mặt với một lỗ hổng bảo mật cố hữu: tấn công đối kháng (Adversarial Attacks) thông qua Mạng đối nghịch tạo sinh (Generative Adversarial Networks - GAN). Kẻ tấn công có thể tạo ra các mẫu mã độc đối kháng (Adversarial Malware Examples - AE) nhằm đánh lừa mô hình phân loại mà vẫn bảo toàn nguyên vẹn hành vi phá hoại gốc.

+-------------------------------------------------------------------------+
|                  VẤN ĐỀ CỐT LÕI CỦA MÔ HÌNH HỌC MÁY HIỆN NAY             |
+-------------------------------------------------------------------------+
| [Mã độc gốc] ---> [Bộ phân loại ML chuẩn] ---> Bị phát hiện (Malware)   |
|                                                                         |
| [Tấn công GAN] -> Sinh biến thể AE (Chèn API)                           |
|       |                                                                 |
|       v                                                                 |
| [Mã độc AE]  ---> [Bộ phân loại Type I / II]  ---> Bỏ lọt (Benign - Lỗi)|
| [Mã độc AE]  ---> [Bộ phân loại Type III]     ---> Nhận diện chuẩn!     |
+-------------------------------------------------------------------------+

Đồ án tập trung giải quyết bài toán cốt lõi: Xây dựng mô hình tấn công hộp đen (Black-Box GAN Attack) trên không gian đặc trưng chuỗi gọi hàm API (API calls), đồng thời đề xuất giải pháp làm giàu dữ liệu nhằm nâng cao độ bền vững (robustness) cho hệ thống phòng thủ ML.

Mục tiêu của dự án

  1. Thiết lập quy trình trích xuất đặc trưng động: Xây dựng môi trường hộp cát Cuckoo Sandbox để thực thi tệp PE (Portable Executable) an toàn và trích xuất vector nhị phân 160 chiều biểu diễn hành vi gọi API.
  2. Tổng hợp dữ liệu có điều kiện: Huấn luyện 2 mô hình CTGAN (Conditional Tabular GAN) để tổng hợp tập kiểm thử quy mô lớn (200.000 bản ghi) và tập dữ liệu huấn luyện mở rộng.
  3. Mô phỏng tấn công Black-Box GAN: Triển khai kiến trúc Generator kết hợp Substitute Detector để sinh mã độc đối kháng đánh lừa 5 thuật toán học máy phổ biến: Random Forest (RF), Support Vector Machine (SVM), Logistic Regression (LR), Decision Tree (DT) và Multi-Layer Perceptron (MLP).
  4. Đề xuất kỹ thuật phòng thủ cấu trúc dữ liệu: Phát triển tập dữ liệu huấn luyện đột biến (Type III Dataset) dựa trên quy luật chèn API lành tính để vô hiệu hóa lỗ hổng đối kháng, đưa tỷ lệ phát hiện thực tế (True Positive Rate - TPR) phục hồi về mức trên 90%.

Phạm vi và giới hạn nghiên cứu

  • Phạm vi dữ liệu: Tập trung vào các tệp thực thi Windows PE 32-bit/64-bit thuộc các họ mã độc nguy hiểm: Ransomware (WannaCry), Trojan, Downloader, Remote Access Trojan (RAT), CoinMiner và các tệp lành tính thu thập từ hệ điều hành chuẩn.
  • Không gian đặc trưng: Vector đặc trưng nhị phân gồm 160 API calls hệ thống trọng yếu.
  • Nguyên tắc bảo toàn ngữ nghĩa (Semantic Preservation): Tấn công đối kháng chỉ áp dụng phép cộng thuộc tính ($0 \rightarrow 1$), tuyệt đối không loại bỏ API hiện hữu ($1 \rightarrow 0$) nhằm tránh làm hỏng cấu trúc tệp hoặc mất tính năng độc hại.

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

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

Các giải pháp nhận diện phần mềm độc hại hiện nay phân tách rõ rệt giữa phương pháp tiếp cận tĩnh và tiếp cận động:

Phương pháp Cơ chế hoạt động Ưu điểm Nhược điểm Độ bền vững đối kháng
Chữ ký tĩnh & Hash So khớp chuỗi byte, MD5/SHA256, YARA Tốc độ cực nhanh, không tốn tài nguyên runtime Vô hiệu hoàn toàn trước biến thể zero-day và mã độc bị mã hóa Rất thấp (Dễ bypass bằng cách thay đổi 1 byte)
Xử lý ngôn ngữ tự nhiên (NLP) tĩnh Trích xuất N-gram Opcode, DLL Imports Khai thác được ngữ nghĩa mã lệnh không cần thực thi Dễ bị qua mặt bởi kỹ thuật chèn lệnh rác (Dead code insertion) Thấp (Dễ bị tấn công bằng Adversarial Patch)
Phân tích hành vi động (Dynamic Sandbox) Thực thi file trong Sandbox, ghi nhận chuỗi API calls Phản ánh chính xác hành vi thực tế, chống giải mã/làm mờ Tốn thời gian thực thi, cần tài nguyên ảo hóa Cao trên dữ liệu chuẩn, nhưng dễ bị đánh lừa bởi Black-Box GAN
+-------------------------------------------------------------------------+
|                  YÊU CẦU HỆ THỐNG THEO MÔ HÌNH MOSCOW                   |
+-------------------------------------------------------------------------+
| [MUST HAVE]   - Môi trường trích xuất API call động qua Cuckoo Sandbox  |
|               - Pipeline huấn luyện 5 mô hình ML cơ sở                  |
|               - Khung tấn công Black-Box GAN bảo toàn ngữ nghĩa mã độc  |
| [SHOULD HAVE] - Hệ thống sinh dữ liệu CTGAN cho dữ liệu bảng phân loại   |
|               - Chiến lược tạo tập huấn luyện Type III phòng thủ        |
| [COULD HAVE]  - Tự động hóa đánh giá TPR theo từng epoch tấn công        |
| [WON'T HAVE]  - Biên dịch ngược tệp nhị phân thời gian thực             |
+-------------------------------------------------------------------------+

Thiết kế hệ thống

Kiến trúc tổng thể của hệ thống bao gồm hai khối chính: Khối phòng thủ / Phát hiện mã độcKhối tấn công Black-Box GAN.

flowchart TD
    subgraph Data_Pipeline [1. Trích xuất & Xử lý Dữ liệu]
        PE[Tệp PE Benign & Malware] --> Cuckoo[Cuckoo Sandbox Dynamic Analysis]
        Cuckoo --> JSON[Execution Reports]
        JSON --> Vec[Trích xuất 160 API Calls Vector Nhị phân]
        Vec --> CleanDS[(Dataset Gốc: 1.441 mẫu)]
    end

    subgraph Defense_Design [2. Thiết kế Mô hình Phòng thủ]
        CleanDS --> TypeI[Mô hình Type I: Train trên Dataset gốc]
        CleanDS --> CTGAN_Train[Huấn luyện CTGAN Benign/Malware]
        CTGAN_Train --> TypeII[Mô hình Type II: Dataset gốc + Synthetic Data]
        CleanDS --> MutateEngine[Thuật toán Đột biến API Hiếm]
        MutateEngine --> TypeIII[Mô hình Type III: Dataset Gốc + 140k Mẫu Đột biến]
    end

    subgraph BlackBox_GAN [3. Khung Tấn công Black-Box GAN]
        MalVector[Malware Vector n] --> Gen[Generator G_theta_g]
        Noise[Vector Nhiễu z] --> Gen
        Gen --> BinaryThresh[Ngưỡng hóa 0.5: Vector o']
        BinaryThresh --> BitOR[Phép logic OR: n' = n OR o']
        BitOR --> AE[Adversarial Malware Example n']
        AE --> TargetBB[Black-Box ML Classifier]
        TargetBB --> BBLabel[Dự đoán nhãn hộp đen]
        BBLabel --> SubDet[Substitute Detector D_theta_d]
        SubDet -. Cung cấp Gradient .-> Gen
    end

Ngăn xếp công nghệ chi tiết

  • Hệ điều hành & Sandbox: Ubuntu 22.04 LTS, Cuckoo Sandbox v2.0.7, VirtualBox Guest Windows 7 x86/x64.
  • Ngôn ngữ & Thư viện lõi: Python v3.9.16, PyTorch v1.12.1 (CUDA 11.6), Scikit-Learn v1.1.3, SDV / CTGAN v0.6.0.
  • Xử lý số liệu & Trực quan hóa: NumPy v1.23.5, Pandas v1.5.2, Matplotlib v3.6.2, Seaborn v0.12.1.

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

Quy trình nghiên cứu tuân thủ chặt chẽ tiêu chuẩn CRISP-DM (Cross-Industry Standard Process for Data Mining) kết hợp kiểm thử vòng lặp bảo mật:

[Hiểu bài toán An toàn thông tin] 
       ↓ 
[Thu thập dữ liệu PE từ VirusShare/VXUnderground] 
       ↓ 
[Xử lý & Chuẩn hóa 160 chiều API] 
       ↓ 
[Thiết kế 3 biến thể Dataset (Type I, II, III)] 
       ↓ 
[Thiết lập Black-Box GAN và Tấn công Evasion] 
       ↓ 
[Đo lường TPR, Độ bền vững & Tối ưu hóa]

Triển khai và kết quả thực nghiệm

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

Vector đặc trưng của mỗi tệp PE là một vector nhị phân $n \in {0, 1}^{160}$. Để sinh mẫu đối kháng $n'$, Generator mạng nơ-ron nhận đầu vào là vector $n$ ghép nối với vector nhiễu ngẫu nhiên $z \sim \mathcal{U}[0, 1)^d$.

$$o = G_{\theta_g}(n, z), \quad o_i \in [0, 1]$$

$$o'_i = \begin{cases} 1 & \text{nếu } o_i \ge 0.5 \ 0 & \text{nếu } o_i < 0.5 \end{cases}$$

$$n' = n \lor o'$$

Để đảm bảo tính khả vi phục vụ lan truyền ngược (Backpropagation) qua hàm phi tuyến, hàm kích hoạt trơn được định nghĩa:

$$G_{\theta_g}^*(n, z) = \max(n, o)$$

Hàm mất mát cho Generator ($L_G$) và Substitute Detector ($L_D$):

$$L_G = \mathbb{E}{m \sim \text{Malware}, z \sim \mathcal{U}[0,1)} \left[ \log D{\theta_d}(G_{\theta_g}^*(m, z)) \right]$$

$$L_D = - \mathbb{E}{x \sim \text{Benign}} \left[ \log(1 - D{\theta_d}(x)) \right] - \mathbb{E}{x \sim \text{Malware}} \left[ \log D{\theta_d}(x) \right]$$

import torch
import torch.nn as nn

class MalGANGenerator(nn.Module):
    """
    Generator tạo perturbation cho vector mã độc nhị phân
    Bảo toàn nguyên vẹn hành vi gốc thông qua phép toán Logical OR
    """
    def __init__(self, input_dim=160, noise_dim=20, hidden_dim=256):
        super(MalGANGenerator, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim + noise_dim, hidden_dim),
            nn.BatchNorm1d(hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.BatchNorm1d(hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, input_dim),
            nn.Sigmoid()
        )

    def forward(self, malware_vec, noise_vec):
        concat_input = torch.cat([malware_vec, noise_vec], dim=1)
        raw_perturbation = self.net(concat_input)
        # Giữ nguyên tính khả vi cho Backpropagation
        differentiable_ae = torch.max(malware_vec, raw_perturbation)
        return differentiable_ae, raw_perturbation

    def generate_binary_ae(self, malware_vec, noise_vec, threshold=0.5):
        with torch.no_grad():
            _, raw_perturbation = self.forward(malware_vec, noise_vec)
            binary_perturbation = (raw_perturbation >= threshold).float()
            adversarial_examples = torch.clamp(malware_vec + binary_perturbation, 0, 1)
            return adversarial_examples

Thuật toán tạo tập dữ liệu Type III kháng đối kháng

Dựa trên phân tích phân phối dữ liệu, kẻ tấn công sẽ ưu tiên chèn các API thường xuất hiện ở tệp Benign nhưng hiếm khi xuất hiện ở Malware. Do đó, nhóm nghiên cứu đã xây dựng thuật toán sinh 140.000 biến thể đột biến từ tập gốc để huấn luyện mô hình Type III:

import numpy as np

def generate_type_iii_robust_dataset(malware_data, rare_api_indices, num_variants=140000):
    """
    Tạo tập dữ liệu đột biến Type III bằng cách kích hoạt ngẫu nhiên 
    các API calls lành tính (ít xuất hiện trong mã độc)
    """
    synthetic_malware_list = []
    num_samples = len(malware_data)
    
    for _ in range(num_variants):
        idx = np.random.randint(0, num_samples)
        sample = malware_data[idx].copy()
        
        # Chọn ngẫu nhiên k API hiếm để kích hoạt (0 -> 1)
        k = np.random.randint(1, len(rare_api_indices) // 4)
        selected_apis = np.random.choice(rare_api_indices, size=k, replace=False)
        sample[selected_apis] = 1.0
        
        synthetic_malware_list.append(sample)
        
    return np.array(synthetic_malware_list)

Kết quả kiểm thử và đánh giá hiệu năng

Hệ thống đánh giá độ chính xác (Accuracy) trên tập kiểm thử CTGAN chuẩn gồm 200.000 mẫu (100.000 Benign, 100.000 Malware) và đo lường tỷ lệ phát hiện mã độc (True Positive Rate - TPR) dưới sự tấn công của Black-Box GAN sau 100 Epochs.

Thuật toán ML Accuracy Type I (Dataset gốc) Accuracy Type II (+ CTGAN Data) Accuracy Type III (+ Đột biến API) TPR dưới tấn công GAN (Type I) TPR dưới tấn công GAN (Type II) TPR dưới tấn công GAN (Type III)
Random Forest (RF) 98.42% 98.85% 95.78% 55.20% 52.40% 94.80%
Support Vector Machine (SVM) 96.15% 97.20% 93.45% 58.60% 48.90% 88.60%
Linear Regression / LR 93.10% 94.50% 89.80% 42.10% 39.50% 84.20%
Decision Tree (DT) 95.80% 96.40% 92.10% 48.30% 46.10% 87.50%
Multi-Layer Perceptron (MLP) 97.60% 98.10% 94.30% 51.70% 47.80% 91.30%
+-------------------------------------------------------------------------+
|                  BIẾN THIÊN TPR DƯỚI TẤN CÔNG BLACK-BOX GAN             |
+-------------------------------------------------------------------------+
| Epoch:       0      20      40      60      80      100                 |
| Type I  :  [1.00]---(0.72)---(0.61)---(0.57)---(0.55)---(0.55) [Bị sập] |
| Type II :  [1.00]---(0.68)---(0.56)---(0.53)---(0.51)---(0.48) [Bị sập] |
| Type III:  [1.00]---(0.82)---(0.91)---(0.94)---(0.95)---(0.95) [VỮNG]   |
+-------------------------------------------------------------------------+

Đổi mới và đóng góp khoa học

Điểm đột phá kỹ thuật

  1. Phát hiện giới hạn của Dữ liệu Tổng hợp CTGAN trong Phòng thủ Đối kháng: Nghiên cứu chứng minh rằng việc bổ sung dữ liệu sinh bởi CTGAN (Type II) chỉ giúp tăng độ chính xác trên dữ liệu tự nhiên ($\approx +0.4% - 1.1%$) nhưng hoàn toàn vô hiệu trước tấn công đối kháng (TPR giảm xuống dưới 50%). Lý do: CTGAN học phân phối xác suất thực tế, trong khi các mẫu đối kháng GAN nằm ở các vùng không gian dữ liệu bất thường ngoài phân phối chuẩn.
  2. Kỹ thuật đột biến không gian đặc trưng định hướng (Targeted Feature Mutation): Thay vì phòng thủ thụ động, phương pháp tạo tập Type III chủ động tiêm các API lành tính có tần suất xuất hiện thấp trong mã độc vào tập huấn luyện. Điều này tái cấu trúc lại các siêu phẳng phân chia (hyperplanes) của mô hình học máy, loại bỏ các "lối tắt đặc trưng" (shortcut features) mà Generator của GAN thường khai thác.

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

Tiêu chí MalGAN (Hu & Tan, 2017) IDSGAN (Lin et al., 2018) Giải pháp Đồ án (2023)
Mục tiêu tấn công Black-Box Malware Detectors Intrusion Detection Systems Multi-Model Defense & Attack Benchmark
Không gian thuộc tính API calls tĩnh Network traffic features 160 Dynamic API Calls thực thi hộp cát
Cơ chế đánh giá Chỉ thực hiện tấn công Chỉ thực hiện tấn công Tấn công đối kháng + Đề xuất cấu trúc Type III phòng thủ
Hiệu quả phục hồi TPR Chưa đề xuất giải pháp Chưa đề xuất giải pháp Phục hồi TPR từ 52.4% lên 94.8% (Mô hình RF)

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

Kịch bản ứng dụng trong an ninh mạng

  • Tích hợp hệ thống EDR/SIEM thế hệ mới: Cung cấp lõi phân loại mã độc có độ bền vững cao, giảm thiểu triệt để tỷ lệ cảnh báo giả (False Positive) và lọt mã độc (False Negative).
  • Nền tảng kiểm thử tự động (Adversarial Red Teaming): Cho phép các trung tâm điều hành an ninh mạng (SOC) tự động kiểm tra độ bền vững của các mô hình AI/ML trước khi đưa vào vận hành thực tế.
+-------------------------------------------------------------------------+
|                  LỘ TRÌNH TRIỂN KHAI DOANH NGHIỆP                       |
+-------------------------------------------------------------------------+
| Giai đoạn 1 (Tháng 1-2): Dựng cụm Cuckoo Sandbox phân tán & pipeline API |
| Giai đoạn 2 (Tháng 3-4): Huấn luyện Offline & tiêm tập đột biến Type III |
| Giai đoạn 3 (Tháng 5-6): Đóng gói Microservice REST API qua Docker/K8s   |
| Giai đoạn 4 (Liên tục):  Adversarial Continuous Retraining tự động       |
+-------------------------------------------------------------------------+

Yêu cầu cấu hình triển khai hạ tầng

  • Phần cứng tối thiểu: CPU Intel Xeon / AMD EPYC 8 cores, 32GB RAM, 500GB NVMe SSD, GPU NVIDIA RTX 3060 12GB (hoặc tương đương) phục vụ huấn luyện nơ-ron.
  • Hạ tầng phần mềm: Docker Engine v24+, Kubernetes cluster cho Cuckoo worker nodes, PostgreSQL lưu trữ metadata phân tích.

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

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

  • Ràng buộc chèn đơn điệu: Nghiên cứu hiện giới hạn ở phép toán $n' = n \lor o'$, chưa mô phỏng được các trường hợp mã độc sử dụng kỹ thuật thay thế API tương đương (API hooking/redirection).
  • Chi phí phân tích động: Quá trình trích xuất qua Cuckoo Sandbox đòi hỏi thời gian thực thi (thường từ 60s - 120s cho mỗi mẫu), tạo độ trễ nhất định khi xử lý luồng tệp dung lượng lớn.

Hướng phát triển tiếp theo

  1. Mở rộng sang chuỗi đồ thị gọi hàm (Control Flow Graph - CFG): Kết hợp Graph Neural Networks (GNN) để phân tích thứ tự phụ thuộc thời gian giữa các API calls thay vì chỉ dùng vector nhị phân tần suất.
  2. Kỹ thuật Binary Rewriting thực tế: Áp dụng thư viện LIEF để chỉnh sửa trực tiếp các byte trong bảng nhập khẩu PE (Import Address Table - IAT) và kiểm tra khả năng thực thi lại trên máy nạn nhân.

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

  • Sinh viên & Học viên: Cung cấp tài liệu tham khảo hoàn chỉnh về quy trình kết hợp giữa An toàn thông tin, Phân tích mã độc động và Học máy đối kháng.
  • Kỹ sư AI & An ninh mạng: Nắm vững cấu trúc mã nguồn xây dựng mạng MalGAN, hàm mất mát tùy biến và kỹ thuật làm giàu dữ liệu để bảo vệ hệ thống phân loại.
  • Doanh nghiệp & Trung tâm SOC: Giảm thiểu rủi ro bị vượt mặt bởi các chiến dịch tấn công có chủ đích (APT), tiết kiệm chi phí ứng cứu sự cố bảo mật với mức ước tính cải thiện ROI lên đến 35% trong năm đầu triển khai.

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

1. Tại sao dữ liệu tổng hợp từ CTGAN không giúp cải thiện độ bền vững của mô hình trước tấn công GAN?

CTGAN được thiết kế để học và tái tạo phân phối xác suất của dữ liệu bình thường trong thế giới thực nhằm tránh hiện tượng quá khớp (overfitting). Trong khi đó, các mẫu mã độc đối kháng do GAN sinh ra lại mang các đặc trưng cố tình bị bóp méo (nằm ở rìa hoặc ngoài phân phối thực tế). Do đó, mô hình học thêm dữ liệu CTGAN (Type II) vẫn hoàn toàn bất lực trước các mẫu đối kháng dị thường.

2. Việc chèn thêm API calls vào vector có làm hỏng chức năng phá hoại của tệp mã độc không?

Không. Trong mô hình tấn công này, chỉ có các API calls mới được thêm vào danh sách sử dụng ($0 \rightarrow 1$), tuyệt đối không có API thiết yếu nào bị gỡ bỏ ($1 \rightarrow 0$). Mã độc chỉ đơn thuần gọi thêm các API lành tính (như truy vấn thời gian hệ thống, kiểm tra khóa registry vô hại) mà không làm gián đoạn luồng thực thi độc hại chính.

3. Thuật toán học máy nào có độ bền vững cao nhất khi chưa áp dụng phòng thủ?

Khi chưa áp dụng phòng thủ (Type I), Random Forest và Support Vector Machine thể hiện độ bền tương đối tốt hơn (TPR duy trì quanh mức 55% - 58%), trong khi các thuật toán nhạy cảm với biến động biên tuyến tính như Linear Regression và Decision Tree bị sụt giảm nghiêm trọng nhất (TPR tụt xuống chỉ còn 42% - 48%).

4. Chi phí tính toán để tạo tập dữ liệu Type III có lớn không?

Rất thấp. Khác với việc huấn luyện mạng sâu GAN tốn nhiều giờ tính toán trên GPU, thuật toán sinh tập Type III thực hiện phép toán ma trận nhị phân ngẫu nhiên trên CPU, cho phép sinh 140.000 vector đột biến chỉ trong vòng dưới 30 giây.

5. Giải pháp này có khả năng chống lại tấn công hộp trắng (White-Box Attack) không?

Có thể thích ứng tốt. Mặc dù nghiên cứu tập trung vào kịch bản tấn công hộp đen (vốn thực tế và nguy hiểm nhất đối với các hệ thống EDR thương mại), nguyên lý loại bỏ "shortcut features" của tập Type III cũng đồng thời làm phẳng không gian gradient, khiến các thuật toán tấn công dựa trên đạo hàm hộp trắng (như FGSM hay JSMA) gặp khó khăn trong việc tìm kiếm hướng nhiễu loạn tối ưu.


Kết luận

Khóa luận tốt nghiệp đã giải quyết trọn vẹn và chuyên sâu bài toán bảo mật của hệ thống học máy phát hiện mã độc trước nguy cơ tấn công từ Mạng đối nghịch tạo sinh (GAN). Thông qua việc xây dựng thành công pipeline phân tích động bằng Cuckoo Sandbox, mô phỏng chính xác khung tấn công Black-Box GAN và đánh giá trên 5 thuật toán học máy tiêu chuẩn, nghiên cứu đã vạch rõ lỗ hổng nghiêm trọng của các hệ thống ML truyền thống khi tỷ lệ phát hiện mã độc bị đánh tụt xuống mức nguy hiểm (~50%).

Đóng góp quan trọng nhất của đồ án là việc chứng minh sự vô hiệu của dữ liệu tổng hợp tự nhiên (CTGAN) trong phòng thủ đối kháng, đồng thời đề xuất thành công kỹ thuật làm giàu dữ liệu đột biến định hướng (Type III Dataset). Giải pháp này đã giúp mô hình Random Forest phục hồi tỷ lệ phát hiện từ 52.40% lên 94.80% trước tấn công đối kháng, mở ra hướng tiếp cận thực tiễn, chi phí thấp và hiệu quả cao để xây dựng các thế hệ phần mềm diệt virus và hệ thống EDR vững chắc trong tương lai.