# Cheat sheet

Quick reference for decisions, evidence and commands. Every command inherits its branch's prerequisites. Values such as `YOUR_OWN_BUCKET`, `./repo`, and loopback addresses are examples for controlled environments; do not replace them with an inventory of unreviewed targets.

## The five-line hunt record

```text
Scope: exact asset/version + policy + environment + permitted action
Hypothesis: starting actor can violate this specific boundary
Control: legitimate operation + expected denied operation
Evidence: request/input + response/state + identity + version + timestamp
Result: confirmed / disproved / blocked / next test
```

## Report thresholds

| Observation | Still missing before promoting it |
|---|---|
| SAST match | Reachable source-to-sink path, effective guards, attacker control and consequence |
| Dependency advisory | Affected deployed version, relevant feature/API and exploitable conditions |
| Secret-looking string | Credible secret type, exposure path, owner context, redacted evidence; no default credential use |
| Different HTTP response | Proof of unauthorized data or action, with valid baseline |
| Public storage/signing URL | Unintended exposure or unauthorized issuance, not intended sharing alone |
| SSRF callback | Security consequence beyond intended fetching; callback alone proves only reachability |
| Missing pinning/hardening flag | Program-accepted threat model and a security consequence |
| Local crash | Target root cause, minimal reproducer, eligible build, security relevance and exposure |
| AI instruction following | Unauthorized data/tool/action boundary and actual execution evidence |
| Smart-contract discrepancy | Violated accepted invariant, exact scoped deployment, runnable local proof |
| Firmware secret/debug interface | Intended trust boundary, physical access assumptions, affected revision and concrete impact |

## Scope traps

| Tempting shortcut | Correct decision |
|---|---|
| “It is in certificate transparency.” | Discovery lead only |
| “It belongs to the same brand.” | Verify ownership and exact policy |
| “The parent domain is listed.” | Verify wildcard/apex/path/port semantics |
| “The app calls this API.” | Check the API's independent inclusion |
| “The repo is public.” | Code access does not authorize deployment testing |
| “It runs on my cloud account.” | Provider rules still apply; isolate other identities/resources |
| “The redirect stayed on the same host.” | Port and path may still have left scope |
| “A scanner marked critical.” | Validate exploitability and apply the program's rubric |
| “I have a CVE.” | Disclosure identity, payment, severity and acceptance remain distinct |

## Tool selection by task

| Task | Starting tools | What they do not establish |
|---|---|---|
| Source navigation | Git, ripgrep, language server, debugger | Product reachability or vulnerability on their own |
| Static analysis | Semgrep, CodeQL where licensed | Complete business-logic or framework coverage |
| Secrets | Gitleaks | Credential validity, ownership or permission to use |
| Dependencies / SBOM | OSV-Scanner, Syft, Trivy | Exploitable application use |
| HTTP/manual API | Browser tools, Burp or ZAP, curl | Intentional versus broken authorization without a control |
| Scoped discovery/probing | Subfinder, ProjectDiscovery httpx | Permission for candidates, redirects or discovered services |
| Mobile | adb, JADX, apktool, platform tooling, permitted instrumentation | Release exploitation from a modified test build |
| Desktop / native | Platform debugger, signing/ACL tools, parser harness | Privilege crossing from a crash alone |
| Cloud / Kubernetes | Official provider CLIs, kubectl, policy exports | Full effective security posture from one command |
| AI | Source search, synthetic fixtures, retrieval/tool audit logs | Security impact from a changed answer alone |
| Web3 | Foundry, Slither, ecosystem-specific tools | Non-EVM or economic correctness from Solidity warnings |
| Hardware / firmware | Vendor tooling, file/hash/readelf/strings, isolated emulation | Runtime impact from a suspicious extracted string |

Tool references and installation links are supplied in each branch's official documentation. Prefer pinned releases and recorded checksums. Prepare scanners and dependency databases before confidential analysis; network-disabled execution requires prepared local inputs. Building an untrusted repo, initializing a toolchain, opening a project in an IDE, or loading a model can execute code even when no exploit test has started.

## Command reference by scope

The following sections collect the documented examples from the technical playbooks, including their prerequisites and caveats. Commands were reviewed against references, not run against live targets. Check `--help` and the installed release before use; an unknown flag is an execution failure, not a reason to silently remove a safety constraint.

## OSS & self-hosted

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/oss.html).

Examples target only an existing local `./repo`; they have not been executed against a target. Create `./evidence` first and keep it outside the scan root. Preinstall pinned tool versions, inspect inherited configurations, and prepare required rules/databases/packs in a separate connected preparation phase. Run private-code analysis with network egress blocked. Scanner exit codes can represent findings or execution failures; preserve stderr and classify the outcome before interpreting the report.

**1. Freeze the source identity.** [Git reference](https://git-scm.com/docs/git-rev-parse).

```bash
git -C ./repo rev-parse --verify HEAD > ./evidence/commit.txt
```

**2. Inventory source and hidden configuration without reading Git objects.** [ripgrep guide](https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md).

```bash
rg --files --hidden -g '!.git' ./repo > ./evidence/files.txt
```

**3. Run reviewed local Semgrep rules.** No registry rules are fetched by this command. [Semgrep CLI](https://docs.semgrep.dev/cli-reference).

```bash
semgrep scan --oss-only --config ./rules --metrics=off \
  --disable-version-check --sarif \
  --output ./evidence/semgrep.sarif ./repo
```

The CE engine uses LGPL-2.1; Semgrep-maintained registry rules have a separate Semgrep Rules License, and third-party rules have their own licenses. Internal research and embedding rules into a commercial scanning service are different uses. Prefer original local rules or rules whose terms fit the intended use. [Semgrep licensing](https://docs.semgrep.dev/licensing), [Rules License](https://semgrep.dev/legal/rules-license/).

**4. Review local Git history for secrets.** A shallow clone limits historical coverage. Inspect the output before sharing. [Gitleaks](https://github.com/gitleaks/gitleaks).

```bash
gitleaks git ./repo --redact=100 --report-format json \
  --report-path ./evidence/gitleaks.json
```

**5. Inventory local packages.** [Syft output formats](https://oss.anchore.com/docs/guides/sbom/formats/).

```bash
syft dir:./repo -o cyclonedx-json=./evidence/sbom.cdx.json
```

**6. Match dependencies using previously cached OSV ecosystem databases.** Full `--offline` prevents network use; `--offline-vulnerabilities` alone still permits other network features. Offline mode lacks commit-level matching. [OSV source scanning](https://google.github.io/osv-scanner/usage/scan-source), [offline mode](https://google.github.io/osv-scanner/usage/offline-mode/).

```bash
osv-scanner scan source --offline -r --format json \
  ./repo > ./evidence/osv.json
```

**7. Inspect dependencies and IaC with prepared Trivy databases/checks.** These flags independently disable online resolution, updates, notices, and telemetry. Missing caches or unsupported flags on older releases require preparation/version correction, not silent fallback to online scanning. [Trivy filesystem CLI](https://trivy.dev/docs/latest/references/configuration/cli/trivy_filesystem/).

```bash
trivy fs --scanners vuln,misconfig --offline-scan \
  --skip-db-update --skip-java-db-update --skip-check-update \
  --skip-version-check --disable-telemetry \
  --format json --output ./evidence/trivy.json ./repo
```

**8. Create and query a Python CodeQL database.** Requires a prepared local query suite and its dependencies; language/build setup differs for other projects. [Database preparation](https://docs.github.com/en/code-security/tutorials/customize-code-scanning/prepare-code-for-analysis), [analysis](https://docs.github.com/en/code-security/tutorials/customize-code-scanning/analyze-code).

```bash
codeql database create ./evidence/codeql-python \
  --language=python --source-root=./repo
codeql database analyze ./evidence/codeql-python \
  ./queries/python-security.qls --format=sarif-latest \
  --output=./evidence/codeql.sarif
```

CodeQL is free for public repositories under its terms. Private organization repositories require the applicable GitHub plan and GitHub Code Security license; possession of source does not grant unrestricted CodeQL use. The query libraries' open-source license does not replace the CLI terms. [GitHub: CodeQL availability and license](https://docs.github.com/en/code-security/concepts/code-scanning/codeql/codeql-cli).



## Web & API

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/web-api.html).

**Pass 1 — third-party discovery.** Read program documentation, public API references, repository references, certificate-transparency results, historical URL indexes, and already collected search-engine/network-index records. Save source and collection time; stale records are leads. Searching an existing Shodan/Censys record is different from requesting a fresh scan. Third-party discovery can disclose the target name to a provider even when it does not probe the target.

**Pass 2 — allowlist review.** Resolve candidates into exact permitted origins/resources. Do not pipe passive output directly into a scanner. Retain excluded and uncertain candidates in a review queue. Separate broad wildcard inventory from a single-app campaign: the latter needs route and workflow discovery more than another million hostnames.

**Pass 3 — active validation.** DNS resolution is a network operation and recursive resolution may reach authoritative infrastructure. HTTP requests, TLS handshakes, screenshots, crawling, directory discovery, port scans, DNS brute force, and vulnerability checks are active. Use the program's identification header and rate limit. If no rate is specified, begin manually; a conservative automation starting point is one worker and at most one request/second, only where automation is permitted. This is a proposed budget, not a universal authorization.

**Pass 4 — application mapping.** Exercise normal workflows through an intercepting proxy. Inventory method, path, operation name, object IDs, role, tenant, side effects, upload/download behavior, integrations, and request source. Compare UI traffic with OpenAPI schemas, SDKs, JavaScript and source maps. Old versions, undocumented operations, export jobs and background tasks become hypotheses, not automatic findings.

```bash
# Third-party discovery only: do not add -active/-nW.
# Review installed config and available provider credentials first.
subfinder -d example.com -silent -o candidates.txt

# Human-reviewed file: exact URLs, explicit schemes and permitted ports.
# Use a reviewed empty YAML config to prevent inherited scan options.
httpx -config scope-httpx.yaml -l approved-origins.txt \
  -nfs -sc -title -location -json -threads 1 -rate-limit 1 \
  -retries 0 -timeout 10 -disable-update-check -o inventory.jsonl

# Single approved URL; -q first ignores inherited curlrc options.
# No -L/--location: inspect any Location before a separate request.
curl -q --proto '=https' --connect-timeout 5 --max-time 15 \
  --dump-header evidence/headers.txt --output evidence/body.txt \
  'https://app.example.com/approved-path'
```

`scope-httpx.yaml` should contain `{}`; `evidence/` must already exist. These commands assume tools are installed. `httpx` here means ProjectDiscovery's binary. Its `-nfs` preserves the input scheme; `-nf` has different behavior. Omit redirect-following, screenshot, TLS-domain, CSP-domain, favicon, additional-port, and extra-path probing flags. `-fhr` limits redirects to the same host, **not** to the same port/path. `-allow/-deny` are IP/CIDR controls, not URL scope enforcement. For exact-path scope, prefer a reviewed single request until client behavior is confirmed. [Subfinder usage](https://docs.projectdiscovery.io/opensource/subfinder/usage), [httpx usage](https://docs.projectdiscovery.io/opensource/httpx/usage), [curl manual](https://curl.se/docs/manpage.html).

Automated vulnerability checks come after mapping. Review each selected template's requests, methods, payload count, redirects, extracted targets, code/headless behavior, callbacks and cleanup. A severity label is not a safety classification. A low rate does not make a destructive request safe. Do not use “run all templates” as a discovery stage.


Use the dedicated [Network services playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/network.html) for the full DNS, TLS, email, database, queue, VPN and appliance workflow.

Only use this branch when the service/IP/port is covered. A website scope does not automatically authorize its hosting provider's network. An open port identifies a reachable service, not a vulnerability; an observed version can be backported, masked or misidentified. Nmap service detection sends protocol probes and can have side effects; even its documentation excludes printer port 9100 by default for that reason. Select individual services before deeper interrogation. [Nmap port states](https://nmap.org/book/man-port-scanning-basics.html), [Nmap version detection](https://nmap.org/book/man-version-detection.html).

For DNS, inspect A/AAAA/CNAME/NS/MX/TXT relationships. Public DNS lookups differ from passive historical DNS searches. A dangling CNAME is evidence of a configuration lead, not proof that the referenced resource is claimable. Resource claiming can change production routing; obtain the program-approved proof method before registration. Zone transfer, dynamic updates, recursion abuse and amplification testing require a specific allowed branch.

For TLS, connect using the intended SNI and verify the intended hostname; a wrong default certificate from an IP-only connection may simply reflect virtual hosting. Certificate SANs provide candidates, not added scope. Avoid treating a scanner's “old cipher” label as meaningful impact without the program's eligibility criteria. [OWASP TLS](https://cheatsheetseries.owasp.org/cheatsheets/Transport_Layer_Security_Cheat_Sheet.html).

```bash
# Active DNS queries; only after the applicable discovery gate.
dig +time=2 +tries=1 app.example.com A
dig +time=2 +tries=1 app.example.com AAAA

# Active handshake to an approved hostname and port.
timeout 15 openssl s_client -connect app.example.com:443 \
  -servername app.example.com -verify_hostname app.example.com \
  -verify_return_error -brief </dev/null
```

The DNS and TLS commands use their official documented query/connection options. Hostname verification and SNI are separate controls. [BIND manual](https://bind9.readthedocs.io/en/latest/manpages.html), [OpenSSL s_client](https://docs.openssl.org/3.5/man1/openssl-s_client/).

For SMTP/IMAP, distinguish the domain's mail configuration from an authorized mail-server service. Review SPF/DKIM/DMARC findings against program exclusions and actual spoofing/identity impact. Any relay or delivery test needs explicit scope and researcher-controlled mailboxes; do not send messages to staff to prove delivery. An MX pointing to a provider does not authorize that provider. For SSH, databases, queues, object stores and administration panels, start with service identity and authentication requirements; never jump from a banner to default-password spraying or reading datasets.



## Network services

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/network.html).

Replace these documentation addresses only with approved assets. Here `192.0.2.53` is an authorized DNS server and `192.0.2.10` an explicitly approved host. Run commands individually; inspect each result before continuing. No default broad scans, NSE script sets, OS detection, traceroute or version detection are enabled.

```bash
# 1. One UDP SOA query to an approved authoritative server.
dig -r @192.0.2.53 example.com SOA \
  +norecurse +notcp +ignore +time=2 +tries=1

# 2. One AAAA lookup; still uses IPv4 transport to this DNS server.
dig -r @192.0.2.53 app.example.com AAAA \
  +norecurse +notcp +ignore +time=2 +tries=1

# 3. Inspect the domain's published DMARC record.
dig -r @192.0.2.53 _dmarc.example.com TXT \
  +norecurse +notcp +ignore +time=2 +tries=1

# 4. TLS handshake with the intended SNI and certificate identity.
timeout 15 openssl s_client -connect app.example.com:443 \
  -servername app.example.com -verify_hostname app.example.com \
  -verify_return_error -brief </dev/null

# 5. SMTP STARTTLS negotiation only: no AUTH or message delivery.
timeout 15 openssl s_client -starttls smtp \
  -connect mail.example.com:587 -servername mail.example.com \
  -verify_hostname mail.example.com -verify_return_error \
  -brief </dev/null

# 6. Explicitly approved TCP ports on one approved IPv4 address.
nmap -sT -Pn -n --disable-arp-ping -p 22,443 \
  --max-rate 1 --scan-delay 1s --max-parallelism 1 \
  --max-retries 0 --host-timeout 30s \
  -oX network-one.xml 192.0.2.10
```

`dig -r` ignores inherited `.digrc` options; `+ignore` prevents automatic TCP fallback after a truncated UDP response. A truncated answer is incomplete, so request TCP separately only if allowed. `+norecurse` suits a known authoritative server; a referral is not a complete answer. Use record types A, CNAME, NS, MX, SPF TXT or a **known** DKIM selector only as separately reviewed queries. [BIND 9.20.13 dig manual](https://bind9.readthedocs.io/en/v9.20.13/manpages.html#dig-dns-lookup-utility).

SNI selects a virtual TLS service; hostname verification checks identity. OpenSSL's STARTTLS option performs the protocol negotiation needed before TLS. A successful handshake does not test authentication or mail delivery. [OpenSSL s_client](https://docs.openssl.org/3.5/man1/openssl-s_client/).

Nmap `-p` overrides its default port set, and `-Pn` skips ordinary host discovery that could touch additional ports. `-n` avoids reverse DNS. Scan timing options do not constitute a hard limit on every kernel-generated packet. For separately authorized IPv6 testing, use `-6` and the exact approved IPv6 address. Do not append `-sV`: version detection introduces additional protocol probes and potential side effects. [Nmap port selection](https://nmap.org/book/man-port-specification.html), [host discovery](https://nmap.org/book/man-host-discovery.html), [timing](https://nmap.org/book/man-performance.html), [IPv6](https://nmap.org/book/man-misc-options.html), [version detection](https://nmap.org/book/man-version-detection.html).



## Mobile

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/mobile.html).

Run these against owned lab devices and local artifacts. The commands inspect metadata or write analysis copies; they do not test discovered Internet hosts. Replace identifiers and paths deliberately. Android commands require the indicated SDK tools on `PATH`; JADX and Apktool require their supported Java runtime. [ADB](https://developer.android.com/tools/adb), [APK Analyzer](https://developer.android.com/tools/apkanalyzer), [APK signer](https://developer.android.com/tools/apksigner), [JADX CLI](https://github.com/skylot/jadx), [Apktool CLI](https://apktool.org/docs/cli-parameters/).

```bash
# Android: choose one owned device when more than one is attached.
adb devices -l
adb -s DEVICE_SERIAL shell pm path com.example.lab
adb -s DEVICE_SERIAL shell dumpsys package com.example.lab
apkanalyzer apk summary ./app.apk
apkanalyzer manifest print ./app.apk
apkanalyzer manifest permissions ./app.apk
apksigner verify --verbose --print-certs ./app.apk
jadx -d ./analysis-jadx ./app.apk
apktool d ./app.apk -o ./analysis-apktool
```

On macOS, inspect a locally acquired/extracted app without modifying its signature. `codesign` applies to both iOS bundles and macOS applications, but entitlements and runtime enforcement differ. Check installed `man plutil` / `man codesign` when tooling differs. [OWASP Plutil](https://mas.owasp.org/MASTG/tools/ios/MASTG-TOOL-0062/), [OWASP entitlement extraction](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0111/).

```bash
plutil -p ./Payload/Lab.app/Info.plist
codesign -dv --verbose=4 ./Payload/Lab.app
codesign -d --entitlements :- ./Payload/Lab.app
```



## Desktop & extensions

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/desktop.html).

These are local inspection examples. Paths refer to lab copies. A successful signature check establishes signature validity under the tool’s rules, not absence of vulnerabilities. PowerShell Authenticode inspection is Windows-specific; Apple commands require macOS. [Microsoft Authenticode](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.security/get-authenticodesignature?view=powershell-7.5), [icacls](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/icacls), [Apple signature verification](https://developer.apple.com/library/archive/technotes/tn2206/_index.html), [GNU readelf](https://sourceware.org/binutils/docs/binutils/readelf.html).

```powershell
# Windows / PowerShell: inspection only.
Get-AuthenticodeSignature -FilePath 'C:\Lab\App.exe' | Format-List
icacls 'C:\Lab\App.exe'
icacls 'C:\Program Files\ExampleApp'
```

```bash
# macOS: inspect a lab copy; do not re-sign it for the baseline.
plutil -p ./Example.app/Contents/Info.plist
codesign -dv --verbose=4 ./Example.app
codesign -d --entitlements :- ./Example.app
codesign --verify --deep --strict --verbose=2 ./Example.app

# Linux or another host with GNU binutils: read ELF metadata without execution.
readelf -hW ./lab-app
readelf -lW ./lab-app
readelf -dW ./lab-app

# Search local source/extracted JavaScript; matches are investigation leads.
rg -n 'ipcMain|contextBridge|nodeIntegration|contextIsolation|openExternal' ./source
rg -n 'onMessage|externally_connectable|host_permissions|nativeMessaging' ./extension
```

For an already prepared AFL++ lab, first inspect `afl-fuzz -h`. A campaign skeleton is `afl-fuzz -i ./seeds -o ./fuzz-results -- ./parser-harness @@`; `@@` supplies the current input filename. It runs until stopped unless bounded by supported runtime options. Configure limits before starting, and interrupt with Ctrl-C. The harness must avoid network calls, production credentials, and side effects outside the disposable lab. [AFL++ execution and resource guidance](https://aflplus.plus/docs/fuzzing_in_depth/).



## Cloud & containers

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/cloud.html).

Use installed official CLIs, your own configured lab credentials and the literal approved IDs. These eight commands read configuration or perform local validation; none grants permission to broaden scope. Do not substitute credentials found in a repository. Protect output files because policies and identities can be confidential.

```bash
# 1. Confirm the AWS principal; no secret value is printed.
aws --profile bounty-lab sts get-caller-identity --output json --no-cli-pager

# 2. Inspect one owned general-purpose bucket's policy status.
aws --profile bounty-lab s3api get-bucket-policy-status \
  --bucket YOUR_OWN_BUCKET --expected-bucket-owner YOUR_ACCOUNT_ID \
  --output json --no-cli-pager

# 3. Confirm Azure's selected subscription and tenant.
az account show --query '{subscription:id,tenant:tenantId,user:user.name}' -o json

# 4. Read the policy attached to one owned GCP project.
gcloud projects get-iam-policy YOUR_OWN_PROJECT_ID --format=json

# 5. Ask permission without reading the canary Secret.
kubectl --context bounty-lab -n tenant-a auth can-i get secrets/bounty-canary

# 6. Review only the owned namespace's configuration.
kubectl --context bounty-lab -n tenant-a get roles,rolebindings,networkpolicies -o json

# 7. Inspect a local image without executing its entrypoint.
docker image inspect YOUR_LOCAL_IMAGE --format '{{.Id}} {{json .Config.User}}'

# 8. Validate a trusted, already-initialized local Terraform module.
terraform -chdir=./owned-lab-iac validate -json
```

Command references: [AWS identity](https://docs.aws.amazon.com/cli/latest/reference/sts/get-caller-identity.html), [bucket status](https://docs.aws.amazon.com/cli/latest/reference/s3api/get-bucket-policy-status.html), [Azure account](https://learn.microsoft.com/en-us/cli/azure/account?view=azure-cli-latest), [GCP policy](https://docs.cloud.google.com/sdk/gcloud/reference/projects/get-iam-policy), [kubectl permission query](https://kubernetes.io/docs/reference/kubectl/generated/kubectl_auth/kubectl_auth_can-i/), [Kubernetes RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/), [Docker inspect](https://docs.docker.com/reference/cli/docker/image/inspect/), [Terraform validate](https://developer.hashicorp.com/terraform/cli/commands/validate).

Interpret results narrowly: bucket policy status is not a complete audit of all object-access paths; a GCP project policy does not enumerate every inherited control; `can-i` evaluates authorization, not admission or exploitability; `terraform validate` checks configuration validity, not security. Terraform may invoke installed provider plugins, so “local” does not mean safe for an untrusted repository.



## AI, agents & MCP

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/ai.html).

These six commands are static/local inspection or protocol discovery against an owned fixture. Use a trusted Python 3.11+ interpreter for `file_digest`; isolated mode and disabled site initialization prevent imports from the working directory and site customizations. No model or repository code is executed by the first four. Local HTTP examples assume your intentionally unauthenticated loopback fixture; for an authenticated fixture, use its documented lab credentials. Inventory results do not establish tool-call authorization.

```bash
# 1. Find loader and execution sinks in a local source checkout.
rg -n 'trust_remote_code|torch\.load|pickle\.loads?|subprocess|shell=True' ./repo

# 2. Fingerprint one local weight artifact without loading the model.
python3 -I -S -c 'import hashlib; f=open("./model/model.safetensors","rb"); print(hashlib.file_digest(f,"sha256").hexdigest())'

# 3. Inspect JSON model configuration without importing custom model code.
python3 -I -S -m json.tool ./model/config.json

# 4. Generate a synthetic marker for your private test document.
python3 -I -S -c 'import secrets; print("B_PRIVATE_" + secrets.token_hex(16))'

# 5. Discover a local MCP server implementing the 2026-07-28 protocol.
curl -q --noproxy '*' --proto '=http' --silent --show-error --max-time 10 http://127.0.0.1:8000/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2026-07-28' -H 'Mcp-Method: server/discover' \
  --data '{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{},"io.modelcontextprotocol/clientInfo":{"name":"bounty-lab","version":"1.0"}}}}'

# 6. List tool schemas, without calling a tool, on the same modern fixture.
curl -q --noproxy '*' --proto '=http' --silent --show-error --max-time 10 http://127.0.0.1:8000/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2026-07-28' -H 'Mcp-Method: tools/list' \
  --data '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{},"io.modelcontextprotocol/clientInfo":{"name":"bounty-lab","version":"1.0"}}}}'
```

References for command semantics: [ripgrep guide](https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md), [Python hashlib](https://docs.python.org/3/library/hashlib.html), [Python JSON](https://docs.python.org/3/library/json.html), [Python secrets](https://docs.python.org/3/library/secrets.html), [MCP changelog](https://modelcontextprotocol.io/specification/2026-07-28/changelog), [MCP HTTP binding](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http), [MCP tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools). Syntax was checked against documentation; these examples were not run against a live target.



## Web3 & protocols

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/web3.html).

Run these from an isolated, reviewed local checkout with its required dependencies. `CHAIN_RPC_URL` is the permitted read-only state provider and `FORK_BLOCK` is a recorded decimal block number. Commands are examples of documented syntax, not a universal installer or completed PoC.

```bash
git rev-parse HEAD
forge --version
slither --version
forge build
slither . --json slither.json
forge test --match-test '^test_PoC$' \
  --fork-url "$CHAIN_RPC_URL" \
  --fork-block-number "$FORK_BLOCK" -vvvv
forge test --match-test '^invariant_' \
  --fork-url "$CHAIN_RPC_URL" \
  --fork-block-number "$FORK_BLOCK"
```

`test_PoC` and `invariant_*` are harness functions you implement; they are not built-in vulnerability checks. Preserve the harness, minimized inputs, dependency lock state and traces. Review untrusted build scripts before execution. [Foundry testing](https://www.getfoundry.sh/forge/testing), [Forge test reference](https://www.getfoundry.sh/reference/forge/test), [Slither usage](https://github.com/crytic/slither/wiki/Usage)

**Submission gate:** correct eligible deployment; realistic attacker; reproducible local fork; necessary privileges disclosed; precise impact category; bounded loss; known issues checked; private reporting channel used; no real funds moved. Read the current PoC requirements linked by the program before submitting; a toy reimplementation can explain the idea but does not establish deployed impact.



## Hardware & firmware

[Context and complete playbook](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/hardware.html).

Use an offline copy of a vendor image in an isolated non-root analysis environment. These commands inspect local files; they do not acquire firmware from an unknown device or authorize testing any embedded endpoint.

```bash
mkdir -p evidence
sha256sum firmware.bin > evidence/firmware.sha256
file firmware.bin > evidence/firmware-type.txt
binwalk firmware.bin > evidence/firmware-layout.txt
strings -a -n 8 firmware.bin > evidence/firmware-strings.txt

# After an appropriate extractor has produced an owned local filesystem:
rg --files extracted-rootfs > evidence/file-inventory.txt
rg -n -i 'password|token|private.key|update|signature' \
  extracted-rootfs > evidence/review-leads.txt

# For an identified ELF binary, not for every firmware format:
readelf -hW extracted-rootfs/usr/sbin/example-daemon
readelf -lW extracted-rootfs/usr/sbin/example-daemon
```

Select the extractor for the detected format, verify its current syntax and inspect archive contents before extraction. Keep unknown images away from host mounts and privileged analysis processes. Binwalk identifies embedded content and can support extraction workflows; high entropy alone does not distinguish encryption from compression. The `rg` matches above are review leads, not confirmed credentials or findings. [Binwalk](https://github.com/ReFirmLabs/binwalk), [OWASP FSTM](https://github.com/scriptingxss/owasp-fstm)

**Evidence bundle:** product/revision photo with unnecessary identifiers redacted; firmware and extracted-file hashes; access model; wiring/interface notes where applicable; synthetic account roles; minimal input; serial or packet logs; observed versus expected behavior; reproducibility count; device recovery status; and exact affected versions. Include proof that emulation assumptions also hold on the claimed product, or clearly limit the claim to the emulated component.




## Search commands by tool or boundary

The [command workbench](https://bug-bounty-field-manual.kmahshooq.chatgpt.site/commands.html) adds filterable snippets from every detailed module. Each snippet links to the canonical setup, expected result, and checklist.