Giới thiệu dự án

Sự bùng nổ của công nghệ chuỗi khối (Blockchain) và tài chính phi tập trung (DeFi - Decentralized Finance) đã đưa hợp đồng thông minh (Smart Contract) trở thành nền tảng cốt lõi cho các giao dịch số tự động hóa. Theo thống kê từ các báo cáo bảo mật Web3 (Immunefi, Chainalysis), tổng thiệt hại do các vụ tấn công khai thác lỗ hổng hợp đồng thông minh trong giai đoạn 2021–2023 đã vượt mức 6,5 tỷ USD, điển hình là các vụ khai thác kinh điển như The DAO hack hay các cuộc tấn công tái nhập (Reentrancy attack) vào các giao thức DeFi trên mạng lưới Ethereum.

Đặc tính bất biến (immutability) của Blockchain khiến mã nguồn sau khi được triển khai (deploy) lên mạng chính (Mainnet) không thể sửa đổi hoặc vá lỗi theo cách truyền thống. Một sai sót nhỏ trong logic mã nguồn có thể dẫn đến việc toàn bộ quỹ tiền bị hacker rút cạn trong vài khối giao dịch. Các phương pháp kiểm tra tĩnh (Static Analysis) truyền thống dựa trên luật (rule-based) hoặc phân tích ký hiệu (symbolic execution) như Slither, Mythril thường gặp phải hai hạn chế lớn: tỷ lệ cảnh báo giả (False Positive - FP) cao và khả năng khái quát hóa kém đối với các biến thể mã nguồn phức tạp.

Đồ án tốt nghiệp "A Study on Smart Contract Vulnerability Detection Using Machine Learning and Graph Representation Approach" do sinh viên Trần Xuân Nam (MSSV: 20521637), ngành An toàn Thông tin, Trường Đại học Công nghệ Thông tin – ĐHQG-HCM, dưới sự hướng dẫn của ThS. Trần Tuấn Dũng (2024), được thực hiện nhằm giải quyết triệt để bài toán này.

flowchart LR
    A[Mã nguồn Solidity] --> B[Tree-sitter Parser]
    B --> C[Abstract Syntax Tree - AST]
    C --> D[Data Flow Graph - DFG]
    D --> E[Crucial DFG - CDFG]
    E --> F[GraphCodeBERT Module]
    E --> G[GCN + Graph2vec Module]
    F --> H[Soft Voting Ensemble]
    G --> H
    H --> I{Dự đoán: Lỗ hổng / An toàn}

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

  1. Nghiên cứu và chuẩn hóa cấu trúc dữ liệu: Xây dựng quy trình chuyển đổi mã nguồn Solidity thành Cây cú pháp trừu tượng (AST - Abstract Syntax Tree), Đồ thị dòng dữ liệu (DFG - Data Flow Graph) và trích xuất Đồ thị dòng dữ liệu quan trọng (CDFG - Crucial Data Flow Graph).
  2. Xây dựng mô hình học sâu kép: Phát triển và tinh chỉnh hai mô hình độc lập gồm mô hình tiền huấn luyện ngữ nghĩa đồ thị GraphCodeBERT và mô hình mạng nơ-ron tích chập đồ thị GCN (Graph Convolutional Network) kết hợp embedding Graph2vec.
  3. Phát triển cơ chế tích hợp (Ensemble Learning): Áp dụng kỹ thuật tổng hợp dự đoán theo xác suất (Soft Voting/Weighted Averaging) để kết hợp sức mạnh biểu diễn cú pháp - ngữ nghĩa của Transformer với khả năng nắm bắt cấu trúc tô pô của GNN.
  4. Thực nghiệm và đánh giá định lượng: Kiểm thử mô hình trên tập dữ liệu hợp đồng thực tế từ Ethereum, so sánh hiệu năng theo các chỉ số Accuracy, Precision, Recall và F1-Score so với các giải pháp hiện hành.

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

Giải pháp tiếp cận dựa trên việc thu gọn không gian đồ thị: lọc bỏ các nút không phụ thuộc để tạo CDFG tập trung vào các điểm nhạy cảm (như call.value, selfdestruct, msg.sender), sau đó đưa qua mạng nơ-ron kép. Kết quả kỳ vọng đạt F1-Score trên 90%, giảm trên 40% tỷ lệ dương tính giả so với các công cụ phân tích tĩnh tiêu chuẩn.

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

  • Phạm vi: Hợp đồng thông minh viết bằng ngôn ngữ Solidity được triển khai trên nền tảng Ethereum Virtual Machine (EVM). Tập trung phát hiện các nhóm lỗ hổng nghiêm trọng: Reentrancy, Integer Overflow/Underflow, Suicidal Contract, và Call Injection.
  • Giới hạn: Nghiên cứu phân tích ở cấp độ mã nguồn (Source Code level), chưa hỗ trợ phân tích trực tiếp mã bytecode đã qua tối ưu hóa sâu hoặc phân tích liên hợp đồng (Cross-contract inter-procedural analysis).

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

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

Phương pháp Công cụ / Đại diện Ưu điểm Nhược điểm Tỷ lệ FP / FN
Static Rule-based Slither, Securify Tốc độ quét nhanh, không cần biên dịch đầy đủ Dễ bị qua mặt bởi biến thể mã, phụ thuộc luật viết tay FP cao (25% - 40%)
Symbolic Execution Mythril, Manticore Độ bao phủ nhánh cao, tìm được path khai thác Bùng nổ trạng thái (Path Explosion), chậm FN trung bình
Deep Learning (Sequence) LSTM, Standard BERT Tự động học đặc trưng, không cần định nghĩa luật Bỏ qua cấu trúc phân nhánh và luồng phụ thuộc dữ liệu phức tạp FP trung bình
Đồ thị + Deep Learning Đề xuất (CDFG + Ensemble) Nắm bắt toàn vẹn ngữ nghĩa và quan hệ luồng dữ liệu then chốt Đòi hỏi tiền xử lý đồ thị phức tạp FP & FN thấp (<10%) 
So sánh yêu cầu hệ thống theo mô hình MoSCoW:
├── Must Have (Bắt buộc):
│   ├── Parser mã nguồn Solidity thành AST chuẩn xác qua Tree-sitter.
│   ├── Thuật toán lọc DFG thành CDFG dựa trên các điểm nút nguy hiểm.
│   ├── Pipeline trích xuất đặc trưng GraphCodeBERT và GCN.
│   └── Bộ phân loại Ensemble nhị phân (Vulnerable vs Safe).
├── Should Have (Nên có):
│   ├── Hỗ trợ cấu hình siêu tham số (Hyperparameter tuning) linh hoạt.
│   └── Vector hóa cấu trúc đồ thị qua Graph2vec cho GCN.
├── Could Have (Có thể có):
│   └── Phân loại đa nhãn (Multi-label classification) theo từng dạng lỗ hổng chi tiết.
└── Won't Have (Chưa thực hiện đợt này):
    └── Plugin tích hợp trực tiếp vào IDE Remix/VSCode hoặc quét on-chain thời gian thực.

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm 3 tầng chức năng chính:

  1. Data Preprocessing & Graph Engineering Layer:

    • Sử dụng thư viện tree-sitter-solidity (v0.20.8) để phân tích từ vựng (lexical analysis) và phân tích cú pháp (parsing) mã nguồn thành AST.
    • Trích xuất chuỗi định danh biến $V = {v_1, v_2, \dots, v_n}$ và thiết lập các cạnh phụ thuộc dữ liệu (Data Dependency Edges).
    • Tối ưu hóa DFG thành CDFG bằng cách xác định tập các nút trọng yếu $K$ (chứa các hàm/biến nhạy cảm: call, callcode, delegatecall, selfdestruct, transfer, balance) và loại bỏ các nút con không kết nối trực tiếp đến $K$.

  2. Dual-Model Training Architecture:

    • Nhánh GraphCodeBERT: Nhận đầu vào là chuỗi token mã nguồn kết hợp ma trận kề biểu diễn CDFG, học biểu diễn ngữ nghĩa thông qua 12 lớp Transformer Encoder với cơ chế Graph-Guided Masked Attention.
    • Nhánh GCN + Graph2vec: Biến đổi đồ thị CDFG thành vector đặc trưng cấu trúc (topology embedding) thông qua graph2vec, sau đó đưa qua các lớp tích chập đồ thị (Graph Convolutional Layers) để tổng hợp thông tin từ láng giềng bậc $k$.

  3. Classification & Ensemble Head:

    • Đầu ra của GraphCodeBERT qua lớp RobertaClassificationHead (Linear projection + Tanh activation + Dropout 0.1).
    • Đầu ra của GCN qua mạng nơ-ron truyền thẳng (Fully Connected Network).
    • Kết quả xác suất được hợp nhất theo công thức Soft Voting: $$P_{\text{final}}(y=1 | x) = \alpha \cdot P_{\text{GraphCodeBERT}}(y=1 | x) + (1-\alpha) \cdot P_{\text{GCN}}(y=1 | x) \quad (\text{với } \alpha = 0.6)$$
Technology Stack Specifications:
├── Core Framework: Python 3.10.12, PyTorch 2.1.2+cu121
├── Graph & NLP Processing:
│   ├── HuggingFace Transformers: v4.35.2
│   ├── PyTorch Geometric (PyG): v2.4.0
│   ├── Tree-sitter: v0.20.8
│   ├── NetworkX: v3.2.1
│   └── KarateClub (Graph2vec): v1.3.3
└── Environment: CUDA 12.1, cuDNN 8.9, Ubuntu 22.04 LTS

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

Dự án áp dụng phương pháp nghiên cứu thực nghiệm lặp (Iterative Experimental Research Methodology) kết hợp khung quy trình chuẩn CRISP-DM:

  • Phase 1 (Data Collection & Labeling): Thu thập 47,398 hợp đồng thông minh đã gán nhãn từ các kho dữ liệu SmartBugs Wild dataset và Ethereum verified contracts.
  • Phase 2 (Graph Transformation): Lập trình thuật toán rút gọn đồ thị DFG $\rightarrow$ CDFG.
  • Phase 3 (Model Implementation): Lập trình các custom layers (GraphConvolutionLayer, RobertaClassificationHead).
  • Phase 4 (Training & Validation): Huấn luyện mô hình với hàm mất mát Binary Cross-Entropy và thuật toán tối ưu AdamW (Learning rate $2\times 10^{-5}$ cho GraphCodeBERT, $1\times 10^{-3}$ cho GCN).

Implementation và kết quả

Development process & Key algorithms

1. Thuật toán lọc nút quan trọng tạo CDFG (Crucial Node Filtering)

Mã nguồn Solidity được parse thành AST để định vị các nút nhạy cảm liên quan đến chuyển dịch tài sản và thay đổi quyền truy cập:

import networkx as nx
from tree_sitter import Language, Parser

def extract_crucial_data_flow_graph(ast_root, raw_dfg):
    """
    Rút gọn DFG thành CDFG bằng cách xác định các nút nhạy cảm (Crucial Nodes)
    và truy vết các phụ thuộc dữ liệu trực tiếp liên quan.
    """
    CRUCIAL_KEYWORDS = {'call', 'callcode', 'delegatecall', 'selfdestruct', 
                        'balance', 'transfer', 'send', 'withdraw'}
    
    crucial_nodes = set()
    for node_id, data in raw_dfg.nodes(data=True):
        token_name = data.get('label', '')
        if any(keyword in token_name.lower() for keyword in CRUCIAL_KEYWORDS):
            crucial_nodes.add(node_id)
            
    # Mở rộng tập nút bao gồm các nút có quan hệ trực tiếp (in/out edges)
    retained_nodes = set(crucial_nodes)
    for c_node in crucial_nodes:
        retained_nodes.update(raw_dfg.predecessors(c_node))
        retained_nodes.update(raw_dfg.successors(c_node))
        
    # Tạo đồ thị con cảm ứng (Induced Subgraph) làm CDFG
    cdfg = raw_dfg.subgraph(retained_nodes).copy()
    return cdfg

2. Cài đặt lớp Graph Convolutional Layer cho GCN

Mô hình GCN xử lý thông tin biểu diễn cấu trúc từ ma trận kề $A$ và ma trận đặc trưng nút $H$:

import torch
import torch.nn as nn

class GraphConvolutionLayer(nn.Module):
    """
    Lớp tích chập đồ thị cơ bản: H^(l+1) = sigma( D^(-1/2) * A_hat * D^(-1/2) * H^(l) * W^(l) )
    """
    def __init__(self, in_features: int, out_features: int, bias: bool = True):
        super(GraphConvolutionLayer, self).__init__()
        self.in_features = in_features
        self.out_features = out_features
        self.weight = nn.Parameter(torch.FloatTensor(in_features, out_features))
        if bias:
            self.bias = nn.Parameter(torch.FloatTensor(out_features))
        else:
            self.register_parameter('bias', None)
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
        if self.bias is not None:
            fan_in, _ = nn.init._calculate_fan_in_and_fan_out(self.weight)
            bound = 1 / math.sqrt(fan_in)
            nn.init.uniform_(self.bias, -bound, bound)

    def forward(self, x: torch.Tensor, adj: torch.Tensor) -> torch.Tensor:
        # x: [num_nodes, in_features], adj: [num_nodes, num_nodes] (đã chuẩn hóa)
        support = torch.mm(x, self.weight)
        output = torch.spmm(adj, support)
        if self.bias is not None:
            return output + self.bias
        return output

3. Cài đặt đầu phân loại RoBERTa Head cho GraphCodeBERT

class RobertaClassificationHead(nn.Module):
    """Head phân loại nhận hidden state của token [CLS] từ GraphCodeBERT"""
    def __init__(self, hidden_size: int = 768, num_labels: int = 2, dropout_prob: float = 0.1):
        super(RobertaClassificationHead, self).__init__()
        self.dense = nn.Linear(hidden_size, hidden_size)
        self.dropout = nn.Dropout(dropout_prob)
        self.out_proj = nn.Linear(hidden_size, num_labels)

    def forward(self, features: torch.Tensor) -> torch.Tensor:
        x = features[:, 0, :]  # Lấy token [CLS]
        x = self.dropout(x)
        x = self.dense(x)
        x = torch.tanh(x)
        x = self.dropout(x)
        x = self.out_proj(x)
        return x

Testing và validation

Tập dữ liệu kiểm thử được phân chia theo tỷ lệ 80% Training, 10% Validation, 10% Independent Test Set trên tổng số 4,800 hợp đồng đã được thẩm định độc lập. Quá trình huấn luyện GraphCodeBERT được thực hiện trong 10 epochs với batch size = 16, sử dụng card đồ họa NVIDIA RTX 3090 (24GB VRAM).

Thống kê quá trình hội tụ:
- Epoch 1: Loss = 0.582, Train F1 = 74.2%, Val F1 = 76.8%
- Epoch 5: Loss = 0.214, Train F1 = 88.6%, Val F1 = 88.1%
- Epoch 10: Loss = 0.089, Train F1 = 94.5%, Val F1 = 90.5% (Tối ưu nhất)

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

Mô hình / Công cụ Accuracy (%) Precision (%) Recall (%) F1-Score (%) Thời gian xử lý / Hợp đồng
Slither (v0.9.3) 71.4% 63.8% 81.2% 71.4% 0.42s
Mythril (v0.23.15) 74.8% 78.1% 68.5% 73.0% 48.60s
Standard GCN (baseline) 82.5% 81.0% 83.2% 82.1% 0.85s
TMP (Zhuang et al.) 86.3% 85.7% 87.1% 86.4% 1.12s
GraphCodeBERT (Single) 89.2% 88.4% 90.1% 89.2% 0.65s
GCN + Graph2vec (Single) 84.1% 83.5% 84.8% 84.1% 0.58s
Ensemble Đề xuất (Kết hợp) 92.4% 91.6% 93.2% 92.4% 0.88s 
Confusion Matrix của mô hình Ensemble đề xuất trên 480 mẫu test:
                ┌───────────────────────────────┐
                │        Dự đoán (Pred)         │
                ├───────────────┬───────────────┤
                │ Vulnerable(1) │    Safe(0)    │
┌───────────────┼───────────────┼───────────────┤
│ Vulnerable(1) │    TP = 224   │    FN = 16    │ (Tổng True Pos = 240)
├───────────────┼───────────────┼───────────────┤
│ Safe(0)       │    FP = 20    │    TN = 220   │ (Tổng True Neg = 240)
└───────────────┴───────────────┴───────────────┘

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

  1. Cơ chế biểu diễn đồ thị CDFG tập trung: Khắc phục nhược điểm "quá tải cấu trúc" của các nghiên cứu trước (như Lei Zhang et al., 2023 khi dùng toàn bộ AST+CFG). Việc rút gọn thành Crucial Data Flow Graph giúp giảm 62.4% số lượng nút dư thừa, tập trung dung lượng bộ nhớ và sự chú ý (attention weights) của mạng nơ-ron vào các luồng lệnh chứa từ khóa nguy cơ cao.
  2. Kiến trúc dung hợp đa góc nhìn (Hybrid Semantic-Structural Ensemble):
    • GraphCodeBERT giải quyết bài toán biểu diễn ngữ nghĩa chuỗi token và quan hệ biến cục bộ.
    • GCN + Graph2vec giải quyết bài toán nhận diện mô hình liên kết không gian (global graph topology).
    • Sự kết hợp giúp tăng 3.2% F1-Score so với việc chỉ sử dụng riêng lẻ GraphCodeBERT và tăng 8.3% so với mô hình GCN thuần túy.
  3. Độ trễ xử lý thấp, khả năng triển khai thực tế: Với thời gian quét trung bình chỉ 0.88 giây/hợp đồng, giải pháp vượt trội hoàn toàn về mặt tốc độ so với các công cụ Symbolic Execution (Mythril mất trung bình ~48.6 giây/hợp đồng), sẵn sàng tích hợp vào quy trình CI/CD.
graph TD
    A[Mã nguồn thô] -->|Tree-sitter| B(Full AST: ~1200 nodes)
    B -->|Phân tích luồng| C(Standard DFG: ~450 nodes)
    C -->|Lọc điểm nóng bảo mật| D[CDFG: ~85 nodes - Giảm 62.4% nhiễu]
    D --> E[Tăng tốc huấn luyện 2.8x & Tăng F1-Score 6.0%]

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

Kịch bản triển khai trong thực tế (Real-world Use Cases)

  • Hệ thống kiểm thử tự động trong CI/CD Pipeline: Tích hợp dưới dạng GitHub Action / GitLab CI. Khi nhà phát triển Solidity tạo Pull Request, hệ thống tự động trích xuất CDFG và chạy inference để ngăn chặn triển khai hợp đồng chứa lỗ hổng bảo mật.
  • Công cụ tiền kiểm định cho các công ty Audit Web3: Giúp các kiểm toán viên (Security Auditors) quét sơ bộ hàng trăm nghìn dòng mã của các giao thức phức tạp để nhanh chóng định vị các hàm có độ rủi ro cao.

Yêu cầu triển khai hệ thống (System & Deployment Specifications)

Cấu hình máy chủ triển khai (Server Requirements):
├── Production Inference Server:
│   ├── CPU: Intel Xeon Silver 4210R (hoặc AMD EPYC 7302P) 16 cores
│   ├── RAM: 32 GB ECC DDR4
│   ├── GPU: 1x NVIDIA Tesla T4 16GB (hoặc NVIDIA RTX 4000 Ada)
│   └── Storage: 100 GB NVMe SSD
└── API Endpoints Container (FastAPI + Triton Inference Server):
    ├── POST /api/v1/analyze/raw-source
    └── POST /api/v1/analyze/jsonl-batch

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

Chi phí thuê chuyên gia audit thủ công một dự án DeFi dao động từ 15,000 USD đến 80,000 USD với thời gian từ 2 đến 4 tuần. Việc ứng dụng giải pháp học máy giúp giảm 70% thời gian rà soát ban đầu, tiết kiệm ước tính 10,000 USD cho mỗi đợt kiểm thử nội bộ trước khi gửi thẩm định chính thức, đưa thời gian thu hồi vốn đầu tư hệ thống (ROI) về dưới 4 tháng.

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

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

  • Mã nguồn bị làm mờ (Obfuscated Code): Nếu mã nguồn cố tình đổi tên hàm nhạy cảm hoặc tách luồng gọi hàm qua nhiều lớp delegatecall gián tiếp, đồ thị CDFG có thể bỏ sót các nút quan trọng.
  • Phụ thuộc vào mã nguồn hoàn chỉnh: Mô hình yêu cầu mã nguồn Solidity có thể parse được qua Tree-sitter, chưa hỗ trợ trực tiếp việc dịch ngược từ EVM Bytecode dạng thô bị mất nhãn biến.
  • Chưa giải quyết triệt để lỗi logic kinh tế (Economic Flashloan Attacks): Mô hình tập trung vào lỗ hổng cấp mã lệnh (Code-level vulnerabilities), chưa phân tích được các lỗi thiết kế mô hình tài chính (Tokenomics logic flaws).

Hướng nâng cấp đề xuất

  1. Mở rộng sang Bytecode Disassembly: Xây dựng đồ thị dòng điều khiển (CFG) từ mã Opcodes/Bytecode để hỗ trợ quét các hợp đồng không công khai mã nguồn trên Etherscan.
  2. Tích hợp Large Language Models (LLMs) giải thích mã: Kết hợp đồ thị CDFG với các mô hình như DeepSeek-Coder hoặc CodeLlama để tự động sinh báo cáo giải thích nguyên nhân lỗ hổng và gợi ý đoạn mã sửa đổi (Patch Generation).
  3. Phân tích liên hợp đồng (Cross-contract Graph Neural Network): Mở rộng CDFG thành đồ thị đa hợp đồng để phát hiện các cuộc tấn công tương tác giao thức phức tạp trong hệ sinh thái DeFi.

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

  • Sinh viên & Học viên ngành An toàn thông tin / Khoa học máy tính: Tài liệu tham khảo hoàn chỉnh về cách áp dụng mô hình đồ thị (GNN) kết hợp Transformer trong bài toán xử lý mã nguồn (Source Code Intelligence).
  • Lập trình viên Blockchain (Solidity Developers): Nắm bắt các mẫu mã nguy hiểm (anti-patterns), hiểu rõ cơ chế tấn công Reentrancy và cách thiết lập luồng dữ liệu an toàn.
  • Doanh nghiệp & Đơn vị phát triển Web3: Sở hữu giải pháp công nghệ có khả năng tích hợp trực tiếp vào quy trình kiểm thử nội bộ với chi phí vận hành thấp và độ chính xác cao.
  • Nhà nghiên cứu bảo mật (Security Researchers): Kế thừa phương pháp trích xuất CDFG và pipeline Ensemble để mở rộng cho các ngôn ngữ Smart Contract khác như Rust (Solana), Move (Aptos/Sui).

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

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

Để huấn luyện lại mô hình với tập dữ liệu đầy đủ (~47,000 mẫu), hệ thống cần tối thiểu 1 GPU có 16GB VRAM (như RTX 3090, RTX 4080 hoặc Tesla T4) và 32GB RAM hệ thống. Đối với môi trường suy luận (Inference), mô hình có thể chạy ổn định trên CPU 8-cores với RAM 16GB (độ trễ ~1.8s/hợp đồng) hoặc chạy trên GPU (độ trễ ~0.88s/hợp đồng).

2. Mô hình xử lý thế nào đối với các hợp đồng Solidity có kích thước cực lớn vượt quá giới hạn 512 tokens của GraphCodeBERT?

Nhờ thuật toán lọc DFG thành CDFG, các câu lệnh không liên quan đến biến tài sản và điều kiện rẽ nhánh quan trọng được loại bỏ. Do đó, kích thước chuỗi token và đồ thị giảm hơn 60%, giúp hầu hết các hàm quan trọng nằm gọn trong giới hạn độ dài ngữ cảnh 512 tokens của mô hình mà không làm mất mát ngữ nghĩa bảo mật.

3. Làm thế nào để tích hợp hệ thống này vào quy trình phát triển hiện có?

Hệ thống cung cấp sẵn interface dưới dạng REST API xây dựng bằng FastAPI. Đội ngũ phát triển có thể thiết lập Webhook kích hoạt khi có commit mới trên Git repository để tự động gửi mã nguồn đến endpoint /api/v1/analyze/raw-source và nhận về phản hồi định dạng JSON chứa trạng thái cảnh báo cùng tọa độ dòng mã vi phạm.

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

Chi phí duy trì bao gồm phí vận hành máy chủ inference cloud (khoảng 80 - 150 USD/tháng trên AWS/GCP). Mô hình nên được huấn luyện bổ sung (Fine-tune) định kỳ 6 tháng một lần với các biến thể lỗ hổng mới xuất hiện trên thị trường, chi phí tính toán huấn luyện lại chỉ tốn khoảng 10 - 20 giờ GPU.

5. Khả năng phát hiện các lỗ hổng chưa từng thấy (Zero-day vulnerabilities) của mô hình ra sao?

Khác với các công cụ phân tích tĩnh truyền thống chỉ tìm kiếm chính xác mẫu signature định trước, phương pháp học sâu trên CDFG có khả năng học các mẫu trừu tượng về sự bất thường trong luồng truyền giá trị biến. Do đó, mô hình có khả năng khái quát hóa và nhận diện được các biến thể tinh vi của lỗ hổng logic mà các bộ luật cố định chưa kịp cập nhật.

Kết luận

Đồ án tốt nghiệp "A Study on Smart Contract Vulnerability Detection Using Machine Learning and Graph Representation Approach" đã giải quyết thành công bài toán phát hiện lỗ hổng bảo mật trong hợp đồng thông minh bằng sự kết hợp giữa kỹ thuật kỹ nghệ đồ thị và học sâu đa mô hình. Việc sáng tạo thuật toán trích xuất Đồ thị dòng dữ liệu quan trọng (CDFG) kết hợp với kiến trúc Ensemble giữa GraphCodeBERT và GCN đã chứng minh hiệu quả vượt trội: đạt độ chính xác 92.4%, F1-Score 92.4% và thời gian quét chỉ 0.88 giây/hợp đồng.

Nghiên cứu không chỉ đóng góp giá trị học thuật quan trọng trong lĩnh vực an toàn thông tin Blockchain mà còn mở ra giải pháp thực tiễn cao giúp bảo vệ tài sản số và nâng cao độ tin cậy cho hệ sinh thái Web3. Độc giả, lập trình viên và các nhóm nghiên cứu có thể tiếp tục mở rộng mô hình sang hướng phân tích bytecode và tự động vá lỗi thông minh nhằm xây dựng các hệ thống bảo mật tự trị toàn diện.