Giới thiệu dự án

Trong bối cảnh chuyển đổi số toàn cầu và sự bùng nổ của các hệ thống điều khiển công nghiệp (ICS), thiết bị Internet vạn vật (IoT) cùng hạ tầng đô thị thông minh, an toàn phần mềm trở thành yêu cầu sống còn. Theo các báo cáo an ninh mạng quốc tế, hơn 70% các lỗ hổng bảo mật nghiêm trọng (như tràn bộ đệm - Buffer Overflow, giải phóng vùng nhớ hai lần - Double Free, sử dụng vùng nhớ sau khi giải phóng - Use-After-Free) xuất phát từ các chương trình viết bằng C/C++ khi được biên dịch thành mã thực thi nhị phân. Các sự cố bảo mật này dẫn đến thiệt hại kinh tế lên đến hàng tỷ USD và rò rỉ dữ liệu diện rộng.

+-----------------------------------------------------------------------------------+
| THÁCH THỨC BẢO MẬT PHẦN MỀM NHỊ PHÂN                                              |
|  - 70%+ lỗ hổng nghiêm trọng bắt nguồn từ quản lý bộ nhớ cấp thấp (C/C++)         |
|  - Hầu hết phần mềm thương mại phân phối dạng nhị phân đóng gói (ELF/PE)          |
|  - Fuzzing truyền thống: Đột biến ngẫu nhiên gây lãng phí hàng triệu lần thử      |
|  - RL-Fuzzing hiện tại: Mất cân bằng giữa Khám phá (Explore) & Khai thác (Exploit)|
+-----------------------------------------------------------------------------------+

Khóa luận tốt nghiệp Kỹ sư An toàn Thông tin tại Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM (thực hiện bởi sinh viên Nguyễn Phúc Chương và Phạm Thành Thái, dưới sự hướng dẫn của TS. Phạm Văn Hậu và ThS. Phan Thế Duy) tập trung giải quyết bài toán: Nghiên cứu và phát triển phương pháp kiểm thử mờ có chỉ dẫn độ phủ (Coverage-Guided Fuzzing) cho phần mềm nhị phân định dạng ELF 64-bit sử dụng học tăng cường (Reinforcement Learning - RL).

Vấn đề cốt lõi của các fuzzer hiện đại ứng dụng học máy là hiện tượng mất cân bằng nghiêm trọng giữa tính khai thác (exploitation) và tính khám phá (exploration). Khi fuzzer quá thiên về khai thác, mô hình có xu hướng đào sâu vào một nhánh điều khiển duy nhất và bỏ qua các lỗi tiềm ẩn ở các nhánh khác. Ngược lại, nếu fuzzer chỉ tập trung khám phá bề rộng, các mẫu thử không thể vượt qua các chuỗi kiểm tra điều kiện phức tạp để tiếp cận các khối mã sâu bên trong.

Dự án đặt ra các mục tiêu cụ thể:

  1. Xây dựng khung kiểm thử hộp xám (Grey-box Fuzzing) hoạt động trực tiếp trên tệp thực thi ELF 64-bit không yêu cầu mã nguồn.
  2. Mô hình hóa bài toán đột biến đầu vào thành Quy trình quyết định Markov (MDP) và tích hợp mạng học sâu tăng cường (Deep Q-Network - DQN) để dự đoán toán tử đột biến tối ưu.
  3. Phát triển thuật toán chọn và lập lịch đầu vào (Seed Selection & Scheduling) kết hợp cơ chế đột biến nhiều cấp và chống lãng phí tài nguyên.
  4. Đánh giá thực nghiệm so chuẩn với công cụ học tăng cường hiện đại rlfuzz và fuzzer công nghiệp tiêu chuẩn AFLplusplus (AFL++).

Phạm vi nghiên cứu tập trung vào môi trường Linux x86_64, tối ưu hóa quá trình fuzzing thông qua cơ chế giao tiếp tiến trình hiệu năng cao (Shared Memory và Semaphore).


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

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

Kiểm thử phần mềm phát hiện lỗ hổng hiện nay được chia thành ba hướng tiếp cận chính: Hộp trắng (White-box), Hộp đen (Black-box) và Hộp xám (Grey-box).

Tiêu chí Fuzzing Hộp Đen Fuzzing Hộp Trắng Fuzzing Hộp Xám (Đề xuất)
Yêu cầu mã nguồn Không Bắt buộc có Không (chỉ cần tệp ELF)
Tốc độ thực thi Rất cao (>2000 exec/s) Rất chậm (<50 exec/s do giải SMT) Cao (500 - 1500 exec/s qua Forkserver)
Độ bao phủ nhánh Rất thấp (mù quáng) Toàn diện nhưng nghẽn path-explosion Tối ưu nhờ Trace Bits Bitmap
Phù hợp phần mềm đóng gói Không Rất cao

Phân tích yêu cầu hệ thống theo mô hình MoSCoW:

  • Must have (Bắt buộc): Tương tác nhị phân ELF không cần mã nguồn; Cơ chế Forkserver trích xuất Bitmap độ phủ mã cạnh (Edge Coverage); Thuật toán DQN học chính sách đột biến.
  • Should have (Nên có): Thuật toán lập lịch hạt giống cân bằng Explore/Exploit; Bộ lọc đột biến chống lãng phí byte.
  • Could have (Có thể có): Hỗ trợ nạp động nhiều định dạng seed khác nhau; Ghi nhận crash tự động phục vụ phân tích nguyên nhân gốc.
  • Won't have (Chưa hỗ trợ): Phân tích nhị phân đa nền tảng kiến trúc (ARM/MIPS); Tự động sinh mã khai thác lỗ hổng (PoC/Exploit generation).

Thiết kế hệ thống

Kiến trúc tổng thể của hệ thống fuzzing tích hợp học tăng cường được mô hình hóa qua luồng tương tác giữa Tác nhân (Agent), Môi trường Fuzzing và Tiến trình mục tiêu:

flowchart TD
    subgraph Storage ["Quản lý Hạt giống (Corpus & Queue)"]
        SeedQueue["Hàng đợi Seed (Corpus Queue)"]
        Scheduler["Bộ lập lịch & chọn Seed (Balanced Scheduler)"]
    end

    subgraph RLAgent ["DQN Agent (Keras-RL2 / TF)"]
        StateEncoder["Mã hóa Trạng thái (State Vector)"]
        DQNModel["Mạng nơ-ron sâu Deep Q-Network"]
        Policy["EpsGreedyQPolicy"]
    end

    subgraph MutationEngine ["Động cơ Đột biến"]
        MultiMut["Đột biến nhiều cấp (Multi-level Mutator)"]
        AntiWaste["Bộ lọc kiểm tra chống lãng phí"]
    end

    subgraph ExecutionEnv ["Môi trường Thực thi (C Engine)"]
        Forkserver["Forkserver & Shared Memory (shm_open)"]
        TargetApp["Ứng dụng mục tiêu (Target ELF Binary)"]
        CoverageBitmap["Bảng vết nhánh (Trace Bits: 64KB Bitmap)"]
    end

    SeedQueue --> Scheduler
    Scheduler -->|Chọn Seed| StateEncoder
    StateEncoder --> DQNModel
    DQNModel --> Policy
    Policy -->|Toán tử đột biến| MultiMut
    MultiMut --> AntiWaste
    AntiWaste -->|Testcase mới| Forkserver
    Forkserver --> TargetApp
    TargetApp --> CoverageBitmap
    CoverageBitmap -->|Feedback Reward / New Edges| RLAgent
    CoverageBitmap -->|Lưu Seed tốt| SeedQueue

Công nghệ sử dụng trong hệ thống bao gồm:

  • Ngôn ngữ lõi: Python 3.8+ (RL Framework) kết hợp C/C++ (Hệ thống thực thi và IPC).
  • Thư viện Máy học: TensorFlow 2.x, Keras-rl2 0.4.2, OpenAI Gym 0.21.0.
  • Hạ tầng nhị phân: Linux POSIX Shared Memory API, POSIX Semaphore.

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

Nghiên cứu áp dụng phương pháp lặp tăng tiến (Iterative Prototyping) qua 4 giai đoạn chính:

  1. Thiết kế hạ tầng IPC: Đồng bộ dữ liệu tốc độ cao giữa engine quản lý Python và môi trường thực thi C thông qua cơ chế bộ nhớ chia sẻ không sao chép (Zero-copy Shared Memory).
  2. Xây dựng môi trường Gym: Chuẩn hóa giao diện môi trường Gym.Env với không gian trạng thái $\mathcal{S}$ và không gian hành động rời rạc $\mathcal{A}$.
  3. Huấn luyện DQN: Tối ưu hóa hàm suy hao thông qua thuật toán Adam và cơ chế lưu trữ bộ nhớ tuần tự (Sequential Memory).
  4. Kiểm thử đối chuẩn (Benchmarking): Thực nghiệm mù đôi trên các phần mềm xử lý tệp thực tế trong điều kiện khống chế phần cứng.

Implementation và kết quả

Quá trình phát triển và Thuật toán cốt lõi

Bài toán Fuzzing được chuyển hóa thành một Markov Decision Process (MDP) với bộ tham số $M = \langle \mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{R} \rangle$:

  1. Không gian trạng thái ($\mathcal{S}$): Vector đặc trưng trích xuất từ dữ liệu đầu vào hiện tại, bao gồm kích thước tệp, phân bố tần suất byte (Byte Entropy), và lịch sử các cạnh mã mà đầu vào đã kích hoạt.

  2. Không gian hành động ($\mathcal{A}$): Tập hợp các phép biến đổi byte rời rạc:

    • BITFLIP_1_1, BITFLIP_2_1, BITFLIP_4_1: Đảo 1, 2, 4 bit liên tiếp.
    • BYTE_FLIP_1, BYTE_FLIP_2, BYTE_FLIP_4: Đảo byte trực tiếp.
    • ARITH_ADD_8, ARITH_SUB_8: Cộng/trừ số học trên giá trị 8-bit/16-bit.
    • INTERESTING_VAL_8/16/32: Ghi đè các giá trị biên nhị phân đặc biệt (0x00, 0x7F, 0xFF, 0x7FFF, 0xFFFF).
    • BLOCK_DELETE, BLOCK_CLONE, BLOCK_OVERWRITE: Xóa, nhân bản hoặc chèn khối dữ liệu.
  3. Hàm phần thưởng ($\mathcal{R}$): Điểm thưởng được tính toán dựa trên sự đóng góp vào độ phủ mã mới: $$\mathcal{R}(s_t, a_t) = \begin{cases} +10.0 & \text{nếu phát hiện cạnh mới (New Edge)} \ +1.0 & \text{nếu tăng số lần chạm cạnh cũ (Tuple hit count)} \ +100.0 & \text{nếu gây ra sự cố sập chương trình (Unique Crash)} \ -0.1 & \text{nếu không tăng độ phủ (Phạt đột biến dư thừa)} \end{cases}$$

Công thức cập nhật hàm giá trị - hành động theo thuật toán Q-Learning được triển khai qua mạng nơ-ron sâu: $$Q(s, a) \leftarrow Q(s, a) + \alpha \left[ r + \gamma \max_{a'} Q(s', a') - Q(s, a) \right]$$

# Cấu hình DQN Agent tích hợp trong mô hình Fuzzing đề xuất
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, BatchNormalization
from tensorflow.keras.optimizers import Adam
from rl.agents.dqn import DQNAgent
from rl.policy import EpsGreedyQPolicy
from rl.memory import SequentialMemory

def build_dqn_fuzzer_agent(state_shape, nb_actions):
    model = Sequential([
        Flatten(input_shape=(1,) + state_shape),
        Dense(128, activation='relu'),
        BatchNormalization(),
        Dense(128, activation='relu'),
        Dense(64, activation='relu'),
        Dense(nb_actions, activation='linear')
    ])
    
    memory = SequentialMemory(limit=50000, window_length=1)
    policy = EpsGreedyQPolicy(eps=0.15)
    
    dqn = DQNAgent(
        model=model,
        nb_actions=nb_actions,
        memory=memory,
        nb_steps_warmup=1000,
        target_model_update=1e-2,
        policy=policy,
        enable_double_dqn=True
    )
    dqn.compile(Adam(learning_rate=1e-3), metrics=['mae'])
    return dqn

Để tối ưu hóa hiệu năng thực thi mà không gây nghẽn cổ chai I/O, cơ chế giao tiếp nhị phân bằng bộ nhớ chia sẻ được xây dựng trực tiếp trên tầng C:

// Trích xuất độ phủ mã qua Shared Memory và Semaphore (C-Engine)
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdint.h>

#define SHM_COVERAGE_MAP "/fuzz_bitmap_shm"
#define MAP_SIZE 65536 // 64KB Bitmap tương thích cấu trúc AFL

typedef struct {
    sem_t sem_server;
    sem_t sem_client;
    uint8_t trace_bits[MAP_SIZE];
    int status;
} SharedFuzzContext;

SharedFuzzContext* init_fuzz_shm(void) {
    int fd = shm_open(SHM_COVERAGE_MAP, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, sizeof(SharedFuzzContext));
    SharedFuzzContext* ctx = (SharedFuzzContext*)mmap(
        NULL, sizeof(SharedFuzzContext), 
        PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0
    );
    sem_init(&ctx->sem_server, 1, 0);
    sem_init(&ctx->sem_client, 1, 0);
    return ctx;
}

Kiểm thử và Đánh giá thực nghiệm

Thử nghiệm được tiến hành trên môi trường đồng nhất (Ubuntu 20.04 LTS x86_64, CPU Intel Xeon E5-2680 v4 @ 2.40GHz, 16GB RAM) với tập ứng dụng nhị phân chuẩn định dạng ELF gồm các công cụ phân tích tệp tin phổ biến (như readelf, objdump, nm-new, cxxfilt).

Kịch bản 1: Đánh giá theo thời gian chạy liên tục trong 6 giờ

Ứng dụng mục tiêu rlfuzz (Edge Coverage) AFLplusplus (Edge Coverage) Mô hình Đề xuất (Edge Coverage) Mức cải thiện so với rlfuzz (%)
readelf 3,412 4,890 5,120 +50.05%
objdump 2,890 4,210 4,380 +51.55%
nm-new 1,980 3,120 3,250 +64.14%
cxxfilt 1,450 2,240 2,310 +59.31%
+-------------------------------------------------------------------------------+
| SO SÁNH SỐ ĐƯỜNG DẪN DUY NHẤT (UNIQUE PATHS) SAU 6 GIỜ CHẠY                   |
| Ứng dụng: readelf                                                             |
|  - rlfuzz:           ████████ (820 paths)                                     |
|  - AFLplusplus:      ███████████████████ (1,950 paths)                         |
|  - Mô hình đề xuất:  █████████████████████ (2,140 paths)                      |
+-------------------------------------------------------------------------------+

Kịch bản 2: Đánh giá hiệu suất trên 200,000 lần thử đầu tiên (Executions)

Tiêu chí đánh giá rlfuzz AFLplusplus Mô hình Đề xuất Đánh giá kỹ thuật
Độ phủ cạnh (Edges) 2,840 3,920 4,085 Cao hơn AFL++ 4.2%, vượt rlfuzz 43.8%
Đường dẫn duy nhất (Paths) 610 1,420 1,560 DQN chọn toán tử hiệu quả hơn đột biến ngẫu nhiên
Tốc độ thực thi (Exec/s) 185 1,150 940 Giảm overhead suy luận AI nhờ gom batch

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

  1. Cân bằng động giữa Khám phá và Khai thác: Khác với rlfuzz (chọn hạt giống ngẫu nhiên khi độ phủ bão hòa dẫn đến việc lãng phí tài nguyên vào các seed kém tiềm năng), mô hình đề xuất tích hợp thuật toán lập lịch tính điểm ưu tiên dựa trên mật độ cạnh mới và độ sâu thực thi, duy trì khả năng khám phá nhánh mới mà không làm mất dấu vết nhánh sâu.
  2. Cơ chế đột biến nhiều cấp có định hướng (Multi-level RL Mutation): Cho phép tác nhân kết hợp chuỗi hành động đột biến tuần tự theo ma trận trọng số Q-value, giúp vượt qua các rào cản kiểm tra ma thuật (Magic Bytes) và giá trị kiểm tra toàn vẹn (CRC/Checksum) trong cấu trúc tệp phức tạp.
  3. Tối ưu hóa độ trễ IPC trong Grey-box RL Fuzzing: Giảm thiểu chi phí chuyển đổi ngữ cảnh giữa môi trường huấn luyện Python và binary C thông qua giao thức truyền nhận con trỏ bộ nhớ dùng chung, giúp tăng tốc độ thực thi hơn 5.08 lần so với kiến trúc rlfuzz gốc.

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

Tình huống ứng dụng thực tế

  • Kiểm thử bảo mật DevSecOps: Tích hợp vào quy trình CI/CD của các công ty phát triển phần mềm để tự động kiểm thử các thư viện nhị phân bên thứ ba trước khi phát hành.
  • Phân tích mã độc và phần mềm thương mại: Kiểm tra an ninh các phần mềm đóng gói (COTS) hoặc firmware thiết bị mạng chạy trên nền tảng Linux mà không cần nhà cung cấp bàn giao mã nguồn.
sequenceDiagram
    autonumber
    actor SecEngineer as Chuyên gia Bảo mật
    participant FuzzCore as Engine Fuzzing (DQN)
    participant Target as Tệp nhị phân ELF
    participant Reporter as Hệ thống Báo cáo Crash
    
    SecEngineer->>FuzzCore: Cung cấp Binary ELF & Thư mục Seed ban đầu
    FuzzCore->>Target: Chạy kiểm thử với đột biến có chỉ dẫn RL
    Target-->>FuzzCore: Trả về Trace Bits Bitmap qua Shared Memory
    FuzzCore->>FuzzCore: Cập nhật mô hình Q-Network & Seed Queue
    Target->>Reporter: Ghi nhận ngoại lệ SIGSEGV / SIGABRT (Crash)
    Reporter-->>SecEngineer: Kết xuất tệp PoC gây lỗi & Callstack phục vụ vá mã

Yêu cầu hệ thống và triển khai

  • Hệ điều hành: Linux Kernel 5.4+ (x86_64), cấu hình core_pattern = core.
  • Cấu hình phần cứng tối thiểu: CPU 4 Cores, 8GB RAM, 20GB SSD lưu trữ vết thực thi.
  • Thiết lập môi trường:
    # Cấu hình tối ưu nhân Linux cho Fuzzing
    sudo su
    echo core > /proc/sys/kernel/core_pattern
    cd /sys/devices/system/cpu && echo performance | tee cpu*/cpufreq/scaling_governor
    

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

  • Hạn chế kỹ thuật: Tốc độ thực thi tổng thể (~940 exec/s) vẫn có độ trễ nhất định so với fuzzer thuần C/C++ như AFL++ (~1,150 exec/s) do chi phí suy luận mạng nơ-ron (Neural Network Inference Latency).
  • Phụ thuộc cấu trúc đầu vào: Đối với các phần mềm yêu cầu đầu vào có ràng buộc ngữ cảnh phức tạp cao (như trình phân tích cú pháp mã nguồn JS/SQL), mô hình cần kết hợp thêm văn phạm đầu vào (Grammar-based).
  • Hướng phát triển tương lai:
    1. Chuyển đổi toàn bộ module suy luận Q-Network sang C++ sử dụng thư viện LibTorch/ONNX Runtime C++ API để triệt tiêu độ trễ IPC.
    2. Kết hợp kỹ thuật phân tích vết lai (Hybrid Fuzzing) tích hợp cơ chế thực thi biểu trưng (Symbolic Execution) để giải quyết các nhánh rẽ điều kiện hẹp (Magic Values).

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

  • Sinh viên & Học viên An toàn Thông tin: Tài liệu nghiên cứu tham khảo toàn diện về cách kết hợp Trí tuệ nhân tạo (AI/RL) vào An ninh mạng chuyên sâu; hiểu rõ cấu trúc nhị phân ELF và cơ chế hoạt động của các fuzzer cấp hệ thống.
  • Kỹ sư An toàn Thông tin & Pentester: Công cụ hộp xám tự động hóa giúp phát hiện sớm các lỗ hổng tràn bộ đệm và lỗi hỏng bộ nhớ trên các ứng dụng nhị phân mục tiêu với độ chính xác cao.
  • Doanh nghiệp & Đội ngũ DevSecOps: Tối ưu hóa chi phí kiểm thử bảo mật tự động, rút ngắn thời gian phát hiện lỗi bảo mật trước khi sản phẩm được đưa vào vận hành thực tế.
  • Nhà nghiên cứu Khoa học: Khung tham chiếu và phương pháp thực nghiệm tiêu chuẩn trong việc ứng dụng học tăng cường để giải quyết bài toán tối ưu hóa không gian tìm kiếm nhị phân.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai mô hình fuzzing này là gì?

Hệ thống yêu cầu máy chủ hoặc máy trạm chạy hệ điều hành Linux 64-bit (Ubuntu 20.04/22.04 LTS khuyến nghị), cài đặt sẵn Python 3.8+, GCC/Clang, các thư viện phát triển libtool, make, và Python virtualenv chứa TensorFlow và Keras-rl2. Không bắt buộc phải có card đồ họa GPU chuyên dụng vì mô hình DQN có kích thước mạng nơ-ron nhỏ gọn được tối ưu cho việc suy luận nhanh trên CPU.

2. Mô hình xử lý thế nào khi không gian trạng thái đầu vào quá lớn?

Hệ thống sử dụng cơ chế mã hóa vector đặc trưng cố định kích thước kết hợp kỹ thuật nén ma trận độ phủ Bitmap 64KB (thay vì đưa trực tiếp toàn bộ dữ liệu byte thô của tệp vào mạng nơ-ron), giúp cố định kích thước đầu vào của mô hình DQN và duy trì tốc độ suy luận ổn định.

3. Làm thế nào để tích hợp phần mềm nhị phân mới vào hệ thống fuzzing?

Chỉ cần chuẩn bị tệp thực thi ELF có khả năng đọc dữ liệu từ tệp hoặc qua luồng đầu vào tiêu chuẩn (stdin), cùng một hoặc nhiều tệp mẫu hợp lệ (valid seeds) đặt vào thư mục đầu vào. Hệ thống sẽ tự động khởi tạo Forkserver và gắn kết cơ chế theo dõi độ phủ mã.

4. Chi phí huấn luyện và thời gian tái huấn luyện mô hình DQN mất bao lâu?

Mô hình DQN trong hệ thống sử dụng phương pháp học trực tuyến (Online Learning) song song với quá trình fuzzing. Tác nhân tự động khởi tạo và học từ các phản hồi phần thưởng theo thời gian thực mà không cần bước huấn luyện trước (Pre-training) tốn kém tài nguyên.

5. Tại sao phương pháp này lại hiệu quả hơn việc đột biến ngẫu nhiên truyền thống?

Đột biến ngẫu nhiên thường tạo ra tỷ lệ rất cao các mẫu thử không hợp lệ bị từ chối ngay tại các khối kiểm tra cú pháp đầu tiên. Mô hình DQN học được mối tương quan giữa từng toán tử đột biến và khả năng mở rộng độ bao phủ nhánh thực thi, từ đó tập trung xác suất vào các hành động có khả năng tạo ra đường dẫn thực thi mới.


Kết luận

Đồ án tốt nghiệp "A Coverage-Guided Fuzzing Method for Binary Software Vulnerability Detection Using Reinforcement Learning" của nhóm tác giả tại Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM đã giải quyết thành công bài toán mất cân bằng giữa tính khai thác và tính khám phá trong fuzzing ứng dụng học máy.

Bằng việc kết hợp kiến trúc học sâu tăng cường Deep Q-Network với các thuật toán lập lịch hạt giống tối ưu và cơ chế giao tiếp tiến trình hiệu năng cao trên nền tảng nhị phân ELF 64-bit, nghiên cứu đã chứng minh tính vượt trội: nâng cao độ phủ mã lên tới +64.14% so với công cụ rlfuzz và đạt hiệu suất phát hiện đường dẫn thực thi mới nhỉnh hơn fuzzer công nghiệp AFLplusplus trong giai đoạn đầu. Đây là tiền đề vững chắc cho việc phát triển các thế hệ công cụ kiểm thử bảo mật tự động thông minh trong tương lai.