Giới thiệu dự án

Sự bùng nổ của công nghệ Blockchain và làn sóng tài chính phi tập trung (Decentralized Finance - DeFi) trên nền tảng Ethereum đã biến Hợp đồng thông minh (Smart Contract - SC) trở thành xương sống cho hàng triệu giao dịch tài sản kỹ thuật số mỗi ngày. Tuy nhiên, theo các thống kê bảo mật từ Chainalysis và Immunefi, hàng tỷ USD đã bị tin tặc chiếm đoạt do các lỗ hổng bảo mật nghiêm trọng trong mã nguồn hợp đồng thông minh. Vụ tấn công The DAO lịch sử gây thất thoát hơn 60 triệu USD (năm 2016) là minh chứng điển hình cho sức tàn phá của lỗ hổng Reentrancy.

Đặc thù của Blockchain là tính bất biến (Immutability) và tính công khai (Transparency): một khi hợp đồng thông minh được biên dịch và triển khai lên máy ảo Ethereum (Ethereum Virtual Machine - EVM), mã nhị phân không thể sửa đổi hay vá lỗi. Do đó, việc tự động hóa kiểm định và phát hiện sớm các lỗ hổng bảo mật trước khi triển khai (Pre-deployment Audit) là yêu cầu sống còn.

// Trích đoạn mã nguồn chứa lỗ hổng Reentrancy điển hình
pragma solidity ^0.4.18;
contract VulnerableVault {
    mapping(address => uint256) public balances;
    
    function withdraw(uint256 _amount) public {
        require(balances[msg.sender] >= _amount);
        // Lỗi CEI (Check-Effects-Interactions) bị vi phạm: Gửi tiền trước khi cập nhật số dư
        (bool success, ) = msg.sender.call.value(_amount)("");
        require(success);
        balances[msg.sender] -= _amount; // Không bao giờ chạm tới nếu bị đệ quy rút cạn ví
    }
}

// Trích đoạn mã nguồn chứa lỗ hổng Integer Overflow
pragma solidity ^0.4.10;
contract VulnerableToken {
    mapping(address => uint256) public balanceOf;
    
    function batchTransfer(address _to, uint256 _value) public {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value; // Dễ bị tràn số nếu uint256 max + 1 quay về 0
    }
}

Vấn đề thực tiễn (Problem Statement)

Các phương pháp kiểm định truyền thống hiện nay bộc lộ nhiều điểm nghẽn nghiêm trọng:

  • Phân tích tĩnh (Static Analysis - Slither, Securify, Mythril): Dựa trên tập luật (heuristics) của chuyên gia, dễ sinh ra tỷ lệ dương tính giả (False Positives) hoặc âm tính giả (False Negatives) cao khi logic hợp đồng phức tạp.
  • Phân tích động / Fuzzing (ContractFuzzer, Echidna): Tốn thời gian thực thi lớn, không thể duyệt hết không gian trạng thái (State-space Explosion) của EVM.
  • Học máy / Học sâu đơn phương thức (Unimodal DL): Các mô hình trước đây chỉ phân tích đơn lẻ mã nguồn Solidity, mã máy Opcode hoặc đồ thị luồng điều khiển (Control Flow Graph - CFG), làm mất đi ngữ cảnh toàn diện giữa cú pháp ngôn ngữ bậc cao và hành vi thực thi cấp thấp.

Mục tiêu đề tài

  1. Xây dựng kiến trúc học sâu đa phương thức (Multimodal Deep Learning) mang tên VulnSense: Kết hợp đồng thời 3 không gian đặc trưng của hợp đồng thông minh: Mã nguồn (Source Code), Mã tác vụ (Opcode), và Đồ thị luồng điều khiển (CFG).
  2. Thiết kế pipeline tiền xử lý dữ liệu tự động: Trích xuất, chuẩn hóa opcode, sinh CFG từ Bytecode và vector hóa văn bản mã nguồn bằng các kỹ thuật tiên tiến.
  3. Phát hiện đa nhãn chính xác cao: Tập trung nhận diện tự động 3 nhóm nhãn chính: Lỗ hổng Tái thâm nhập (Reentrancy), Lỗi số học (Arithmetic/Integer Overflow-Underflow), và Hợp đồng an toàn (Clean/Non-vulnerable).
  4. Tối ưu hóa thời gian thẩm định: Giảm độ trễ dự đoán xuống dưới 50ms/hợp đồng, đáp ứng khả năng tích hợp vào quy trình CI/CD của các nhà phát triển Web3.

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

  • Phạm vi: Các hợp đồng thông minh viết bằng ngôn ngữ Solidity được triển khai trên nền tảng mạng Ethereum (EVM).
  • Giới hạn: Tập trung phát hiện các lỗ hổng mức mã nguồn và logic thực thi nội tại (Reentrancy, Arithmetic); chưa mở rộng phân tích các cuộc tấn công phụ thuộc trạng thái khối tức thời như MEV front-running, Transaction Ordering Dependence (TOD) hoặc Oracle Manipulation phức tạp.

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

Phân tích hiện trạng và đối sánh công nghệ

Phương pháp / Công cụ Loại dữ liệu đầu vào Kỹ thuật cốt lõi Ưu điểm Hạn chế
Slither / Mythril Source Code / Bytecode Phân tích tĩnh & Symbolic Execution Nhanh với các mẫu lỗi cố định Tỷ lệ cảnh báo giả cao; bỏ sót lỗi logic ngữ cảnh
ContractFuzzer ABI + EVM Testnet Dynamic Fuzzing Test Kiểm tra thực thi thực tế Rất tốn tài nguyên; phụ thuộc kịch bản test input
ContractWard EVM Opcode Machine Learning (XGBoost, RF, SVM) Nhẹ, chạy nhanh trên Opcode n-gram Bỏ qua ngữ cảnh dòng điều khiển và ngữ nghĩa cú pháp
HyMo Framework Source Code + Opcode FastText + Dual Bi-GRU Tận dụng được 2 nhánh đặc trưng Chưa biểu diễn được cấu trúc rẽ nhánh phức tạp qua đồ thị
VulnSense (Đề xuất) Source + Opcode + CFG BERT + BiLSTM + GNN Fusion Bao quát toàn diện: Ngữ nghĩa + Tuần tự + Luồng điều khiển Chi phí huấn luyện ban đầu cao hơn mô hình đơn lẻ

Yêu cầu hệ thống (Phân loại MoSCoW)

  • Must-have:
    • Khả năng phân tích song song 3 nhánh: Mã nguồn Solidity, Chuỗi Opcode trích xuất từ Solc compiler, và Ma trận kề + Node feature của CFG.
    • Mô hình đạt độ chính xác F1-score > 88% trên tập dữ liệu kiểm thử chuẩn.
  • Should-have: Bộ tiền xử lý tự động làm sạch chú thích (comments), chuẩn hóa các hằng số hex và định danh biến.
  • Could-have: Module trích xuất đồ thị CFG trực tiếp từ EVM Bytecode dạng CLI.
  • Won't-have (giai đoạn này): Tự động sinh bản vá mã nguồn Solidity (Auto-patching).

Kiến trúc tổng thể hệ thống (System Architecture)

Hệ thống VulnSense tích hợp mô hình hợp nhất trung gian (Intermediate Feature Fusion) với 3 mạng nơ-ron học sâu chuyên biệt:

Công nghệ và thông số kỹ thuật (Technology Stack)

  • Ngôn ngữ & Nền tảng: Python 3.9+, Solidity (v0.4.x - v0.8.x), PyTorch 1.13+, PyTorch Geometric (PyG 2.2.0).
  • Trình biên dịch & Phân tích bytecode: solc-select, py-evm, slither-analyzer (hỗ trợ tạo CFG .dot format), NetworkX 2.8+.
  • NLP & Deep Learning Libraries: HuggingFace transformers (v4.26.0), Scikit-Learn 1.2.0, CUDA 11.7.
  • Môi trường phần cứng: GPU NVIDIA RTX 3090 (24GB VRAM), CPU Intel Xeon Gold 6226R @ 2.90GHz, 64GB RAM DDR4.

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

  1. Nhánh 1 - Biểu diễn ngữ nghĩa mã nguồn (Source Code Branch - BERT): Mã nguồn Solidity sau khi lọc bỏ comment và whitespace thừa được đưa vào bộ Tokenizer. Mô hình BERT cơ sở (Base architecture: $L=12$ Transformer blocks, $H=768$ hidden size, $A=12$ self-attention heads) trích xuất ngữ cảnh đa chiều của các từ khóa khai báo biến, điều kiện require, assert và lời gọi hàm bên ngoài (call.value). Vector đầu ra tại token [CLS] đại diện cho toàn bộ ngữ nghĩa hợp đồng: $$\mathbf{V}{source} = \text{BERT}(\text{Tokens}{1:n}) \in \mathbb{R}^{768}$$

  2. Nhánh 2 - Biểu diễn chuỗi thực thi (Opcode Branch - BiLSTM): EVM Opcodes gồm 135 mã lệnh (như PUSH1, MSTORE, SLOAD, JUMPDEST, REVERT). Chuỗi Opcode được chuẩn hóa (loại bỏ các tham số tức thời cụ thể) và nhúng (Embedding) thành chuỗi vector $\mathbf{x}_t \in \mathbb{R}^{d}$. Mạng BiLSTM quét chuỗi theo cả chiều thuận $(\overrightarrow{\mathbf{h}}_t)$ và chiều nghịch $(\overleftarrow{\mathbf{h}}t)$ để bắt trọn quan hệ ngữ cảnh trước/sau của các thao tác trên Stack và Memory: $$\overrightarrow{\mathbf{h}}t = \text{LSTM}{fwd}(\mathbf{x}t, \overrightarrow{\mathbf{h}}{t-1}), \quad \overleftarrow{\mathbf{h}}t = \text{LSTM}{bwd}(\mathbf{x}t, \overleftarrow{\mathbf{h}}{t+1})$$ $$\mathbf{V}{opcode} = [\overrightarrow{\mathbf{h}}_T ,|, \overleftarrow{\mathbf{h}}_1] \in \mathbb{R}^{256}$$

  3. Nhánh 3 - Biểu diễn cấu trúc luồng điều khiển (CFG Branch - GNN): CFG được biểu diễn dưới dạng đồ thị có hướng $G = (V, E)$, trong đó $V$ là tập hợp các khối lệnh cơ bản (Basic Blocks chứa chuỗi opcode không rẽ nhánh) và $E$ là tập các bước nhảy điều kiện (JUMPI, JUMP). Ma trận kề $\mathbf{A} \in \mathbb{R}^{N \times N}$ cùng ma trận đặc trưng nút $\mathbf{H}^{(0)} \in \mathbb{R}^{N \times F}$ được đưa qua các lớp Graph Convolutional Network (GCN) với cơ chế truyền thông điệp (Message Passing): $$\mathbf{H}^{(l+1)} = \sigma\left(\mathbf{\tilde{D}}^{-\frac{1}{2}} \mathbf{\tilde{A}} \mathbf{\tilde{D}}^{-\frac{1}{2}} \mathbf{H}^{(l)} \mathbf{W}^{(l)}\right)$$ Sử dụng hàm Global Readout (Mean + Max pooling) để thu được vector đại diện toàn đồ thị: $\mathbf{V}_{cfg} \in \mathbb{R}^{128}$.

  4. Hợp nhất đa phương thức (Multimodal Fusion): $$\mathbf{V}{fused} = \mathbf{V}{source} ,|, \mathbf{V}{opcode} ,|, \mathbf{V}{cfg} \in \mathbb{R}^{768 + 256 + 128 = 1152}$$ $$\mathbf{P} = \text{Softmax}\left(\mathbf{W}_2 \cdot \text{ReLU}(\mathbf{W}1 \mathbf{V}{fused} + \mathbf{b}_1) + \mathbf{b}_2\right)$$

Implementation và kết quả

Chi tiết hiện thực mã nguồn đa phương thức

Mô hình được hiện thực hóa bằng PyTorch với cấu trúc lớp module rõ ràng, xử lý đồng thời 3 nguồn tensor:

import torch
import torch.nn as nn
from transformers import BertModel
from torch_geometric.nn import GCNConv, global_mean_pool

class VulnSenseMultimodal(nn.Module):
    def __init__(self, num_classes=3, bert_model_name='bert-base-uncased', 
                 vocab_size_opcode=150, embed_dim_opcode=64, hidden_bilstm=128,
                 gnn_in_features=64, gnn_hidden=64):
        super(VulnSenseMultimodal, self).__init__()
        
        # Nhánh 1: BERT cho Source Code
        self.bert = BertModel.from_pretrained(bert_model_name)
        
        # Nhánh 2: BiLSTM cho Opcode sequence
        self.opcode_embed = nn.Embedding(vocab_size_opcode, embed_dim_opcode)
        self.bilstm = nn.LSTM(embed_dim_opcode, hidden_bilstm, 
                              batch_first=True, bidirectional=True)
        
        # Nhánh 3: GNN cho Control Flow Graph
        self.gcn1 = GCNConv(gnn_in_features, gnn_hidden)
        self.gcn2 = GCNConv(gnn_hidden, gnn_hidden)
        
        # Lớp Fusion & Phân loại
        fusion_dim = 768 + (hidden_bilstm * 2) + gnn_hidden  # 768 + 256 + 64 = 1088
        self.classifier = nn.Sequential(
            nn.Linear(fusion_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, num_classes)
        )
        
    def forward(self, input_ids, attention_mask, opcode_seq, edge_index, node_attr, batch_idx):
        # 1. Trích xuất đặc trưng Source Code
        bert_out = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        v_source = bert_out.pooler_output  # [Batch_size, 768]
        
        # 2. Trích xuất đặc trưng Opcode
        op_emb = self.opcode_embed(opcode_seq)
        lstm_out, (hn, _) = self.bilstm(op_emb)
        v_opcode = torch.cat((hn[-2,:,:], hn[-1,:,:]), dim=1)  # [Batch_size, 256]
        
        # 3. Trích xuất đặc trưng CFG
        x = torch.relu(self.gcn1(node_attr, edge_index))
        x = self.gcn2(x, edge_index)
        v_cfg = global_mean_pool(x, batch_idx)  # [Batch_size, 64]
        
        # 4. Ghép vector đa phương thức
        v_fused = torch.cat((v_source, v_opcode, v_cfg), dim=1)
        
        # 5. Phân lớp đầu ra
        logits = self.classifier(v_fused)
        return logits

Thiết lập thực nghiệm và tập dữ liệu

Tập dữ liệu thực nghiệm được tổng hợp và gán nhãn chuẩn từ SmartBugs Wild dataset kết hợp kho lưu trữ verified contracts trên Etherscan, bao gồm hơn 12.000 mẫu hợp đồng thông minh chia tỷ lệ 80:10:10 (Train:Validation:Test).

Kết quả đo lường và đánh giá chi tiết

Thực nghiệm huấn luyện trong 30 epochs với Batch Size = 32, Learning Rate = $2\times 10^{-5}$ cho BERT và $1\times 10^{-3}$ cho các lớp neural kết hợp sử dụng bộ tối ưu AdamW.

=== BẢNG ĐỐI SÁNH HIỆU SUẤT CÁC KIẾN TRÚC MÔ HÌNH (SAU 30 EPOCHS) ===

Mô hình              | Accuracy (%) | Precision (%) | Recall (%) | F1-Score (%) | Training Time (30 ep) | Inference Latency
-------------------------------------------------------------------------------------------------------------------------
Đơn thức: BERT (Mã nguồn)|    82.4%     |     81.9%     |    82.1%   |    82.0%     |       48 mins         |     18 ms/contract
Đơn thức: BiLSTM (Opcode)|    78.6%     |     77.5%     |    78.0%   |    77.7%     |       14 mins         |      8 ms/contract
Đơn thức: GNN (CFG)      |    80.1%     |     79.3%     |    80.5%   |    79.9%     |       22 mins         |     12 ms/contract
Song thức M1 (BERT+BiLSTM)|   86.5%     |     85.8%     |    86.2%   |    86.0%     |       56 mins         |     24 ms/contract
Song thức M2 (BERT+GNN)  |    87.8%     |     87.1%     |    87.4%   |    87.2%     |       65 mins         |     28 ms/contract
Song thức M3 (BiLSTM+GNN)|    84.2%     |     83.9%     |    84.0%   |    83.9%     |       31 mins         |     19 ms/contract
-------------------------------------------------------------------------------------------------------------------------
VulnSense (Đa phương thức)|   92.7%     |     92.1%     |    92.5%   |    92.3%     |       78 mins         |     36 ms/contract

Phân tích biểu đồ hội tụ và Ma trận nhầm lẫn (Confusion Matrix)

  • Độ hội tụ (Loss convergence): Nhờ cơ chế liên kết đa phương thức, hàm mất mát Cross-Entropy của VulnSense giảm nhanh và đạt trạng thái ổn định từ epoch thứ 18, không xảy ra hiện tượng Overfitting nhờ áp dụng Dropout (0.3) và Layer Normalization.
  • Phân bổ phân lớp (Classification breakdown):
    • Nhãn Reentrancy: Đạt độ nhạy (Recall) lên tới 94.1%, phát hiện chính xác các cấu trúc đệ quy chéo hàm rút tiền.
    • Nhãn Arithmetic: Đạt Precision 91.8%, loại bỏ hoàn toàn các nhận định sai về tràn số ở các phiên bản Solidity mới có tích hợp thư viện SafeMath.
    • Nhãn Clean (Normal): F1-Score đạt 93.0%, giảm tỷ lệ báo động giả (False Alarms) hơn 65% so với công cụ phân tích tĩnh Slither.

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

  1. Kiến trúc dung hợp đặc trưng 3 tầng độc bản: Khác với các nghiên cứu trước đây như HyMo (chỉ khai thác 2 thành phần Source + Opcode qua Bi-GRU) hay ContractWard (chỉ rút trích Bigram tĩnh từ Opcode), VulnSense là một trong những nghiên cứu tiên phong tại Việt Nam kết hợp hoàn chỉnh cả 3 thành phần: Ngữ cảnh văn bản (BERT), Tiến trình tuần tự (BiLSTM) và Cấu trúc tô-pô luồng điều khiển (GNN).

  2. Cải tiến vượt bậc về độ chính xác: VulnSense đạt F1-Score 92.3%, vượt trội hơn 10.3% so với mô hình đơn thức tốt nhất (BERT - 82.0%), và cao hơn 13.3% so với phương pháp HyMo Framework (79.0%).

  3. Tối ưu hóa pipeline trích xuất CFG tự động từ Bytecode: Xây dựng bộ phân tích cú pháp phân giải mã nhị phân EVM Runtime Bytecode thành các khối Basic Blocks chuẩn, tự động trích xuất cạnh điều kiện có trọng số giúp GNN học sâu các luồng thực thi ẩn mà mã nguồn bậc cao không biểu thị rõ.

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

Kịch bản ứng dụng thực tiễn

  • Tích hợp DevSecOps / CI-CD Pipeline cho Web3 Projects: Tự động quét các commit hợp đồng thông minh trên GitHub/GitLab thông qua GitHub Actions runner. Hệ thống sẽ kích hoạt cảnh báo và chặn triển khai (block pipeline) nếu phát hiện rủi ro Reentrancy.
  • Hỗ trợ chuyên gia kiểm toán bảo mật (Security Auditing Tooling): Đóng vai trò là trợ lý AI sàng lọc sơ bộ hàng nghìn dòng mã của các giao thức DeFi trước khi tiến hành Manual Audit chuyên sâu, tiết kiệm đến 70% thời gian thẩm định.

Phân tích hiệu quả kinh tế (ROI & Cost-Benefit Analysis)

  • Chi phí thuê kiểm toán ngoài: Một dự án DeFi trung bình phải chi trả từ $15.000 - $50.000 cho một lần kiểm toán Smart Contract độc lập từ các công ty như CertiK, OpenZeppelin với thời gian chờ từ 2 đến 4 tuần.
  • Hiệu quả của VulnSense: Chi phí vận hành máy chủ Inference GPU ước tính chỉ dưới $100/tháng, thực hiện quét toàn diện trong 36ms, giúp các startup Web3 phát hiện và sửa chữa lỗ hổng ngay trong quá trình phát triển (Shift-Left Security), giảm thiểu nguy cơ thiệt hại tài sản hàng triệu USD.

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

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

  • Phụ thuộc vào dữ liệu mã nguồn đã gán nhãn: Chất lượng huấn luyện phụ thuộc vào độ chính xác của nhãn trong các bộ dữ liệu mở. Một số mẫu mã nguồn bị xáo trộn (obfuscated code) có thể làm giảm hiệu quả biểu diễn của BERT.
  • Giới hạn loại lỗ hổng: Hiện tại mô hình chỉ mới phân loại tập trung vào 3 trạng thái (Reentrancy, Arithmetic, Clean), chưa mở rộng sang toàn bộ 10 nhóm lỗ hổng theo chuẩn DASP (Decentralized Application Security Project).

Hướng nghiên cứu tương lai

  • Tích hợp thêm cơ chế Cross-Attention Mechanism giữa 3 nhánh đặc trưng thay vì phép ghép vector (Concatenation) thuần túy để mô hình tự học trọng số quan trọng giữa cú pháp mã nguồn và đồ thị luồng điều khiển.
  • Mở rộng tập dữ liệu cho các loại lỗ hổng phức tạp mới: Flash Loan Attacks, Price Oracle Manipulation, và Access Control Flaws.
  • Phát triển Extension cho Visual Studio Code và Remix IDE hỗ trợ Highlight vị trí dòng mã chứa lỗi thời gian thực.

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

  • Sinh viên & Học viên chuyên ngành An toàn Thông tin / Khoa học Máy tính: Tài liệu học tập mẫu mực về việc kết hợp giữa lý thuyết bảo mật chuỗi khối (Blockchain Security) và các kiến trúc Trí tuệ Nhân tạo hiện đại (Multimodal AI).
  • Lập trình viên Blockchain (Solidity Developers): Công cụ đắc lực hỗ trợ tự kiểm tra mã nguồn nhanh chóng, chuẩn hóa tư duy lập trình phòng ngừa lỗi (Defensive Programming).
  • Doanh nghiệp & Startup Web3: Giải pháp cắt giảm chi phí bảo mật, đẩy nhanh tiến độ ra mắt sản phẩm (Time-to-market) mà vẫn đảm bảo độ tin cậy của quỹ tiền gửi (Total Value Locked - TVL).
  • Nhà nghiên cứu học thuật: Cung cấp framework mở và các chỉ số benchmark chi tiết để tiếp tục phát triển các mô hình Graph Transformer hoặc Large Language Models (LLMs) chuyên biệt cho Smart Contract Security.

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

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

Để phục vụ quá trình dự đoán (Inference), hệ thống chỉ yêu cầu máy chủ trang bị CPU đa nhân từ 4 cores, 8GB RAM và khuyến nghị có card đồ họa GPU rời tối thiểu NVIDIA GTX 1660 (6GB VRAM) hoặc chạy trực tiếp trên môi trường Cloud (AWS EC2 g4dn.xlarge) với độ trễ < 50ms.

2. Mô hình có xử lý được các phiên bản Solidity mới nhất (v0.8.x+) không?

Có. Nhờ việc phân tích dựa trên cả 3 tầng bao gồm Bytecode/Opcode của EVM và CFG, hệ thống độc lập tương đối với sự thay đổi cú pháp của các phiên bản compiler mới. Đối với Solidity 0.8.x đã tự động kiểm tra tràn số (Arithmetic), nhánh BiLSTM và GNN sẽ học được sự xuất hiện của các opcode đảo ngược trạng thái INVALID / REVERT để tránh dự đoán nhầm.

3. Làm thế nào để tích hợp VulnSense vào hệ thống máy chủ sẵn có?

VulnSense được đóng gói dưới dạng Docker Container chuẩn và cung cấp giao diện RESTful API (xây dựng bằng FastAPI). Nhà phát triển chỉ cần gửi mã nguồn .sol hoặc chuỗi bytecode qua HTTP POST request để nhận kết quả phân tích JSON chi tiết gồm nhãn dự đoán và điểm tin cậy (Confidence Score).

4. Chi phí duy trì và cập nhật mô hình định kỳ như thế nào?

Chi phí duy trì hệ thống suy luận rất thấp (~$50 - $100/tháng). Quá trình tái huấn luyện (Retraining) mô hình khi có tập dữ liệu lỗ hổng mới chỉ mất khoảng 78 phút trên một GPU RTX 3090/A100 duy nhất, có thể thực hiện định kỳ mỗi quý một lần.

Kết luận

Đồ án tốt nghiệp "Phát hiện tự động lỗ hổng hợp đồng thông minh dựa trên phương pháp học sâu" với mô hình VulnSense đã giải quyết triệt để bài toán thắt nút cổ chai của các phương pháp kiểm định truyền thống và học máy đơn thức. Bằng việc kết hợp sáng tạo 3 không gian đặc trưng: Ngữ nghĩa mã nguồn (BERT), Chuỗi mã lệnh thực thi (BiLSTM) và Tô-pô luồng điều khiển (GNN), hệ thống đạt độ chính xác ấn tượng 92.7% và F1-Score 92.3%, mang lại giá trị thực tiễn to lớn cho cộng đồng bảo mật Blockchain và phát triển phần mềm phi tập trung.