sc-lang-rust

Scan Rust codebases for unsafe blocks, FFI misuse, and concurrency hazards.

7|Updated Apr 9, 2026
One-click install
npx skills add https://github.com/fatihkan/badi --skill sc-lang-rust-fatihkan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sc-lang-rust
Source: https://github.com/fatihkan/badi/tree/main/.claude/skills/security-check/sc-lang-rust
Command: npx skills add https://github.com/fatihkan/badi --skill sc-lang-rust-fatihkan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Rust codebases can harbor subtle security flaws even with Rust's safety guarantees. This skill identifies Rust-specific security anti-patterns, focusing on unsafe blocks, FFI boundaries, concurrency hazards, and other patterns that undermine Rust's safety guarantees.

Core Features & Use Cases

  • Unsafe Block Audit: Detects unchecked unsafe blocks and invariant violations that could lead to memory safety issues.
  • FFI Boundary Validation: Checks for unsafe bindings and unsafe interactions at C/Rust borders that may introduce UB.
  • Concurrency Pitfalls: Flags data races and improper synchronization in async and multi-threaded code.
  • Pattern Coverage: Uses the Rust Security Checklist (references/rust-security-checklist.md) as its reference for comprehensive coverage.
  • Use Case: Integrate into CI to catch security regressions in Rust crates before merge.

Quick Start

Run a Rust project security scan to detect unsafe blocks, FFI misuse, and concurrency hazards.

Frequently Asked Questions about sc-lang-rust

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

FAQPage Schema
How do I scan Rust code for unsafe blocks and FFI misuse?

To scan Rust code for unsafe blocks and FFI misuse, run a project security scan that detects unchecked unsafe blocks, validates unsafe C bindings, and produces structured findings based on the Rust Security Checklist.

What security vulnerabilities exist in Rust async tasks and multi-threaded code?

Rust async tasks and multi-threaded code can harbor concurrency hazards like data races and improper synchronization, which undermine Rust's safety guarantees and lead to undefined behavior if not properly validated.

Can I integrate a Rust security scan into CI to catch regressions before merge?

Yes, you can integrate this Rust security scan into CI pipelines to catch security regressions in Rust crates before merge, checking for unsafe code, FFI boundaries, and concurrency hazards automatically.

Does Rust static analysis cover third-party crate risks and external interfaces?

Rust static analysis covers third-party crate risks and external interfaces by scanning codebases that rely on unsafe code and FFI, identifying unsafe interactions at C/Rust borders that may introduce undefined behavior.

Why does Rust code still have memory safety issues despite its safety guarantees?

Rust code still has memory safety issues because unsafe blocks, FFI boundary violations, and invariant breaches bypass Rust's safety guarantees, introducing subtle security flaws and undefined behavior into the codebase.

What is the best way to audit unsafe Rust code for invariant violations?

The best way to audit unsafe Rust code for invariant violations is to scan against the Rust Security Checklist, which detects unchecked unsafe blocks and flags patterns that undermine memory safety guarantees.