Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và phát triển phần mềm quy mô lớn, an toàn thông tin đã trở thành yếu tố sống còn đối với mọi tổ chức và doanh nghiệp. Theo thống kê từ cơ sở dữ liệu lỗ hổng bảo mật quốc gia (NVD - National Vulnerability Database) và tổ chức MITRE, số lượng lỗ hổng và phơi nhiễm phổ biến (CVE - Common Vulnerabilities and Exposures) được công bố hàng năm liên tục tăng trưởng theo cấp số nhân, trong đó các lỗ hổng có điểm đánh giá mức độ nghiêm trọng CVSS (Common Vulnerability Scoring System) ở mức Cao (7.0 - 8.9) và Nghiêm trọng (9.0 - 10.0) chiếm tỷ trọng đáng kể.

Các lỗi vi phạm an toàn bộ nhớ (Memory Safety) như tràn bộ đệm (Buffer Overflow), rò rỉ bộ nhớ (Memory Leak), điều kiện tranh định (Race Condition) hay lỗi xác thực đầu vào (Input Validation) có thể bị tin tặc khai thác để leo thang đặc quyền (Privilege Escalation), gây từ chối dịch vụ (DoS) hoặc chiếm quyền điều khiển hệ thống.

       +-------------------------------------------------------------+
       |                  Thực trạng lỗ hổng phần mềm                |
       |  - Hơn 19,000+ lỗ hổng mức độ Nghiêm trọng (CVSS 9.0 - 10.0)|
       |  - Các công cụ SAST truyền thống: Tỷ lệ báo giả (FPR) > 40% |
       |  - Chi phí vá lỗi tại giai đoạn vận hành cao gấp 30 lần SDLC|
       +-------------------------------------------------------------+

Vấn đề cốt lõi nằm ở chỗ các phương pháp kiểm tra mã nguồn tĩnh truyền thống (Static Application Security Testing - SAST) dựa trên so khớp mẫu từ vựng (Pattern Matching) hoặc tập luật cú pháp (Rule-based AST) bộc lộ nhược điểm nghiêm trọng: tỷ lệ dương tính giả (False Positive) và âm tính giả (False Negative) rất cao do không nắm bắt được ngữ cảnh ngữ nghĩa (Semantic Context) phức tạp của mã nguồn.

Đồ án tốt nghiệp đại học ngành Công nghệ Thông tin tại Học viện Công nghệ Bưu chính Viễn thông với đề tài "Phát hiện lỗ hổng sử dụng phương pháp xử lý ngôn ngữ tự nhiên" (Thực hiện: Sinh viên Phạm Ngọc Quân - Lớp D17CQAT02-B; Cán bộ hướng dẫn: TS. Đỗ Xuân Chợ) đã tập trung giải quyết triệt để bài toán này. Đồ án đề xuất cách tiếp cận chuyển đổi mã nguồn thành chuỗi token ngữ nghĩa và ứng dụng các mô hình Học sâu kết hợp Xử lý ngôn ngữ tự nhiên (Natural Language Processing - NLP) tiên tiến như Word2Vec kết hợp LSTM/BiLSTM và mô hình ngôn ngữ ngữ cảnh hai chiều BERT nhằm tự động nhận diện và phân loại lỗ hổng phần mềm với độ chính xác cao.

Mục tiêu dự án

  1. Hệ thống hóa cơ sở lý thuyết: Phân tích toàn diện cấu trúc lỗ hổng bảo mật, cơ chế đánh giá CVSS/CVE và đánh giá giới hạn của các kỹ thuật phân tích tĩnh (Static Analysis) và phân tích động (Dynamic Analysis).
  2. Xây dựng quy trình tiền xử lý mã nguồn chuyên biệt: Thiết kế pipeline trích xuất, khử nhiễu (loại bỏ comment, chuẩn hóa biến/hàm) và phân tách mã nguồn thành chuỗi từ/từ con (Tokenization).
  3. Hiện thực hóa và huấn luyện các mô hình NLP chuyên sâu: Triển khai mô hình Word2Vec (Skip-gram) kết hợp mạng nơ-ron hồi quy LSTM, BiLSTM và tinh chỉnh (Fine-tuning) mô hình Transformer (BERT).
  4. Đánh giá và tối ưu hóa thực nghiệm: Đo lường hiệu năng trên tập dữ liệu chuẩn CWE/SARD, so sánh độ chính xác giữa các kiến trúc học sâu nhằm tìm ra mô hình tối ưu cho triển khai thực tế.

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

  • Phạm vi nghiên cứu: Phân tích mã nguồn C/C++/Java tập trung vào các lớp lỗ hổng bộ nhớ kinh điển (CWE-121, CWE-119, CWE-401) và lỗi xác thực dữ liệu đầu vào.
  • Giới hạn kỹ thuật: Mô hình xử lý ở cấp độ hàm/tệp mã nguồn đơn lập (Function/File level), chưa mở rộng toàn diện sang phân tích liên thủ tục phức tạp (Inter-procedural Data Flow) trên toàn bộ hệ thống phân tán.

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

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

Các công cụ phân tích tĩnh truyền thống hiện nay chủ yếu hoạt động dựa trên ba nguyên lý: so khớp chuỗi (Grep-like), phân tích từ vựng (Lexical Analysis) và duyệt cây cú pháp trừu tượng (Abstract Syntax Tree - AST).

Phương pháp / Công cụ Cơ chế hoạt động Ưu điểm Nhược điểm & Tỷ lệ sai số
So khớp mẫu (Grep) Tìm kiếm chuỗi hàm nguy hiểm (strcpy, gets) Tốc độ quét cực nhanh, dễ cấu hình Không hiểu ngữ cảnh; tỷ lệ dương tính giả (FPR) > 60%
Lexical Scan (Flawfinder, ITS4, RATS) Phân tách Lexer token, tra cứu từ điển quy tắc rủi ro Phát hiện nhanh các điểm gọi API thiếu an toàn Không theo dõi được luồng dữ liệu; bỏ sót lỗi logic
AST Rule-Checking (Cppcheck, Splint) Xây dựng AST, duyệt cây kiểm tra vi phạm điều kiện Phân biệt được định danh biến và cấu trúc cú pháp Tập luật cứng nhắc; thời gian chạy lớn, khó mở rộng
Dynamic Taint / Fuzzing Thực thi chương trình với dữ liệu đầu vào biến dị Xác định chính xác lỗ hổng thực tế có thể khai thác Độ bao phủ mã nguồn thấp, đòi hỏi môi trường chạy hoàn chỉnh 
                                  KHOẢNG TRỐNG CÔNG NGHỆ
[Phân tích cú pháp thô]  ---->  [KHUYẾT THIẾU NGỮ NGHĨA]  <----  [Tập luật thủ công cứng nhắc]
                                          |
                                          v
                [Giải pháp NLP / Deep Learning: Học biểu diễn mã nguồn tự động]

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

  • Must Have (Bắt buộc có): Pipeline tiền xử lý mã nguồn loại bỏ comment/nhiễu; bộ biểu diễn vector Word2Vec (Skip-gram); mô hình phân loại chuỗi tuần tự BiLSTM; mô hình ngôn ngữ BERT Fine-tuned; phân loại đa lớp các mã CWE.
  • Should Have (Nên có): Tự động chuẩn hóa tên định danh người dùng đặt; xuất ma trận nhầm lẫn (Confusion Matrix) và biểu đồ ROC-AUC.
  • Could Have (Có thể có): Khả năng tích hợp mở rộng vào pipeline CI/CD dưới dạng webhook kiểm tra mã nguồn tự động.
  • Won't Have (Chưa thực hiện ở giai đoạn này): Tự động tạo bản vá sửa lỗi mã nguồn (Automated Program Repair).

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế theo mô hình đường ống (Pipeline-based Architecture) khép kín gồm 4 tầng chức năng:

graph TD
    A["Mã nguồn thô (C/C++/Java)"] --> B["Tầng Tiền xử lý & Khử nhiễu (Cleaning & Tokenization)"]
    B --> C["Tầng Nhúng biểu diễn (Embedding Layer)"]
    C --> D1["Nhánh 1: Word2Vec + LSTM / BiLSTM"]
    C --> D2["Nhánh 2: BERT Transformer Encoder"]
    D1 --> E["Tầng Phân loại (Dense + Softmax Layer)"]
    D2 --> E
    E --> F["Dự đoán xác suất Lỗ hổng (CWE Classes / Safe)"]

Technology Stack và phiên bản chi tiết

  • Ngôn ngữ lập trình: Python 3.8.12
  • Framework Học máy / Học sâu: PyTorch 1.10.0, TensorFlow 2.7.0, HuggingFace Transformers 4.15.0
  • Thư viện Xử lý ngôn ngữ & Nhúng từ: Gensim 4.1.2 (Word2Vec), NLTK 3.6.5, Tree-sitter 0.20.0
  • Phân tích dữ liệu & Đánh giá: Scikit-Learn 1.0.2, NumPy 1.21.4, Pandas 1.3.5
  • Môi trường phần cứng: NVIDIA GPU CUDA Compute 8.6, 16GB VRAM

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

Quy trình nghiên cứu áp dụng mô hình chuẩn CRISP-DM (Cross-Industry Standard Process for Data Mining) chuyên sâu cho dữ liệu mã nguồn:

  1. Thu thập dữ liệu: Trích xuất mẫu mã nguồn từ cơ sở dữ liệu NIST SARD và dự án mã nguồn mở chứa nhãn CVE/CWE.
  2. Tiền xử lý và chuẩn hóa: Loại bỏ ký tự thừa, bóc tách chuỗi token bằng trình phân tích từ vựng tùy biến.
  3. Huấn luyện mô hình: Triển khai huấn luyện song song mạng Word2Vec + BiLSTM và Fine-tuning BERT với cơ chế Attention.
  4. Kiểm thử và đánh giá: Đo lường theo các chỉ số F1-Score, Precision, Recall và ROC.

Implementation và kết quả

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

Mã nguồn thô được xử lý qua thuật toán làm sạch nhằm loại bỏ các thành phần gây sai lệch trong quá trình học máy:

/* Đoạn mã nguồn thô chứa lỗ hổng tràn bộ đệm CWE-121 */
void CWE121_Buffer_Overflow_badSink (void * data) {
    /* treating pointer as a char* when it may point to a wide string */
    size_t dataLen = strlen((char *)data);
    void * dest = (void *)ALLOCA((dataLen + 1) * sizeof(wchar_t));
    (void) wcscpy(dest, data);
    printLine((char *) dest);
}

Sau khi qua pipeline tiền xử lý, toàn bộ ghi chú bị loại bỏ, các ký tự phân cách toán tử và cú pháp ((, ), {, }, *, +) được tách rời thành các token độc lập:

Chuỗi Token chuẩn hóa:
void CWE121_Buffer_Overflow_badSink ( void * data ) { size_t dataLen = strlen ( ( char * ) data ) ; void * dest = ( void * ) ALLOCA ( ( dataLen + 1 ) * sizeof ( wchar_t ) ) ; ( void ) wcscpy ( dest , data ) ; printLine ( ( char * ) dest ) ; }

Kiến trúc các thuật toán cốt lõi

1. Mô hình Word2Vec (Skip-gram Architecture)

Mô hình Skip-gram học biểu diễn vector phân tán của token bằng cách tối đa hóa xác suất logarit của các từ ngữ cảnh trong cửa sổ $c$:

$$\arg\max_{\theta} \sum_{t=1}^{T} \sum_{-c \le j \le c, j \neq 0} \log P(w_{t+j} | w_t)$$

Trong đó hàm xác suất sử dụng Softmax chuẩn hóa ma trận trọng số ngữ cảnh $V$ và từ đích $U$:

$$P(w_O | w_I) = \frac{\exp(v_{w_O}^{\top} u_{w_I})}{\sum_{w=1}^{W} \exp(v_w^{\top} u_{w_I})}$$

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

BiLSTM khắc phục hiện tượng mất mát đạo hàm (Vanishing Gradient) và nắm bắt sự phụ thuộc xa theo cả hai chiều xuôi (Forward) và ngược (Backward) thông qua hệ thống cổng:

$$\begin{aligned} f_t &= \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \quad &&\text{(Cổng quên - Forget Gate)} \ i_t &= \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \quad &&\text{(Cổng vào - Input Gate)} \ \tilde{C}t &= \tanh(W_c \cdot [h{t-1}, x_t] + b_c) \quad &&\text{(Trạng thái ứng viên - Candidate State)} \ C_t &= f_t \odot C_{t-1} + i_t \odot \tilde{C}t \quad &&\text{(Cập nhật trạng thái tế bào - Cell State)} \ o_t &= \sigma(W_o \cdot [h{t-1}, x_t] + b_o) \quad &&\text{(Cổng ra - Output Gate)} \ h_t &= o_t \odot \tanh(C_t) \quad &&\text{(Trạng thái ẩn - Hidden State)} \end{aligned}$$

Vector đầu ra biểu diễn toàn diện chuỗi mã nguồn là sự kết hợp nối tiếp của hai luồng:

$$H_t = [\overrightarrow{h_t} \oplus \overleftarrow{h_t}]$$

import torch
import torch.nn as nn

class VulnerabilityBiLSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_classes, dropout=0.3):
        super(VulnerabilityBiLSTM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.bilstm = nn.LSTM(
            embedding_dim, 
            hidden_dim, 
            num_layers=2, 
            bidirectional=True, 
            batch_first=True, 
            dropout=dropout
        )
        self.fc = nn.Linear(hidden_dim * 2, num_classes)
        self.softmax = nn.LogSoftmax(dim=1)
        
    def forward(self, x):
        embedded = self.embedding(x)
        lstm_out, (hidden, cell) = self.bilstm(embedded)
        # Nối hidden state cuối cùng của 2 chiều
        hidden_cat = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)
        logits = self.fc(hidden_cat)
        return self.softmax(logits)

3. Mô hình BERT (Bidirectional Encoder Representations from Transformers)

BERT sử dụng kiến trúc Multi-Head Self-Attention để gán trọng số tương quan giữa mọi cặp token trong mã nguồn bất kể khoảng cách:

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V$$

Kết quả thử nghiệm và đánh giá thực nghiệm

Thử nghiệm được thực hiện trên 3 kịch bản chính với bộ dữ liệu chuẩn hóa gồm hàng chục nghìn đoạn mã gán nhãn:

  • Kịch bản 1: Đánh giá khả năng phân loại nhị phân (Vulnerable vs Safe).
  • Kịch bản 2: Phân loại đa lớp các dòng lỗ hổng phổ biến (Buffer Overflow, Memory Leak, Resource Management Errors).
  • Kịch bản 3: Đánh giá độ bền vững và tốc độ suy luận khi tinh chỉnh tham số độ dài chuỗi đầu vào.
Mô hình thử nghiệm Accuracy (%) Precision (%) Recall (%) F1-Score (%) ROC-AUC
Rule-based AST Checker 68.4% 58.2% 61.5% 59.8% 0.652
Flawfinder Baseline 64.1% 52.6% 74.3% 61.6% 0.638
Word2Vec + LSTM 82.7% 81.3% 80.9% 81.1% 0.884
Word2Vec + BiLSTM 89.5% 88.9% 89.2% 89.0% 0.941
BERT (Fine-tuned) 93.8% 93.2% 94.1% 93.6% 0.978 
                       BIỂU ĐỒ SO SÁNH F1-SCORE GIỮA CÁC MÔ HÌNH
[Rule-based AST]  ===> 59.8%
[Flawfinder]      ===> 61.6%
[W2V + LSTM]      =========> 81.1%
[W2V + BiLSTM]    ===================> 89.0%
[BERT Transformer]===========================> 93.6%

Kết quả thực nghiệm chứng minh mô hình BERT đạt hiệu năng cao nhất với F1-score đạt 93.6%, vượt trội hơn 32.0% so với công cụ phân tích từ vựng truyền thống Flawfinder và cải thiện 4.6% so với kiến trúc BiLSTM.

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

  1. Khắc phục triệt để điểm mù ngữ cảnh: Không dựa vào các biểu thức quy tắc cứng nhắc, mô hình học biểu diễn mã nguồn tự động thông qua vector nhúng đa chiều, giúp nhận diện các biến thể lỗ hổng tinh vi ngay cả khi tên biến hoặc cấu trúc rẽ nhánh bị thay đổi.
  2. Tối ưu hóa pipeline tiền xử lý mã nguồn: Thiết lập quy tắc phân tách token kết hợp bảo toàn ký hiệu cú pháp lập trình đặc thù của ngôn ngữ C/C++, giảm thiểu kích thước không gian từ vựng nhưng vẫn giữ nguyên vẹn ngữ nghĩa lệnh.
  3. Ứng dụng thành công cơ chế Học chuyển giao (Transfer Learning): Minh chứng tính khả thi vượt bậc của việc chuyển giao tri thức từ các mô hình ngôn ngữ lớn (LLMs/Transformers) sang bài toán an toàn mã nguồn, mở ra hướng nghiên cứu mới trong lĩnh vực DevSecOps và Trí tuệ nhân tạo phục vụ an ninh mạng.

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

Kịch bản ứng dụng thực tế (DevSecOps Integration)

Mô hình có thể đóng gói thành một vi dịch vụ (Microservice) thông qua Docker container và tích hợp trực tiếp vào quy trình kiểm soát mã nguồn liên tục (CI/CD Pipeline) trên GitHub Actions hoặc GitLab CI:

[Developer Push Code] 
        |
        v
[GitLab CI / GitHub Actions Trigger]
        |
        v
[Antigravity Vulnerability Scan Service (BERT/BiLSTM REST API)]
        |
        +---> [Phát hiện An toàn] --------> [Cho phép Merge / Deploy]
        |
        +---> [Phát hiện Lỗ hổng CWE] ---> [Chặn Pipeline & Cảnh báo dòng mã lỗi]

Phân tích chi phí - lợi ích (ROI)

  • Tiết kiệm thời gian rà soát: Giảm hơn 70% thời gian kiểm thử bảo mật thủ công (Manual Code Review) của các kỹ sư an ninh mạng.
  • Giảm chi phí xử lý sự cố: Việc phát hiện sớm lỗ hổng ngay trong giai đoạn lập trình (Shift-Left Security) giúp giảm thiểu chi phí khắc phục gấp 30 lần so với việc phát hành bản vá khẩn cấp sau khi hệ thống đã bị tấn công trên môi trường Production.

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

Hạn chế kỹ thuật

  • Độ dài chuỗi đầu vào bị giới hạn: Mô hình BERT tiêu chuẩn có giới hạn ngữ cảnh 512 token, gây thách thức khi phân tích các tệp mã nguồn dài hàng nghìn dòng nếu không áp dụng kỹ thuật chia nhỏ cửa sổ trượt (Sliding Window).
  • Phụ thuộc vào dữ liệu huấn luyện: Mô hình Word2Vec tự đào tạo trên tập dữ liệu cục bộ có thể gặp hiện tượng Out-Of-Vocabulary (OOV) đối với các thư viện bên thứ ba hoàn toàn mới.

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

  • Kết hợp Đồ thị luồng điều khiển (CFG), Đồ thị luồng dữ liệu (DFG) cùng Cây cú pháp trừu tượng (AST) với mô hình mạng nơ-ron đồ thị (Graph Neural Networks - GNN) để phân tích toàn diện mã nguồn theo cấu trúc không gian và ngữ nghĩa.
  • Tích hợp kiến trúc Transformer-XL hoặc Longformer để mở rộng chiều dài chuỗi xử lý lên đến 4096+ token mà không làm suy giảm hiệu năng bộ nhớ GPU.

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

  • Sinh viên & Học viên chuyên ngành ATTT/CNTT: Tài liệu tham khảo chuẩn mực về phương pháp luận kết hợp liên ngành giữa Trí tuệ nhân tạo (NLP/Deep Learning) và An toàn không gian mạng (Software Security).
  • Lập trình viên & Kỹ sư phần mềm: Nắm bắt các mẫu viết mã thiếu an toàn thường gặp, hiểu rõ cơ chế phát sinh lỗ hổng bộ nhớ và cách thức các công cụ quét mã nguồn thông minh hoạt động.
  • Doanh nghiệp & Đội ngũ DevSecOps: Sở hữu cơ sở lý thuyết và giải pháp kiến trúc khả thi để tự động hóa quy trình rà soát an ninh mã nguồn với độ chính xác cao và chi phí tối ưu.
  • Nhà nghiên cứu khoa học: Điểm tựa thực nghiệm và nguồn dữ liệu đối chuẩn đáng tin cậy để tiếp tục phát triển các mô hình học sâu lai (Hybrid Deep Learning Models) cho bài toán phân tích lỗ hổng phức tạp.

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ì?

Đối với môi trường huấn luyện lại (Training), hệ thống cần tối thiểu 1 GPU chuyên dụng (VRAM từ 8GB trở lên như NVIDIA RTX 3060/T4) và 16GB RAM hệ thống. Đối với môi trường suy luận (Inference) phục vụ quét mã thực tế, mô hình có thể chạy ổn định trên CPU tiêu chuẩn đa nhân (Intel Core i7 / AMD Ryzen 7 hoặc CPU Cloud 4 vCPU) với độ trễ dưới 200ms cho mỗi tệp mã nguồn.

2. Làm thế nào mô hình xử lý được các biến và hàm do người dùng tự đặt tên?

Trong giai đoạn tiền xử lý, hệ thống sử dụng thuật toán chuẩn hóa định danh (Identifier Normalization), thay thế các tên biến và hàm tùy biến không thuộc thư viện chuẩn thành các token trừu tượng có tính quy luật (ví dụ: var_1, func_1), giúp mô hình tập trung học logic cấu trúc cú pháp thay vì bị phụ thuộc vào tên gọi cụ thể.

3. Phương pháp này có thay thế hoàn toàn chuyên gia rà soát mã nguồn không?

Không. Phương pháp đóng vai trò là một trợ lý đắc lực tự động hóa rà soát ở quy mô lớn với tốc độ cao, giúp phát hiện và lọc bỏ hơn 90% các lỗi bảo mật phổ biến. Các chuyên gia an ninh mạng vẫn đóng vai trò quyết định trong việc thẩm định các lỗ hổng logic nghiệp vụ cấp cao (Business Logic Flaws) phức tạp.

4. Mô hình có khả năng nhận diện các lỗ hổng Zero-day không?

Nhờ khả năng học khái quát hóa (Generalization) các mẫu ngữ cảnh và dòng chảy dữ liệu thay vì ghi nhớ chữ ký tĩnh (Signature), mô hình có khả năng phát hiện các biến thể lỗ hổng mới (Zero-day variants) có cơ chế hoạt động tương đồng với các lớp CWE đã biết.

5. Chi phí và thời gian triển khai giải pháp vào hệ thống thực tế mất bao lâu?

Sử dụng các mô hình đã được huấn luyện sẵn (Pre-trained/Fine-tuned weights), thời gian tích hợp hệ thống dưới dạng Docker Microservice vào pipeline CI/CD chỉ mất từ 2 đến 3 ngày làm việc với chi phí bản quyền mã nguồn mở hoàn toàn miễn phí.

Kết luận

Đồ án tốt nghiệp "Phát hiện lỗ hổng sử dụng phương pháp xử lý ngôn ngữ tự nhiên" của sinh viên Phạm Ngọc Quân dưới sự hướng dẫn của TS. Đỗ Xuân Chợ đã chứng minh tính đúng đắn và hiệu quả vượt bậc của việc ứng dụng Xử lý ngôn ngữ tự nhiên và Học sâu vào lĩnh vực An toàn bảo mật phần mềm.

Bằng việc kết hợp chặt chẽ giữa xử lý từ vựng nâng cao, kiến trúc BiLSTM hai chiều và sức mạnh biểu diễn ngữ cảnh của Transformer BERT, giải pháp đã vượt qua những giới hạn cố hữu của các công cụ SAST truyền thống, đạt độ chính xác 93.8% và F1-score 93.6%. Đây là nền tảng công nghệ quan trọng, sẵn sàng mở rộng và tích hợp vào các nền tảng phát triển phần mềm hiện đại nhằm xây dựng các hệ sinh thái ứng dụng an toàn và bền vững.