address-sanitizer

Detect buffer overflows and use-after-free bugs in C/C++ code during fuzzing.

Updated Feb 24, 2026
One-click install
npx skills add https://github.com/ofelixdev/cc-kit --skill address-sanitizer-ofelixdev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: address-sanitizer
Source: https://github.com/ofelixdev/cc-kit/tree/main/template/skills/address-sanitizer
Command: npx skills add https://github.com/ofelixdev/cc-kit --skill address-sanitizer-ofelixdev

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps detect critical memory errors like buffer overflows and use-after-free bugs in C/C++ code, preventing crashes and security vulnerabilities.

Core Features & Use Cases

  • Memory Error Detection: Identifies common memory corruption bugs during runtime.
  • Fuzzing Integration: Essential for effective fuzz testing of C/C++ and Rust code.
  • Use Case: When fuzzing a C library, integrate AddressSanitizer to catch heap buffer overflows that could lead to exploitable vulnerabilities.

Quick Start

Compile your C++ program with AddressSanitizer enabled using the clang compiler.

Frequently Asked Questions about address-sanitizer

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

FAQPage Schema
How do I detect memory errors like buffer overflows in C/C++?

Memory errors like buffer overflows are detected by compiling C/C++ programs with AddressSanitizer using flags like -fsanitize=address in Clang or GCC to instrument runtime memory access and catch corruption bugs.

When do I need AddressSanitizer for fuzzing?

AddressSanitizer is essential for effective fuzz testing of C/C++ and Rust code because it catches heap buffer overflows and use-after-free bugs during runtime that could lead to exploitable vulnerabilities.

Can I use AddressSanitizer with Rust unsafe blocks?

AddressSanitizer applies to Rust code with unsafe blocks, detecting memory corruption bugs during testing and fuzzing by instrumenting compiled code with the standard sanitizer flags.

What compiler flags are required to enable memory error detection?

Memory error detection requires compile-time instrumentation using flags like -fsanitize=address for Clang or GCC, enabling the runtime checks needed to identify use-after-free and buffer overflow bugs.

Does AddressSanitizer work without compiling the source code?

AddressSanitizer requires compile-time instrumentation of the source code, meaning it cannot be attached to pre-compiled binaries and needs the build process to inject runtime memory checks.