llvm-security

Apply LLVM sanitizers and hardening flags to detect vulnerabilities in C/C++ builds.

69|11|Updated May 16, 2026
One-click install
npx skills add https://github.com/NeverSight/NeverC --skill llvm-security-neversight
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: llvm-security
Source: https://github.com/NeverSight/NeverC/tree/main/.agents/skills/llvm-security
Command: npx skills add https://github.com/NeverSight/NeverC --skill llvm-security-neversight

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps you reduce software risk by applying LLVM security features that catch memory and logic faults, mitigate exploitation techniques, and improve secure build practices.

Core Features & Use Cases

  • Sanitizers for runtime detection: AddressSanitizer (ASan), MemorySanitizer (MSan), ThreadSanitizer (TSan), and UndefinedBehaviorSanitizer (UBSan) to identify common vulnerability classes during testing.
  • Hardening mitigations: Stack protection options, Control Flow Integrity (CFI), Shadow Call Stack, and position-independent executables for stronger exploit resistance.
  • Secure development workflows: Integrates guidance for symbolic execution and fuzzing with sanitizers to improve bug discovery and validation.

Quick Start

Use the llvm-security skill to generate a hardening and testing build plan for your C/C++ project using LLVM sanitizers, CFI/stack protections, and fuzzing-compatible instrumentation.

Frequently Asked Questions about llvm-security

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

FAQPage Schema
How do I configure LLVM sanitizers and CFI for a secure C/C++ build?

Configure LLVM sanitizers and CFI by selecting AddressSanitizer, MemorySanitizer, or UndefinedBehaviorSanitizer flags alongside Control Flow Integrity options during compilation to detect memory errors and mitigate exploitation techniques.

What LLVM flags do I need to detect memory errors and undefined behavior?

You need AddressSanitizer, MemorySanitizer, ThreadSanitizer, and UndefinedBehaviorSanitizer flags to detect memory errors, undefined behavior, and race conditions during runtime testing of your C/C++ project.

How does Control Flow Integrity and shadow call stack harden C/C++ builds?

Control Flow Integrity and shadow call stack harden C/C++ builds by enforcing valid call targets and protecting return addresses, which mitigates exploitation techniques like ROP and improves overall exploit resistance.

Can I combine fuzzing with symbolic execution and sanitizers for vulnerability analysis?

Yes, you can combine fuzzing with symbolic execution and LLVM sanitizers to improve bug discovery and validation workflows, enabling comprehensive vulnerability analysis and runtime fault detection in C/C++ builds.

Does this approach work for detecting race conditions in C/C++ builds?

Yes, this approach works for detecting race conditions by applying ThreadSanitizer during runtime testing, which identifies concurrency issues and race conditions within your C/C++ builds.

What is the best way to generate a hardening and testing build plan for C/C++ projects?

The best way to generate a hardening and testing build plan is to apply LLVM security tooling, combining stack protection options, secure compilation flags, and fuzzing-compatible instrumentation to validate runtime behavior.