Skip to content
Skills Library
Security · Analysis

attack-surface

/attack-surface

This skill should be used when the user asks to "map attack surface", "list entry points", "inventory API endpoints", "find all inputs", "enumerate routes", "discover exposed endpoints", or "map external interfaces". Also triggers when the user asks about exposed APIs, form handlers, file upload endpoints, WebSocket handlers, CLI argument parsers, or wants to understand where external data enters the system.

Repository
claude-code ↗
Licence
MIT
Last repository change
07.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

This skill should be used when the user asks to "map attack surface", "list entry points", "inventory API endpoints", "find all inputs", "enumerate routes", "discover exposed endpoints", or "map external interfaces". Also triggers when the user asks about exposed APIs, form handlers, file upload endpoints, WebSocket handlers, CLI argument parsers, or wants to understand where external data enters the system.

Triggers from the description

map attack surfacelist entry pointsinventory API endpointsfind all inputsenumerate routesdiscover exposed endpointsmap external interfaces
Original author description

This skill should be used when the user asks to "map attack surface", "list entry points", "inventory API endpoints", "find all inputs", "enumerate routes", "discover exposed endpoints", or "map external interfaces". Also triggers when the user asks about exposed APIs, form handlers, file upload endpoints, WebSocket handlers, CLI argument parsers, or wants to understand where external data enters the system.

How it works

  1. Supported Flags
  2. Workflow
  3. Output Format
  4. Pragmatism Notes
Original SKILL.md headings · 154 lines, 961 words
SKILL.md preview
---
name: attack-surface
description: >
  This skill should be used when the user asks to "map attack surface",
  "list entry points", "inventory API endpoints", "find all inputs",
  "enumerate routes", "discover exposed endpoints", or "map external
  interfaces". Also triggers when the user asks about exposed APIs,
  form handlers, file upload endpoints, WebSocket handlers, CLI argument
  parsers, or wants to understand where external data enters the system.
disable-model-invocation: true
---

# Attack Surface Mapping

Discover and inventory every entry point where external data enters the
application. Produces a ranked catalog of all routes, APIs, input handlers,
and external interfaces organized by exposure level and trust boundary.

## Supported Flags

Read `../../shared/schemas/flags.md` for the full flag specification.

| Flag | Attack Surface Behavior |
|------|------------------------|
| `--scope` | Default `full`. Attack surface mapping benefits from whole-codebase visibility. Narrow scopes produce partial inventories with a warning. |
| `--depth quick` | Framework route extraction only (Grep for route decorators and definitions). |
| `--depth standard` | Route extraction + read handlers to classify input types and auth requirements. |
| `--depth deep` | Standard + trace each entry point to internal sinks, map trust boundary crossings. |
| `--depth expert` | Deep + rank by exploitability, identify shadow/undocumented endpoints, DREAD scoring. |
| `--severity` | Not directly applicable. Used to filter the exposure ranking in output. |
| `--format` | Default `text`. Use `json` for machine-readable inventory, `md` for wiki export. |

## Workflow

### Step 1: Determine Scope

1. Parse `--scope` flag. Default to `full` for this skill (attack surface requires broad visibility).
2. Resolve to a concrete file list.
3. Prioritize discovery in: route files, controller directories, API definitions, middleware,
   OpenAPI/Swagger specs, GraphQL schemas, gRPC proto files, CLI entry points, WebSocket handlers.

### Step 2: Discover Framework and Language

Identify the application framework(s) to determine route registration patterns:

| Framework | Route Pattern |
|-----------|--------------|
| Express/Koa/Fastify | `app.get()`, `router.post()`, `fastify.route()` |
| Django | `urlpatterns`, `path()`, `re_path()`, `@api_view` |
| Flask | `@app.route()`, `@blueprint.route()` |
| Spring | `@GetMapping`, `@PostMapping`, `@RequestMapping` |
| Rails | `routes.rb`, `resources :`, `get '/'` |
| Next.js/Nuxt | `pages/` and `app/` directory conventions, `route.ts` |
| ASP.NET | `[HttpGet]`, `[Route]`, `MapGet()`, `MapPost()` |
| Go net/http | `http.HandleFunc()`, `mux.Handle()`, gorilla/chi patterns |
| FastAPI | `@app.get()`, `@router.post()` |
| gRPC | `.proto` service definitions, generated server stubs |
| GraphQL | Schema definitions, resolver registrations |

### Step 3: Extract Entry Points

For each framework detected, systematically extract all entry points:

1. **HTTP Routes**: Method, path, handler function, middleware chain.
2. **API Endpoints**: REST, GraphQL queries/mutations, gRPC services.
3. **Form Handlers**: HTML form action targets, multipart upload handlers.
4. **File Upload Endpoints**: Endpoints accepting file data, storage destinations.
5. **WebSocket Handlers**: Connection endpoints, message handlers.
6. **CLI Arguments**: Argument parsers (`argparse`, `commander`, `cobra`, `clap`).
7. **Message Queue Consumers**: Kafka/RabbitMQ/SQS message handlers.
8. **Scheduled Tasks**: Cron jobs, scheduled functions that process external data.
9. **Webhook Receivers**: Endpoints accepting callbacks from external services.
10. **Server-Sent Events**: SSE endpoints, streaming responses.

### Step 4: Classify Each Entry Point

For every discovered entry point, determine:

1. **Authentication**: None, API key, session, JWT, OAuth, mTLS, or unknown.
2. **Authorization**: None, role-based, attribute-based, or unknown.
3. **Input Types**: Query params, path params, headers, body (JSON/XML/form), files, cookies.
4. **Validation**: Present (with details) or absent.
5. **Rate Limiting**: Present or absent.
6. **Network Exposure**: Internet-facing, internal network, localhost only.
7. **Protocol**: HTTP, HTTPS, WebSocket, gRPC, raw TCP, message queue.

### Step 5: Rank by Exposure

Assign an exposure level to each entry point:

| Level | Criteria |
|-------|----------|
| **CRITICAL** | Internet-facing, no authentication, accepts user input, interacts with sensitive data or system resources |
| **HIGH** | Internet-facing with authentication but handling sensitive data, or unauthenticated endpoints with limited input validation |
| **MEDIUM** | Authenticated endpoints with proper validation, or internal endpoints with no authentication |
| **LOW** | Internal endpoints with authentication, limited input surface, or read-only operations on non-sensitive data |

At `--depth deep` and `--depth expert`, trace each HIGH/CRITICAL entry point
inward to identify what sinks they reach (databases, file system, external
services, system commands).

### Step 6: Identify Shadow Endpoints

At `--depth expert`, look for:

- Debug/admin routes not behind auth middleware (e.g., `/debug`, `/admin`, `/metrics`, `/health` exposing internals).
- Routes registered dynamically or via reflection that don't appear in static route lists.
- Endpoints in test/staging configuration that may be active in production.
- API versions that are deprecated but still routed.
- OpenAPI/Swagger UI exposed without authentication.

### Step 7: Report

Output the attack surface inventory.

## Output Format

This skill produces an **inventory**, not vulnerability findings. However, when
entry points have clearly missing security controls (no auth on sensitive
endpoints), emit findings using the standard schema from `../../shared/schemas/findings.md`.

Finding ID prefix: **SURF** (e.g., `SURF-001`).

### Inventory Table

```
## Attack Surface Inventory

### Summary
- Total entry points: N
- Internet-facing: N (N unauthenticated)
- Internal: N
- Exposure: N CRITICAL, N HIGH, N MEDIUM, N LOW

### Entry Points by Exposure

| # | Method | Path | Auth | Input Types | Validation | Rate Limit | Exposure |
|---|--------|------|------|-------------|------------|------------|----------|
| 1 | POST | /api/v1/users | None | JSON body | None | No | CRITICAL |
| 2 | GET | /api/v1/users/:id | JWT | Path param | Partial | Yes | MEDIUM |
| ... |

### Trust Boundary Map (--depth deep)
[Mermaid diagram showing entry points grouped by trust boundary]

### Shadow Endpoints (--depth expert)
[Undocumented or debug endpoints discovered]

### Findings
[Standard findings for missing security controls on entry points]
```

Findings follow `../../shared/schemas/findings.md` with:
- `metadata.tool`: `"attack-surface"`
- `metadata.framework`: depends on invoking context (or `null` if standalone)
- `references.cwe`: `CWE-16` (Configuration), `CWE-306` (Missing Authentication)

## Pragmatism Notes

- Health check endpoints (`/health`, `/ready`) without auth are normal in container orchestration.
  Only flag if they expose sensitive internal state.
- Internal APIs behind a service mesh or VPN still warrant inventory but at lower exposure.
- CLI tools that only run locally have minimal attack surface unless they parse untrusted files.
- Static file serving endpoints are low priority unless directory traversal is possible.

Versions

RepositoryScoreLicence
This page · florianbuetow/claude-code100MIT
swarmsec-app/SwarmSec-Audit-plugin90MIT

Database snapshot: 13.11.2026 · package version 3df54bc8af11 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100orca-exposure-map
    External attack surface mapping — internet-facing assets ranked by risk, exposed ports/services, and attacker's-eye view of the environment. Use when user asks about attack surface, exposure, or external view (e.g., "exposure map", "attack surface", "what's exposed",…
  • 100external-attack-surface-review
    Map and review your organization's own internet-facing attack surface — domains and subdomains (certificate transparency, DNS), IP ranges and ASNs, exposed services and versions (Shodan/Censys data on your assets), cloud endpoints, dangling DNS, exposed admin panels and edge…
  • 100pasta-scope
    This skill should be used when the user asks to "define technical scope", "map attack surface", "identify entry points", "build a data flow diagram", or is running PASTA stage 2. Also triggers when the user asks about DFDs, network boundaries, external dependencies, or…
  • 95easm-review-attack-surface
    Review the organization's external attack surface using Zscaler EASM. Lists organizations, retrieves findings (exposed services, vulnerabilities, misconfigurations), checks for lookalike domains, and generates a prioritized risk summary. Use when a security team asks: 'What is…
  • 100security-review
    Security-focused code review with attack surface mapping and risk classification. Use when reviewing PRs for security, auditing code changes, or analyzing potential vulnerabilities. Triggers on: 'security review', 'use security mode', 'audit this', 'check for vulnerabilities',…
  • 100harden
    Harden code where untrusted input enters the system. Use when implementing auth, handling user input, storing sensitive data, integrating external APIs, adding file uploads or LLM features, or crossing any trust boundary. Don't use for secret scanning (/safe-repo) or dependency CVEs (/deps-audit).

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.