AFLplusplus VS qemuafl

Compare AFLplusplus vs qemuafl and see what are their differences.

AFLplusplus

The fuzzer afl++ is afl with community patches, qemu 5.1 upgrade, collision-free coverage, enhanced laf-intel & redqueen, AFLfast++ power schedules, MOpt mutators, unicorn_mode, and a lot more! (by AFLplusplus)

qemuafl

This fork of QEMU enables fuzzing userspace ELF binaries under AFL++. (by AFLplusplus)
Our great sponsors
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • SaaSHub - Software Alternatives and Reviews
AFLplusplus qemuafl
16 1
4,552 74
5.5% -
9.6 0.0
6 days ago about 2 months ago
C C
Apache License 2.0 GNU General Public License v3.0 or later
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

AFLplusplus

Posts with mentions or reviews of AFLplusplus. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-06-08.
  • Decoding C/C++ Compilation Process: From Source Code to Binary
    5 projects | /r/cpp | 8 Jun 2023
    It could be cool to see some explanation of CFG representations or GIMPLE/LLVM here. GCC/Clang can print those out as text, or just compile to that code and not go lower if you ask them to. There are some interesting things you can do with bytecode, like Rellic, AFL++, or optview2. It seems a bit reductive imo to go straight from high-level code to disassembly without at all examining any layers in between. Especially if we use something like Polygeist or CIR.
  • Olive programming language
    3 projects | /r/C_Programming | 30 Mar 2023
    Be outside the loop? At least that's how they do it in their example https://github.com/AFLplusplus/AFLplusplus/blob/stable/instrumentation/README.persistent_mode.md
  • How do you test compiler projects?
    7 projects | /r/Compilers | 30 Nov 2022
    I use fuzzers, as every programmer should, and do not commit unless my compiler can be fuzzed for at least 24 hours without any crashes (if I were selling the software, I'd increase that period). I use AFL++ in LTO mode and comby-decomposer with a crappy script I made to collect crash test cases. I am also interested in afl-compiler-fuzzer, but have not yet tried it. Later, I'd like to try my hand at making a test generator that reaches codegen more often (no compile errors in the random source code). I use afl-tmin to minimize test cases, but the result is always illegible without manual work, and usually has extra junk the minimizer is incapable of deleting. Something like C-Reduce would be useful here.
  • November 2022 monthly "What are you working on?" thread
    25 projects | /r/ProgrammingLanguages | 3 Nov 2022
    1: https://github.com/ArkScript-lang/Ark 2: https://github.com/AFLplusplus/AFLplusplus
  • AFLplusplus VS jazzer.js - a user suggested alternative
    2 projects | 12 Sep 2022
  • Frelatage: A fuzzing library to find vulnerabilities and bugs in Python applications
    4 projects | /r/Python | 17 Mar 2022
    Frelatage is a coverage-based Python fuzzing library which can be used to fuzz python code. The development of Frelatage was inspired by various other fuzzers, including AFL/AFL++, Atheris and PyFuzzer.The main purpose of the project is to take advantage of the best features of these fuzzers and gather them together into a new tool in order to efficiently fuzz python applications.
  • 60x speed-up of Linux “perf”
    7 projects | news.ycombinator.com | 9 Sep 2021
    With AFL++ you can even determine exactly where the fork happens:

    https://github.com/AFLplusplus/AFLplusplus/blob/stable/instr...

  • Adventures in Fuzzing Matrix’s Encryption
    4 projects | news.ycombinator.com | 14 Jun 2021
    Author here. As one of the other comments mentions, afl++ (and to some extent vanilla afl) already has capability to automatically scrape magic values from arguments to special functions like `strcmp` and the like. The older technique is called libtokencap (https://github.com/AFLplusplus/AFLplusplus/blob/stable/utils...), but afl++ also has a newer feature called AUTODICT (https://github.com/AFLplusplus/AFLplusplus/blob/stable/instr...).

    But this only solves the problem of magic constants expected in the input. If the check depends on dynamic properties of the input or happens deeper in the code after the input's already been through some transformations, it can't be solved like this. There are other techniques to help with this, though. One of the earlier attempts to solve such types of more complex checks is called laf-intel (https://github.com/AFLplusplus/AFLplusplus/blob/stable/instr...) and boils down to transforming a more complex check into a nested series of simpler checks. This makes it more probable that the fuzzer's random mutation will be able to solve the outer check and hence hit new coverage, enabling the fuzzer to detect the mutation as productive.

    afl++ has a more modern variant of this called CmpLog (https://github.com/AFLplusplus/AFLplusplus/blob/stable/instr...) which is based on the RedQueen technique. The paper for RedQueen is a really interesting read: https://www.syssec.ruhr-uni-bochum.de/media/emma/veroeffentl...

    The problem of checksums is at times also solved by simply modifying the binary so that the checksum is neutralized and always succeeds, especially if you have access to source code.

    As for the problem of fuzzing stateful things like the double ratchet, one way of tackling the problem is to think of the input to the fuzzer as not only the raw bytes that you'll be passing to the program you're fuzzing, but as a blueprint specifying which high-level operations you'll be performing on the input. Then you teach your fuzzer to be smarter and be able to perform a bunch of those operations.

    So, let's say you take 512 bytes as the input to the fuzzer. You treat the first 256 bytes as the message to decode and the latter 256 bytes as the high-level cryptographic operations to perform on this message, each byte specifying one of those operations. So you could say a byte of value 1 represents the operation "ENCRYPT WITH KEY K1", 2 represents "ENCRYPT WITH KEY K2", 3 represents "DECRYPT WITH KEY K1", 4 represents "DECRYPT WITH KEY K2", 5 represents "PERFORM SHA2" and so on. Now you can feasibly end up with a sequence which will take a message encrypted with key K1, decrypt it, modify the message, then re-encrypt with key K2. Or, in the case of the double ratchet algorithm, have it perform multiple successive encryption steps to evolve the state of the ratchet and be able to fuzz more deeply.

    Of course, the encoding needs to be rather dense for this to work well so that ideally each low-level bit mutation the fuzzer does on an input still encodes a valid sequence of valid high-level operations.

  • How Fuzzing with QEMU (and AFL) Works
    5 projects | dev.to | 5 Jun 2021
    By patching QEMU, TriforceAFL and AFL++ managed to get coverage feedback out of any binary that QEMU can run. How cool is that?!
  • First C++ OSS Project - Liquid Parser/Renderer
    2 projects | /r/cpp | 16 Mar 2021
    Another alternative seems to be AFL / AFLplusplus (a fork): https://github.com/AFLplusplus/AFLplusplus

qemuafl

Posts with mentions or reviews of qemuafl. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2021-06-05.
  • How Fuzzing with QEMU (and AFL) Works
    5 projects | dev.to | 5 Jun 2021
    QEMU user-mode is a tool of QEMU that allows emulating just the userspace (in contrast to the normal mode where both the user-mode and the kernel are emulated). This is done by forwarding any syscalls from the target program to the host machine. The main benefits are improved performance and less complex enviroment but it sacrifices on the portability. AFL++ fork of QEMU uses this mechanism while adding coverage tracking and optional performance optimizations.

What are some alternatives?

When comparing AFLplusplus and qemuafl you can also consider the following projects:

honggfuzz - Security oriented software fuzzer. Supports evolutionary, feedback-driven fuzzing based on code coverage (SW and HW based)

LibAFL - Advanced Fuzzing Library - Slot your Fuzzer together in Rust! Scales across cores and machines. For Windows, Android, MacOS, Linux, no_std, ...

oss-fuzz - OSS-Fuzz - continuous fuzzing for open source software.

syzkaller - syzkaller is an unsupervised coverage-guided kernel fuzzer

American Fuzzy Lop - american fuzzy lop - a security-oriented fuzzer

TriforceAFL - AFL/QEMU fuzzing with full-system emulation.

sharpfuzz - AFL-based fuzz testing for .NET

panda - Platform for Architecture-Neutral Dynamic Analysis

browser-fuzzer-3 - Browser Fuzzer 3 is designed as a hybrid framework/standalone fuzzer; the modules it uses are extensible but also highly integrated into the core. bf3 can be used via command line to set all necessary flags for each fuzzing operation.

fuzzer-qemu - Blackbox Fuzzer using LibAFL and AFL++ QEMU

addr2line - A cross-platform `addr2line` clone written in Rust, using `gimli`

bsod-kernel-fuzzing - BSOD: Binary-only Scalable fuzzing Of device Drivers