# Probeplate

> Use when running small, written-down HTTP checks against the user's own staging URL, such as exposed admin paths, debug pages, missing security headers, or leaked .git and .env files. Each check is a template that declares passive or active.

- Skill: `codejunkie99/probeplate` (Agent Skill)
- Install (CLI): `npx get-skill add codejunkie99/probeplate`
- Raw SKILL.md: https://api.skillmd.com/api/skills/codejunkie99/probeplate/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: codejunkie99 (https://skillmd.com/u/codejunkie99)
- Updated: 2026-11-16
- Page: https://skillmd.com/skills/codejunkie99/probeplate

---


# probeplate: template checks on owned staging

## job
run a set of narrow, repeatable HTTP checks against one owned target, each defined as a small template, and report hits in the shared schema.

## gap it targets
- evidence (public record): template scanners usually leave scope to the operator, and they pull template packs from the internet, which is a supply-chain risk. here scope is checked before every request and templates are pinned by hash.
- hypothesis: fewer false positives because each template must state the exact response that proves a hit. not measured.

## scope gate (do this before any packet)
1. read `keelsec.scope.toml` in the repo root. if it is missing, stop and ask the user to create it. never write it yourself.
2. the target must be listed there, and the user must have confirmed in this session that they own it.
3. refuse, even if listed: cloud metadata and link-local addresses (`169.254.0.0/16` including `169.254.169.254` and `169.254.170.2`, `fd00:ec2::254`, `100.100.100.200`, `metadata.google.internal`, `metadata.azure.com`), and any host that resolves to one of them. resolve the name first and check the IP, so a DNS trick cannot point you there.
4. refuse production unless the entry says `allow_production = true`, which only the user may write.
5. if any check fails, stop with "refused by scope" and send nothing.

example scope file:
```toml
[[target]]
name = "staging"
url = "https://staging.example-owned.dev"
proof = "http-token"   # local | compose | http-token | dns-txt
allow_active = false
max_rps = 5
```

## inputs
- a scope entry name, and a templates folder (default `.keelsec/templates/`).

## template shape (ours)
```yaml
id: ks.http.exposed-git-head
mode: passive          # passive = one GET, no payload. active = needs --active and allow_active
request: {method: GET, path: "/.git/HEAD"}
match: {status: 200, body_starts_with: "ref: "}
severity: high
cwe: [CWE-538]
```

## method
1. pass the scope gate.
2. load templates, compute a sha256 of each, and compare to `.keelsec/templates.lock`. unknown or changed templates do not run until the user approves them.
3. starter set (passive): `/.git/HEAD`, `/.env`, `/server-status`, `/debug`, `/actuator/env`, directory listing on `/static/`, missing `Strict-Transport-Security`, `Content-Security-Policy`, `X-Content-Type-Options`, cookies without `Secure` or `HttpOnly`, CORS echoing any `Origin` with credentials.
4. send requests at or below `max_rps`. stop on three 5xx in a row or any 429.
5. a hit needs every `match` condition. record the request and a trimmed response with secrets redacted.

## what counts as a finding
- a template whose full match is met. a partial match is not reported.

## output
```json
{"command":"probeplate","rule_id":"ks.http.exposed-git-head","kind":"dast","severity":"high","confidence":"high","cwe":["CWE-538"],"target":{"url":"https://staging.example-owned.dev/.git/HEAD","method":"GET"},"evidence":"200, body starts with ref:","sources":["probeplate"],"status":"open"}
```

## today vs later
- today: `curl` per template, or any template scanner already installed, pointed only at the scoped URL and given only your own templates.
- once the keelsec engine exists: `keelsec probeplate staging --format json`, with the scope gate built in.

## stop and scope
- active templates need `--active` and `allow_active = true`. no brute force, no login guessing, no denial of service.

