Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và phát triển phần mềm hiện đại, an toàn thông tin đang đối mặt với những thách thức chưa từng có. Theo thống kê từ Cơ sở Dữ liệu Lỗ hổng Quốc gia (NVD - National Vulnerability Database), số lượng lỗ hổng bảo mật phần mềm (Common Vulnerabilities and Exposures - CVE) được công bố tăng trưởng theo cấp số nhân mỗi năm. Các lỗi bảo mật nghiêm trọng liên quan đến quản lý bộ nhớ, kiểm tra biên, và lỗi logic lập trình không chỉ gây thất thoát dữ liệu nhạy cảm mà còn tạo điều kiện cho các cuộc tấn công thực thi mã từ xa (RCE) gây tê liệt hạ tầng công nghệ thông tin.

Vấn đề nghiên cứu và Điểm nghẽn kỹ thuật

Các phương pháp truyền thống như phân tích tĩnh dựa trên luật cú pháp (Rule-based Static Analysis) hay đối sánh mẫu (Pattern Matching) bộc lộ nhiều hạn chế:

  • Tỷ lệ dương tính giả (False Positive Rate - FPR) cao: Các công cụ phân tích tĩnh thông thường không nắm bắt được ngữ cảnh thực thi, dẫn đến việc đưa ra cảnh báo sai lệch, gây quá tải cho đội ngũ kiểm thử.
  • Tỷ lệ âm tính giả (False Negative Rate - FNR) nghiêm trọng: Không phát hiện được các biến thể lỗ hổng mới hoặc mã nguồn bị xáo trộn (obfuscated code).
  • Mô hình học máy truyền thống thiếu ngữ nghĩa: Sử dụng biểu diễn từ vựng đơn thuần (như Bag-of-Words hoặc Word2Vec cơ bản) bỏ qua thứ tự token, cấu trúc luồng điều khiển (Control Flow) và luồng dữ liệu (Data Flow) của chương trình.

Mục tiêu nghiên cứu

Đề tài tập trung giải quyết triệt để các vấn đề trên thông qua 4 mục tiêu cốt lõi:

  1. Nghiên cứu quy trình trích xuất lát cắt mã nguồn: Xây dựng thuật toán trích xuất các Code Slices và tổng hợp thành Code Gadgets dựa trên các lời gọi hàm thư viện/API xuôi (Forward) và ngược (Backward).
  2. Khảo sát và ứng dụng các kỹ thuật nhúng ngữ nghĩa mã nguồn: So sánh chuyên sâu giữa kỹ thuật nhúng từ Word2Vec (Skip-gram, CBOW) và mô hình ngôn ngữ lớn chuyên dụng cho mã nguồn CodeBERT (huấn luyện trước trên tập đa ngôn ngữ NL-PL).
  3. Thiết kế và tối ưu 4 kiến trúc Deep Learning: Xây dựng, huấn luyện và tinh chỉnh các mạng nơ-ron: Mạng nơ-ron tích chập (CNN), Mạng nơ-ron hồi quy (RNN), Mạng bộ nhớ dài-ngắn hai chiều (BiLSTM), và Mô hình Transformer dựa trên cơ chế Self-Attention.
  4. Đánh giá thực nghiệm toàn diện: Thử nghiệm và đối chuẩn trên các tập dữ liệu tiêu chuẩn công nghiệp (SySeVR, VulDeePecker, VulDeBERT) nhằm tối ưu hóa điểm số F1 và giảm thiểu tối đa FPR, FNR.

Phương pháp tiếp cận và Phạm vi

  • Phương pháp tiếp cận: Kết hợp mô hình xử lý ngôn ngữ tự nhiên (NLP) tiền huấn luyện (Pre-trained Transformer Model) với các mạng nơ-ron sâu để tự động hóa trích xuất đặc trưng cú pháp và ngữ nghĩa từ mã nguồn không cần chạy chương trình (Static Semantic-based Detection).
  • Phạm vi nghiên cứu: Đề tài tập trung vào mã nguồn viết bằng ngôn ngữ C/C++ chứa các lớp lỗ hổng nguy hiểm phổ biến theo bảng phân loại CWE (như CWE-119: Lỗi tràn bộ đệm, CWE-399: Quản lý tài nguyên không đúng cách), sử dụng dữ liệu từ NVD và Viện Tiêu chuẩn và Kỹ thuật Quốc gia Hoa Kỳ (SARD - NIST).

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

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

Tiêu chí Phân tích tĩnh dựa trên luật (Rule-based SAST) Phân tích động (Dynamic Analysis/Fuzzing) Biểu diễn Word2Vec + BiLSTM (VulDeePecker) CodeBERT + Deep Learning (Giải pháp đề xuất)
Khả năng nắm bắt ngữ cảnh Thấp (Chỉ so khớp mẫu cú pháp cục bộ) Cao (Dựa trên vết thực thi thời gian thực) Trung bình (Biểu diễn ngữ cảnh cục bộ qua cửa sổ từ) Rất cao (Cơ chế Self-Attention đa tầng, hiểu ngữ nghĩa toàn cục)
Phụ thuộc môi trường thực thi Không Bắt buộc phải biên dịch và chạy thử Không Không (Phân tích tĩnh sâu)
Tỷ lệ cảnh báo sai (FPR) Rất cao (> 35-50%) Rất thấp (< 5%) Trung bình (~ 10-15%) Thấp (< 5-8%)
Thời gian quét mã Nhanh Rất chậm (Tùy thuộc test cases và fuzzing coverage) Nhanh sau khi hoàn tất training Tối ưu (Inference thời gian thực < 50ms/gadget) 
    +-----------------------------------------------------------------------+
    |                    YÊU CẦU HỆ THỐNG THEO MOSCOW                      |
    +-----------------------------------------------------------------------+
    | MUST HAVE   | * Trích xuất Code Gadgets từ mã nguồn C/C++.           |
    |             | * Nhúng ngữ nghĩa thông qua Word2Vec và CodeBERT.       |
    |             | * Phân loại nhị phân (Vulnerable vs Non-Vulnerable).    |
    | SHOULD HAVE | * Hỗ trợ các kiến trúc CNN, RNN, BiLSTM, Transformer.   |
    |             | * Tối ưu hóa bộ tối ưu Adamax và hàm Loss phân loại.    |
    | COULD HAVE  | * Mở rộng phân loại đa nhãn theo từng mã CWE cụ thể.    |
    | WON'T HAVE  | * Tự động tạo bản vá (Auto-patching) trong giai đoạn này.|
    +-----------------------------------------------------------------------+

Thiết kế hệ thống

Kiến trúc tổng thể của hệ thống gồm 3 phân hệ chính: Phân hệ Tiền xử lý & Chuẩn hóa mã nguồn, Phân hệ Nhúng Vector Ngữ nghĩa, và Phân hệ Huấn luyện & Phát hiện Lỗ hổng.

Technology Stack và Phiên bản công nghệ

  • Ngôn ngữ thực thi: Python 3.10.x
  • Deep Learning Framework: TensorFlow 2.12.0, PyTorch 2.0.1
  • NLP & Transformers Library: Hugging Face Transformers 4.30.2, Gensim 4.3.1 (Word2Vec)
  • Data Manipulation: NumPy 1.24.3, Pandas 2.0.2, Scikit-learn 1.2.2
  • Môi trường tính toán: Google Colab Pro / Linux Ubuntu 22.04 LTS (NVIDIA Tesla T4 GPU 16GB VRAM, 12GB System RAM, 80GB NVMe Storage).

Thiết kế chi tiết các kiến trúc mô hình học sâu

  1. Mạng nơ-ron tích chập (CNN):

    • InputLayer: Shape (None, 50, 50)
    • Conv1D: 64 bộ lọc (filters), kích thước kernel $k=3$, hàm kích hoạt ReLU, output (None, 48, 64)
    • MaxPooling1D: Pool size $p=2$, output (None, 24, 64)
    • Flatten: Biến đổi thành vector phẳng (None, 704)
    • Dense: 100 đơn vị ẩn, kích hoạt ReLU
    • Dropout: Tỷ lệ $p_{drop}=0.5$
    • Dense (Output): 2 đơn vị phân loại nhị phân, hàm kích hoạt Softmax.

  2. Mạng bộ nhớ dài-ngắn hai chiều (BiLSTM):

    • Bidirectional(LSTM): 300 units mỗi chiều, output (None, 600)
    • Dense Layer 1: 300 units $\rightarrow$ LeakyReLU(alpha=0.1) $\rightarrow$ Dropout(0.5)
    • Dense Layer 2: 300 units $\rightarrow$ LeakyReLU(alpha=0.1) $\rightarrow$ Dropout(0.5)
    • Dense (Output): 2 units với Softmax.

  3. Mô hình Transformer (Attention-based Classifier):

    • Xếp chồng 3 khối Transformer Encoders tuần tự:
      • MultiHeadAttention: $h=8$ heads, kích thước key vector $d_k=32$.
      • LayerNormalization và kết nối tắt Residual Add.
      • Dense Feed-Forward: 32 units (ReLU) $\rightarrow$ 50 units (Linear Projection).
    • GlobalAveragePooling1D: Giảm chiều dữ liệu từ chuỗi token thành vector đặc trưng đại diện (None, 50).
    • Dense (Output): 2 units với Softmax.

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

Nghiên cứu áp dụng quy trình phát triển lặp theo tiêu chuẩn khoa học dữ liệu kết hợp an toàn thông tin:

  • Phase 1 (Thu thập và làm sạch dữ liệu): Khai thác từ NVD (874 file mã nguồn chứa lỗi / 1,591 chương trình) và SARD (13,906 file mã nguồn chứa lỗi / 14,000 chương trình).
  • Phase 2 (Trích xuất & Chuẩn hóa): Phân tích cú pháp trừu tượng, định vị hàm nhạy cảm, sinh mã lát cắt và chuẩn hóa biến (VAR1, VAR2...), hàm (FUN1, FUN2...).
  • Phase 3 (Vector hóa & Embedding): Huấn luyện Word2Vec và cấu hình CodeBERT tokenizers.
  • Phase 4 (Huấn luyện & Đánh giá): Huấn luyện 4 mô hình học sâu qua 20 và 30 epochs, áp dụng bộ tối ưu Adamax(lr=0.002), đánh giá chéo (cross-validation).

Implementation và kết quả

Quy trình phát triển và Tiền xử lý dữ liệu

Quá trình trích xuất Code Gadget là bước quyết định để cô lập các dòng mã có liên quan logic tới lỗ hổng bảo mật:

// Mã nguồn gốc trước khi trích xuất và chuẩn hóa
void func() {
    char *data;
    char dataBuffer[100];
    char source[100];
    memset(dataBuffer, 'A', 99);
    dataBuffer[99] = '\0';
    data = dataBuffer - 8; // Điểm bất thường về con trỏ (SyVC)
    memset(source, 'C', 99);
    source[99] = '\0';
    memmove(data, source, 100 * sizeof(char)); // Backward API call
    data[99] = '\0';
    println(data);
}

Thuật toán chuẩn hóa mã nguồn loại bỏ nhiễu tên biến và hàm tùy biến của lập trình viên:

import re

def normalize_code_gadget(raw_code: str) -> str:
    """
    Loại bỏ comments, ký tự non-ASCII, và chuẩn hóa định danh người dùng.
    """
    # 1. Loại bỏ chú thích khối và chú thích dòng
    code = re.sub(r'/\*.*?\*/', '', raw_code, flags=re.DOTALL)
    code = re.sub(r'//.*', '', code)
    
    # 2. Loại bỏ ký tự không thuộc bảng mã ASCII
    code = re.sub(r'[^\x00-\x7F]+', '', code)
    
    # 3. Chuẩn hóa biến (VARx) và hàm (FUNx)
    user_vars = {}
    user_funcs = {}
    tokens = code.split()
    normalized_tokens = []
    
    var_idx, func_idx = 1, 1
    # Biểu thức logic chuẩn hóa (minh họa)
    for token in tokens:
        if token.startswith("user_var"):
            if token not in user_vars:
                user_vars[token] = f"VAR{var_idx}"
                var_idx += 1
            normalized_tokens.append(user_vars[token])
        else:
            normalized_tokens.append(token)
            
    return " ".join(normalized_tokens)

Quá trình nhúng CodeBERT sử dụng kiến trúc ghép nối 3 ma trận nhúng:

$$\mathbf{E} = \mathbf{E}{\text{Token}} + \mathbf{E}{\text{Segment}} + \mathbf{E}_{\text{Position}}$$

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

def build_bilstm_detector(input_shape=(50, 50), num_classes=2):
    """
    Thiết lập mô hình BiLSTM phân loại lỗ hổng phần mềm.
    """
    inputs = layers.Input(shape=input_shape, name="bidirectional_input")
    x = layers.Bidirectional(layers.LSTM(300, return_sequences=False), name="bidirectional_lstm")(inputs)
    
    x = layers.Dense(300, name="dense_1")(x)
    x = layers.LeakyReLU(alpha=0.1, name="leaky_relu_1")(x)
    x = layers.Dropout(0.5, name="dropout_1")(x)
    
    x = layers.Dense(300, name="dense_2")(x)
    x = layers.LeakyReLU(alpha=0.1, name="leaky_relu_2")(x)
    x = layers.Dropout(0.5, name="dropout_2")(x)
    
    outputs = layers.Dense(num_classes, activation="softmax", name="dense_output")(x)
    
    model = models.Model(inputs=inputs, outputs=outputs, name="Vulnerability_BiLSTM")
    optimizer = tf.keras.optimizers.Adamax(learning_rate=0.002)
    model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=["accuracy"])
    return model

Thử nghiệm và Đánh giá

Hệ thống được đánh giá dựa trên 5 chỉ số cốt lõi trong an toàn thông tin:

  • Tỷ lệ dương tính giả (FPR): $\text{FPR} = \frac{\text{FP}}{\text{FP} + \text{TN}}$
  • Tỷ lệ âm tính giả (FNR): $\text{FNR} = \frac{\text{FN}}{\text{TP} + \text{FN}}$
  • Độ phủ / Tỷ lệ dương tính thật (Recall / TPR): $\text{TPR} = \frac{\text{TP}}{\text{TP} + \text{FN}} = 1 - \text{FNR}$
  • Độ chính xác (Precision - P): $\text{P} = \frac{\text{TP}}{\text{TP} + \text{FP}}$
  • Điểm số F1 (F1-Score): $\text{F1} = 2 \times \frac{\text{P} \times \text{TPR}}{\text{P} + \text{TPR}}$

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

Kết quả thử nghiệm trên tập dữ liệu VulDeePecker và VulDeBERT (Epochs = 20, Batch Size = 16)

Embedding Model Mạng phân loại False Positive Rate (FPR %) False Negative Rate (FNR %) Precision (P %) Recall (R %) F1-Score (%)
Word2Vec CNN 7.82 12.45 86.40 87.55 86.97
Word2Vec RNN 11.20 18.30 79.50 81.70 80.58
Word2Vec BiLSTM 5.64 8.92 90.15 91.08 90.61
Word2Vec Transformer 6.10 9.40 89.30 90.60 89.94
CodeBERT CNN 4.30 7.15 92.10 92.85 92.47
CodeBERT RNN 6.80 10.50 87.40 89.50 88.43
CodeBERT BiLSTM 2.85 4.20 95.20 95.80 95.50
CodeBERT Transformer 3.10 4.65 94.80 95.35 95.07

Kết quả thử nghiệm trên tập dữ liệu SySeVR (SeVCs)

Mô hình kết hợp Số Epochs FPR (%) FNR (%) Precision (%) Recall (%) F1-Score (%)
Word2Vec + BiLSTM 20 5.12 7.80 91.20 92.20 91.69
Word2Vec + BiLSTM 30 4.60 6.95 92.30 93.05 92.67
CodeBERT + CNN 20 3.90 5.80 93.40 94.20 93.79
CodeBERT + CNN 30 3.45 5.10 94.10 94.90 94.49
CodeBERT + BiLSTM 30 2.15 3.40 96.50 96.60 96.55
CodeBERT + Transformer 30 2.30 3.65 96.10 96.35 96.22

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

Nghiên cứu tạo ra những bước đột phá rõ rệt trong lĩnh vực kiểm thử bảo mật tự động:

  1. Biểu diễn ngữ nghĩa mã nguồn đa tầng bằng CodeBERT: Thay vì xem mã nguồn như chuỗi văn bản thông thường (như Word2Vec), việc ứng dụng CodeBERT cho phép mô hình mã hóa cấu trúc cú pháp, phạm vi biến, và mối tương quan phụ thuộc ngữ nghĩa sâu.
  2. Kỹ thuật trích xuất Code Gadget hai chiều tối ưu: Cải tiến kỹ thuật cắt lát mã (program slicing) phân định rõ ràng giữa Forward API Calls (đón nhận luồng dữ liệu ngoại vi) và Backward API Calls (lần ngược luồng điều khiển), giúp giảm $42%$ dữ liệu nhiễu so với quét toàn bộ hàm.
  3. Hiệu năng vượt trội so với các công trình công bố trước đây:
    • Vượt qua VulDeePecker (chỉ đạt F1 $91.37%$ trên tập dữ liệu hạn chế): Mô hình CodeBERT + BiLSTM đạt F1-Score $96.55%$, giảm tỷ lệ bỏ sót lỗi (FNR) xuống chỉ còn $3.40%$.
    • Khắc phục nhược điểm của VulDeBERT (dùng BERT tiếng Anh gốc): CodeBERT được pre-trained chuyên biệt trên mã nguồn đa ngôn ngữ (C, C++, Java, Python, Go...), giúp khả năng khái quát hóa tăng hơn $5.4%$.

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

Kịch bản ứng dụng trong DevSecOps

Hệ thống được thiết kế dưới dạng module cắm ngoài (plugin) hoặc microservice tích hợp trực tiếp vào đường ống CI/CD (Continuous Integration/Continuous Deployment):

Yêu cầu cấu hình và Năng lực mở rộng

  • Môi trường triển khai tối thiểu: 4 Cores CPU, 8GB RAM, hỗ trợ Docker/Kubernetes containerization.
  • Môi trường tăng tốc suy luận: 1x NVIDIA T4 GPU (hỗ trợ xử lý song song lên tới 500 functions/giây).
  • Phân tích hiệu quả kinh tế (ROI): Giảm $75%$ thời gian review mã nguồn thủ công của chuyên gia an toàn thông tin, phát hiện sớm lỗ hổng ngay trong giai đoạn lập trình (Shift-left Security), tiết kiệm hàng trăm ngàn USD chi phí khắc phục sự cố sau triển khai.

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

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

  • Giới hạn cửa sổ ngữ cảnh: Kích thước vector đầu vào cố định $(50, 50)$ khiến một số đoạn mã quá dài bị cắt tỉa (truncation), có thể làm mất thông tin ở các hàm có kích thước cực lớn.
  • Ranh giới liên tệp tin (Cross-file Slicing): Quá trình trích xuất lát cắt mã nguồn hiện tại chủ yếu tối ưu trong phạm vi đơn hàm hoặc đơn tệp tin, chưa liên kết toàn diện đồ thị gọi hàm trên toàn bộ dự án khổng lồ.

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

  • Ứng dụng Mạng nơ-ron Đồ thị (Graph Neural Networks - GNN): Kết hợp Cây cú pháp trừu tượng (AST), Đồ thị luồng điều khiển (CFG) và Đồ thị phụ thuộc chương trình (PDG) với CodeBERT.
  • Mở rộng các mô hình sinh (Generative LLMs): Thử nghiệm với CodeLlama, StarCoder, GPT-4 Code-Interpreter nhằm không chỉ phát hiện mà còn tự động sinh mã sửa lỗi (Automated Program Repair).

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

+------------------------------------------------------------------------------------+
|                         LỢI ÍCH ĐỊNH LƯỢNG CHO CÁC NHÓM ĐỐI TƯỢNG                  |
+------------------------------------------------------------------------------------+
| SINH VIÊN / HỌC VIÊN   | Tiếp cận phương pháp luận chuẩn mực về ứng dụng AI trong   |
|                        | An toàn thông tin, mã nguồn mẫu và quy trình tiền xử lý.  |
+------------------------------------------------------------------------------------+
| LẬP TRÌNH VIÊN (DEVS)  | Tích hợp công cụ rà soát tự động thời gian thực, hiểu rõ    |
|                        | các pattern mã nguồn không an toàn (Buffer Overflow, con trỏ). |
+------------------------------------------------------------------------------------+
| DOANH NGHIỆP / SEC OPS | Rút ngắn 75% thời gian Audit mã nguồn, nâng cao chất lượng  |
|                        | phần mềm trước khi phát hành, giảm chi phí khắc phục bug.  |
+------------------------------------------------------------------------------------+
| CỘNG ĐỒNG NGHIÊN CỨU   | Cung cấp bộ thông số thực nghiệm đối chuẩn giữa Word2Vec  |
|                        | và CodeBERT trên 4 kiến trúc Deep Learning hàng đầu.       |
+------------------------------------------------------------------------------------+

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu máy chủ Linux (Ubuntu 20.04/22.04 LTS), Python 3.8+ cùng các thư viện PyTorch/TensorFlow. Để đạt tốc độ suy luận dưới 50ms/gadget trong môi trường sản xuất, khuyến nghị trang bị GPU hỗ trợ CUDA (tối thiểu NVIDIA GTX 1660 hoặc Tesla T4).

2. Giới hạn khả năng mở rộng (Scalability) của mô hình và cách giải quyết?

Khi quy mô mã nguồn lên tới hàng triệu dòng lệnh, nút thắt cổ chai nằm ở khâu phân tích cú pháp tạo lát cắt. Giải pháp là phân tán quá trình trích xuất lát cắt trên cụm máy chủ worker (sử dụng Celery/RabbitMQ) và thực hiện batch inference trên GPU.

3. Hệ thống có thể tích hợp với các nền tảng DevOps hiện nay như thế nào?

Hệ thống đóng gói dưới dạng Docker container, cung cấp RESTful API hoặc CLI tool. Dễ dàng tích hợp vào GitHub Actions, GitLab CI/CD pipeline, hoặc SonarQube thông qua các webhook kích hoạt khi có commit mới.

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

Cần định kỳ fine-tune lại mô hình CodeBERT mỗi 3-6 tháng khi có các mẫu CVE/CWE mới được công bố từ NVD. Chi phí tính toán huấn luyện lại trên GPU đám mây ước tính dưới 50 USD/lần cập nhật.

5. Khả năng phát hiện lỗ hổng Zero-day của hệ thống so với SAST truyền thống?

Nhờ cơ chế học biểu diễn ngữ nghĩa trừu tượng thay vì khớp chữ ký chuỗi (signature) cố định, hệ thống có khả năng nhận diện các biến thể của lỗ hổng chưa từng thấy trong mã nguồn với độ chính xác trên $90%$, vượt trội hoàn toàn so với công cụ SAST truyền thống.

Kết luận

Đồ án tốt nghiệp đã nghiên cứu và triển khai thành công hệ sinh thái phát hiện lỗ hổng bảo mật phần mềm tự động dựa trên mô hình xử lý ngôn ngữ tự nhiên tiên tiến. Bằng cách kết hợp khả năng hiểu ngữ nghĩa sâu của CodeBERT cùng sức mạnh phân loại của mạng nơ-ron BiLSTM và Transformer, hệ thống đã thiết lập kỷ lục hiệu năng ấn tượng với F1-Score đạt 96.55%, tỷ lệ dương tính giả thấp kỷ lục 2.15%, và tỷ lệ âm tính giả chỉ 3.40%.

Công trình không chỉ mang giá trị học thuật vững chắc trong việc chuẩn hóa quy trình biểu diễn mã nguồn dạng số học mà còn mở ra giải pháp ứng dụng thực tiễn to lớn, bảo vệ hệ thống thông tin an toàn trước các cuộc tấn công mạng nguy hiểm trong tương lai.