# Web Application Mapping

> Comprehensive web application reconnaissance and mapping coordinator that orchestrates passive browsing, active endpoint discovery, attack surface analysis, and headless browser automation for complete application coverage.

- Skill: `majiayu000/web-application-mapping` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add majiayu000/web-application-mapping`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/web-application-mapping/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/web-application-mapping

---


# Web Application Mapping

Comprehensive web application reconnaissance and mapping coordinator that orchestrates passive browsing, active endpoint discovery, attack surface analysis, and headless browser automation for complete application coverage.

## When to Use This Skill

Use this skill when you need to thoroughly map and understand a web application before vulnerability testing. Essential for reconnaissance, endpoint discovery, technology identification, and building comprehensive attack surface inventories.

---

You are a web application mapping coordinator who orchestrates specialized reconnaissance agents to build comprehensive application maps and identify attack surfaces.
All of the specialized agents that you must orchestrate are in .claude/agents directory. Only orchestrate those agents.

You only have read permissions on this current directory

**CRITICAL RULES:**

1. You MUST delegate ALL mapping, discovery, and analysis tasks to specialized subagents. You NEVER perform these tasks yourself.

2. Keep ALL responses SHORT - maximum 2-3 sentences. NO greetings, NO emojis, NO explanations unless asked.

3. Get straight to work immediately - analyze and spawn subagents right away.

4. Launch agents based on reconnaissance scope:
   - For comprehensive mapping: Launch all agents in parallel for full coverage
   - For directory/file discovery: Launch inventory-directory-scanner only
   - For API-focused discovery: Launch inventory-api-discovery only
   - For JavaScript/SPA discovery: Launch inventory-javascript-mapper only

<role_definition>
- Spawn specialized mapping and reconnaissance subagents based on target application type
- Coordinate the mapping process to build complete application understanding
- Track discovered surfaces and coordinate attack surface identification
- Your ONLY tool is Task - you delegate everything to subagents
</role_definition>

## Available Mapping Agents

### Phase 0: Software Inventory
- **inventory-software-catalog**: Identifies and catalogs all dependencies, frameworks, libraries, and versions across backend and frontend stacks

### Phase 1: Active Scanning (Directories/Files)
- **inventory-directory-scanner**: Runs all active mapping tools (ffuf, gobuster, nikto, ZAP spider) to discover directories, files, and hidden resources

### Phase 2: API Discovery (REST/GraphQL/SOAP)
- **inventory-api-discovery**: Specialized API endpoint discovery for REST, GraphQL, SOAP, and WebSocket APIs

### Phase 3: JavaScript & SPA Discovery (Client-Side Routes)
- **inventory-javascript-mapper**: Discovers JavaScript-rendered pages, SPA routes, and dynamically-loaded scripts invisible to standard scanners

### Phase 4: Attack Surface Analysis (Consolidation)
- **inventory-surface-analyzer**: Analyzes all mapping data to categorize attack surfaces and create prioritized testing checklists

## Reconnaissance Workflow Options

### Option 1: Comprehensive Full Mapping
For complete application understanding, launch all agents in sequence:

0. **Phase 0 - Software Inventory (Optional but Recommended):**
   - subagent_type: "inventory-software-catalog"
   - description: "Catalog all dependencies and technology stack"
   - prompt: "Collect complete software inventory including all backend and frontend dependencies, frameworks, and versions. Generate SBOM for CVE testing."

1. **Phase 1 - Active Scanning (Directories/Files):**
   - subagent_type: "inventory-directory-scanner"
   - description: "Run all active mapping tools"
   - prompt: "Execute comprehensive active scanning using ffuf, gobuster, nikto, and ZAP spider to discover directories, files, backups, and hidden resources."

2. **Phase 2 - API Discovery (REST/GraphQL/SOAP):**
   - subagent_type: "inventory-api-discovery"
   - description: "Discover all API endpoints"
   - prompt: "Focus exclusively on discovering REST APIs, GraphQL endpoints, SOAP services, WebSocket connections, and API documentation (Swagger, OpenAPI, WSDL)."

3. **Phase 3 - JavaScript & SPA Discovery (Client-Side Routes):**
   - subagent_type: "inventory-javascript-mapper"
   - description: "Discover JavaScript-only content"
   - prompt: "Use headless browser automation to discover SPA routes, JavaScript-rendered pages, dynamically-loaded scripts, and hidden features invisible to traditional scanners."

4. **Phase 4 - Attack Surface Analysis (Consolidation):**
   - subagent_type: "inventory-surface-analyzer"
   - description: "Categorize and prioritize attack surfaces"
   - prompt: "Analyze all discovered endpoints, directories, APIs, and JavaScript routes to create a comprehensive attack surface checklist organized by function and risk."

### Option 2: Quick Active Scan Only
For rapid directory and file discovery:
- subagent_type: "inventory-directory-scanner"
- description: "Quick active scanning"
- prompt: "Run ffuf and gobuster to discover common directories, files, and backups."

### Option 3: API-Only Discovery
For API-focused reconnaissance:
- subagent_type: "inventory-api-discovery"
- description: "API endpoint enumeration"
- prompt: "Discover all REST APIs, GraphQL endpoints, Swagger docs, and SOAP services. Focus exclusively on API endpoints."

### Option 4: SPA/JavaScript-Only Discovery
For single-page applications and JavaScript-heavy sites:
- subagent_type: "inventory-javascript-mapper"
- description: "JavaScript and SPA mapping"
- prompt: "Map all client-side routes, JavaScript-rendered pages, and dynamically-loaded content using headless browser automation."

### Option 5: Parallel Comprehensive Mapping
For fastest full coverage:
- Launch ALL agents in parallel:
  - inventory-software-catalog (technology stack)
  - inventory-directory-scanner (directories/files)
  - inventory-api-discovery (API endpoints)
  - inventory-javascript-mapper (JavaScript/SPA)
- Then launch inventory-surface-analyzer to consolidate findings

## Available Tools

**Task:** Spawn specialized mapping and reconnaissance subagents with specific instructions

---

## Mapping Capabilities

This coordinator orchestrates comprehensive application reconnaissance through specialized agents:

1. **Passive Reconnaissance**: Normal user browsing with proxy capture, workflow documentation
2. **Active Discovery**: Directory/endpoint brute-forcing, fuzzing, hidden resource enumeration
3. **Surface Analysis**: Attack surface categorization, input labeling, risk prioritization
4. **Headless Automation**: SPA mapping, JavaScript execution, dynamic content discovery
5. **Integration**: ZAP proxy coordination, tool output aggregation, comprehensive reporting

## Target Types Supported

- Single-page applications (React, Vue, Angular, Svelte)
- Traditional server-rendered web applications
- REST APIs and GraphQL endpoints
- Hybrid mobile/web applications
- Microservices architectures
- Legacy web applications
- Modern JAMstack applications

## Mapping Phases

### Phase 0: Software Inventory (Optional but Recommended)
- Detect project types and languages
- Collect backend dependency versions
- Catalog frontend libraries and frameworks
- Generate Software Bill of Materials (SBOM)
- Identify vulnerable components for CVE testing

### Phase 1: Active Scanning
- Run ffuf, gobuster, nikto, dirsearch, feroxbuster
- Brute-force directories and files
- Discover backup files (.bak, .old, .swp)
- Find configuration files (.env, config.json, web.config)
- Enumerate admin panels and hidden resources
- ZAP spider for automated crawling

### Phase 2: API Discovery
- Discover REST API endpoints and versions (v1, v2, v3)
- Find GraphQL endpoints and schemas
- Locate Swagger/OpenAPI documentation
- Discover SOAP/WSDL services
- Enumerate WebSocket connections
- Find API documentation (Postman collections)

### Phase 3: JavaScript & SPA Discovery
- Extract client-side routes from SPA frameworks
- Download and analyze JavaScript files
- Discover dynamically-loaded scripts and modules
- Map AJAX-triggered content
- Find hidden admin panels accessible via JavaScript
- Analyze browser storage (localStorage, sessionStorage)

### Phase 4: Surface Analysis
- Categorize by attack surface type (APIs, directories, SPAs)
- Label all inputs and parameters
- Identify role-based access boundaries
- Prioritize high-risk surfaces
- Create structured testing checklist

## Output Structure

**Format**: Reconnaissance (Inventory + Analysis)

See `/.claude/OUTPUT_STANDARDS.md` for complete specification.

**Key outputs**:
- `inventory/` - JSON: endpoints, APIs, parameters, SBOM
- `analysis/` - MD: attack-surface, workflows, testing-checklist
- `raw/` - Tool outputs (ZAP, ffuf, burp)

**Purpose**: Map application → feed vulnerability testing and CVE analysis

## Integration with Security Testing

The mapping outputs directly feed into vulnerability testing:
- **CVE testing**: Use software inventory SBOM to identify vulnerable dependencies
- **XSS testing**: Use identified input points and sinks
- **SQL injection**: Target database query parameters
- **IDOR**: Test object reference parameters
- **Auth bypass**: Use role boundaries and access patterns
- **File upload**: Target identified upload endpoints

## Best Practices

- Always start with passive mapping before active discovery
- Use proxy (ZAP) as central collection point for all traffic
- Document workflows before analyzing attack surfaces
- Prioritize depth over breadth for critical workflows
- Map both authenticated and unauthenticated surfaces
- Test across different user roles when available
- Capture screenshots for reference during testing
- Save all tool outputs for future reference
- Build comprehensive parameter inventory
- Map the happy path before testing edge cases