Giới thiệu dự án
Trong kỷ nguyên chuyển đổi số và phát triển phần mềm nguồn mở bùng nổ, các cuộc tấn công chuỗi cung ứng phần mềm (Software Supply Chain Attacks) và mã độc biến thể ngày càng gia tăng với mức độ tinh vi phức tạp. Theo thống kê từ Cybersecurity Ventures, thiệt hại do tội phạm mạng toàn cầu ước tính vượt mốc 10.5 nghìn tỷ USD hàng năm, trong đó hơn 60% các sự cố bảo mật bắt nguồn từ việc tái sử dụng mã nguồn chứa lỗ hổng đã biết (Known Vulnerabilities - CVE) nhưng không được vá kịp thời.
Phát hiện sự tương đồng trong mã nhị phân (Binary Code Similarity Detection - BCSD) là kỹ thuật nền tảng cho phép so sánh hai đoạn mã máy (machine code/binary bytecode) mà không cần tiếp cận mã nguồn gốc (source code). Kỹ thuật này đóng vai trò then chốt trong:
- Phân tích và truy vết mã độc (Malware Analysis & Triage): Nhận diện các biến thể mã độc mới được phát triển từ các dòng mã độc cũ hoặc các framework tấn công đã biết.
- Truy vết lỗ hổng 1-day (Vulnerability Hunting & 1-day Exploits): Rà soát các thư viện nhị phân bên thứ ba tích hợp trong firmware thiết bị IoT/SCADA để phát hiện các hàm chứa mã lỗi đã được công bố CVE.
- Kiểm định bản quyền và chống đạo văn phần mềm (Software Plagiarism & License Compliance): Phát hiện việc vi phạm giấy phép nguồn mở (GPL, MIT, Apache) trong các phần mềm thương mại đóng gói dạng binary.
[Mã nguồn C/C++]
/ \
[GCC -O0 / x86] [Clang -O3 / ARM]
| |
[Binary Executable A] [Binary Executable B]
\ /
\--[ Khác biệt lớn về ]--/
- Cấu trúc lệnh máy (Instruction Set)
- Đồ thị luồng điều khiển (CFG)
- Phân bổ thanh ghi (Register Allocation)
Thách thức cốt lõi của bài toán BCSD bắt nguồn từ sự phân kỳ mã nhị phân: cùng một mã nguồn khi biên dịch bằng các trình biên dịch khác nhau (GCC, Clang, MSVC), các mức độ tối ưu hóa khác nhau (-O0, -O1, -O2, -O3, -Os), hoặc các kiến trúc vi xử lý khác nhau (x86, x86_64, ARM, MIPS) sẽ tạo ra các file nhị phân có cấu trúc lệnh máy, phân bổ thanh ghi và đồ thị luồng điều khiển (Control Flow Graph - CFG) hoàn toàn khác biệt.
Đồ án tập trung giải quyết bài toán trên thông qua việc nghiên cứu, phát triển và thử nghiệm giải pháp BinShoo – một hệ thống phát hiện sự tương đồng mã nhị phân kết hợp giữa biểu diễn trung gian đa nền tảng VEX-IR, phương pháp vector hóa cải tiến Proc2vec+, và kiến trúc mạng nơ-ron sâu Siamese Neural Network.
Mục tiêu nghiên cứu cụ thể
- Xây dựng đường ống tiền xử lý mã nhị phân chuẩn hóa: Sử dụng công cụ dịch ngược (decompiler) IDA Pro kết hợp cùng Intermediate Representation (VEX-IR) để triệt tiêu sự phụ thuộc vào tập lệnh của từng kiến trúc phần cứng.
- Cải tiến kỹ thuật vector hóa Proc2vec+: Phát triển thuật toán phân rã basic block thành các lát cắt ngữ nghĩa (Strands), kết hợp chuỗi tối ưu hóa trình biên dịch bao gồm: Copy Propagation, Dead Code Elimination, Variable Normalization, Inlining, và Constant Folding để tạo vector đặc trưng bền vững qua hàm băm MD5.
- Thiết kế kiến trúc học sâu tối ưu BinShoo: Phát triển mạng nơ-ron Siamese kết hợp lớp tích chập không gian (CNN) và lớp học chuỗi thời gian (LSTM/GRU) nhằm ánh xạ các cặp vector đặc trưng vào không gian tương đồng ngữ nghĩa.
- Thực nghiệm và đánh giá toàn diện: Đo lường hiệu năng mô hình trên tập dữ liệu chuẩn quy mô lớn BinaryCorp với các tác vụ so khớp cặp đơn (One-to-one) và xếp hạng truy xuất (One-to-many), đối chiếu trực tiếp với các giải pháp tiền nhiệm như Zeek, BinDeep, và các mô hình nền tảng ngôn ngữ BERT.
Phạm vi và giới hạn của đề tài
- Đối tượng phân tích: Các tệp tin thực thi nhị phân định dạng ELF và PE được biên dịch từ ngôn ngữ C/C++ trên các kiến trúc x86, ARM, MIPS dưới 5 mức tối ưu hóa phổ biến (
-O0, -O1, -O2, -O3, -Os).
- Đơn vị phân tích: Mức độ hàm (Function-level granularity), tập trung vào việc trích xuất và so khớp ngữ nghĩa của từng function độc lập.
- Phương pháp tiếp cận: Phân tích tĩnh (Static Binary Analysis) kết hợp học sâu (Deep Learning), không yêu cầu thực thi động mã nhị phân trong môi trường sandbox.
Phân tích và thiết kế giải pháp
Phân tích hiện trạng và các giải pháp tiền nhiệm
Các phương pháp phát hiện sự tương đồng mã nhị phân trong nghiên cứu hiện đại được chia thành ba nhóm tiếp cận chính:
| Phương pháp |
Đại diện tiêu biểu |
Ưu điểm |
Nhược điểm / Hạn chế |
| So khớp cấu trúc đồ thị (Graph-based) |
BinDiff, Genius, Gemini |
Khai thác trực quan cấu trúc rẽ nhánh của đồ thị CFG |
Không ổn định; CFG thay đổi mạnh khi bật tối ưu hóa (-O3); chi phí tính toán đồ thị đẳng cấu (Graph Isomorphism) đạt độ phức tạp $O(V!)$ |
| Mô hình ngôn ngữ tự nhiên (NLP/Transformer) |
SAFE, Asm2Vec, BERT, jTrans |
Nắm bắt ngữ nghĩa chuỗi lệnh tốt; học được ngữ cảnh token đa dạng |
Cần tài nguyên GPU cực lớn để huấn luyện trước (pre-training); suy luận chậm, số lượng tham số khổng lồ |
| Biểu diễn trung gian kết hợp học sâu |
Zeek (Proc2vec), BinDeep |
Độc lập kiến trúc nhờ IR; tốc độ xử lý nhanh; mô hình gọn nhẹ |
Proc2vec nguyên bản còn nhạy cảm với nhiễu mã rác; chưa áp dụng triệt để tối ưu hóa cục bộ |
Hạn chế lớn nhất của phương pháp Zeek (Proc2vec) là việc chia nhỏ hàm chưa triệt để và chưa xử lý các biểu thức hằng hoặc biến tạm sinh ra trong quá trình nâng mã sang IR, dẫn đến việc băm ngữ nghĩa bằng MD5 bị phân mảnh khi mã trải qua các mức tối ưu hóa khác nhau. Trong khi đó, BinDeep phụ thuộc nhiều vào chuỗi lệnh assembly thô, dễ bị ảnh hưởng khi chuyển đổi cross-architecture.
Yêu cầu hệ thống theo mô hình MoSCoW
- Must Have (Bắt buộc phải có):
- Module tự động trích xuất ranh giới hàm và bytecode nhị phân thông qua IDA Pro API.
- Bộ dịch chuyển mã máy sang VEX-IR sử dụng thư viện PyVEX/Angr.
- Thuật toán bóc tách Basic Block thành các Strand ngữ nghĩa tối thiểu.
- Pipeline tối ưu hóa mã: Dead Code Elimination, Constant Folding, Copy Propagation.
- Mạng nơ-ron Siamese huấn luyện hàm mất mát Contrastive/Cross-Entropy cho bài toán One-to-one và One-to-many.
- Should Have (Nên có):
- Module chuẩn hóa biến nội bộ (Normalization) để đồng nhất định dạng thanh ghi tạm.
- Khả năng xếp hạng truy xuất lỗ hổng với thang đo Mean Reciprocal Rank (MRR) và Recall@1.
- Could Have (Có thể mở rộng):
- Tích hợp cơ sở dữ liệu vector hóa quy mô lớn để hỗ trợ tìm kiếm hàng triệu hàm trong thời gian thực.
- Won't Have (Chưa thực hiện trong phạm vi này):
- Hỗ trợ giải mã và giải ảo hóa các kỹ thuật làm rối mã nâng cao (Anti-debugging, Code Virtualization/VMProtect).
Thiết kế kiến trúc tổng thể của BinShoo
Hệ thống BinShoo được thiết kế theo mô hình xử lý đường ống phân tầng khép kín:
Technology Stack chi tiết
+-------------------------------------------------------------------------+
| BINSHOO PIPELINE |
+-------------------------------------------------------------------------+
| [Disassembly Engine] IDA Pro v7.7+ / v8.3 | IDAPython (Python 3.10) |
| [IR Translation] Angr Framework v9.2.45 | PyVEX Engine |
| [Vector Preprocessing] NumPy v1.24.3 | Scipy v1.10.1 |
| [Deep Learning Model] PyTorch v2.2.0+cu121 | Torchvision v0.17.0 |
| [Evaluation Engine] Scikit-learn v1.3.2 | Pandas v2.0.3 |
| [Target Architectures] x86 (32/64-bit), ARM (v7/v8), MIPS |
+-------------------------------------------------------------------------+
Thiết kế Vector hóa Proc2vec+ và VEX-IR
Đơn vị cơ bản của VEX-IR là IRSB (IR Super Block), đại diện cho một basic block độc lập. Mỗi IRSB chứa một danh sách các câu lệnh IRStmt và các biểu thức IRExpr.
Ví dụ về câu lệnh VEX-IR sau khi chuyển đổi từ mã máy:
// Ví dụ chuyển đổi phép gán và tính toán trong VEX-IR
t12 = GET:I32(offset=20) // Đọc giá trị thanh ghi tại offset 20 lưu vào biến tạm t12
t13 = Sub32(t12, 0x00000001) // Trừ t12 đi 1, lưu vào t13
t2 = Add32(t13, 0x00000001) // Cộng t13 với 1, lưu vào t2
PUT(offset=8) = t2 // Cập nhật giá trị t2 vào thanh ghi tại offset 8
Quá trình trích xuất Strand đóng vai trò cô lập các luồng phụ thuộc dữ liệu: thay vì giữ nguyên cả Basic Block dài (dễ bị thay đổi khi tối ưu hóa), hàm được chia thành các lát cắt câu lệnh có quan hệ định nghĩa - sử dụng (Def-Use Chain). Mỗi Strand sau đó được chuẩn hóa biến thành dạng tổng quát v0, v1, v2... và băm bằng hàm MD5. Vector đại diện của toàn bộ Function được hình thành dựa trên tần suất xuất hiện của các mã băm này trong từ điển không gian cố định $D = 1024$.
Implementation và kết quả
Quy trình phát triển thuật toán bóc tách Strand
Thuật toán bóc tách Strand nhận đầu vào là danh sách các câu lệnh $bb$ trong một Basic Block và trả về tập hợp các Strand $S$:
def extract_strands(basic_block_stmts):
"""
Thuật toán trích xuất danh sách Strand từ một Basic Block VEX-IR
Input: basic_block_stmts - Danh sách các câu lệnh IRStmt trong một Basic Block
Output: S - Danh sách các Strand độc lập ngữ nghĩa
"""
uncovered = list(range(len(basic_block_stmts)))
strands = []
while len(uncovered) > 0:
last_idx = uncovered.pop()
current_strand = [basic_block_stmts[last_idx]]
used_vars = get_referenced_variables(basic_block_stmts[last_idx])
# Duyệt ngược để tìm các câu lệnh gán biến liên quan trực tiếp
for i in range(last_idx - 1, -1, -1):
defined_vars = get_defined_variables(basic_block_stmts[i])
needed_vars = defined_vars.intersection(used_vars)
if len(needed_vars) > 0:
current_strand.insert(0, basic_block_stmts[i])
if i in uncovered:
uncovered.remove(i)
# Cập nhật danh sách biến phụ thuộc mới
used_vars = used_vars.difference(defined_vars)
used_vars = used_vars.union(get_referenced_variables(basic_block_stmts[i]))
strands.append(current_strand)
return strands
Kỹ thuật tối ưu hóa mã trong Proc2vec+
Sau khi bóc tách Strand, hệ thống áp dụng 4 bước chuẩn hóa liên hoàn:
- Copy Propagation: Tìm các lệnh gán dạng
t2 = t1 và thay thế trực tiếp các vị trí sử dụng t2 bằng t1, loại bỏ các phép gán trung gian dư thừa.
- Dead Code Elimination: Xóa bỏ toàn bộ các câu lệnh khởi tạo biến tạm
WrTmp(t_n) mà giá trị của nó không bao giờ được tham chiếu ở các câu lệnh tiếp theo trong khối.
- Constant Folding: Tính toán trước các biểu thức chứa hằng số ngay tại thời điểm xử lý. Ví dụ: Biểu thức
Add32(0x00000004, 0x00000002) được rút gọn trực tiếp thành hằng số 0x00000006.
- Variable Normalization: Đổi tên tuần tự tất cả các biến tạm
t0, t1, t2... theo thứ tự xuất hiện từ trên xuống dưới trong từng Strand, giúp loại bỏ sự khác biệt ngẫu nhiên về chỉ số biến giữa các lần phân tích.
+-----------------------------------------------------------------------------------+
| MINH HỌA QUÁ TRÌNH TỐI ƯU HÓA STRAND TRONG PROC2VEC+ |
+-----------------------------------------------------------------------------------+
| [Raw VEX-IR Block] |
| t12 = GET:I32(offset=20) |
| t13 = Sub32(t12, 0x00000001) |
| t2 = Add32(t13, 0x00000001) |
| PUT(offset=8) = t2 |
| |
| [Sau Copy Propagation & Constant Folding] |
| t12 = GET:I32(offset=20) |
| PUT(offset=8) = t12 <-- Triệt tiêu phép toán -1 + 1 |
| |
| [Sau Variable Normalization] |
| v0 = GET:I32(offset=20) |
| PUT(offset=8) = v0 --> Băm MD5: "a8f5c9e2b1..." -> Vector Index |
+-----------------------------------------------------------------------------------+
Kiến trúc mạng Siamese Neural Network trong BinShoo
Mô hình học sâu BinShoo sử dụng cấu trúc mạng nơ-ron hai nhánh song song chia sẻ chung trọng số (Weight Sharing). Mỗi nhánh bao gồm sự kết hợp giữa khối trích xuất đặc trưng không gian (1D Convolutional Layer + MaxPooling) và khối trích xuất đặc trưng chuỗi phụ thuộc (Bi-directional LSTM / GRU).
import torch
import torch.nn as nn
class BinShooSubNetwork(nn.Module):
def __init__(self, input_dim=1024, embedding_dim=128):
super(BinShooSubNetwork, self).__init__()
# Khối trích xuất đặc trưng không gian (CNN)
self.conv_block = nn.Sequential(
nn.Conv1d(in_channels=1, out_channels=64, kernel_size=5, stride=1, padding=2),
nn.BatchNorm1d(64),
nn.ReLU(),
nn.MaxPool1d(kernel_size=2, stride=2),
nn.Dropout(p=0.3)
)
# Khối trích xuất đặc trưng chuỗi tuần tự (Bi-LSTM)
self.lstm = nn.LSTM(input_size=64, hidden_size=64, num_layers=2,
batch_first=True, bidirectional=True)
# Lớp fully-connected ánh xạ ra không gian embedding
self.fc = nn.Sequential(
nn.Linear(128 * (input_dim // 2), embedding_dim),
nn.ReLU(),
nn.Linear(embedding_dim, embedding_dim)
)
def forward(self, x):
# x shape: (batch_size, 1, input_dim)
conv_out = self.conv_block(x)
# conv_out shape: (batch_size, 64, input_dim // 2)
lstm_in = conv_out.permute(0, 2, 1)
lstm_out, _ = self.lstm(lstm_in)
# lstm_out shape: (batch_size, input_dim // 2, 128)
flattened = lstm_out.reshape(lstm_out.size(0), -1)
embedding = self.fc(flattened)
return embedding
class BinShooSiameseNetwork(nn.Module):
def __init__(self, input_dim=1024, embedding_dim=128):
super(BinShooSiameseNetwork, self).__init__()
self.feature_extractor = BinShooSubNetwork(input_dim, embedding_dim)
self.cosine_sim = nn.CosineSimilarity(dim=1, eps=1e-6)
def forward(self, func_vec_a, func_vec_b):
embed_a = self.feature_extractor(func_vec_a)
embed_b = self.feature_extractor(func_vec_b)
similarity = self.cosine_sim(embed_a, embed_b)
return similarity
Thử nghiệm và đánh giá kết quả
Hệ thống được huấn luyện và đánh giá trên tập dữ liệu chuẩn BinaryCorp (bao gồm hàng triệu hàm được biên dịch từ các dự án mã nguồn mở như OpenSSL, Coreutils, SQLite, AES-crypt):
- Tập huấn luyện (Training Set): 8,357 tệp nhị phân với 3,126,367 hàm.
- Tập kiểm thử (Testing Set): 1,908 tệp nhị phân với 444,574 hàm.
1. Đánh giá hiệu quả của kỹ thuật vector hóa: Proc2vec vs. Proc2vec+
Thực nghiệm so sánh khả năng giữ vững độ chính xác qua các mức tối ưu hóa khác nhau (-O0 đến -O3, -Os):
| Phương pháp vector hóa |
Recall@1 (%) |
Recall@5 (%) |
MRR (Mean Reciprocal Rank) |
Thời gian xử lý / Hàm (ms) |
| Proc2vec (Nguyên bản của Zeek) |
64.28% |
79.15% |
0.712 |
1.82 ms |
| Proc2vec+ (Đề xuất trong đề tài) |
78.64% |
89.42% |
0.835 |
2.45 ms |
| Mức độ cải thiện |
+14.36% |
+10.27% |
+0.123 |
Chênh lệch không đáng kể |
2. So sánh hiệu năng giữa các kiến trúc học sâu
Đánh giá trên bài toán One-to-many với kích thước nhóm tìm kiếm $PoolSize = 100$:
| Kiến trúc mô hình |
Accuracy (%) |
Precision (%) |
Recall (%) |
F1-Score (%) |
MRR (Pool=100) |
| CNN đơn thuần |
76.2% |
75.8% |
74.5% |
75.1% |
0.684 |
| LSTM đơn thuần |
79.4% |
78.9% |
78.1% |
78.5% |
0.715 |
| CNN + GRU |
83.1% |
82.5% |
81.9% |
82.2% |
0.762 |
| CNN + LSTM |
84.7% |
84.1% |
83.6% |
83.8% |
0.781 |
| Zeek (2-layer MLP) |
78.5% |
77.2% |
76.9% |
77.0% |
0.720 |
| BinShoo (Đề xuất) |
91.8% |
91.2% |
90.5% |
90.8% |
0.867 |
3. So sánh trực tiếp giữa BinShoo, BinDeep và BERT (Poolsize = 10)
| Công cụ / Mô hình |
Recall@1 (%) |
MRR |
Tốc độ suy luận (Hàm / giây) |
Bộ nhớ GPU tiêu thụ (VRAM) |
| BinDeep (2020) |
82.4% |
0.851 |
145 hàm/s |
1.8 GB |
| BERT for Binary |
89.2% |
0.903 |
24 hàm/s |
9.4 GB |
| BinShoo (Đồ án) |
88.9% |
0.901 |
380 hàm/s |
2.2 GB |
Nhận xét thực nghiệm: Mô hình BinShoo đạt độ chính xác và chỉ số MRR tương đương với mô hình ngôn ngữ lớn BERT (88.9% so với 89.2%), nhưng mang lại tốc độ suy luận nhanh gấp ~15.8 lần và tiết kiệm hơn 76% tài nguyên VRAM. Điều này chứng minh tính vượt trội của việc kết hợp trích xuất đặc trưng có cấu trúc (VEX-IR Strands) với mạng học sâu tinh gọn.
Đổi mới và đóng góp
1. Cải tiến kỹ thuật phân tích ngữ nghĩa mức vi mô (Micro-semantics Strand Analysis)
Đồ án đã giải quyết triệt để vấn đề "nhiễu biên dịch" bằng cách không đánh giá hàm dựa trên các Basic Block thô. Thay vào đó, thuật toán phân tách thành các Strand kết hợp cùng chuỗi tối ưu hóa (Copy Propagation, Constant Folding, Dead Code Elimination) giúp loại bỏ tới 92.4% các biến thể mã máy vô nghĩa sinh ra do các cờ tối ưu hóa -O2/-O3 của trình biên dịch.
[Mã Assembly thô] (Khác nhau hoàn toàn về thanh ghi & lệnh)
|
v
[Nâng mã VEX-IR]
|
v
[Phân tách Strand + Tối ưu hóa] ---> Triệt tiêu 92.4% biến thể mã rác
|
v
[Biểu diễn Vector đồng nhất]
2. Phương pháp vector hóa Proc2vec+ vượt trội
Nâng cấp từ giải pháp của Zeek, phương pháp Proc2vec+ tích hợp cơ chế chuẩn hóa danh danh biến nội bộ (Variable Normalization), giải quyết triệt để tình trạng lệch chỉ số biến tạm giữa các nền tảng kiến trúc khác nhau (x86 sang ARM/MIPS). Kết quả thực nghiệm chứng minh Proc2vec+ giúp tăng 14.36% chỉ số Recall@1 so với phiên bản Proc2vec gốc.
3. Kiến trúc mạng lai Siamese tối ưu cho không gian nhúng nhị phân
Không sử dụng các mạng nơ-ron hồi quy đơn lẻ, BinShoo kết hợp sức mạnh trích xuất bất biến không gian của 1D-CNN và khả năng liên kết chuỗi ngữ cảnh của Bi-LSTM. Mô hình đạt độ chính xác tổng thể 91.8% trong khi vẫn duy trì footprint tính toán cực kỳ nhỏ gọn, cho phép triển khai suy luận thực tế trên các máy trạm phân tích mã độc tiêu chuẩn không cần cụm máy chủ GPU chuyên dụng.
Ứng dụng thực tế và triển khai
Kịch bản ứng dụng thực tế (Real-world Use Cases)
[Cơ sở dữ liệu mẫu CVE]
|
[Firmware Router / IoT] v
| [BinShoo CLI Engine]
+------------> (Trích xuất & Vector hóa)
|
v
[So khớp mức độ tương đồng]
|
+-----------------------+-----------------------+
| |
[Độ tương đồng > 90%] [Độ tương đồng < 50%]
| |
[Cảnh báo lỗ hổng CVE] [Hàm an toàn / Chưa rõ]
- Rà soát lỗ hổng Firmware IoT (Automated 1-day Vulnerability Hunting):
- Bối cảnh: Doanh nghiệp sản xuất thiết bị mạng cần kiểm tra hàng trăm bản build firmware dạng binary không có mã nguồn để rà soát thư viện
libcrypto.so bị dính lỗ hổng Heartbleed (CVE-2014-0160).
- Giải pháp: BinShoo trích xuất vector hàm lỗi nguồn và quét tự động trong toàn bộ firmware mục tiêu, định vị chính xác vị trí hàm dính mã độc chỉ trong vòng 3.5 phút.
- Triệt phá hạ tầng mã độc APT (Malware Family Clustering & Lineage):
- Giúp các trung tâm SOC/CERT phân loại các mẫu mã độc mới phát hiện vào đúng các nhóm tin tặc (Lazarus, APT29, Cobalt Strike) bằng cách so sánh mã nhị phân với kho dữ liệu mẫu mã độc đã gán nhãn.
Chiến lược triển khai hệ thống (Deployment Architecture)
Hệ thống có thể được đóng gói và vận hành dưới 3 hình thức linh hoạt:
- Standalone CLI Tool: Công cụ dòng lệnh tích hợp vào CI/CD Pipeline để tự động quét kiểm tra mã nhị phân trước khi release sản phẩm.
- IDA Pro Plugin: Giao diện đồ họa tích hợp trực tiếp vào môi trường dịch ngược IDA Pro, cho phép chuyên gia phân tích click chọn hàm và tìm kiếm các hàm tương đồng trên cơ sở dữ liệu cloud.
- Microservices API: Dịch vụ RESTful API phục vụ tra cứu hàng loạt, kết hợp cùng cơ sở dữ liệu vector Milvus/FAISS để lưu trữ và lập chỉ mục hàng triệu hàm nhị phân.
Thông số yêu cầu hệ thống (System Requirements)
- Hệ điều hành: Linux (Ubuntu 20.04/22.04 LTS), macOS, hoặc Windows 10/11 x64.
- Yêu cầu phần cứng tối thiểu:
- CPU: 4 Cores (Intel Core i5 hoặc AMD Ryzen 5).
- RAM: 8 GB.
- Ổ cứng: 10 GB dung lượng trống.
- Cấu hình đề xuất cho môi trường doanh nghiệp:
- CPU: 16 Cores (Intel Xeon hoặc AMD EPYC).
- GPU: NVIDIA RTX 3060 trở lên (VRAM >= 8 GB, hỗ trợ CUDA 12.x) để tăng tốc độ suy luận theo batch lớn.
- RAM: 32 GB.
Hạn chế và hướng phát triển
Hạn chế kỹ thuật hiện tại
- Chưa vượt qua các kỹ thuật làm rối mã nâng cao (Obfuscation Resilience): Đối với các tệp tin nhị phân bị làm rối bằng OLLVM (Control Flow Flattening, Bogus Control Flow) hoặc các phần mềm bảo vệ thương mại (Themida, VMProtect), đồ thị luồng điều khiển và cấu trúc lệnh bị bóp méo nghiêm trọng, làm giảm độ chính xác của bước tách Strand.
- Thời gian dịch ngược phụ thuộc vào IDA Pro: Khâu phân tích tĩnh phụ thuộc vào tốc độ phân tích tự động (auto-analysis) của IDA Pro đối với các file nhị phân có kích thước hàng trăm megabyte.
Hướng nghiên cứu và mở rộng tương lai
- Tích hợp học biểu diễn đồ thị (Graph Neural Networks - GNN): Kết hợp vector hóa ngữ nghĩa cấp độ Strand của Proc2vec+ với mạng đồ thị GNN (như Gated Graph Neural Networks) để bảo toàn đồng thời cả ngữ nghĩa vi mô và cấu trúc vĩ mô của toàn bộ đồ thị CFG.
- Mở rộng hỗ trợ kiến trúc và ngôn ngữ: Mở rộng đường ống phân tích cho các mã byte của ngôn ngữ hiện đại như WebAssembly (WASM), Golang, Rust và bytecode của Java/Android DEX.
- Cơ chế xếp hạng lại sử dụng mô hình ngôn ngữ (Cross-Encoder Re-ranking): Áp dụng mô hình Transformer nhỏ ở bước cuối cùng để xếp hạng lại (re-rank) top 10 hàm có độ tương đồng cao nhất nhằm tối ưu hóa điểm số Recall@1 tiệm cận tuyệt đối 99%.
Đối tượng hưởng lợi
+-----------------------------------------------------------------------------------+
| CÁC ĐỐI TƯỢNG HƯỞNG LỢI CHÍNH |
+-----------------------------------------------------------------------------------+
| [Sinh viên & Nghiên cứu sinh] --> Tài liệu tham khảo toàn diện về ứng dụng AI |
| trong Reverse Engineering & An toàn thông tin |
| [Kỹ sư An toàn thông tin] --> Công cụ mã nguồn mở hỗ trợ rà soát lỗ hổng |
| và phân tích mã độc tự động, nhanh gấp 15 lần |
| [Doanh nghiệp & Đơn vị làm phần mềm] --> Tối ưu chi phí rà soát bản quyền mã |
| nguồn mở và kiểm thử bảo mật chuỗi cung ứng |
+-----------------------------------------------------------------------------------+
- Sinh viên và Học viên ngành An toàn Thông tin / Khoa học Máy tính: Có được tài liệu nghiên cứu chuyên sâu, chi tiết về cách kết hợp giữa kỹ thuật dịch ngược mã nguồn cấp thấp (Reverse Engineering, VEX-IR) với các mô hình học sâu hiện đại.
- Chuyên gia phân tích mã độc (Malware Analysts & SOC Teams): Sở hữu một giải pháp phân tích mã nhị phân có độ chính xác cao (91.8%), tốc độ xử lý nhanh (380 hàm/giây), hỗ trợ đắc lực cho công tác ứng cứu sự cố và phân loại mã độc tự động.
- Doanh nghiệp phát triển phần mềm và Thiết bị nhúng/IoT: Tối ưu hóa chi phí và thời gian kiểm thử bảo mật phần mềm, ngăn ngừa nguy cơ bị tấn công từ các lỗ hổng chuỗi cung ứng phần mềm chưa được vá.
Câu hỏi thường gặp (FAQs)
1. Yêu cầu kỹ thuật tối thiểu để triển khai và chạy thử nghiệm BinShoo là gì?
Hệ thống yêu cầu môi trường máy chủ chạy hệ điều hành Linux/Ubuntu có cài đặt Python 3.10+, IDA Pro (phiên bản từ 7.5 trở lên có hỗ trợ IDAPython), và môi trường PyTorch 2.x. Nếu chỉ sử dụng cho tác vụ suy luận (Inference), hệ thống chỉ yêu cầu CPU thông thường và 8 GB RAM.
2. Proc2vec+ khác biệt như thế nào so với kỹ thuật Proc2vec gốc trong công cụ Zeek?
Proc2vec gốc chỉ bóc tách Strand cơ bản và băm trực tiếp. Proc2vec+ bổ sung 4 kỹ thuật tối ưu hóa compiler trung gian: loại bỏ mã chết (Dead Code Elimination), lan truyền bản sao (Copy Propagation), gập hằng số (Constant Folding), và chuẩn hóa tên biến (Normalization). Nhờ đó, Proc2vec+ loại bỏ các sai lệch cú pháp do trình biên dịch tối ưu hóa gây ra, giúp tăng chỉ số Recall@1 thêm 14.36%.
3. Hệ thống có khả năng so khớp mã nhị phân giữa các kiến trúc vi xử lý khác nhau (Cross-Architecture) không?
Có. Nhờ việc sử dụng ngôn ngữ biểu diễn trung gian VEX-IR (từ dự án Valgrind/Angr), mọi tập lệnh của các kiến trúc khác nhau như x86, x86_64, ARM, MIPS đều được nâng cấp và chuyển đổi về một tập ngữ nghĩa chuẩn hóa chung trước khi đưa vào bước trích xuất vector.
4. Tại sao đồ án không sử dụng trực tiếp các mô hình Transformer như BERT cho toàn bộ quy trình?
Mặc dù BERT đạt độ chính xác cao nhưng đòi hỏi chi phí tính toán rất lớn, tốc độ suy luận chậm (chỉ khoảng 24 hàm/giây) và tiêu tốn nhiều bộ nhớ GPU (gần 10 GB VRAM). Kiến trúc của BinShoo đạt độ chính xác tương đương BERT (88.9% so với 89.2%) nhưng tốc độ xử lý nhanh hơn gần 16 lần và tiêu thụ tài nguyên phần cứng thấp hơn 76%, phù hợp cho môi trường ứng dụng thực tế.
5. Chi phí triển khai và thời gian hoàn vốn đầu tư (ROI) cho doanh nghiệp được tính toán ra sao?
Giải pháp được xây dựng hoàn toàn trên nền tảng mã nguồn mở và kiến trúc học sâu tối ưu phần cứng. Đối với một doanh nghiệp bảo mật hoặc kiểm thử phần mềm, việc tự động hóa khâu rà soát nhị phân giúp tiết kiệm hàng trăm giờ làm việc thủ công của các chuyên gia dịch ngược cao cấp, mang lại thời gian hoàn vốn (ROI) ước tính chỉ trong vòng 3 đến 6 tháng sau khi đưa vào vận hành.
Kết luận
Đồ án tốt nghiệp "A Study on Binary Code Similarity Detection using Language Model and Deep Neural Networks" đã giải quyết thành công bài toán phát hiện sự tương đồng mã nhị phân đa kiến trúc và đa tối ưu hóa. Thông qua việc đề xuất phương pháp vector hóa cải tiến Proc2vec+ và mô hình học sâu BinShoo, nghiên cứu đã chứng minh tính hiệu quả vượt trội trong việc bóc tách và chuẩn hóa ngữ nghĩa mã máy.
Với độ chính xác phân loại đạt 91.8%, chỉ số MRR đạt 0.867 trên tập dữ liệu chuẩn BinaryCorp và tốc độ xử lý vượt trội đạt 380 hàm/giây, BinShoo mở ra hướng tiếp cận thực tiễn cao cho các ứng dụng rà soát lỗ hổng bảo mật tự động, phân tích mã độc, và bảo vệ bản quyền phần mềm. Kết quả này tạo tiền đề vững chắc cho việc tiếp tục tích hợp các mô hình biểu diễn đồ thị (GNN) và các kỹ thuật chống rối mã nâng cao trong các giai đoạn phát triển tiếp theo.
