security-bounty-hunter
affaan-m/everything-claude-code
Hunt exploitable, bounty-worthy security vulnerabilities in code repositories with minimal noise.
What is security-bounty-hunter?
Focuses on remotely reachable vulnerabilities suitable for responsible disclosure or bounty submission. Filters out local-only findings and patterns that bounty platforms typically reject, prioritizing practical exploitability over theoretical safety issues.
- Identifies remotely reachable attack paths and user-controlled inputs flowing to dangerous sinks
- Triages findings to distinguish bounty-worthy issues from low-signal patterns
- Provides structured workflow from scope verification through proof-of-concept validation
- Covers SSRF, auth bypass, deserialization-to-RCE, SQL injection, command injection, path traversal, and XSS patterns
- Filters out local-only code, hardcoded commands, missing headers, and self-XSS without network impact
- Validates exploitability before report submission
How to install security-bounty-hunter
npx skills add https://github.com/affaan-m/everything-claude-code --skill security-bounty-hunterHow to use security-bounty-hunter
- 1.Check the target program's scope, SECURITY.md, disclosure channel, and exclusion list
- 2.Identify real entry points: HTTP handlers, uploads, background jobs, webhooks, parsers, and integration endpoints
- 3.Run static tooling (e.g., semgrep) as triage input and filter out tests, demos, vendored code, and non-reachable paths
- 4.Manually trace the code path end-to-end from user input to sink
- 5.Confirm user control reaches a meaningful sink and the vulnerability is exploitable
- 6.Create a minimal proof-of-concept to validate impact
- 7.Check for duplicates in existing advisories, CVEs, or open tickets before submitting
Use cases
- Scanning a repository for exploitable vulnerabilities prior to responsible disclosure
- Preparing a Huntr or HackerOne bounty submission with minimal false positives
- Triaging findings to determine which issues actually qualify for bounty payouts
- Verifying that a vulnerability is reachable from a real network or user boundary before drafting a report
- Identifying high-impact patterns like SSRF, auth bypass, and RCE in web applications and APIs
- Security researchers and bug bounty hunters
- Developers preparing vulnerability disclosures
- Teams conducting focused security assessments for bounty programs
- Engineers triaging static analysis results for real exploitability
security-bounty-hunter FAQ
Prioritize remotely reachable, user-controlled attack paths: SSRF, auth bypass, deserialization-to-RCE, SQL injection, command injection, path traversal, and auto-triggered XSS. Skip local-only pickle/torch loads, hardcoded shell commands, missing headers alone, and self-XSS.
Check the program's explicit scope rules, SECURITY.md, disclosure channel, and exclusion list first. Then verify the code path is reachable from a real network or user boundary and the input is genuinely user-controlled.
Yes, tools like semgrep can help triage, but treat them as input only. Always manually filter out tests, demos, vendored code, and non-reachable paths, then verify exploitability by reading the real code path end-to-end.
Include a description of the vulnerability and its impact, the vulnerable code file and line range with a snippet, a minimal proof-of-concept, the affected version or commit, and confirmation it is not already covered by an advisory or CVE.
Create the smallest safe proof-of-concept that demonstrates the vulnerability works. Confirm the code path is reachable, the input is user-controlled, the sink is meaningful, and the impact is real before submitting.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: security-bounty-hunter description: Hunt for exploitable, bounty-worthy security issues in repositories. Focuses on remotely reachable vulnerabilities that qualify for real reports instead of noisy local-only findings. metadata: origin: ECC direct-port adaptation version: "1.0.0"
Security Bounty Hunter
Use this when the goal is practical vulnerability discovery for responsible disclosure or bounty submission, not a broad best-practices review.
When to Use
- Scanning a repository for exploitable vulnerabilities
- Preparing a Huntr, HackerOne, or similar bounty submission
- Triage where the question is "does this actually pay?" rather than "is this theoretically unsafe?"
How It Works
Bias toward remotely reachable, user-controlled attack paths and throw away patterns that platforms routinely reject as informative or out of scope.
In-Scope Patterns
These are the kinds of issues that consistently matter:
| Pattern | CWE | Typical impact |
|---|---|---|
| SSRF through user-controlled URLs | CWE-918 | internal network access, cloud metadata theft |
| Auth bypass in middleware or API guards | CWE-287 | unauthorized account or data access |
| Remote deserialization or upload-to-RCE paths | CWE-502 | code execution |
| SQL injection in reachable endpoints | CWE-89 | data exfiltration, auth bypass, data destruction |
| Command injection in request handlers | CWE-78 | code execution |
| Path traversal in file-serving paths | CWE-22 | arbitrary file read or write |
| Auto-triggered XSS | CWE-79 | session theft, admin compromise |
Skip These
These are usually low-signal or out of bounty scope unless the program says otherwise:
- Local-only
pickle.loads,torch.load, or equivalent with no remote path eval()orexec()in CLI-only toolingshell=Trueon fully hardcoded commands- Missing security headers by themselves
- Generic rate-limiting complaints without exploit impact
- Self-XSS requiring the victim to paste code manually
- CI/CD injection that is not part of the target program scope
- Demo, example, or test-only code
Workflow
- Check scope first: program rules, SECURITY.md, disclosure channel, and exclusions.
- Find real entrypoints: HTTP handlers, uploads, background jobs, webhooks, parsers, and integration endpoints.
- Run static tooling where it helps, but treat it as triage input only.
- Read the real code path end to end.
- Prove user control reaches a meaningful sink.
- Confirm exploitability and impact with the smallest safe PoC possible.
- Check for duplicates before drafting a report.
Example Triage Loop
semgrep --config=auto --severity=ERROR --severity=WARNING --json
Then manually filter:
- drop tests, demos, fixtures, vendored code
- drop local-only or non-reachable paths
- keep only findings with a clear network or user-controlled route
Report Structure
## Description
[What the vulnerability is and why it matters]
## Vulnerable Code
[File path, line range, and a small snippet]
## Proof of Concept
[Minimal working request or script]
## Impact
[What the attacker can achieve]
## Affected Version
[Version, commit, or deployment target tested]
Quality Gate
Before submitting:
- The code path is reachable from a real user or network boundary
- The input is genuinely user-controlled
- The sink is meaningful and exploitable
- The PoC works
- The issue is not already covered by an advisory, CVE, or open ticket
- The target is actually in scope for the bounty program
Related skills
More from affaan-m/everything-claude-code and the wider catalog.

security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.

golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.

coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.

frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.

backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.

golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.