Vai al contenuto
New

DeepSeek V4.1 Flash free for 7 days: 10M tokens a day after a top-up of $10 or more. Until Nov 30.

How it works
trailofbits/fp-checkReverse engineering e fuzzing

fp-check

⁨Systematically verifies suspected security bugs to eliminate false positives, producing a TRUE POSITIVE or FALSE POSITIVE verdict with documented evidence for each. Use when asked whether a specific finding is real, exploitable, or a false positive, or to verify or validate a suspected vulnerability⁩

v2026.11.12-149d7b23 installazioni+3 in 7 giorni8,2K StelleCC-BY-SA-4.0sincronizzato 22 ore fa

Installa

Non hai ancora la CLI di NotHoly? Installala prima.

$ curl -fsSL https://notholy.com/install.sh | sh
$ notholy skills install trailofbits/fp-check

Scrive in ⁦~/.notholy/skills⁩ dopo aver controllato la firma e lo SHA-256.

FirmaFirmato, ed25519
/2nuZ+/Of7…8upoUeBg==La CLI controlla lo SHA-256 e la firma prima di scrivere qualsiasi file.
Pacchettobea8048d…b08e9c97
bea8048de413…0430b08e9c979 file · ⁦15.5 KB⁩
ScansioneBasso1 segnalazione
  • Link a domini esterni
Vedi la scansione completa
Sorgentegithub.com/trailofbits/skills/tree/main/plugins/fp-check/skills/fp-check@149d7b2

Questa voce non è ancora scritta in italiano, quindi è mostrata in un'altra lingua: English.

When to Use

  • "Is this bug real?" or "is this a true positive?"
  • "Is this a false positive?" or "verify this finding"
  • "Check if this vulnerability is exploitable"
  • Any request to verify or validate a specific suspected bug

When NOT to Use

  • Finding or hunting for bugs ("find bugs", "security analysis", "audit code")
  • General code review for style, performance, or maintainability
  • Feature development, refactoring, or non-security tasks
  • When the user explicitly asks for a quick scan without verification

Rationalizations to Reject

If you catch yourself thinking any of these, STOP.

Rationalization Why It's Wrong Required Action
"Rapid analysis of remaining bugs" Every bug gets full verification Return to task list, verify next bug through all phases
"This pattern looks dangerous, so it's a vulnerability" Pattern recognition is not analysis Complete data flow tracing before any conclusion
"Skipping full verification for efficiency" No partial analysis allowed Execute all steps per the chosen verification path
"The code looks unsafe, reporting without tracing data flow" Unsafe-looking code may have upstream validation Trace the complete path from source to sink
"Similar code was vulnerable elsewhere" Each context has different validation, callers, and protections Verify this specific instance independently
"This is clearly critical" LLMs are biased toward seeing bugs and overrating severity Complete devil's advocate review; prove it with evidence

Step 0: Understand the Claim and Context

Before any analysis, restate the bug in your own words. If you cannot do this clearly, ask the user for clarification. Half of false positives collapse at this step — the claim doesn't make coherent sense when restated precisely.

Document:

  • What is the exact vulnerability claim? (e.g., "heap buffer overflow in parse_header() when content_length exceeds 4096")
  • What is the alleged root cause? (e.g., "missing bounds check before memcpy at line 142")
  • What is the supposed trigger? (e.g., "attacker sends HTTP request with oversized Content-Length header")
  • What is the claimed impact? (e.g., "remote code execution via controlled heap corruption")
  • What is the threat model? What privilege level does this code run at? Is it sandboxed? What can the attacker already do before triggering this bug? (e.g., "unauthenticated remote attacker vs privileged local user"; "runs inside Chrome renderer sandbox" vs "runs as root with no sandbox")
  • What is the bug class? Classify the bug and consult bug-class-verification.md for class-specific verification requirements that supplement the generic phases below.
  • Execution context: When and how is this code path reached during normal execution?
  • Caller analysis: What functions call this code and what input constraints do they impose?
  • Architectural context: Is this part of a larger security system with multiple protection layers?
  • Historical context: Any recent changes, known issues, or previous security reviews of this code area?

Route: Standard vs Deep Verification

After Step 0, choose a verification path.

Standard Verification

Use when ALL of these hold:

  • Clear, specific vulnerability claim (not vague or ambiguous)
  • Single component — no cross-component interaction in the bug path
  • Well-understood bug class (buffer overflow, SQL injection, XSS, integer overflow, etc.)
  • No concurrency or async involved in the trigger
  • Straightforward data flow from source to sink

Follow standard-verification.md. No task tracking — work through the linear checklist sequentially, documenting findings inline.

Deep Verification

Use when ANY of these hold:

  • Ambiguous claim that could be interpreted multiple ways
  • Cross-component bug path (data flows through 3+ modules or services)
  • Race conditions, TOCTOU, or concurrency in the trigger mechanism
  • Logic bugs without a clear spec to verify against
  • Standard verification was inconclusive or escalated
  • User explicitly requests full verification

Follow deep-verification.md. Track each phase as a task with explicit dependencies, and execute the phases using the plugin's analysis agents.

Default

Start with standard. Standard verification has two built-in escalation checkpoints that route to deep when complexity exceeds the linear checklist.

Batch Triage

When verifying multiple bugs at once:

  1. Run Step 0 for all bugs first — restating each claim often collapses obvious false positives immediately
  2. Route each bug independently (some may be standard, others deep)
  3. Process all standard-routed bugs first, then deep-routed bugs
  4. After all bugs are verified, check for exploit chains — findings that individually failed gate review may combine to form a viable attack

Final Summary

After processing ALL suspected bugs, provide:

  1. Counts: X TRUE POSITIVES, Y FALSE POSITIVES
  2. TRUE POSITIVE list: Each with brief vulnerability description
  3. FALSE POSITIVE list: Each with brief reason for rejection

References

  • Standard Verification — Linear single-pass checklist for straightforward bugs
  • Deep Verification — Full task-based orchestration for complex bugs
  • Gate Reviews — Six mandatory gates and verdict format
  • Bug-Class Verification — Class-specific verification requirements for memory corruption, logic bugs, race conditions, integer issues, crypto, injection, info disclosure, DoS, and deserialization
  • False Positive Patterns — 13-item checklist and red flags for common false positive patterns
  • Evidence Templates — Documentation templates for data flow, mathematical proofs, attacker control, and devil's advocate reviews

File di questa versione

Permessi

PermessoDichiaratoTrovato dalla scansione
Legge fileSìSì
Scrive fileSìSì
Esegue comandi shellSìSì
Usa la reteSìSì
Usa i connettoriNoNo
Controlla un browserNoNo

Segnalazioni della scansione

Rivisto il 13 nov 2026

  1. InfoLink · Link a domini esterni

Una scansione pulita abbassa il rischio, ma non prova che il pacchetto sia sicuro. Leggi quello che installi.

VersionePubblicataCommitSHA-256FirmaCambio di permessi
v2026.11.12-149d7b213 nov 2026149d7b2bea8048dFirmata–

Chiedi tutto quello che il tuo perimetro consente.

Crea un account, aggiungi crediti e fai la prima domanda in chat o nel terminale.

  1. 1/3

    Crea l'account

    Privato o azienda. Puoi passare ad azienda in seguito senza perdere saldo o chiavi.

    PrivatoAzienda
  2. 2/3

    Aggiungi crediti

    Con carta. Paghi a token, senza abbonamento.

    $5.00ricarica minima
  3. 3/3

    Chiedi

    In chat, oppure installa la CLI ed esegui notholy login nel terminale.

    $ notholy login