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) đã đư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 kỹ thuật số không cần bên thứ ba tín nhiệm. Với giá trị tài sản bị khóa (Total Value Locked - TVL) trong các giao thức DeFi đạt hàng chục tỷ USD, an ninh mạng cho hợp đồng thông minh trở thành vấn đề sống còn. Theo các thống kê từ các tổ chức bảo mật Web3, các vụ tấn công khai thác lỗ hổng hợp đồng thông minh đã gây thất thoát hàng tỷ USD mỗi năm, điển hình là vụ tấn công lịch sử vào The DAO (2016) làm thiệt hại hơn 60 triệu USD, hay hàng loạt sự cố bảo mật nghiêm trọng trong các giao thức DeFi giai đoạn 2020–2023.

Vấn đề nghiên cứu (Problem Statement)

Đặc tính cốt lõi của hợp đồng thông minh khi triển khai trên mạng lưới blockchain (như Ethereum) là tính bất biến (immutability). Mã nguồn sau khi đã đưa lên khối (on-chain) sẽ không thể chỉnh sửa hay vá lỗi theo cách truyền thống. Nếu hợp đồng tồn tại lỗ hổng bảo mật, kẻ tấn công có thể liên tục rút cạn tài sản mà quản trị viên không thể can thiệp khẩn cấp trừ khi có cơ chế tự hủy hoặc ngắt mạch thiết kế từ trước.

Hiện nay, các phương pháp kiểm thử và phát hiện lỗ hổng truyền thống bộc lộ nhiều điểm nghẽn nghiêm trọng:

  • Kiểm thử thủ công (Manual Audit): Phụ thuộc hoàn toàn vào chuyên môn của chuyên gia bảo mật, tốn kém chi phí và mất nhiều tuần để hoàn thiện một báo cáo.
  • Phân tích tĩnh (Static Analysis) & Phân tích biểu tượng (Symbolic Execution): Thường tạo ra tỷ lệ dương tính giả (False Positives) rất cao, không thể chứng minh lỗ hổng có thể khai thác được trong môi trường thực tế (Exploitability).
  • Kiểm thử tự động sinh chuỗi giao dịch: Các công cụ hiện có gặp khó khăn trong việc tạo ra chuỗi các lời gọi hàm (Transaction Call Sequence) phức tạp, đúng thứ tự và có logic phụ thuộc dữ liệu để kích hoạt trạng thái lỗ hổng.

Mục tiêu dự án

  1. Nghiên cứu và phân loại: Hệ thống hóa các dạng lỗ hổng bảo mật nguy hiểm trên hợp đồng thông minh Solidity, tập trung vào Reentrancy (Tái nhập), Suicidal/Selfdestruct (Tự hủy ngoài ý muốn), Integer Overflow/Underflow (Tràn số) và Block Gas Limit.
  2. Thiết kế không gian trạng thái và hành động: Trích xuất thuộc tính hợp đồng từ Cây cú pháp trừu tượng (AST) và Giao diện nhị phân ứng dụng (ABI), kết hợp kỹ thuật biểu diễn vector (Word2Vec/FastText).
  3. Phát triển mô hình học tăng cường sâu: Xây dựng tác tử (Agent) áp dụng Deep Q-Network (DQN) và Deep Recurrent Q-Network (DRQN) có khả năng tự động học và sinh chuỗi lời gọi hàm tối ưu nhằm kích hoạt lỗ hổng.
  4. Hiện thực hóa công cụ SCE (Smart Contract Exploiter): Triển khai hệ thống tự động sinh mã hợp đồng tấn công (Attack Contract), kiểm thử trên mạng cục bộ Ganache và đánh giá hiệu năng so với các giải pháp hiện nay.

Phương pháp tiếp cận giải pháp

Đồ án tiếp cận bài toán tự động hóa khai thác dưới dạng Quy trình ra quyết định Markov (Markov Decision Process - MDP). Tác tử bảo mật tương tác trực tiếp với hợp đồng nạn nhân được triển khai trên môi trường giả lập Ganache. Thông qua cơ chế thử nghiệm và nhận phản hồi phần thưởng (Reward System), mô hình học cách xâu chuỗi các giao dịch (nạp tiền, chuyển quyền sở hữu, gọi hàm rút tiền đệ quy) để đạt mục tiêu cuối cùng là rút cạn tiền hoặc vô hiệu hóa hợp đồng.

+-------------------------------------------------------------------------+
|                              SCE FRAMEWORK                              |
|                                                                         |
|  +---------------------+        +------------------------------------+  |
|  | Target Contract     |  AST   | Feature Extraction & Embedding     |  |
|  | (.sol / Bytecode)   |------->| (ABI Parsing, FastText / Word2Vec) |  |
|  +---------------------+        +-----------------+------------------+  |
|                                                   | State Vector        |
|                                                   v                     |
|  +---------------------+ Action  +------------------------------------+  |
|  | Local Ganache Node  |<--------| Reinforcement Learning Agent       |  |
|  | (EVM Environment)   |-------->| (DQN / DRQN Policy Network)        |  |
|  +---------------------+ State,  +------------------------------------+  |
|                          Reward                                         |
+-------------------------------------------------------------------------+

Kết quả kỳ vọng và Phạm vi nghiên cứu

  • Kết quả đo lường được: Tỷ lệ khai thác thành công đạt trên 85% trên các tập hợp đồng kiểm thử chuẩn; giảm thời gian tạo Proof-of-Concept (PoC) từ hàng giờ xuống dưới 30 giây cho mỗi hợp đồng; vượt trội so với DQN truyền thống trong các kịch bản phụ thuộc chuỗi trạng thái lịch sử.
  • Phạm vi và Giới hạn: Nghiên cứu tập trung vào hợp đồng viết bằng ngôn ngữ Solidity chạy trên Ethereum Virtual Machine (EVM); mục tiêu khai thác trọng tâm là Reentrancy và Suicidal Contract. Các lỗ hổng logic nghiệp vụ đa giao thức phức tạp (như Flash Loan manipulation trên nhiều sàn DEX) được định hướng phát triển trong tương lai.

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

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

Công cụ / Phương pháp Cơ chế hoạt động Ưu điểm Nhược điểm / Hạn chế
Slither Phân tích tĩnh dựa trên CFG và AST Tốc độ quét cực nhanh, quét toàn bộ mã nguồn Tỷ lệ cảnh báo giả cao; không sinh được kịch bản khai thác thực tế (PoC)
Mythril Phân tích biểu tượng (Symbolic Execution) Độ bao phủ nhánh cao, phát hiện được lỗi tiềm ẩn sâu Bùng nổ không gian trạng thái (Path Explosion); thời gian thực thi lâu
ContractFuzzer Fuzzing động dựa trên ABI Kiểm thử thực tế trên EVM, ít cảnh báo giả Sinh tham số ngẫu nhiên kém hiệu quả; khó tìm được chuỗi gọi hàm nhiều bước
SCE (Đề xuất) Học tăng cường sâu (DQN / DRQN) Tự học chuỗi khai thác tối ưu; tự động sinh Attack Contract; xác thực 100% qua PoC Cần thời gian huấn luyện mô hình ban đầu; phụ thuộc vào hàm phần thưởng

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

  • Must Have (Bắt buộc):
    • Bộ phân tích trích xuất ABI và AST từ mã nguồn Solidity.
    • Môi trường tương tác giả lập EVM cục bộ kết nối qua RPC (Ganache).
    • Thuật toán DQN và DRQN có khả năng tạo chuỗi giao dịch tối đa hóa phần thưởng khai thác.
    • Module tự động sinh hợp đồng tấn công proxy cho lỗi Reentrancy.
  • Should Have (Nên có):
    • Cơ chế nhúng từ (Embedding) bằng Word2Vec hoặc FastText cho tên hàm và kiểu dữ liệu tham số.
    • Hệ thống lưu vết trải nghiệm (Experience Replay Memory) và mạng mục tiêu (Fixed Target Network).
  • Could Have (Có thể có):
    • Giao diện trực quan hóa quá trình hội tụ phần thưởng và biểu đồ chuỗi giao dịch.
  • Won't Have (Chưa thực hiện ở giai đoạn này):
    • Khai thác lỗ hổng giao thức cross-chain hoặc các lỗ hổng zero-knowledge rollup.

Thiết kế hệ thống

Hệ thống SCE bao gồm 4 khối thành phần chính:

+-----------------------------------------------------------------------------------+
|                            HỆ THỐNG KIẾN TRÚC SCE                                 |
+-----------------------------------------------------------------------------------+
| 1. Parser Module       | Trích xuất AST & ABI; phân loại hàm thay đổi trạng thái  |
| 2. Representation Unit | Mã hóa thuộc tính hàm thành Vector trạng thái            |
| 3. RL Agent Core       | Mạng DQN / DRQN (Dense + LSTM layers) quyết định Action |
| 4. Execution Sandbox   | Ganache Testnet + Web3.py thực thi và tính toán Reward   |
+-----------------------------------------------------------------------------------+

Technology Stack và Phiên bản

  • Ngôn ngữ phát triển: Python v3.9+ (Xây dựng Agent & Pipeline), Solidity v0.4.x - v0.8.x (Ngôn ngữ hợp đồng thông minh mục tiêu).
  • Framework Học sâu / Học tăng cường: PyTorch v1.12+, Gym Toolkit.
  • Blockchain Interface & Sandbox: Web3.py v5.31+, Ganache CLI v7.4.x, Node.js v16.x LTS.
  • Phân tích mã nguồn: solc-select, py-solc-x, slither-analyzer (hỗ trợ phân tích AST ban đầu), Gensim v4.2+ (Word2Vec/FastText).

Thiết kế không gian trạng thái (State) và không gian hành động (Action)

  • Không gian trạng thái ($S$): Biểu diễn trạng thái số dư hợp đồng nạn nhân, số dư tài khoản tấn công, các biến trạng thái nội bộ (Internal State Variables trích từ AST) và lịch sử các hàm đã thực thi trong episode.
  • Không gian hành động ($A$): Tập hợp các chữ ký hàm (Function Signatures) có thể gọi trong hợp đồng, kết hợp với các bộ tham số payload và giá trị msg.value (gửi kèm ETH hoặc không).

Methodology

Quy trình nghiên cứu áp dụng phương pháp phát triển lặp kết hợp nghiên cứu thực nghiệm (Experimental Agile Research):

  1. Giai đoạn 1 (Milestone 1 - Tuần 1-3): Thu thập và chuẩn hóa bộ dữ liệu mẫu hợp đồng thông minh chứa các lỗ hổng điển hình (SmartBug dataset, CVEs thực tế).
  2. Giai đoạn 2 (Milestone 2 - Tuần 4-7): Xây dựng module Parser AST/ABI và thiết lập môi trường EVM tương thích thông qua Ganache.
  3. Giai đoạn 3 (Milestone 3 - Tuần 8-12): Thiết kế cấu trúc mạng DQN/DRQN, xây dựng hàm phần thưởng và huấn luyện mô hình.
  4. Giai đoạn 4 (Milestone 4 - Tuần 13-15): Kiểm thử, tinh chỉnh siêu tham số, so sánh hiệu năng giữa DQN và DRQN với các mức episode khác nhau (800, 1000, 5000).

Ma trận rủi ro và giải pháp kiểm soát

  • Rủi ro bùng nổ không gian hành động: Không gian hàm và tham số quá lớn làm chậm hội tụ. Giải pháp: Tiền lọc các hàm không làm thay đổi trạng thái (View/Pure functions) thông qua ABI parser.
  • Rủi ro kẹt tại cực trị địa phương (Local Optima): Tác tử chỉ liên tục gọi một hàm nạp tiền. Giải pháp: Áp dụng chiến lược $\epsilon$-Greedy phân rã theo hàm mũ kết hợp hàm thưởng phạt lũy tiến.

Implementation và kết quả

Development Process

1. Mô hình hóa bài toán học tăng cường cho hợp đồng thông minh

Tác tử tương tác với môi trường theo thời gian rời rạc $t$. Tại mỗi bước, tác tử quan sát trạng thái $s_t$, chọn hành động $a_t$ (gọi một hàm cụ thể với tham số xác định), môi trường chuyển sang $s_{t+1}$ và trả về phần thưởng $r_{t+1}$.

Phương trình cập nhật giá trị hàm Q-Learning theo xấp xỉ Bellman: $$Q(s_t, a_t) \leftarrow (1 - \alpha) Q(s_t, a_t) + \alpha \left[ r_{t+1} + \gamma \max_{a} Q(s_{t+1}, a) \right]$$

Trong đó:

  • $\alpha \in (0, 1]$: Tốc độ học (Learning Rate, thiết lập $\alpha = 0.001$).
  • $\gamma \in (0, 1]$: Hệ số chiết khấu phần thưởng tương lai ($\gamma = 0.99$).

Hàm mất mát (Loss function) cho việc tối ưu mạng nơ-ron: $$L(\theta) = \mathbb{E}{\left(s, a, r, s'\right) \sim \mathcal{D}} \left[ \left( r + \gamma \max{a'} Q(s', a'; \theta^-) - Q(s, a; \theta) \right)^2 \right]$$ (với $\theta$ là trọng số mạng chính sách và $\theta^-$ là trọng số mạng mục tiêu Fixed Target Network).

2. Cấu trúc mạng DRQN (Deep Recurrent Q-Network)

Để giải quyết bài toán phụ thuộc thời gian khi một chuỗi khai thác yêu cầu thứ tự gọi hàm nghiêm ngặt (ví dụ: donate() $\rightarrow$ attack() $\rightarrow$ fallback() kích hoạt đệ quy withdraw()), mô hình tích hợp tầng tái phát (Recurrent Layer - LSTM):

State Vector (Input) ---> [Dense Layer: 128 units] (ReLU)
                     ---> [LSTM Layer: 128 units] (Xử lý chuỗi phụ thuộc thời gian)
                     ---> [Dense Layer: 64 units] (ReLU)
                     ---> [Output Layer: |Action Space|] (Q-values cho từng hàm)

3. Minh họa mã nguồn: Hợp đồng nạn nhân và Hợp đồng tấn công tự sinh

Mã nguồn hợp đồng nạn nhân bị lỗi Reentrancy (SimpleDAO.sol):

pragma solidity ^0.8.0;

contract SimpleDAO {
    mapping (address => uint256) public credit;

    function donate(address to) public payable {
        credit[to] += msg.value;
    }

    function withdraw(uint256 amount) public {
        if (credit[msg.sender] >= amount) {
            // LỖ HỔNG: Gửi Ether trước khi trừ số dư nội bộ
            (bool success, ) = msg.sender.call{value: amount}("");
            require(success, "Transfer failed");
            credit[msg.sender] -= amount;
        }
    }

    function queryCredit(address to) public view returns (uint256) {
        return credit[to];
    }
}

Mã nguồn hợp đồng tấn công tự sinh bởi công cụ SCE (Attack.sol):

pragma solidity ^0.8.0;

interface ISimpleDAO {
    function donate(address to) external payable;
    function withdraw(uint256 amount) external;
}

contract Attack {
    ISimpleDAO public target;
    address public owner;

    constructor(address _targetAddress) {
        target = ISimpleDAO(_targetAddress);
        owner = msg.sender;
    }

    function contribute() public payable {
        target.donate{value: msg.value}(address(this));
    }

    function attack() public {
        target.withdraw(1 ether);
    }

    // Hàm nhận tiền tự động kích hoạt đệ quy rút cạn số dư
    fallback() external payable {
        if (address(target).balance >= 1 ether) {
            target.withdraw(1 ether);
        }
    }
}

Testing và validation

Quá trình thực nghiệm được tiến hành trên máy chủ phòng thí nghiệm InSecLab với cấu hình: CPU Intel Core i7 12 nhân, 32GB RAM, GPU NVIDIA RTX 3080 10GB, cài đặt Ubuntu 22.04 LTS.

Bảng kết quả huấn luyện mô hình qua các mức Episode

Thuật toán Số Episode Thời gian huấn luyện (phút) Tỷ lệ khai thác thành công (Tập Train) Tỷ lệ khai thác thành công (Tập Test)
DQN 800 24.5 58.2% 52.1%
DRQN 800 29.1 74.6% 71.3%
DQN 1,000 32.8 68.4% 63.5%
DRQN 1,000 38.2 86.1% 83.4%
DQN 5,000 165.0 79.2% 72.8%
DRQN 5,000 192.4 93.5% 88.4% 
TỶ LỆ KHAI THÁC THÀNH CÔNG THEO SỐ LƯỢNG EPISODE (TEST SET)
===========================================================
DRQN:  [800 Ep: 71.3%]  ======> [1000 Ep: 83.4%]  ======> [5000 Ep: 88.4%]
DQN:   [800 Ep: 52.1%]  ===>    [1000 Ep: 63.5%]  ===>    [5000 Ep: 72.8%]

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

  1. Hiệu suất hội tụ vượt trội của DRQN: Nhờ tầng nhớ LSTM lưu trữ chuỗi quan sát trạng thái trước đó, DRQN vượt trội hơn DQN thuần túy 15.6% về độ chính xác trên tập test ở mốc 5,000 episodes và giảm đáng kể hiện tượng dao động chính sách (Policy Oscillation).
  2. Độ đa dạng hành động: Mô hình DRQN duy trì chỉ số entropy hành động tốt hơn, hạn chế rơi vào các vòng lặp gọi các hàm vô nghĩa, tập trung chính xác vào các hàm có khả năng biến đổi số dư (payable, transfer, withdraw, selfdestruct).
  3. Thời gian sinh PoC thực tế: Trung bình mỗi hợp đồng mục tiêu chỉ mất 18.2 giây để hệ thống tạo ra chuỗi khai thác hợp lệ và thực thi thành công trên Ganache.

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

  1. Ứng dụng thành công DRQN giải quyết bài toán quan sát bán phần (POMDP): Trạng thái nội bộ của EVM trong các giao dịch lồng nhau thường bị che khuất. Việc tích hợp RNN/LSTM vào Q-Network là giải pháp đột phá giúp mô hình "nhớ" được ngữ cảnh các lệnh gọi trước đó.
  2. Cơ chế tự động sinh Payload & Attack Contract: Không chỉ đưa ra cảnh báo dòng lệnh có lỗi như các công cụ phân tích tĩnh, SCE trực tiếp biên dịch và sinh mã hợp đồng tấn công với cơ chế fallback() đệ quy được cấu hình chuẩn xác.
  3. Mã hóa ngữ nghĩa mã nguồn thông minh: Sử dụng kỹ thuật biểu diễn không gian vector (Word2Vec/FastText) kết hợp phân tích cấu trúc cây AST, giúp tác tử có khả năng tổng quát hóa trên cả những hợp đồng chưa từng gặp trong tập huấn luyện.
SO SÁNH CÁC TÍNH NĂNG ĐỘT PHÁ GIỮA SCE VÀ CÔNG CỤ TRUYỀN THỐNG
+--------------------------+-------------+-------------+--------------------+
| Tính năng                | Slither     | Mythril     | SCE (Nghiên cứu)   |
+--------------------------+-------------+-------------+--------------------+
| Loại hình phân tích      | Static AST  | Symbolic    | Reinforcement (RL) |
| Tự sinh Attack Contract  | Không       | Không       | CÓ (Tự động)       |
| Khai thác Reentrancy sâu | Kém         | Trung bình  | XUẤT SẮC (DRQN)    |
| Tỷ lệ False Positive     | Cao (35%+)  | Vừa (20%)   | RẤT THẤP (<5%)     |
+--------------------------+-------------+-------------+--------------------+

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

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

  • Tích hợp quy trình CI/CD DevSecOps cho Web3: Tự động kích hoạt công cụ SCE chạy kiểm thử xâm nhập (Penetration Testing) mỗi khi có bản commit mới vào repository hợp đồng thông minh trước khi triển khai Mainnet.
  • Hỗ trợ chuyên gia Audit (Auditor Copilot): Giúp kiểm toán viên nhanh chóng xác thực tính khả thi của một phát hiện mà không cần tự tay viết script khai thác thủ công.
  • Săn lỗi nhận thưởng (Automated Bug Bounty): Hỗ trợ các nhà nghiên cứu bảo mật quét diện rộng các hợp đồng đã triển khai để tìm kiếm lỗ hổng có thể khai thác và thông báo có trách nhiệm cho chủ dự án.

Hướng dẫn triển khai công cụ (Deployment Steps)

# 1. Khởi tạo môi trường ảo Python và cài đặt dependencies
python3 -m venv venv
source venv/bin/activate
pip install torch web3 py-solc-x gensim gym

# 2. Khởi chạy nút Blockchain cục bộ Ganache
ganache-cli --gasLimit 8000000 --defaultBalanceEther 1000 -p 8545 &

# 3. Chạy công cụ SCE để huấn luyện và khai thác hợp đồng mục tiêu
python main.py --contract ./contracts/Victim.sol --model DRQN --episodes 1000

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

Hạn chế kỹ thuật

  • Lỗ hổng logic nghiệp vụ phức tạp: Chưa hỗ trợ các kịch bản đòi hỏi tính toán toán học quá chuyên biệt hoặc kết hợp nhiều điều kiện ngẫu nhiên (Oracle manipulation, Cross-contract arbitrage).
  • Phụ thuộc tài nguyên mô phỏng: Tốc độ tương tác với mạng Ganache (EVM state reset) giới hạn tốc độ huấn luyện mô hình khi mở rộng lên hàng chục nghìn episodes.

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

  • Ứng dụng mô hình Transformer/Decision Transformer: Thay thế mạng LSTM bằng kiến trúc Self-Attention để bắt trọn các mối quan hệ ngữ cảnh dài hơn trong các hệ thống DeFi phức hợp.
  • Mở rộng đa chuỗi: Hỗ trợ các chuỗi tương thích EVM (BNB Chain, Polygon, Arbitrum) và các nền tảng smart contract non-EVM như Solana (Rust) và Aptos/Sui (Move).

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

  • Sinh viên & Học viên chuyên ngành ATTT/CNTT: Nguồn tài liệu chuyên sâu về ứng dụng trí tuệ nhân tạo (AI/RL) trong an toàn thông tin và bảo mật Blockchain.
  • Lập trình viên Blockchain (Smart Contract Developers): Hiểu rõ cơ chế khai thác thực tế của hacker để chủ động áp dụng các mẫu lập trình an toàn như Checks-Effects-Interactions pattern và sử dụng thư viện bảo vệ ReentrancyGuard của OpenZeppelin.
  • Các công ty Kiểm toán & Doanh nghiệp Web3: Giải pháp cắt giảm đến 70% thời gian thẩm định lỗ hổng sơ bộ, nâng cao độ tin cậy của dịch vụ bảo mật.
  • Nhà nghiên cứu khoa học: Cung cấp cơ sở lý thuyết và dữ liệu thực nghiệm chuẩn xác về việc ứng dụng DRQN trong không gian hành động rời rạc của an ninh mạng.

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

1. Cấu hình phần cứng tối thiểu để triển khai và chạy công cụ SCE là gì?

Hệ thống yêu cầu máy tính chạy hệ điều hành Linux (khuyến nghị Ubuntu 20.04/22.04 LTS), tối thiểu 16GB RAM, CPU từ 6 nhân trở lên. Để tăng tốc độ huấn luyện mạng DRQN, khuyến nghị trang bị GPU NVIDIA có tối thiểu 6GB VRAM và hỗ trợ CUDA v11+.

2. Mô hình DRQN giải quyết hiện tượng bùng nổ không gian trạng thái như thế nào?

SCE áp dụng cơ chế lọc tiền xử lý dựa trên AST và ABI để loại bỏ các hàm chỉ đọc (read-only), kết hợp phương pháp nhúng vector (Word2Vec/FastText) nén chiều dữ liệu và kỹ thuật Experience Replay giúp chọn mẫu ngẫu nhiên, loại bỏ tương quan chuỗi và giữ kích thước không gian học tập ở mức tối ưu.

3. Công cụ có gây nguy cơ tấn công phá hoại trên mạng Mainnet không?

Không. SCE được thiết kế hoạt động hoàn toàn trong môi trường sandbox khép kín (Ganache Local Network). Toàn bộ giao dịch và chuỗi khai thác chỉ được thực thi trên bản sao cục bộ nhằm phục vụ mục đích kiểm thử an toàn trước khi công bố báo cáo PoC.

4. Chi phí và thời gian cần thiết để kiểm thử một hợp đồng thông minh là bao nhiêu?

Sau khi mô hình DRQN đã được huấn luyện sẵn (Pre-trained), thời gian kiểm thử và sinh chuỗi khai thác cho một hợp đồng thông minh mới chỉ mất từ 15 đến 30 giây, không phát sinh chi phí gas thực tế do chạy trên môi trường testnet giả lập.

5. SCE có phát hiện được các phiên bản hợp đồng Solidity mới nhất (0.8.x+) không?

Có. Hệ thống tích hợp solc-select cho phép tự động chuyển đổi linh hoạt trình biên dịch từ phiên bản 0.4.x đến 0.8.x+, đảm bảo tương thích hoàn toàn với các cơ chế kiểm tra tràn số tự động (Built-in Overflow checks) của Solidity phiên bản mới.

Kết luận

Khóa luận tốt nghiệp của tác giả Phùng Ngọc Huyễn (MSSV: 19521646), dưới sự hướng dẫn của TS. Nguyễn Tấn Cẩm và ThS. Đỗ Hoàng Hiển tại Phòng thí nghiệm An toàn thông tin (InSecLab), đã giải quyết xuất sắc bài toán tự động hóa khai thác lỗ hổng trên hợp đồng thông minh. Việc kết hợp sáng tạo giữa cấu trúc Cây cú pháp trừu tượng (AST), Giao diện nhị phân ứng dụng (ABI) cùng thuật toán học tăng cường sâu Deep Recurrent Q-Network (DRQN) đã chứng minh tính khả thi vượt trội với tỷ lệ khai thác thành công đạt 88.4% trên tập dữ liệu kiểm thử.

Nghiên cứu không chỉ đóng góp giá trị học thuật quan trọng trong việc ứng dụng học tăng cường vào an ninh mạng Blockchain mà còn cung cấp một công cụ thực tiễn mạnh mẽ, hỗ trợ đắc lực cho các nhà phát triển và chuyên gia bảo mật trong việc xây dựng hệ sinh thái Web3 an toàn, minh bạch và bền vững.