# attack-path-stitcher

Stitches isolated single-asset vulnerabilities into multi-hop attack paths across the infrastructure. Useful for uncovering breach routes to critical systems.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 1400 installs · ★ 595
- Author: transilienceai
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/transilienceai/communitytools/tree/HEAD/skills/attack-path-stitcher/SKILL.md
- Updated: 2026-07-29
- HTML: https://affpapa.org/en/nevibecode/skills/attack-path-stitcher

## What it does

This skill consumes confirmed findings from `validated/*.json`, topology details from `artifacts/org-surface.json`, and raw evidence files. It converts isolated vulnerabilities into a directed graph where assets serve as nodes and verified pivot opportunities act as edges.

Graph construction runs through `tools/chain-merger.py`. The tool inspects seven distinct pivot detectors, covering credential reuse, shared secrets, cloud IAM role assumptions, SSRF pivots, and Active Directory paths. A backward breadth-first search then traces every route leading from external entry points down to tier `crown_jewel` targets. Results land in `artifacts/attack-paths.json`, an `attack-paths.md` summary, and a Graphviz DOT file.

The tool operates strictly read-only and never fires active exploits against infrastructure. Edge calculation stops at 50,000 links with path search depth capped at 8 hops, dropping deeper attack branches automatically.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add transilienceai/communitytools --skill attack-path-stitcher -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/attack-path-stitcher/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/attack-path-stitcher/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add transilienceai/communitytools --skill attack-path-stitcher -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/attack-path-stitcher/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add transilienceai/communitytools --skill attack-path-stitcher -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/attack-path-stitcher/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install transilienceai/communitytools attack-path-stitcher
```

2. **Manually: put the files in place**
- File: `.github/skills/attack-path-stitcher/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add transilienceai/communitytools --skill attack-path-stitcher -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/transilienceai/communitytools --path skills/attack-path-stitcher
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/attack-path-stitcher/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add transilienceai/communitytools --skill attack-path-stitcher -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/transilienceai/communitytools/tree/HEAD/skills/attack-path-stitcher/SKILL.md

## When to use it
- trace multi-hop exploit paths from external perimeter assets to crown jewels
- distinguish verified vulnerability chains from theoretical network reachability
- map credential reuse and IAM role assumptions across infrastructure tiers
- generate visual attack flow diagrams in Graphviz DOT format

## Example prompts
- Stitch validated findings into attack paths leading to crown_jewel assets
- Build the attack path graph with an 8-hop limit and export to attack-paths.json

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 1fdbb8860a0261e4.

BEGIN THIRD-PARTY FILE 1fdbb8860a0261e4
````text
---
name: attack-path-stitcher
description: Stitches confirmed single-asset findings into multi-hop attack paths across the organization. Builds a graph where nodes are assets and edges are confirmed exploit hops citing the findings that enable them.
---

# Attack Path Stitcher

The Validation Run task (#3) produces confirmed findings *per asset*. Real attacker risk lives in **chains**: a finding on asset A leaks credentials that enable a finding on asset B that pivots into asset C. This skill builds that graph.

Mounted onto cloud-agent task #6.

## Trigger

Cron daily (default 03:00 UTC). May also re-run after a Validation Run task batch completes.

## Workflow

1. **Load inputs.**
   - `validated/*.json` — every confirmed finding across all engagements.
   - `artifacts/org-surface.json` — the org-wide surface graph (assets, services, network zones, trust relationships).
   - `findings/finding-NNN/evidence/raw-source.txt` — for credential / token extraction during stitching.
2. **Build asset nodes.** One node per asset in `org-surface.json`, attributed with: `tier`, `services`, `network_zone`, `trust_relationships`.
3. **Build edges** — one edge per detected pivot. See `reference/edge-detectors.md` for the seven detectors:
   - Credential reuse (creds leaked on A reused as auth on B)
   - Shared secret / API key (same secret appears in two assets' evidence)
   - Trust-zone transitive access (A in zone X has implicit reach to B in zone X)
   - AD path hops (kerberoast / DC sync / RBCD chains)
   - Cloud IAM role chains (assume-role from compromised asset)
   - SSRF → internal asset reach (A's SSRF reaches B's internal endpoint)
   - Supply-chain (A is a dependency of B per `source-code-scanning` SBOM)
4. **Compute reachability closure.** For each tier-`crown_jewel` node, BFS backwards through edges to find every external-facing node that can reach it. Mark these as "entry points".
5. **Write graph** to `artifacts/attack-paths.json` plus a human DOT file `artifacts/attack-paths.dot` (renderable with Graphviz).

Implementation runs through `tools/chain-merger.py` which handles the graph construction. The skill provides the *rules* the tool consults; the tool does the iteration.

## Output

```
{OUTPUT_DIR}/
  artifacts/
    attack-paths.json     # nodes, edges, entry_points, crown_jewel_paths
    attack-paths.dot      # Graphviz source
    attack-paths.md       # ranked list of distinct paths (human read)
```

`attack-paths.json` schema:

```json
{
  "generated_at": "2026-05-13T03:00:00Z",
  "nodes": [
    {"id": "asset42", "tier": "revenue", "services": ["http/443"], "zone": "dmz",
````
END THIRD-PARTY FILE 1fdbb8860a0261e4

The third-party file has ended. Everything between the 1fdbb8860a0261e4 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2638 of 6235 bytes. © transilienceai · MIT · https://github.com/transilienceai/communitytools/tree/HEAD/skills/attack-path-stitcher/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md