Giới thiệu dự án

Sự bùng nổ của hệ điều hành Android trên toàn cầu đi kèm với nguy cơ an ninh mạng nghiêm trọng. Theo thống kê của Statcounter (12/2022), Android chiếm 72.37% thị phần hệ điều hành di động toàn cầu. Báo cáo mối đe dọa di động của Kaspersky ghi nhận 1,661,743 gói cài đặt độc hại (malicious installers), 196,476 Trojan ngân hàng (Banking Trojans), và 10,543 mã độc tống tiền (Ransomware) mới. Đáng chú ý, tỷ lệ tấn công bằng phần mềm quảng cáo độc hại (Adware) đã tăng mạnh từ 16.92% lên 26.38%, trong khi các dòng mã độc nguy hiểm khác chiếm tới 67% tổng số vụ tấn công.

+-----------------------------------------------------------------------------------+
|               BỐI CẢNH MỐI ĐE DỌA MÃ ĐỘC ANDROID (KASPERSKY REPORT)               |
+-----------------------------------------------------------------------------------+
|  [1,661,743] Malicious Installers  |  [196,476] Banking Trojans  |  [10,543] Ransomware |
|  Adware Attacks: Tăng từ 16.92% lên 26.38% | Malware khác: Chiếm tỷ lệ 67%        |
+-----------------------------------------------------------------------------------+

Thực trạng này đặt ra thách thức lớn: các kỹ thuật phân tích đơn lẻ truyền thống bộc lộ nhiều lỗ hổng. Phân tích tĩnh (Static Analysis) không thể xử lý mã bị làm rối (code obfuscation), kỹ thuật tải mã động (dynamic code loading), hay reflection. Ngược lại, phân tích động (Dynamic Analysis) gặp khó khăn trước các hành vi lẩn tránh máy ảo (anti-sandbox/anti-emulator) và không thể bao quát toàn bộ các nhánh thực thi (execution paths).

Đồ án khóa luận tốt nghiệp của Kỹ sư ngành An toàn Thông tin Nguyễn Ngọc Trưởng (Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM, dưới sự hướng dẫn của TS. Lê Kim Hùng) đã giải quyết triệt để bài toán này bằng việc xây dựng framework phân tích kết hợp AndroAnalyzer ứng dụng học sâu (Deep Learning).

Mục tiêu của đề tài

  1. Thiết kế framework AndroAnalyzer: Tự động hóa trích xuất toàn diện tập đặc trưng tĩnh và động từ các tệp Android Package Kit (APK).
  2. Kỹ thuật trích xuất trạng thái Reboot: Ghi nhận sự biến đổi tài nguyên hệ thống và API calls trước và sau khi khởi động lại (Reboot) môi trường giả lập để chống lẩn tránh.
  3. Tối ưu hóa không gian đặc trưng: Triển khai thuật toán Boruta Feature Selection kết hợp Random Forest để giảm chiều dữ liệu từ 9,841 đặc trưng thô xuống 232 đặc trưng tối ưu.
  4. Xây dựng mô hình Deep Learning phân loại nhị phân: Phát hiện chính xác ứng dụng lành tính (Benign) và mã độc (Malware).
  5. Xây dựng mô hình Deep Learning phân loại đa lớp: Nhận diện chính xác 5 họ ứng dụng gồm: Benign, Adware, Banking Malware, SMS Malware, Mobile Riskware.
  6. Triển khai ứng dụng Web tương tác: Cung cấp giao diện trực quan cho phép người dùng tải tệp APK, trích xuất đặc trưng và nhận diện mã độc thời gian thực.

Đối tượng và phạm vi nghiên cứu

  • Đối tượng nghiên cứu: Tập tin APK thuộc 5 nhóm phân loại: Adware, Banking Malware, SMS Malware, Mobile Riskware, và Benign (được xác thực nhãn qua VirusTotal).
  • Phạm vi nghiên cứu: Nền tảng Android OS, phân tích tĩnh thông qua cấu trúc tệp APK và phân tích động trên môi trường giả lập Android x86 Architecture (không bao gồm các nền tảng di động khác như iOS hay các họ mã độc ngoài 5 danh mục trên).

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

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

Phương pháp phân tích Ưu điểm kỹ thuật Hạn chế cốt lõi Khả năng chống Obfuscation / Evasion
Phân tích tĩnh thuần túy (FlowDroid, AmAndroid, DroidSieve) Thời gian xử lý nhanh; độ phủ mã nguồn (code coverage) cao; trích xuất permissions, intents, metadata toàn diện. Bất lực trước Dynamic Code Loading, Reflection, Native Payloads; bỏ sót các hành vi runtime. Thấp (Dễ bị vượt qua bởi đóng gói mã, làm rối chuỗi).
Phân tích động thuần túy (Cuckoo Sandbox, DroidScribe, DL-Droid) Nắm bắt hành vi thời gian thực: Network traffic, System calls, Logcat, Battery, Memory dump. Chi phí tính toán cao; mã độc phát hiện môi trường Sandbox/Emulator và tự tắt hành vi nguy hiểm. Trung bình (Dễ bị bypass bởi kỹ thuật Anti-Sandbox).
Chuyển đổi ảnh (Image-based CV) (MalNet, Gray/RGB mapping) Tận dụng được các mô hình thị giác máy tính tiên tiến (CNN); không cần giải mã sâu toàn bộ cấu trúc. Không phát hiện được Injection Attacks; không tương thích tốt với framework hiện đại (Flutter, React Native, Xamarin). Kém đối với kiến trúc đa thư viện (.so, .dll).
Phân tích kết hợp (Hybrid Analysis - AndroAnalyzer) Hợp nhất đặc trưng tĩnh từ AndroidManifest.xml và đặc trưng động đa chiều trước/sau Reboot máy ảo. Đòi hỏi pipeline tiền xử lý và kỹ thuật chọn lọc đặc trưng (Feature Selection) khắt khe để tránh nghẽn dữ liệu. Rất cao (Vô hiệu hóa cả kỹ thuật Obfuscation lẫn Anti-Sandbox).

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

  • Must have (Bắt buộc):
    • Module Static Feature Extraction trích xuất permissions, services, receivers, providers, activities, intent actions/categories, và số lượng tài nguyên đa phương tiện.
    • Module Dynamic Feature Extraction tích hợp DroidBot và Frida Tools để theo dõi bộ nhớ (PSS, dirty memory), mạng, tiến trình, logcat, và API calls.
    • Bộ lọc đặc trưng Boruta giảm thiểu nhiễu dữ liệu.
    • Bộ phân loại học sâu CNN-MLP đạt độ chính xác >95%.
  • Should have (Nên có):
    • Khả năng trích xuất vector vi phân trạng thái trước và sau khi Reboot trình giả lập ($\Delta C_{D} = C_{dyn_after} - C_{dyn_before}$).
    • Giao diện Web phân tích tệp APK tự động.
  • Could have (Có thể có):
    • Tự động sinh báo cáo kỹ thuật chi tiết mã độc dưới dạng PDF/JSON.
  • Won't have (Chưa hỗ trợ):
    • Phân tích can thiệp phần cứng trên thiết bị Android vật lý (Hardware-in-the-loop).

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

Kiến trúc tổng thể của framework AndroAnalyzer gồm 4 tầng xử lý liên hoàn khép kín:

graph TD
    APK[Target APK File] --> SFE[Static Feature Extraction\nAndroguard Engine]
    APK --> DFE[Dynamic Feature Extraction\nDroidBot + Frida + Emulator x86]
    
    SFE --> SData[Static Data Vector\nN_static = 9523]
    DFE --> DDataBefore[Before Reboot Data\nAPI calls, Mem, Net, Logcat]
    DFE --> Reboot[Reboot Emulator] --> DDataAfter[After Reboot Data\nState Delta Extraction]
    
    DDataBefore & DDataAfter --> DData[Dynamic Data Vector\nN_dynamic = 318]
    
    SData & DData --> FPrep[Feature Preprocessing\nC_final in R^9841]
    FPrep --> FSelect[Feature Selection\nBoruta Algorithm + Random Forest]
    FSelect --> FilteredData[Optimized Features\nN_selected = 232]
    
    FilteredData --> DLModel[Deep Learning Classifier\nCNN-MLP Architecture]
    DLModel --> OutBin[Binary Output: Benign / Malware]
    DLModel --> OutMulti[Multiclass Output: Adware, Banking, SMS, Riskware, Benign]

Technology Stack

  • Framework & Libraries: TensorFlow 2.x, Keras, Scikit-learn, NumPy, Pandas.
  • Phân tích mã nguồn Android: Androguard 3.4.0 (Python), Frida Tools (Hooking Engine), DroidBot (UI Transition Graph & Automatic Input Generation).
  • Backend & Web Interface: Node.js, Express.js, Python 3.9+, Flask API, Bootstrap 5.
  • Môi trường thực thi: Android SDK Emulator (Kiến trúc x86_64, Android API Level 28/29, Root Privilege via su).

Implementation và kết quả

Quy trình tiền xử lý và biểu diễn không gian đặc trưng

  1. Biểu diễn vector đặc trưng tĩnh ($C_{static}$):

    • Các tài nguyên số lượng (image, audio, video, meta-data, activities, providers, receivers) mã hóa thành vector $C_{res} \in \mathbb{R}^{13}$.
    • Nhóm đặc trưng danh mục bao gồm quyền hạn (permissions - $C_p$), bộ lọc hành động (actions - $C_a$), danh mục intent (categories - $C_c$), và dịch vụ chạy ngầm (services - $C_s$) được mã hóa One-Hot theo sự xuất hiện nhị phân $c_j \in {0, 1}$.
    • Vector tĩnh tổng hợp: $$C_{static} = C_{res} \oplus C_p \oplus C_a \oplus C_c \oplus C_s \in \mathbb{R}^{9523}$$

  2. Biểu diễn vector đặc trưng động ($C_{dynamic}$):

    • Các thông số thống kê gồm 36 chỉ số runtime (Process, Logcat, Battery Wakelock, Network I/O, PSS Total, Shared/Private Dirty Memory, Heap Alloc, OpenSSLSockets, WebViews, Local/Proxy Binders) trích xuất thành 2 vector trước và sau reboot: $C_{dyn_before}, C_{dyn_after} \in \mathbb{R}^{36}$.
    • Vector biến thiên trạng thái: $C_{D} = C_{dyn_after} - C_{dyn_before} \in \mathbb{R}^{36}$.
    • Nhóm 105 API calls được mã hóa One-Hot: $C_{api_before}, C_{api_after} \in \mathbb{R}^{105}$.
    • Vector động tổng hợp: $$C_{dynamic} = C_{api_before} \oplus C_{api_after} \oplus C_{dyn_before} \oplus C_{dyn_after} \oplus C_{D} \in \mathbb{R}^{318}$$
    • Vector đầu vào thô hoàn chỉnh: $$C_{final} = C_{static} \oplus C_{dynamic} \in \mathbb{R}^{9841}$$

Trích đoạn Code Engine phân tích tĩnh & triển khai Frida

Trích xuất đặc trưng tĩnh bằng Androguard:

from androguard.bytecodes import apk, dvm

def extract_static_features(apk_path):
    app = apk.APK(apk_path)
    manifest_data = {
        "package_name": app.get_package(),
        "permissions": app.get_permissions(),
        "activities": app.get_activities(),
        "services": app.get_services(),
        "receivers": app.get_receivers(),
        "providers": app.get_providers(),
        "intent_filters": app.get_intent_filters('activity', app.get_main_activity())
    }
    
    # Trích xuất Smali classes và API Invocation
    dex_handler = dvm.DalvikVMFormat(app.get_dex())
    methods = [method.get_name() for cls in dex_handler.get_classes() for method in cls.get_methods()]
    return manifest_data, methods

Cấu hình máy chủ hook động và khởi động Frida Server qua ADB:

# Lấy ABI của emulator/thiết bị
adb shell getprop ro.product.cpu.abi

# Đẩy frida-server vào thư mục tạm và cấp quyền thực thi root
adb push ./frida-server-16.x-android-x86 /data/local/tmp/frida-server
adb shell "chmod +x /data/local/tmp/frida-server"
adb shell "su -c /data/local/tmp/frida-server &"

# Kiểm tra tiến trình runtime đang lắng nghe
frida-ps -U

Thuật toán lựa chọn đặc trưng Boruta Feature Selection

Để triệt tiêu các chiều dữ liệu gây nhiễu trong 9,841 đặc trưng, thuật toán Boruta tạo ra các đặc trưng bóng (Shadow Features) bằng cách xáo trộn ngẫu nhiên giá trị của từng cột dữ liệu ban đầu:

$$SF = {So_1, So_2, \dots, So_N}, \quad \text{với } So_j = \text{shuffle}(O_j)$$

Tạo ma trận hợp nhất $U = OF \cup SF$ kích thước $2N$ chiều và huấn luyện mô hình rừng ngẫu nhiên (Random Forest). Độ quan trọng $Z\text{-score}$ của từng đặc trưng $i$ được tính bằng:

$$Zscore_i = \frac{imp_i - \mu_{imp}}{\sigma_{imp}}$$

Trong đó $imp_i$ là tỷ lệ xuất hiện của đặc trưng trong các cây quyết định ($imp_i = \frac{m}{M \times 2N}$), $\mu_{imp}$ và $\sigma_{imp}$ lần lượt là giá trị trung bình và độ lệch chuẩn của toàn bộ độ quan trọng trong ma trận $U$. Một đặc trưng được giữ lại khi và chỉ khi:

$$Zscore_i > \max(Zscore_{shadow})$$

+-------------------------------------------------------------------------------+
|                    HIỆU QUẢ CỦA THUẬT TOÁN BORUTA (10 LOOPS)                  |
+-------------------------------------------------------------------------------+
|  Chỉ số đánh giá          |  Tập gốc (9,841 Features) | Tập Boruta (232 Features)|
+---------------------------+---------------------------+-----------------------+
|  Độ chính xác (Accuracy)  |          94.12%           |       98.15% (+4.03%) |
|  F1-Score                 |          93.85%           |       98.10% (+4.25%) |
|  Thời gian huấn luyện     |         142.60 s          |         9.45 s        |
|  Thời gian dự đoán/mẫu    |          0.088 s          |         0.003 s       |
+-------------------------------------------------------------------------------+

Thiết kế mạng học sâu CNN-MLP

Kiến trúc mạng nơ-ron kết hợp CNN-MLP được xây dựng nhằm khai thác khả năng học biểu diễn không gian cục bộ của Conv1D và khả năng ánh xạ phi tuyến của MLP:

[Input Vector: (232, 1)]
         │
         ▼
[Conv1D Layer #1: 32 Filters, Kernel Size=3, Stride=1, Padding='valid', Activation='ReLU']
         │  Output Shape: (230, 32)
         ▼
[AveragePooling1D #1: Pool Size=2]
         │  Output Shape: (115, 32)
         ▼
[Conv1D Layer #2: 64 Filters, Kernel Size=3, Stride=1, Padding='valid', Activation='ReLU']
         │  Output Shape: (113, 64)
         ▼
[AveragePooling1D #2: Pool Size=2]
         │  Output Shape: (56, 64)
         ▼
[Flatten Layer] ──> Output Dimension: 56 x 64 = 3,584 units
         │
         ▼
[Dense Layer #1: 128 Units, Activation='ReLU']
         │
         ▼
[Dropout Layer: Rate = 0.3]
         │
         ▼
[Dense Layer #2: 64 Units, Activation='ReLU']
         │
         ▼
[Output Layer]
   ├── Nhị phân (Binary): 1 Unit (Activation='Sigmoid') ──> [Benign vs. Malware]
   └── Đa lớp (Multiclass): 5 Units (Activation='Softmax') ──> [Benign, Adware, Banking, SMS, Riskware]

Kết quả thực nghiệm và kiểm thử

Mô hình được huấn luyện và đánh giá trên bộ dữ liệu chuẩn hóa gồm 6,000 tệp APK (phân phối cân bằng giữa các họ mã độc và mẫu lành tính).

+-----------------------------------------------------------------------------------+
|               KẾT QUẢ PHÂN LOẠI CHI TIẾT (CLASSIFICATION REPORT)                  |
+-----------------------------------------------------------------------------------+
|  Danh mục ứng dụng      |  Precision (%) |  Recall (%)   |  F1-Score (%) | Sample |
+-------------------------+----------------+---------------+---------------+--------+
|  Benign (Lành tính)     |     98.85      |     98.20     |     98.52     |  1200  |
|  Adware                 |     93.45      |     94.10     |     93.77     |  1200  |
|  Banking Malware        |     95.12      |     94.80     |     94.96     |  1200  |
|  SMS Malware            |     96.30      |     95.90     |     96.10     |  1200  |
|  Mobile Riskware        |     91.25      |     91.15     |     91.20     |  1200  |
+-------------------------+----------------+---------------+---------------+--------+
|  Độ chính xác tổng thể (Phát hiện mã độc nhị phân):       98.08%                  |
|  Độ chính xác tổng thể (Phân loại 5 họ mã độc đa lớp):    94.83%                  |
+-----------------------------------------------------------------------------------+

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

  1. Cơ chế trích xuất vi phân trạng thái Reboot ($\Delta C_D$): Lần đầu tiên tích hợp việc so sánh trạng thái tiêu thụ tài nguyên hệ thống (Memory PSS, CPU, Binder IPC, Wakelock) trước và sau khi Reboot máy ảo để phát hiện các payload khởi động ngầm theo chu kỳ (BOOT_COMPLETED).
  2. Kỹ thuật chọn lọc Boruta Shadow Feature trên không gian lớn: Giảm 97.6% số chiều dữ liệu (từ 9,841 xuống 232 đặc trưng) giúp triệt tiêu hiện tượng Overfitting, tăng độ chính xác phân loại thêm 4%, và giảm thời gian suy luận (inference time) xuống dưới 3ms/mẫu.
  3. Mô hình học sâu tích hợp CNN-MLP: Khắc phục nhược điểm của mô hình MLP thuần túy (dễ rơi vào cực tiểu cục bộ) và CNN thuần túy (kém hiệu quả trên dữ liệu bảng dạng vector phẳng), nâng cao F1-score lên 94.83% trong bài toán phân loại đa lớp phức tạp.

So sánh đối sánh với các công trình nghiên cứu tiêu biểu

Công trình & Tác giả Phương pháp tiếp cận Kích thước mẫu thực nghiệm Độ chính xác phát hiện (Detection Acc) Độ chính xác phân loại họ (Classification Acc)
NADM (Duc et al., 2018) Phân tích tĩnh thuần túy + MLP 129,013 APKs 92.00% (F1-score) Không hỗ trợ
DroidScribe (Dash et al., 2016) Phân tích động + SVM Conformal 4,442 APKs 94.00% 84.00%
DL-Droid (Alzaylaee et al., 2020) Phân tích động Stateful + DNN 30,000 APKs 95.49% 87.20%
EntropLyzer (Keyes et al., 2021) Phân tích động 6 nhóm + Decision Tree Dataset CCCS-CIC-AndMal2020 96.10% 87.00%
AndroAnalyzer (Đề tài đề xuất) Phân tích kết hợp Hybrid + Boruta + CNN-MLP 6,000 APKs (AndroAnalyzer Dataset) 98.08% 94.83% (+7.83%)

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

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

  • Cổng kiểm duyệt ứng dụng tự động (App Store Ingestion Gate): Tích hợp vào CI/CD pipeline của các kho ứng dụng của bên thứ ba (Apkpure, Apkcombo) nhằm quét và tự động ngăn chặn các tệp APK độc hại do nhà phát triển tải lên trước khi phát hành đến người dùng.
  • Trung tâm giám sát an toàn thông tin doanh nghiệp (Mobile SOC Triage): Tự động phân tích các ứng dụng không rõ nguồn gốc được cài đặt trên thiết bị làm việc của nhân viên (BYOD policy), ngăn chặn nguy cơ đánh cắp thông tin tài chính qua Banking Trojans hoặc rò rỉ dữ liệu qua SMS Malware.
+-------------------------------------------------------------------------------+
|             KIẾN TRÚC TRIỂN KHAI HỆ THỐNG ANDROANALYZER TRÊN CLOUD            |
+-------------------------------------------------------------------------------+
|  [User Browser / Mobile SOC]                                                  |
|         │ (HTTPS Upload APK / REST API)                                       |
|         ▼                                                                     |
|  [Nginx Reverse Proxy & Load Balancer]                                        |
|         │                                                                     |
|         ▼                                                                     |
|  [Node.js / Express Web Gateway] ──> [PostgreSQL / MongoDB Database]          |
|         │                                                                     |
|         ▼ (Task Queue via Redis / Celery)                                     |
|  [Analysis Worker Nodes (Docker Containers with KVM Hardware Acceleration)]  |
|         ├── Static Worker: Androguard Smali/Manifest Parser                   |
|         └── Dynamic Worker: Headless Android x86 Emulator + Frida Hooking     |
|         │                                                                     |
|         ▼                                                                     |
|  [Inference Engine (TensorFlow Serving / Python Daemon)]                     |
|         └── Boruta 232 Features Filter ──> CNN-MLP Neural Network Classifier  |
+-------------------------------------------------------------------------------+

Yêu cầu phần cứng và phần mềm triển khai

  • Server OS: Ubuntu 20.04 / 22.04 LTS x86_64.
  • CPU: Tối thiểu 8 Cores (hỗ trợ Intel VT-x hoặc AMD-V để tăng tốc giả lập KVM).
  • RAM: Tối thiểu 32 GB ECC RAM (cho phép chạy đồng thời 4 máy ảo sandbox).
  • GPU: NVIDIA T4 hoặc RTX 3060 12GB trở lên (tối ưu hóa inference song song).
  • Lưu trữ: 500 GB NVMe SSD (tốc độ đọc ghi cao phục vụ Snapshot máy ảo).

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

Hạn chế kỹ thuật

  • Thời gian phân tích động: Quá trình thực thi động và reboot trình giả lập mất từ 2 đến 5 phút cho mỗi tệp APK, tạo điểm nghẽn khi cần phân tích quy mô hàng triệu ứng dụng mỗi ngày.
  • Phụ thuộc kiến trúc x86: Một số ứng dụng mã độc nhắm vào tập chỉ thị ARM sử dụng native library (.so) phức tạp có thể hoạt động không chính xác trên môi trường giả lập x86 nếu thiếu translator hiệu năng cao.

Hướng nghiên cứu mở rộng

  • Tích hợp đồ thị tri thức mã nguồn (Graph Neural Networks - GNN): Xây dựng đồ thị luồng điều khiển (Control Flow Graph - CFG) và đồ thị luồng dữ liệu (Data Flow Graph - DFG) để trích xuất đặc trưng cấu trúc sâu hơn.
  • Phân tích động trên thiết bị thật (Physical Device Farm): Mở rộng cụm kiểm thử sang các bo mạch ARM vật lý để loại bỏ hoàn toàn khả năng phát hiện máy ảo của các dòng mã độc tinh vi.

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

+-------------------------------------------------------------------------------+
|                        GIÁ TRỊ MANG LẠI CHO CÁC ĐỐI TƯỢNG                     |
+-------------------------------------------------------------------------------+
| Sinh viên & Học viên:                                                         |
| - Cung cấp tài liệu tham khảo chuẩn mực về kiến trúc Android Runtime và Smali.|
| - Mã nguồn mẫu về kỹ thuật kết hợp CNN-MLP và thuật toán Boruta.              |
|                                                                               |
| Kỹ sư & Nhà phát triển An toàn Thông tin:                                     |
| - Bộ công cụ tự động hóa pipeline phân tích APK tĩnh và động với Frida.       |
| - Phương pháp kỹ thuật trích xuất vi phân tài nguyên hệ thống qua Reboot.     |
|                                                                               |
| Doanh nghiệp & Nhà vận hành App Store:                                        |
| - Giảm thiểu 90% thời gian phân tích thủ công (Manual Triage) của chuyên viên.|
| - Tăng tỷ lệ phát hiện mã độc chính xác lên 98.08%, bảo vệ thương hiệu.       |
|                                                                               |
| Nhà nghiên cứu Khoa học Dữ liệu / An ninh mạng:                               |
| - Phương pháp luận chuẩn hóa xử lý dữ liệu bảng nhiều chiều (9,841 -> 232).   |
| - Điểm chuẩn (Benchmark) tin cậy trên 5 danh mục mã độc di động phổ biến.    |
+-------------------------------------------------------------------------------+

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

1. Hệ thống cần cấu hình phần cứng tối thiểu như thế nào để triển khai?

Để triển khai hệ thống AndroAnalyzer hoàn chỉnh cho môi trường thử nghiệm, máy chủ cần tối thiểu CPU 4 nhân hỗ trợ ảo hóa phần cứng (Intel VT-x/AMD-V), 16GB RAM, và 50GB ổ cứng SSD để vận hành Android Emulator và Docker Container. Đối với môi trường sản xuất xử lý đồng thời, khuyến nghị sử dụng CPU 8 nhân, 32GB RAM và GPU chuyên dụng.

2. Khả năng mở rộng (Scalability) của AndroAnalyzer khi xử lý hàng ngàn tệp APK mỗi ngày ra sao?

AndroAnalyzer được thiết kế theo kiến trúc Microservices phân tán. Thành phần tốn tài nguyên nhất là Dynamic Feature Extraction có thể được mở rộng theo chiều ngang (Horizontal Scaling) bằng cách phân bổ nhiều Worker Node chạy trình giả lập không đầu (Headless Emulators) qua cơ chế hàng đợi Redis/Celery. Tầng suy luận (Inference Engine) của mạng CNN-MLP xử lý vector 232 chiều chỉ mất dưới 3ms/mẫu, cho phép phân loại hàng chục nghìn vector mỗi giây.

3. Làm thế nào AndroAnalyzer phát hiện được mã độc khi chúng cố tình không thực thi mã độc trong máy ảo?

AndroAnalyzer giải quyết vấn đề này nhờ cơ chế kép:

  • Trích xuất tĩnh đa tầng: Thu thập toàn bộ lời gọi API, quyền hạn và thành phần khai báo trong mã nguồn, bắt giữ các dấu hiệu nguy hiểm ngay cả khi mã độc không kích hoạt.
  • Trích xuất vi phân sau Reboot: Theo dõi sự biến đổi các tiến trình đăng ký khởi động cùng hệ thống (BOOT_COMPLETED), mức tiêu thụ pin bất thường (Wakelock) và socket mạng sau khi khởi động lại thiết bị giả lập.

4. Tệp tin APK được làm rối (Code Obfuscation) có làm giảm độ chính xác của hệ thống không?

Không đáng kể. Nhờ module Dynamic Feature Extraction ghi nhận hành vi thực tế trong bộ nhớ PSS, kết nối mạng thời gian thực và API calls khi ứng dụng tương tác với hệ điều hành thông qua công cụ DroidBot, các kỹ thuật làm rối tên lớp, tên hàm hay đóng gói mã (packing) ở tầng tĩnh đều bị vô hiệu hóa khi mã độc bung payload vào bộ nhớ runtime.

5. Chi phí vận hành và thời gian thu hồi vốn (ROI) khi doanh nghiệp ứng dụng giải pháp này?

Chi phí ban đầu chủ yếu là hạ tầng máy chủ ảo hóa cục bộ hoặc đám mây (ước tính 100 - 300 USD/tháng cho quy mô vừa). Giải pháp giúp tự động hóa hoàn toàn khâu rà quét sơ bộ, giảm thiểu 80% thời gian phân tích thủ công của đội ngũ chuyên gia bảo mật (SOC/Incident Response), giảm thiểu rủi ro vi phạm dữ liệu (Data Breach) có thể gây thiệt hại hàng trăm nghìn USD, mang lại ROI dương chỉ sau 3 đến 6 tháng vận hành.

Kết luận

Đề tài khóa luận tốt nghiệp "Phân tích kết hợp các ứng dụng Android để phát hiện và phân loại ứng dụng độc hại bằng cách sử dụng học sâu" của Kỹ sư Nguyễn Ngọc Trưởng (GVHD: TS. Lê Kim Hùng, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM) đã giải quyết trọn vẹn bài toán an ninh mạng cấp thiết trên nền tảng di động. Bằng việc xây dựng framework AndroAnalyzer, kết hợp đồng thời ưu điểm của phân tích tĩnh và phân tích động vi phân trạng thái Reboot, ứng dụng thuật toán lọc đặc trưng Boruta và mạng nơ-ron CNN-MLP, công trình đã thiết lập các chỉ số ấn tượng:

  • Đạt độ chính xác 98.08% trong bài toán phát hiện mã độc nhị phân.
  • Đạt độ chính xác 94.83% trong bài toán phân loại chi tiết 5 họ ứng dụng (Benign, Adware, Banking Malware, SMS Malware, Mobile Riskware), vượt trội hơn các công trình công bố trước đây từ 7% đến 10%.
  • Rút gọn không gian vector từ 9,841 xuống 232 đặc trưng cốt lõi, tối ưu hóa tốc độ xử lý và khả năng mở rộng.

Giải pháp mở ra tiềm năng ứng dụng thực tiễn to lớn trong việc xây dựng các cổng kiểm soát ứng dụng an toàn cho các kho ứng dụng, hỗ trợ đắc lực cho các trung tâm điều hành an ninh mạng (SOC) và cung cấp cơ sở phương pháp luận vững chắc cho các nghiên cứu chuyên sâu tiếp theo trong lĩnh vực An toàn Thông tin.