# io.github.cyanheads/pentest-mcp-server (remote · pentest.caseyjhand.com)

Offline methodology engine for authorized penetration testing, CTF, and security research.

- Trust score: 68/100 (medium)
- Change this week: +6
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `pentest.caseyjhand.com`: 68/100 (this document), [markdown](https://verifymcp.io/servers/cyanheads-pentest-mcp-server/pentest.md), [page](https://verifymcp.io/servers/cyanheads-pentest-mcp-server/pentest)
- npm · `@cyanheads/pentest-mcp-server`: 35/100, [markdown](https://verifymcp.io/servers/cyanheads-pentest-mcp-server/cyanheads-pentest-mcp-server.md), [page](https://verifymcp.io/servers/cyanheads-pentest-mcp-server/cyanheads-pentest-mcp-server)

## Channel facts

- Endpoint: `https://pentest.caseyjhand.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.1.6`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 66/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 7 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 61/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1793 tokens (~256/item across 7 items; 7 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http cyanheads-pentest-mcp-server https://pentest.caseyjhand.com/mcp
```

### Codex

```toml
[mcp_servers.cyanheads-pentest-mcp-server]
url = "https://pentest.caseyjhand.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cyanheads-pentest-mcp-server": {
      "type": "remote",
      "url": "https://pentest.caseyjhand.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cyanheads-pentest-mcp-server --url https://pentest.caseyjhand.com/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  cyanheads-pentest-mcp-server:
    url: "https://pentest.caseyjhand.com/mcp"
```

### Other

```json
{
  "mcpServers": {
    "cyanheads-pentest-mcp-server": {
      "type": "http",
      "url": "https://pentest.caseyjhand.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-01 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 66, +2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 64, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-28 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 62, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 62)

First indexed and scored.

## MCP tools (7)

### `pentest_guide` (~223 tokens)

Pentest Guide

Return a structured attack methodology playbook for the given attack vector and optional target context, for use in authorized penetration testing, CTF, or security research. Covers reconnaissance, enumeration, exploitation, and post-exploitation phases for the vector, filtered to what is relevant given the provided stack and WAF profile. Each phase includes: what to look for, tools to use, common mistakes, detection indicators that would alert defenders, and recommended mitigations. Next-tool suggestions are pre-filled with payload generator and technique lookup calls. Covers 15 vectors via the vector enum. Authorized testing only.

Input parameters:

- `phase` (string): Restrict output to a specific phase. Use "all" for a complete playbook. Use a specific phase when working through a step-by-step flow.
- `target_context` (object): Optional target profile for authorized engagement. Providing this narrows the playbook to what is most relevant for the specific environment.
- `vector` (string, required): Attack vector to retrieve methodology for. Each vector has its own methodology branch covering recon through exploitation. Authorized testing only.

Output parameters:

- `attack_technique_ids` (array): Relevant ATT&CK technique IDs for cross-referencing with pentest_lookup_technique.
- `authorized_use_reminder` (string): Reminder that this methodology applies to authorized testing only. Included in every response.
- `nextToolSuggestions` (array): Suggested follow-up tool calls with arguments pre-populated from the playbook findings.
- `owasp_references` (array): Relevant OWASP Testing Guide test case IDs (e.g., "WSTG-INPV-01").
- `phases` (array): Ordered methodology phases. Contains only the requested phase when phase input is not "all".
- `vector` (string): The requested attack vector.

### `pentest_analyze_response` (~290 tokens)

Pentest Analyze Response

Analyze a server response from authorized probing for information leakage, fingerprinting signals, and exploitation opportunities scoped to the authorized engagement. Accepts raw HTTP response headers and body (paste from Burp, curl, or any HTTP client) and returns structured findings grouped by category. Each finding includes: what was detected, why it matters for an authorized tester, how a defender detects misuse, and recommended remediation. Identifies version disclosures, stack traces, debug headers, internal paths, JWT/cookie patterns, CORS misconfigurations, and other common leakage patterns. Use as the bridge between recon/probing output and the methodology and payload tools.

Input parameters:

- `context` (string): Freeform context about the authorized test target — e.g., "login endpoint", "GraphQL API", "file upload handler". Narrows the pattern matching to relevant categories. Max 2,000 characters.
- `response_body` (string): Response body text. Paste raw HTML, JSON, XML, or error text. Truncate to the first 10,000 characters for very large responses — the first portion carries most leakage signals.
- `response_headers` (string): Raw HTTP response headers (paste from Burp, curl -v, or similar). Include the status line if available. Max 20,000 characters.
- `status_code` (integer): HTTP status code (100–599). Helps classify the response type.

Output parameters:

- `authorized_use_reminder` (string): Reminder that response analysis is for authorized testing only. Rendered first.
- `findings` (array): Structured findings ordered by severity descending (high first).
- `fingerprints` (object): Technology fingerprinting summary for use in target_context when calling pentest_guide or pentest_map_techniques.
- `nextToolSuggestions` (array): Suggested next tool calls — typically pentest_guide with fingerprint-populated stack, or pentest_generate_payloads for directly exploitable findings.
- `summary` (string): One-paragraph summary of findings and recommended next steps for the authorized tester.

### `pentest_lookup_technique` (~218 tokens)

Pentest Lookup Technique

Look up a MITRE ATT&CK technique by ID or keyword for authorized penetration testing and security research. Returns the full technique record: name, associated tactics, description, detection opportunities (log sources, behavioral indicators), real-world procedure examples from public reporting, recommended mitigations, and related sub-techniques. The detection and mitigation sections make this equally useful for defenders building detection coverage. Accepts exact IDs (T1190, T1059.001) or keyword search (e.g., "sql injection", "pass the hash", "web shell upload").

Input parameters:

- `include_subtechniques` (boolean): Include sub-techniques in the result. Set to false when only the parent technique summary is needed.
- `query` (string, required): ATT&CK technique ID (e.g., "T1190", "T1059.001") or keyword describing the technique (e.g., "sql injection", "pass the hash", "web shell upload"). ID lookup is exact; keyword lookup returns the best…

Output parameters:

- `attack_version` (string): ATT&CK dataset version used (e.g., "Enterprise v19.1"). Included so callers know the data vintage.
- `authorized_use_reminder` (string): Reminder that technique data is for authorized testing and research only. Rendered first.
- `description` (string): ATT&CK description of the technique.
- `detection` (object): Detection context — directly useful for blue team detection coverage.
- `mitigations` (array): Recommended mitigations from ATT&CK.
- `name` (string): Technique name.
- `platforms` (array): Target platforms (e.g., "Windows", "Linux", "Web Application").
- `procedure_examples` (array): Real-world usage examples from ATT&CK public reporting. Useful for understanding adversary application of the technique.
- `sub_techniques` (array): Sub-techniques of this parent technique. Empty when querying a sub-technique itself, or when include_subtechniques is false.
- `tactics` (array): ATT&CK tactics this technique belongs to (e.g., "Initial Access", "Execution").
- `technique_id` (string): ATT&CK technique ID (e.g., "T1190").

### `pentest_lookup_group` (~215 tokens)

Pentest Lookup Group

Look up a MITRE ATT&CK threat group (intrusion set) or software entry by name or ID for authorized penetration testing and threat intelligence. Returns the group or software record: ATT&CK ID, display name, known aliases, type (group vs. software), description, and the techniques it uses with procedure-level context from public ATT&CK reporting. Accepts exact ATT&CK IDs (G0007 for threat groups, S0002 for software) or keyword/name search (e.g., "APT28", "Mimikatz", "Lazarus Group"). Equally useful for defenders building detection coverage around specific adversary tradecraft.

Input parameters:

- `query` (string, required): ATT&CK threat group ID (e.g., "G0007"), software ID (e.g., "S0002"), or name/keyword (e.g., "APT28", "Mimikatz", "Lazarus Group"). ID lookup is exact and case-insensitive; name/keyword search returns…

Output parameters:

- `aliases` (array): Known alternate names from ATT&CK.
- `attack_version` (string): ATT&CK dataset version used (e.g., "Enterprise v19.1"). Included so callers know the data vintage.
- `authorized_use_reminder` (string): Reminder that threat group data is for authorized testing and research only. Rendered first.
- `description` (string): ATT&CK description (truncated to 800 characters).
- `id` (string): ATT&CK ID (e.g., "G0007" for a group, "S0002" for software).
- `name` (string): Primary display name (e.g., "APT28", "Mimikatz").
- `techniques_used` (array): Techniques this group or software is known to use, with procedure-level context from public ATT&CK reporting (up to 20 entries). Use pentest_lookup_technique with each technique_id for full technique…
- `type` (string): "group" for intrusion sets (threat actors), "software" for malware and tools.

### `pentest_map_techniques` (~272 tokens)

Pentest Map Techniques

Given a profile of the authorized test target (technology stack, exposed services, authentication type, OS), return a ranked list of ATT&CK techniques and OWASP test cases most relevant to that profile — not a generic dump of all techniques. Ranking factors: platform match, service match, auth type exposure, technique prevalence. Each result includes why it is relevant to this specific profile, the detection opportunity, and the recommended mitigation. Use when starting an authorized engagement to prioritize the testing scope; pair with pentest_guide to get the full methodology for each top-ranked vector.

Input parameters:

- `auth_type` (string): Authentication mechanism in use. Surfaces auth-specific attack techniques.
- `limit` (integer): Maximum number of techniques to return (1–50, default 15). Higher values give broader coverage; lower values focus on highest-relevance items.
- `os` (string): Target operating system. Narrows to OS-specific techniques.
- `services` (array): Exposed services and interfaces (e.g., ["REST API", "GraphQL", "file upload", "admin panel"]). Narrows technique relevance.
- `stack` (array): Technology stack components (e.g., ["Node.js", "Express", "PostgreSQL", "Redis"]). Each element matched against technique platform and procedure examples.

Output parameters:

- `attack_version` (string): ATT&CK dataset version used for technique data.
- `authorized_use_reminder` (string): Reminder that technique mapping is for authorized testing engagements only. Rendered first.
- `owasp_test_cases` (array): Relevant OWASP Testing Guide test cases for the profile (up to 10).
- `profile_summary` (string): One-sentence summary of the target profile as interpreted by the ranking algorithm.
- `ranked_techniques` (array): Techniques ordered by relevance_score descending.

### `pentest_generate_payloads` (~286 tokens)

Pentest Generate Payloads

Generate payload templates for authorized testing against systems the tester owns or is permitted to test. Payloads are annotated templates — each includes why it works in the specified context, what vulnerability class it tests, detection signatures that WAF/IDS products might fire, and recommended mitigations. Context-awareness is core: an XSS payload for an HTML attribute differs entirely from one for a JS template literal, and both differ from a DOM-based sink. When a WAF profile is specified, bypass variants reference known public research for that WAF product. All payloads are illustrative templates for authorized testing only.

Input parameters:

- `category` (string, required): Vulnerability category for payload generation.
- `count` (integer): Number of payload variants to return (1–20, default 5). More variants cover different bypass approaches for the same context.
- `encoding` (array): Apply an encoding chain to payloads at generation time. Applied in order (left to right). Use pentest_encode for more control over per-payload encoding.
- `injection_context` (string, required): Precise injection context. Critical for XSS: an HTML attribute payload differs from a JS string payload. Provide the most specific context for the best results.
- `waf_profile` (string): WAF or filter in front of the authorized test target. When a specific WAF is named, bypass variants referencing known public research are included.

Output parameters:

- `authorized_use_reminder` (string): Reminder that these templates are for authorized testing only.
- `category` (string): Requested payload category.
- `injection_context` (string): Requested injection context.
- `payloads` (array): Payload templates ordered by coverage breadth, each annotated with offense and defense context.

### `pentest_encode` (~218 tokens)

Pentest Encode

Transform a payload string through one or more encoding layers for bypass research during authorized testing. Accepts a chain of encodings applied in order (e.g., ["unicode", "url", "base64"] applies Unicode → URL-encode → base64). Returns the transformed payload with a step-by-step decoding explanation: how a WAF or server would decode each layer, and why the combined encoding might bypass a specific filter. Use to understand filter bypass mechanics in an authorized engagement and to confirm that a target's decoding pipeline matches an expected bypass path. Payloads are transformed mathematically — no live probing occurs.

Input parameters:

- `chain` (array, required): Ordered list of encodings to apply (1–6 steps). Applied left to right. E.g., ["unicode", "url"] applies Unicode escape first, then URL-encodes the result.
- `explain` (boolean): Include step-by-step decode explanation. Set to false for raw transform output only.
- `payload` (string, required): Input payload string to encode. Max 10,000 characters.

Output parameters:

- `authorized_use_reminder` (string): Reminder that encoding transforms are for authorized bypass research only.
- `bypass_rationale` (string): Why this encoding combination might bypass common filter patterns. Included when explain is true.
- `decode_path` (string): Step-by-step explanation of how a decoder (WAF, server, browser) would reverse the encoding chain. Included when explain is true.
- `detection_note` (string): How defenders detect encoded payload variants — decoding normalizers, entropy analysis, behavioral detection. Always included to maintain the dual offense/defense framing.
- `encoded` (string): Final encoded payload after all chain steps applied.
- `intermediate_steps` (array): Intermediate values at each encoding step, for tracing the chain.
- `original` (string): The input payload.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/cyanheads-pentest-mcp-server/pentest#diagnostics

## Score history

- 2026-08-03: 68
- 2026-08-02: 67
- 2026-08-01: 67
- 2026-07-31: 66
- 2026-07-30: 64
- 2026-07-29: 64
- 2026-07-28: 63
- 2026-07-27: 62
- 2026-07-26: 62

## Links

- Remote endpoint: https://pentest.caseyjhand.com/mcp
- Repository: https://github.com/cyanheads/pentest-mcp-server
- Changelog RSS feed: https://verifymcp.io/servers/cyanheads-pentest-mcp-server/pentest/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/cyanheads-pentest-mcp-server/pentest/changelog.json
- HTML version of this page: https://verifymcp.io/servers/cyanheads-pentest-mcp-server/pentest