ruzzy

Identifies memory corruption and undefined behavior in Ruby applications and C extensions via coverage-guided fuzzing and sanitizers.

1|Updated Apr 7, 2026
One-click install
npx skills add https://github.com/rohanbhatia27/rohanstutoring-redesign --skill ruzzy-rohanbhatia27
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ruzzy
Source: https://github.com/rohanbhatia27/rohanstutoring-redesign/tree/main/.agents/skills/ruzzy
Command: npx skills add https://github.com/rohanbhatia27/rohanstutoring-redesign --skill ruzzy-rohanbhatia27

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires libfuzzer, clang, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

Ruzzy addresses the challenge of identifying vulnerabilities in Ruby applications and C extensions by providing a coverage-guided fuzzer that can uncover memory corruption and undefined behavior.

Core Features & Use Cases

  • Coverage-Guided Fuzzing: Identifies previously unknown vulnerabilities by analyzing the code's execution path.
  • Ruby and C Extensions Support: Fuzz both pure Ruby code and Ruby C extensions.
  • Sanitizer Integration: Integrates with AddressSanitizer and UndefinedBehaviorSanitizer for detailed error reporting.
  • Use Case: Use Ruzzy to test a Ruby gem with native extensions for memory safety issues.

Quick Start

Set up the environment and run the toy example to check if Ruzzy is working correctly.

Frequently Asked Questions about ruzzy

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

FAQPage Schema
How do I find memory corruption in Ruby C extensions?

To find memory corruption in Ruby C extensions, you use coverage-guided fuzzing integrated with AddressSanitizer to identify vulnerabilities and undefined behavior during execution. Ruzzy supports fuzzing both pure Ruby code and native C extensions.

What is coverage-guided fuzzing for Ruby applications?

Coverage-guided fuzzing for Ruby applications analyzes execution paths to identify previously unknown memory corruption and undefined behavior. This technique systematically tests code paths to uncover hidden vulnerabilities in Ruby applications and C extensions.

Do I need clang and libfuzzer to fuzz Ruby code?

Yes, you need clang and libfuzzer to fuzz Ruby code with Ruzzy, as these dependencies provide the underlying compilation and coverage-guided fuzzing engine required to detect memory safety issues.

Can I use AddressSanitizer to test Ruby gems with native extensions?

Yes, you can use AddressSanitizer to test Ruby gems with native extensions. Ruzzy integrates sanitizer tools to provide detailed error reporting for memory corruption and undefined behavior found in C extensions.

What's the best way to detect undefined behavior in Ruby applications?

The best way to detect undefined behavior in Ruby applications is using a fuzzer with UndefinedBehaviorSanitizer integration. Ruzzy provides coverage-guided fuzzing that systematically uncovers memory safety issues in both Ruby and C extensions.

Why does my Ruby fuzzer not report memory safety issues?

Your Ruby fuzzer may not report memory safety issues if it lacks sanitizer integration. Combining coverage-guided fuzzing with AddressSanitizer and UndefinedBehaviorSanitizer, as Ruzzy does, provides detailed error reporting for memory corruption.