Giới thiệu dự án

Bối cảnh ngành và thực trạng an toàn thông tin

Sự bùng nổ của hệ sinh thái di động đã đưa hệ điều hành Android (Android OS) trở thành nền tảng phổ biến nhất toàn cầu, chiếm hơn 70% thị phần thiết bị di động. Tuy nhiên, tính chất mã nguồn mở kết hợp với cơ chế cho phép cài đặt ứng dụng từ các nguồn bên thứ ba thông qua tệp tin gói ứng dụng APK (Android Package Kit) đã biến Android thành mục tiêu hàng đầu của tội phạm mạng.

Theo báo cáo an ninh mạng toàn cầu từ viện nghiên cứu AV-TEST (AV-ATLAS), giai đoạn 2022–2023 ghi nhận trung bình hơn 105.000 mẫu mã độc Android mới xuất hiện mỗi tháng, trong đó hơn 90% tồn tại dưới dạng tệp APK độc hại. Tại Việt Nam, thống kê an ninh mạng năm 2023 cho thấy hơn 6.062.715 thiết bị bị lây nhiễm mã độc, trên 740.000 tài khoản ngân hàng và mạng xã hội bị xâm phạm, gây thiệt hại ước tính vượt mức 17.000 tỷ VNĐ.

+-------------------------------------------------------------------------+
|                  THỐNG KÊ THÁCH THỨC MÃ ĐỘC ANDROID                     |
+-------------------------------------------------------------------------+
|  > 105.000 mẫu mã độc mới/tháng (AV-TEST 2022-2023)                     |
|  90% phân phối qua tệp APK độc hại (Adware, SMS Malware, Banking Trojan)|
|  6.06+ triệu thiết bị lây nhiễm tại Việt Nam năm 2023                   |
|  > 17.000 tỷ VNĐ thiệt hại tài chính liên quan đến đánh cắp dữ liệu     |
+-------------------------------------------------------------------------+

Vấn đề cốt lõi (Problem Statement)

Các kỹ thuật phát hiện truyền thống bộc lộ những hạn chế nghiêm trọng trước các dòng mã độc thế hệ mới:

  • Phân tích dựa trên chữ ký (Signature-based Detection): Hoàn toàn tê liệt trước các kỹ thuật làm rối mã (Code Obfuscation), đa hình (Polymorphism), và biến thể Zero-day.
  • Phân tích động (Dynamic Analysis): Đòi hỏi môi trường hộp cát (Sandbox) hoặc thiết bị thực để theo dõi lệnh gọi hệ thống (System Calls), tiêu tốn tài nguyên phần cứng lớn, thời gian thực thi kéo dài và dễ bị mã độc phát hiện cơ chế máy ảo (Anti-VM/Anti-Emulator) để ẩn giấu hành vi.
  • Phân tích tĩnh đơn phương thức (Single-modal Static Analysis): Các mô hình Học máy (Machine Learning) hoặc Học sâu (Deep Learning) truyền thống thường chỉ khai thác một loại đặc trưng đơn lẻ (như quyền truy cập Permissions, bộ lọc ý định Intents, hoặc chuỗi mã tác vụ Dalvik Opcodes). Cách tiếp cận này bỏ sót mối tương quan không gian giữa các chỉ lệnh mã máy và tần suất gọi tài nguyên hệ điều hành.

Mục tiêu dự án

  1. Xây dựng quy trình phân tích tĩnh tự động hóa: Trích xuất toàn diện 3 nhóm đặc trưng tĩnh cốt lõi từ tệp APK: mã tác vụ máy ảo (Dalvik Opcode/Mnemonic), gói giao diện lập trình ứng dụng (API Package), và câu lệnh hệ thống (System Command).
  2. Đề xuất kỹ thuật biểu diễn dữ liệu mới: Chuyển đổi chuỗi Opcode tuần tự thành ma trận liền kề 2 chiều kích thước $225 \times 225$, tương đương một ảnh mức xám (Grayscale Image) để nắm bắt quan hệ ngữ cảnh và phân bố không gian của tập chỉ lệnh.
  3. Thiết kế kiến trúc học sâu đa phương thức (Multimodal Deep Learning Architecture): Kết hợp mạng nơ-ron tích chập (Convolutional Neural Network - CNN) để xử lý ảnh ma trận Opcode và mạng nơ-ron truyền thẳng (Feed-Forward Neural Network - FFNN) để xử lý véc-tơ tần suất System Command & API Package.
  4. Đánh giá và tối ưu hóa mô hình: Thực nghiệm phân loại 3 lớp dữ liệu (Benign, SMS Malware, Adware) trên tập dữ liệu chuẩn CICMalDroid-2020, tối ưu hóa hàm mất mát (Loss) và độ chính xác (Accuracy).

Phương pháp tiếp cận và kết quả kỳ vọng

Giải pháp áp dụng mô hình phân nhánh học song song hai phương thức dữ liệu: nhánh xử lý hình ảnh không gian của mã nguồn và nhánh xử lý véc-tơ tần suất hành vi. Hai luồng đặc trưng sau đó được hợp nhất (Feature Fusion) tại tầng kết nối dày đặc trước khi đưa ra quyết định phân loại qua hàm kích hoạt Softmax.

                    +------------------------------------+
                    |        Tệp tin Android APK         |
                    +-----------------+------------------+
                                      |
                     [Phân tích tĩnh - Static Analysis]
                                      |
            +-------------------------+-------------------------+
            |                                                   |
            v                                                   v
   [Dalvik Opcodes]                                 [API Packages & System Cmds]
            |                                                   |
 (Biến đổi ma trận 2D)                              (Trích xuất véc-tơ 437 chiều)
            v                                                   v
  [Ảnh xám 225x225]                                    [Véc-tơ tần suất]
            |                                                   |
            v                                                   v
  +-------------------+                               +-------------------+
  |    Nhánh 1: CNN   |                               |   Nhánh 2: FFNN   |
  | Conv2D + MaxPool  |                               | Dense Layers + DO |
  +---------+---------+                               +---------+---------+
            |                                                   |
            +-------------------------+-------------------------+
                                      |
                                      v
                        [Concatenate Layer (Fusion)]
                                      |
                           [Dense + Dropout Layer]
                                      |
                              [Softmax Classifier]
                                      |
                   +------------------+------------------+
                   |                  |                  |
                   v                  v                  v
               0: Benign          1: SMS Malware      2: Adware

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

  • Nghiên cứu tập trung vào phân tích tĩnh tệp nhị phân APK, không can thiệp bộ nhớ khi thực thi.
  • Khai thác tập dữ liệu CICMalDroid-2020 với các mẫu thuộc 3 họ: Benign (lành tính), SMS Malware (mã độc tin nhắn), và Adware (mã độc quảng cáo).

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

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

Phương pháp nghiên cứu Nhóm đặc trưng khai thác Mô hình sử dụng Ưu điểm Nhược điểm / Lỗ hổng
Sanz et al. [1] Android Permissions Naive Bayes, Random Forest, SVM Xử lý nhanh, trích xuất trực tiếp từ Manifest Độ chính xác ~92%; dễ bị qua mặt nếu mã độc dùng ít quyền
DroidMat (Wu et al.) [3] Intents + Permissions + API Calls k-NN, k-Means Kết hợp thông tin ngữ cảnh tĩnh; đạt 97.87% Bị vô hiệu hóa nếu mã độc không gọi trực tiếp API qua Manifest
Canfora et al. [4] Dalvik Opcodes chọn lọc Random Forest, SVM Đào sâu cấu trúc mã thực thi; đạt 93.9% Phụ thuộc tập Opcode cố định, dễ lỗi thời trước các biến thể mới
TaeGuen et al. [7] 7 nhóm đặc trưng hỗn hợp Multimodal DNN (5 nhánh DNN) Độ chính xác cao (98%), bao quát nhiều đặc trưng Chi phí tính toán lớn, chưa tối ưu hóa đặc trưng không gian của Opcode
Giải pháp đề xuất Opcode Matrix 2D + API Package + System Command Multimodal CNN + FFNN Late Fusion Tận dụng tối đa tương quan không gian và tần suất hành vi; trích xuất tĩnh tốc độ cao Cần bước tiền xử lý ảnh ma trận kích thước $225 \times 225$

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc):
    • Khả năng dịch ngược và phân tách tệp APK thông qua thư viện Androguard và công cụ Apktool.
    • Bộ từ điển 224 Dalvik Opcodes chuẩn và thuật toán chuyển đổi chuỗi opcode thành ma trận liền kề $225 \times 225$.
    • Trích xuất véc-tơ đặc trưng 437 chiều đại diện cho System Commands và API Packages.
    • Kiến trúc tích hợp đa phương thức CNN-FFNN phân loại chính xác 3 lớp nhãn.
  • Should Have (Nên có):
    • Kỹ thuật cắt gọt (Truncation) và đệm mã (Padding) chuỗi Opcode tại ngưỡng tối ưu (50.000 đến 200.000 opcodes).
    • Tích hợp lớp chuẩn hóa và Dropout để chống hiện tượng quá khớp (Overfitting).
  • Could Have (Có thể có):
    • Giao diện lập trình ứng dụng (RESTful API) phục vụ việc quét tự động mã độc cho hệ thống CI/CD di động.
  • Won't Have (Chưa thực hiện trong phạm vi này):
    • Giải mã động các mẫu mã độc áp dụng kỹ thuật đóng gói (Packing) hoặc nạp mã động từ máy chủ từ xa (Dynamic Code Loading).

Thiết kế kiến trúc hệ thống

+---------------------------------------------------------------------------------------+
|                               KIẾN TRÚC MÔ HÌNH FUSION                                |
+---------------------------------------------------------------------------------------+
| NHÁNH 1 (CNN):                                                                        |
| Input: (225, 225, 1) Matrix                                                           |
|  --> Conv2D (32 filters, 3x3, ReLU) --> MaxPooling2D (2x2)                            |
|  --> Conv2D (64 filters, 3x3, ReLU) --> MaxPooling2D (2x2)                            |
|  --> Conv2D (128 filters, 3x3, ReLU) --> MaxPooling2D (2x2)                           |
|  --> Flatten --> Dense (128 units, ReLU) --> Vector h_cnn (128 dims)                  |
|                                                                                       |
| NHÁNH 2 (FFNN):                                                                       |
| Input: (437,) Frequency Vector                                                        |
|  --> Dense (128 units, ReLU) --> Dropout (0.3)                                        |
|  --> Dense (64 units, ReLU)                                                           |
|  --> Dense (32 units, ReLU) --> Vector h_ffnn (32 dims)                               |
|                                                                                       |
| HỢP NHẤT VÀ PHÂN LOẠI:                                                                |
| Concatenate([h_cnn, h_ffnn]) --> Combined Vector (160 dims)                           |
|  --> Dense (128 units, ReLU)                                                          |
|  --> Dropout (0.5)                                                                    |
|  --> Dense (3 units, Softmax) --> Output: [P(Benign), P(SMS), P(Adware)]              |
+---------------------------------------------------------------------------------------+

Technology Stack chi tiết

+-------------------+----------------------+--------------------------------------------+
| Thành phần        | Công nghệ / Thư viện | Phiên bản  | Vai trò chức năng             |
+-------------------+----------------------+------------+-------------------------------+
| Ngôn ngữ cốt lõi  | Python               | 3.10.x     | Xử lý dữ liệu & mô hình hóa   |
| Engine Học sâu    | TensorFlow / Keras   | 2.14.0     | Xây dựng và huấn luyện mô hình|
| Dịch ngược APK    | Androguard           | 3.3.5      | Phân tích mã Dalvik Bytecode  |
| Trích xuất Smali  | Apktool              | 2.9.0      | Giải nén Manifest và Smali    |
| Tính toán ma trận | NumPy                | 1.24.3     | Xử lý mảng 2D liền kề         |
| Quản lý dữ liệu   | Pandas               | 2.0.3      | Xử lý ma trận đặc trưng CSV   |
| Tăng tốc phần cứng| NVIDIA CUDA / cuDNN  | 12.2 / 8.9 | Tính toán song song trên GPU  |
+-------------------+----------------------+------------+-------------------------------+

Implementation và kết quả

Quy trình trích xuất đặc trưng

1. Biến đổi Dalvik Opcode thành ma trận liền kề 2 chiều

Mỗi phương thức trong tệp APK được dịch ngược thành danh sách các lệnh Opcode. Giả sử tập từ điển chứa $N = 224$ opcode chuẩn cộng thêm 1 giá trị đệm (Blank/Padding), ta có không gian kích thước $225 \times 225$.

Nếu trong luồng thực thi của ứng dụng xuất hiện cặp chỉ lệnh liên tiếp $(Op_A \to Op_B)$, phần tử tại tọa độ $(Index(Op_A), Index(Op_B))$ trong ma trận kề $M \in \mathbb{R}^{225 \times 225}$ sẽ được cộng thêm 1:

$$M(i, j) = \sum_{t=1}^{L-1} \mathbb{I}(Op_t = i \land Op_{t+1} = j)$$

import numpy as np
from androguard.misc import AnalyzeAPK

def extract_opcode_matrix(apk_path, max_length=50000):
    a, d, dx = AnalyzeAPK(apk_path)
    opcode_dict = {...} # Ánh xạ 224 opcodes sang index [0..223], index 224 là blank
    matrix = np.zeros((225, 225), dtype=np.float32)
    
    opcodes_sequence = []
    for method in dx.get_methods():
        if method.is_external():
            continue
        for instruction in method.get_instructions():
            opcodes_sequence.append(instruction.get_name())
            if len(opcodes_sequence) >= max_length:
                break
        if len(opcodes_sequence) >= max_length:
            break
            
    # Xây dựng ma trận liền kề 2 chiều
    for t in range(len(opcodes_sequence) - 1):
        idx_src = opcode_dict.get(opcodes_sequence[t], 224)
        idx_dst = opcode_dict.get(opcodes_sequence[t+1], 224)
        matrix[idx_src, idx_dst] += 1.0
        
    # Chuẩn hóa ma trận mức xám [0, 1]
    if np.max(matrix) > 0:
        matrix = matrix / np.max(matrix)
    return matrix

2. Trích xuất véc-tơ tần suất System Command và API Package

Sử dụng Apktool để dịch ngược mã nguồn sang định dạng Smali, kết hợp phân tích tĩnh để lập chỉ mục tần suất xuất hiện của 437 lệnh hệ thống (như chmod, mount, su, ls) và các gói API trọng yếu (android.telephony, android.net.wifi, java.lang.reflect):

import os
import re
import pandas as pd

def extract_api_and_commands(smali_dir, feature_vocab):
    # feature_vocab gồm 437 API packages và System Commands
    feature_vector = {feature: 0 for feature in feature_vocab}
    
    for root, _, files in os.walk(smali_dir):
        for file in files:
            if file.endswith('.smali'):
                with open(os.path.join(root, file), 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
                    for feature in feature_vocab:
                        # Đếm tần suất xuất hiện của đặc trưng trong mã nguồn Smali
                        count = len(re.findall(re.escape(feature), content))
                        feature_vector[feature] += count
                        
    return pd.DataFrame([feature_vector])

Xây dựng mô hình học sâu phối hợp (Multimodal Fusion Model)

import tensorflow as tf
from tensorflow.keras import layers, models

def build_multimodal_network():
    # 1. Nhánh CNN xử lý ảnh ma trận Opcode 225x225
    cnn_input = layers.Input(shape=(225, 225, 1), name="Opcode_Matrix_Input")
    x1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(cnn_input)
    x1 = layers.MaxPooling2D((2, 2))(x1)
    
    x1 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x1)
    x1 = layers.MaxPooling2D((2, 2))(x1)
    
    x1 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x1)
    x1 = layers.MaxPooling2D((2, 2))(x1)
    
    x1 = layers.Flatten()(x1)
    cnn_features = layers.Dense(128, activation='relu', name="CNN_Feature_Layer")(x1)
    
    # 2. Nhánh FFNN xử lý véc-tơ tần suất 437 chiều
    ffnn_input = layers.Input(shape=(437,), name="Command_API_Input")
    x2 = layers.Dense(128, activation='relu')(ffnn_input)
    x2 = layers.Dropout(0.3)(x2)
    x2 = layers.Dense(64, activation='relu')(x2)
    ffnn_features = layers.Dense(32, activation='relu', name="FFNN_Feature_Layer")(x2)
    
    # 3. Tầng kết hợp (Late Fusion via Concatenation)
    combined = layers.concatenate([cnn_features, ffnn_features], name="Concatenate_Layer")
    
    # 4. Tầng Dense phân loại đầu ra
    dense_fusion = layers.Dense(128, activation='relu')(combined)
    dense_fusion = layers.Dropout(0.5)(dense_fusion)
    output = layers.Dense(3, activation='softmax', name="Classification_Output")(dense_fusion)
    
    model = models.Model(inputs=[cnn_input, ffnn_input], outputs=output, name="Multimodal_Malware_Detector")
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

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

Thực nghiệm được triển khai trên môi trường máy chủ với GPU NVIDIA GeForce RTX 4060 (8GB VRAM), CPU Intel Core i7-13620H, 24GB RAM DDR5. Tập dữ liệu kiểm thử độc lập bao gồm 80 tệp APK (40 Benign, 20 SMS Malware, 20 Adware), hoàn toàn tách biệt với tập huấn luyện (~900 mẫu).

Hàm mất mát Categorical Crossentropy:

$$\mathcal{L}(y, \hat{y}) = -\sum_{i=1}^{N} \sum_{c=1}^{C} y_{i, c} \log(\hat{y}_{i, c})$$

Trong đó:

  • $N$ là tổng số mẫu kiểm thử.
  • $C = 3$ là số lớp phân loại (Benign, SMS, Adware).
  • $y_{i, c}$ là giá trị nhãn thực tế dạng One-Hot.
  • $\hat{y}_{i, c}$ là xác suất dự đoán của mô hình.
+-----------------------------------------------------------------------------------+
|               BẢNG SO SÁNH HIỆU NĂNG THỰC NGHIỆM TẠI EPOCH 100                    |
+------------------------------------+---------------------+------------------------+
| Cấu hình mô hình                   | Training Loss / Acc | Validation Loss / Acc  |
+------------------------------------+---------------------+------------------------+
| 1. CNN đơn lẻ (Opcode 50.000)      | 0.1240 / 95.80%     | 0.2850 / 91.25%        |
| 2. CNN đơn lẻ (Opcode 100.000)     | 0.1015 / 96.50%     | 0.2410 / 92.50%        |
| 3. CNN đơn lẻ (Opcode 200.000)     | 0.0820 / 97.20%     | 0.2180 / 93.75%        |
| 4. FFNN đơn lẻ (437 Features)      | 0.1450 / 94.60%     | 0.3120 / 88.75%        |
| 5. Multimodal Fusion (Đề xuất)     | **0.0210 / 99.40%** | **0.0760 / 97.50%**    |
+------------------------------------+---------------------+------------------------+

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

Các đột phá kỹ thuật chính

  1. Biến đổi ma trận không gian 2D cho Dalvik Opcode: Thay vì xử lý Opcode như chuỗi văn bản $1D$ (thường gặp hạn chế về chiều dài chuỗi trong RNN/LSTM), phương pháp chuyển đổi thành ma trận kề $225 \times 225$ cho phép áp dụng bộ lọc tích chập (Convolutional Kernels) để khai thác các cấu trúc rẽ nhánh, vòng lặp và mẫu quan hệ giữa các chỉ lệnh mã máy với độ phức tạp tính toán cố định $\mathcal{O}(1)$ về kích thước đầu vào mạng nơ-ron.
  2. Cơ chế phối hợp đa phương thức (Late Multimodal Fusion): Khắc phục triệt để điểm yếu của các mô hình đơn phương thức. Khi mã độc áp dụng kỹ thuật đổi tên hàm/làm rối API (API Obfuscation), nhánh CNN vẫn nhận diện được sự bất thường trong ma trận kề Opcode; ngược lại, khi cấu trúc mã nguồn bị xáo trộn, nhánh FFNN vẫn bắt được dấu vết qua tần suất các lệnh hệ thống nhạy cảm.
  3. Mức cải thiện hiệu năng định lượng:
    • Giảm độ mất mát (Validation Loss) từ 0.2180 (mô hình CNN tốt nhất) và 0.3120 (FFNN) xuống còn 0.0760 (giảm hơn 65.1% sai số dự đoán).
    • Tăng độ chính xác phân loại (Validation Accuracy) lên mức 97.50%, vượt trội so với các mô hình đơn lẻ (+3.75% so với CNN và +8.75% so với FFNN).
          SO SÁNH ĐỘ CHÍNH XÁC KIỂM THỬ (VALIDATION ACCURACY)
100% +---------------------------------------------------------+
     |                                                  [97.5%] |
 95% |                                  [93.75%]           *    |
     |                  [91.25%]           *               |    |
 90% |  [88.75%]           *               |               |    |
     |     *               |               |               |    |
 85% |     |               |               |               |    |
     +-----+---------------+---------------+---------------+----+
         FFNN           CNN (50k)       CNN (200k)       FUSION

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

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

+----------------------------------------------------------------------------------------+
|                       QUY TRÌNH KIỂM DUYỆT ỨNG DỤNG TỰ ĐỘNG                            |
+----------------------------------------------------------------------------------------+
|                                                                                        |
|  [Nhà phát triển tải lên APK]                                                          |
|               |                                                                        |
|               v                                                                        |
|  [Cổng API Gateway: FastAPI]                                                           |
|               |                                                                        |
|               v                                                                        |
|  [Hàng đợi tác vụ Celery + Redis Broker]                                               |
|               |                                                                        |
|               v                                                                        |
|  [Worker Node: Trích xuất tĩnh (Androguard + Apktool)]                                 |
|               |                                                                        |
|               +----------------------------+                                           |
|               |                            |                                           |
|               v                            v                                           |
|       [Ma trận Opcode 2D]          [Véc-tơ Tần suất 437]                               |
|               |                            |                                           |
|               +------------+---------------+                                           |
|                            |                                                           |
|                            v                                                           |
|         [Inference Engine: TensorFlow Serving / GPU]                                   |
|                            |                                                           |
|                            v                                                           |
|            { Benign: 0.01, SMS: 0.02, Adware: 0.97 }                                   |
|                            |                                                           |
|            +---------------+---------------+                                           |
|            |                               |                                           |
|     (P(Malware) < 0.5)              (P(Malware) >= 0.5)                                |
|            v                               v                                           |
|     [Phê duyệt xuất bản]            [Cách ly & Cảnh báo SOC]                           |
+----------------------------------------------------------------------------------------+
  1. Cổng kiểm duyệt tự động cho kho ứng dụng (App Store Vetting Pipeline): Tích hợp vào khâu kiểm duyệt trước khi phát hành ứng dụng lên CH Play hoặc chợ ứng dụng doanh nghiệp, loại bỏ mã độc tự động chỉ trong vòng 3–5 giây cho mỗi tệp tin APK mà không cần cấp quyền thực thi.
  2. Hệ thống phản ứng sự cố Endpoint (Mobile EDR & SOC): Hỗ trợ các trung tâm điều hành an ninh mạng (SOC) tự động phân loại tệp tin nghi ngờ được trích xuất từ thiết bị người dùng nội bộ, nhanh chóng khoanh vùng biến thể SMS Trojan hoặc Adware.

Phân tích hiệu quả kinh tế và ROI

  • Thời gian xử lý: Trung bình 3.2 giây/mẫu APK (nhanh hơn 95% so với quy trình phân tích động Sandbox tiêu chuẩn vốn mất từ 60 đến 180 giây/mẫu).
  • Chi phí hạ tầng: Giảm thiểu nhu cầu duy trì trang trại thiết bị ảo (Virtual Device Farm) đắt đỏ. Một máy chủ GPU tiêu chuẩn có thể xử lý hơn 25.000 ứng dụng/ngày.

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

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

  • Kỹ thuật làm rối nâng cao: Đối với các mẫu mã độc sử dụng công cụ mã hóa nhị phân sâu (Native Code Encryption via JNI/NDK) hoặc làm biến dạng hoàn toàn bảng opcode, nhánh trích xuất tĩnh cần được bổ sung thêm cơ chế giải nén lớp vỏ (Unpacking).
  • Phạm vi nhãn dữ liệu: Mô hình hiện mới phân loại chuyên sâu trên 3 lớp đại diện (Benign, SMS Malware, Adware); chưa bao phủ toàn bộ các họ mã độc phức tạp khác như Banking Trojan hay Ransomware.

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

  1. Tích hợp Đồ thị luồng điều khiển (Control Flow Graph - CFG) với Graph Neural Networks (GNN): Nâng cấp biểu diễn ma trận kề Opcode sang đồ thị thực thi hướng ngữ nghĩa để tăng cường khả năng chống làm rối mã.
  2. Cơ chế Attention-based Multimodal Fusion: Ứng dụng kiến trúc Transformer để mô hình tự động gán trọng số thích ứng (Dynamic Attention Weights) cho từng luồng đặc trưng tùy thuộc vào mức độ tin cậy của tệp APK đầu vào.

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

+----------------------------------------------------------------------------------------+
|                                  GIÁ TRỊ MANG LẠI                                      |
+---------------------+------------------------------------------------------------------+
| Nhóm đối tượng      | Giá trị thực tiễn & Lợi ích định lượng                           |
+---------------------+------------------------------------------------------------------+
| Sinh viên &         | - Nguồn tài liệu học thuật hoàn chỉnh về AI trong An toàn TT.    |
| Nghiên cứu sinh     | - Code mẫu chi tiết về trích xuất Bytecode và kiến trúc Fusion.  |
+---------------------+------------------------------------------------------------------+
| Kỹ sư An ninh       | - Giải pháp phát hiện mã độc tĩnh tốc độ cao, độ chính xác 97.5%.|
| (SecOps/SOC)        | - Tiết kiệm 90%+ thời gian thẩm định sơ bộ các tệp APK độc hại.  |
+---------------------+------------------------------------------------------------------+
| Doanh nghiệp &      | - Kiến trúc microservices dễ dàng tích hợp vào Mobile CI/CD.    |
| Nhà phát triển App  | - Cắt giảm chi phí vận hành máy ảo phân tích hành vi tốn kém.     |
+---------------------+------------------------------------------------------------------+

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

1. Yêu cầu phần cứng tối thiểu để triển khai mô hình là gì?

Hệ thống có thể triển khai trên cả CPU và GPU. Cấu hình tối thiểu: CPU 4 nhân (x86_64), 8GB RAM, dung lượng ổ đĩa trống 5GB. Để đạt thông lượng cao nhất khi suy luận quy mô lớn (Batch Inference), khuyến nghị sử dụng GPU hỗ trợ CUDA với tối thiểu 4GB VRAM (ví dụ: NVIDIA GTX 1650 hoặc RTX 3050 trở lên).

2. Mô hình có khả năng chống lại kỹ thuật làm rối mã (Obfuscation) không?

Có. Nhờ vào cơ chế kết hợp đa phương thức: nếu kẻ tấn công làm rối chuỗi Opcode (chèn lệnh rác nop, thay đổi luồng nhảy goto), nhánh FFNN với 437 đặc trưng System Command & API Package vẫn duy trì khả năng nhận diện dấu vết tương tác cấp hệ thống, và ngược lại.

3. Tại sao chọn kích thước ma trận Opcode là 225x225?

Bộ máy ảo Dalvik trên hệ điều hành Android định nghĩa chuẩn 224 chỉ lệnh mã máy (Opcode). Hệ thống sử dụng 224 vị trí tương ứng cho các Opcode này và dành riêng vị trí thứ 225 (chỉ số 224) cho chỉ lệnh giả blank phục vụ việc đệm dữ liệu (Padding). Do đó, ma trận $225 \times 225$ thể hiện trọn vẹn toàn bộ không gian chuyển trạng thái có thể xảy ra giữa hai chỉ lệnh liên tiếp bất kỳ.

4. Hệ thống tích hợp vào quy trình CI/CD như thế nào?

Mô hình có thể đóng gói thành một Docker Container chạy dịch vụ FastAPI. Trong quy trình CI/CD (như GitLab CI, GitHub Actions), sau bước build tệp APK, một HTTP POST request chứa tệp nhị phân sẽ được gửi tới API để trả về điểm số rủi ro (Risk Score). Nếu điểm rủi ro vượt ngưỡng an toàn, pipeline sẽ tự động chặn bản phát hành.

5. Thời gian và tài nguyên cần thiết để huấn luyện lại mô hình là bao nhiêu?

Với tập dữ liệu chuẩn ~1.000 mẫu, quá trình huấn luyện 100 epochs trên GPU NVIDIA RTX 4060 mất khoảng 12 đến 15 phút. Chi phí huấn luyện lại thấp cho phép hệ thống định kỳ cập nhật tri thức mới mỗi tuần để đối phó với các biến thể mã độc phát sinh.

Kết luận

Đồ án tốt nghiệp "Nghiên cứu phát hiện mã độc Android dựa trên mô hình học sâu đa phương thức" đã giải quyết thành công bài toán cân bằng giữa tốc độ xử lý của phân tích tĩnh và độ chính xác của phân tích hành vi chuyên sâu. Bằng việc sáng tạo trong chuyển đổi chuỗi Dalvik Opcode thành ảnh ma trận kề $2D$ kết hợp mạng CNN cùng mạng FFNN phân tích tần suất lệnh hệ điều hành, mô hình đạt độ chính xác ấn tượng 97.50% trên tập kiểm thử độc lập, giảm thiểu hơn 65% sai số so với các kỹ thuật đơn lẻ.

Giải pháp mở ra hướng ứng dụng thực tiễn to lớn trong việc xây dựng các cổng kiểm duyệt ứng dụng tự động, bảo vệ hàng triệu người dùng thiết bị thông minh trước các làn sóng tấn công mạng ngày càng tinh vi.