aflpp

Automates multi-core fuzzing campaigns for C and C++ projects with LTO, CMPLOG, sanitizer integration.

Updated Nov 23, 2025
One-click install
npx skills add https://github.com/manuelbrandner85/Weltenbibliothekapp --skill aflpp-manuelbrandner85
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: aflpp
Source: https://github.com/manuelbrandner85/Weltenbibliothekapp/tree/main/.agents/skills/aflpp
Command: npx skills add https://github.com/manuelbrandner85/Weltenbibliothekapp --skill aflpp-manuelbrandner85

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the difficulty of finding deep-seated memory corruption and logic bugs in complex C/C++ codebases by providing a robust, parallelized fuzzing environment.

Core Features & Use Cases

  • Multi-core Fuzzing: Scales fuzzing campaigns across multiple CPU cores to maximize execution throughput and coverage.
  • Advanced Mutation: Utilizes sophisticated mutation strategies and CMPLOG/RedQueen path constraint solving to explore code paths that standard fuzzers miss.
  • Use Case: Use this skill to harden a critical network protocol implementation by identifying crashes and hangs before they can be exploited in production.

Quick Start

Use the aflpp skill to initialize a multi-core fuzzing campaign on the target binary using the provided seed directory.

Frequently Asked Questions about aflpp

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run multi-core fuzzing for a C++ project to find memory corruption?

Multi-core fuzzing for C++ projects automates parallel mutation testing across CPU cores to identify memory corruption. This skill scales execution throughput using advanced instrumentation like LTO and sanitizer integration to maximize code coverage.

What is CMPLOG mutation testing and how does it improve C++ vulnerability detection?

CMPLOG mutation testing, also known as RedQueen path constraint solving, explores complex code paths that standard fuzzing misses. It improves C++ vulnerability detection by solving path constraints to trigger deeper logic bugs and memory corruption.

Do I need a specific compiler or test harness to start fuzzing C code?

You need a configured environment with Clang or GCC and a defined libFuzzer-style harness to start fuzzing C code. The harness performs automated mutation testing, while the compiler enables required instrumentation modes for deep code coverage.

What's the best way to harden a network protocol implementation against exploits?

Fuzzing a network protocol implementation hardens it by identifying crashes and hangs before production deployment. This skill achieves this by scaling multi-core campaigns to uncover deep-seated memory corruption and logic vulnerabilities in the codebase.

Can I use sanitizer integration with LTO during automated C++ mutation testing?

Sanitizer integration works with LTO during automated C++ mutation testing to provide deep code coverage analysis. This combination detects complex memory corruption vulnerabilities by instrumenting the compiled binary throughout the fuzzing campaign.

Why does standard fuzzing miss deep-seated logic bugs in complex C codebases?

Standard fuzzing misses deep-seated logic bugs in complex C codebases due to limited execution throughput and basic mutation strategies. Multi-core parallelized fuzzing overcomes this using CMPLOG constraint solving and sanitizer integration for deeper path exploration.