Security audit
Security checks for vulnerabilities and agentic risk
This is a Rust code-review guidance skill, and I found no hidden execution, persistence, or data-exfiltration behavior.
This skill is appropriate for Rust code review. Before installing, expect it to guide an agent to inspect Rust project files and possibly recommend standard Rust checks; use normal caution before running cargo commands on code you do not trust.
Referenced artifact was not completely inspected
| Async pitfalls, Send/Sync bounds, poll contract, Pin mechanics, cancellation soundness | [references/async-concurrency.md](references/async-concurrency.md) |
Referenced artifact was not completely inspected
repr, PhantomData, generics vs dyn Trait, wide pointers, auto-trait leakage | [references/types-layout.md](references/types-layout.md) |
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).
ly moves the string into self. Using it on a function that immediately calls .as_ref() is a misleading signature — switch to &str.
Symmetric trap: returning String when the function sometimes already has a borrowed slice forces an unnecessary allocation on the happy path. Cow<'_, str> is the right answer when the borrowed case is common.
Drop::drop(&mut self) cannot return Result, cannot .await, and cannot reliably spawn async work because the executor may be shutting down. For I/O-flavored types whose cleanup can fail:
Drop that swallows errors and does what it can synchronouslyfn close(self) -> Result<(), CloseError> (or async fn close(self)) — and document it prominentlyimpl Connection {
pub fn close(self) -> Result<(), CloseError> {
// graceful shutdown, surfaces errors
}
}
The move-out trap. Once you implement Drop,
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).
ly moves the string into self. Using it on a function that immediately calls .as_ref() is a misleading signature — switch to &str.
Symmetric trap: returning String when the function sometimes already has a borrowed slice forces an unnecessary allocation on the happy path. Cow<'_, str> is the right answer when the borrowed case is common.
Drop::drop(&mut self) cannot return Result, cannot .await, and cannot reliably spawn async work because the executor may be shutting down. For I/O-flavored types whose cleanup can fail:
Drop that swallows errors and does what it can synchronouslyfn close(self) -> Result<(), CloseError> (or async fn close(self)) — and document it prominentlyimpl Connection {
pub fn close(self) -> Result<(), CloseError> {
// graceful shutdown, surfaces errors
}
}
The move-out trap. Once you implement Drop,
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).
ly moves the string into self. Using it on a function that immediately calls .as_ref() is a misleading signature — switch to &str.
Symmetric trap: returning String when the function sometimes already has a borrowed slice forces an unnecessary allocation on the happy path. Cow<'_, str> is the right answer when the borrowed case is common.
Drop::drop(&mut self) cannot return Result, cannot .await, and cannot reliably spawn async work because the executor may be shutting down. For I/O-flavored types whose cleanup can fail:
Drop that swallows errors and does what it can synchronouslyfn close(self) -> Result<(), CloseError> (or async fn close(self)) — and document it prominentlyimpl Connection {
pub fn close(self) -> Result<(), CloseError> {
// graceful shutdown, surfaces errors
}
}
The move-out trap. Once you implement Drop,
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.
### Drop safety
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).
::Acquire) { std::thread::park(); } unsafe { (*self.channel.message.get()).assume_init_read() } } }
### Drop safety
A channel storing `MaybeUninit<T>` **must** implement `Drop` to run `T`'s destructor when dropped with an unreceived message. Forgetting this leaks any non-trivial `T` (`Vec`, `Box`, `File`, `Arc`).
```rust
impl<T> Drop for Channel<T> {
fn drop(&mut self) {
if *self.ready.get_mut() {
unsafe { self.message.get_mut().assume_init_drop() }
}
}
}
// BAD: unconditional drop. Runs T::drop on uninit memory if no send happened.
impl<T> Drop for Channel<T> {
fn drop(&mut self) {
unsafe { self.message.get_mut().assume_init_drop() }
}
}
send writes the MaybeUninit<T>, then flips the ready flag. If the user's T::clone or moves can panic, the flag must only be set after the value is fully written. Code that flips ready before writing exposes the rec
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).
to a local; when the scope unwinds, drop runs. Tokio uses this for the executor handle during Future::poll so the handle is cleared even if poll panics. scopeguard::defer! packages the pattern for ad-hoc use.
fn with_flag(flag: &AtomicBool, f: impl FnOnce()) {
flag.store(true, Ordering::Release);
struct Guard<'a>(&'a AtomicBool);
impl Drop for Guard<'_> {
fn drop(&mut self) { self.0.store(false, Ordering::Release); }
}
let _guard = Guard(flag);
f();
} // _guard drops here, even on panic
The single most common bug: let _ = Guard(flag) instead of let _guard = Guard(flag). The bare _ pattern is not a binding — it drops the value immediately at the ;, before the protected code runs. Reviewers miss this because the two lines look identical at a glance.
State-restore variant uses mem::replace / mem::take to capture the prior value:
struct Restore<'a, T>(&'a mut T, Option<T>);
impl<T> Drop for Restore<'_, T> {
Skill instructs the agent to omit warnings, disclaimers, or ethical commentary. Stripping safety caveats hides risk from the user and is a common jailbreak preamble.
| Pointer validity | Non-null, aligned, initialized, within allocation bounds |
| Aliasing | No simultaneous `&T` and `&mut T` to the same memory |
| Panic safety | State is consistent if user-provided code panics mid-operation |
| Drop safety | `Drop` impl doesn't access dangling data; `PhantomData` used for drop check |
| Send/Sync | Manual implementations have correct bounds; raw pointers covered |
| UnsafeCell | All interior mutation goes through `UnsafeCell` |
| FFI | Extern blocks are `unsafe extern` (Edition 2024); signatures match the foreign ABI |
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.
- A `Drop` impl that unconditionally calls `assume_init_drop` on a `MaybeUninit<T>` field — drops uninitialized memory when the gate flag is false. The correct shape is `if *self.ready.get_mut() { unsafe { self.value.get_mut().assume_init_drop() } }`.
- For lazy one-shot init, prefer `OnceLock::get_or_init` over hand-rolled `MaybeUninit` + `AtomicBool` unless allocation or `const fn` construction is a hard requirement.
- `[FILE:LINE] MAYBEUNINIT_UNCONDITIONAL_DROP` — `assume_init_drop` in a `Drop` impl without checking an init flag.
- `[FILE:LINE] MAYBEUNINIT_DOUBLE_READ` — two `assume_init_read` calls reachable on the same `MaybeUninit` storage.
## Mutex and RwLock Poisoning
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.
- A `Drop` impl that unconditionally calls `assume_init_drop` on a `MaybeUninit<T>` field — drops uninitialized memory when the gate flag is false. The correct shape is `if *self.ready.get_mut() { unsafe { self.value.get_mut().assume_init_drop() } }`.
- For lazy one-shot init, prefer `OnceLock::get_or_init` over hand-rolled `MaybeUninit` + `AtomicBool` unless allocation or `const fn` construction is a hard requirement.
- `[FILE:LINE] MAYBEUNINIT_UNCONDITIONAL_DROP` — `assume_init_drop` in a `Drop` impl without checking an init flag.
- `[FILE:LINE] MAYBEUNINIT_DOUBLE_READ` — two `assume_init_read` calls reachable on the same `MaybeUninit` storage.
## Mutex and RwLock Poisoning
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.
// GOOD - log if you can't propagate if let Err(e) = save_to_disk(&data) { tracing::error!(error = %e, "failed to save data to disk"); }
This is a natural-language locale/platform policy concern because the guidance singles out Apple Silicon behavior as a default portability constraint rather than clearly framing it as conditional platform-specific advice. Although technical in nature, it could be interpreted as forcing a specific platform assumption without explicit opt-in.
No suspicious patterns detected.