Skip to main content
skill CX Codex

threat-model-generator — Claude Code skill: what it does

threat-model-generator builds a STRIDE threat model: lists assets, enumerates threats with risk scores, picks mitigations and works out what risk is left.

MIT 270 installs ★ 64 updated 2026-01-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add patricio0312rev/skills --skill threat-model-generator -a claude-code
Open on GitHub

What threat-model-generator does

The skill walks all six STRIDE categories, from spoofing and tampering to denial of service and elevation of privilege. It opens with an asset inventory where every item gets a type, a sensitivity level and a criticality level. Threats follow, each tied to one asset, with an attack vector, likelihood, impact and a numeric score.

Mitigations come next, rated for effectiveness, cost and priority. The residual-risk calculation uses only the strongest measure, so two medium ones will not add up to a high one. When the leftover risk still looks too big, the fix is a stronger control rather than a second copy of the same.

What you get at the end is a document: architecture overview, trust boundaries, an asset table, threats grouped by category with their mitigations. Monitoring is flagged whenever the remaining risk stays at 3 or above, and below that the model treats the risk as acceptable.

What it helps with

  • map a new feature against all six STRIDE categories before release
  • build an asset inventory with sensitivity and criticality levels
  • score each threat by likelihood, impact and numeric risk
  • pick mitigations with cost and priority in view
  • spot which threats still need monitoring after the fixes land

Example prompts for the agent

  • Build a STRIDE threat model for our auth service
  • List the assets in this API and rate how sensitive each one is
  • What's the residual risk on credential theft once we add MFA and login rate limits?

How to install threat-model-generator

1Skills CLI (Vercel)

npx skills add patricio0312rev/skills --skill threat-model-generator -a claude-code

2Manually: put the files in place

~/.claude/skills/threat-model-generator/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/threat-model-generator/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about threat-model-generator

How do I install threat-model-generator in Claude Code?

Run npx skills add patricio0312rev/skills --skill threat-model-generator -a claude-code. The skill lands at ~/.claude/skills/threat-model-generator/SKILL.md.

What does threat-model-generator do?

It runs a STRIDE analysis: assets first, then threats with attack vectors and risk scores, then mitigations, then the risk that survives them.

How is the residual risk calculated?

The strongest mitigation sets the reduction: 0.8 for high effectiveness, 0.5 for medium, 0.2 for low. The result is rounded, and a value of 3 or more marks the threat as needing monitoring.

Source text

SKILL.md · MIT
---
name: threat-model-generator
description: Creates comprehensive threat models using STRIDE methodology with asset identification, threat enumeration, mitigation strategies, and residual risk assessment. Use for "threat modeling", "security analysis", "STRIDE", or "risk assessment".
---

# Threat Model Generator

Systematically identify and mitigate security threats.

## STRIDE Methodology

```
S - Spoofing: Impersonating someone/something
T - Tampering: Modifying data or code
R - Repudiation: Claiming you didn't do something
I - Information Disclosure: Exposing protected information
D - Denial of Service: Making system unavailable
E - Elevation of Privilege: Gaining unauthorized permissions
```

## Asset Identification

```typescript
interface Asset {
  name: string;
  type: "data" | "service" | "user" | "infrastructure";
  sensitivity: "public" | "internal" | "confidential" | "restricted";
  criticality: "low" | "medium" | "high" | "critical";
}

const assets: Asset[] = [
  {
    name: "User Credentials (passwords, tokens)",
    type: "data",
    sensitivity: "restricted",
    criticality: "critical",
  },
  {
    name: "Payment Information (credit cards)",
    type: "data",
    sensitivity: "restricted",
    criticality: "critical",
  },
  {
    name: "API Service",
    type: "service",
    sensitivity: "internal",
    criticality: "high",
  },
  {
    name: "User Profile Data",
    type: "data",
    sensitivity: "confidential",
    criticality: "medium",
  },
];
```

## Threat Enumeration

```typescript
interface Threat {
  id: string;
  category: "S" | "T" | "R" | "I" | "D" | "E";
  description: string;
  asset: string;
  attackVector: string;
  likelihood: "low" | "medium" | "high";
  impact: "low" | "medium" | "high" | "critical";
  riskScore: number;
}

const threats: Threat[] = [
  {
    id: "T-001",
    category: "S",
    description: "Attacker impersonates user with stolen credentials",
    asset: "User Credentials",
    attackVector: "Phishing, credential stuffing, brute force",
    likelihood: "high",
    impact: "critical",
    riskScore: 9,
  },
  {
    id: "T-002",
    category: "T",
    description: "SQL injection allows data modification",
    asset: "User Profile Data",
    attackVector: "Malicious SQL in input fields",
    likelihood: "medium",
    impact: "high",
    riskScore: 7,
  },
  {
    id: "T-003",
    category: "I",
    description: "API exposes sensitive user data without auth",
    asset: "User Profile Data",
    attackVector: "Direct API access, IDOR",
    likelihood: "medium",
    impact: "high",
    riskScore: 7,
  },
  {
    id: "T-004",
    category: "D",
    description: "DDoS attack overwhelms API",
    asset: "API Service",
    attackVector: "Volumetric attack, application-layer flood",
    likelihood: "medium",
    impact: "high",
    riskScore: 7,
  },
  {
    id: "T-005",
    category: "E",
    description: "Privilege escalation via role manipulation",
    asset: "User Profile Data",
    attackVector: "Parameter tampering, insecure direct object reference",
    likelihood: "low",
    impact: "critical",
    riskScore: 6,
  },
];
```

## Mitigation Strategies

```typescript
interface Mitigation {
  threatId: string;
  strategy: string;
  implementation: string;
  effectiveness: "low" | "medium" | "high";
  cost: "low" | "medium" | "high";
  priority: 1 | 2 | 3;
}

const mitigations: Mitigation[] = [
  {
    threatId: "T-001",
    strategy: "Multi-factor authentication",
    implementation: "TOTP via authenticator app + SMS backup",
    effectiveness: "high",
    cost: "medium",
    priority: 1,
  },
  {
    threatId: "T-001",
    strategy: "Rate limiting on login attempts",
    implementation: "Max 5 attempts per 15 minutes per IP",
    effectiveness: "medium",
    cost: "low",
    priority: 1,
  },
  {
    threatId: "T-002",
    strategy: "Parameterized queries",
    implementation: "Use ORM (Prisma) for all database access",
    effectiveness: "high",
    cost: "low",
    priority: 1,
  },
  {
    threatId: "T-003",
    strategy: "Authentication & Authorization",
    implementation: "JWT tokens + RBAC middleware on all routes",
    effectiveness: "high",
    cost: "low",
    priority: 1,
  },
  {
    threatId: "T-004",
    strategy: "Rate limiting & CDN",
    implementation: "CloudFlare with rate limits + WAF rules",
    effectiveness: "high",
    cost: "medium",
    priority: 2,
  },
  {
    threatId: "T-005",
    strategy: "Role-based access control",
    implementation: "Enforce RBAC checks on all mutations",
    effectiveness: "high",
    cost: "low",
    priority: 1,
  },
];
```

## Residual Risk Assessment

```typescript
interface ResidualRisk {
  threatId: string;
  originalRisk: number;
  mitigatedRisk: number;
  residualRisk: number;
  acceptanceReason?: string;
  monitoringRequired: boolean;
}

function calculateResidualRisk(
  threat: Threat,
  mitigations: Mitigation[]
): ResidualRisk {
  const threatMitigations = mitigations.filter((m) => m.threatId === threat.id);

  // Calculate risk reduction
  const maxEffectiveness = Math.max(
    ...threatMitigations.map((m) => {
      if (m.effectiveness === "high") return 0.8;
      if (m.effectiveness === "medium") return 0.5;
      return 0.2;
    })
  );

  const mitigatedRisk = threat.riskScore * (1 - maxEffectiveness);

  return {
    threatId: threat.id,
    originalRisk: threat.riskScore,
    mitigatedRisk,
    residualRisk: Math.round(mitigatedRisk),
    acceptanceReason:
      mitigatedRisk < 3 ? "Risk reduced to acceptable level" : undefined,
    monitoringRequired: mitigatedRisk >= 3,
  };
}
```

## Threat Model Document Template

```markdown
# Threat Model: User Authentication System

**Date:** 2024-01-15
**Owner:** Security Team
**Reviewers:** Engineering, Product

## 1. System Overview

### Architecture

- Frontend: React SPA
- Backend: Node.js + Express
- Database: PostgreSQL
- Auth: JWT tokens

### Trust Boundaries

- Internet → CDN
- CDN → Backend API
- Backend API → Database

## 2. Assets

| Asset            | Type | Sensitivity  | Criticality |
| ---------------- | ---- | ------------ | ----------- |
| User Credentials | Data | Restricted   | Critical    |
| Session Tokens   | Data | Restricted   | Critical    |
| User Profile     | Data | Confidential | Medium      |

## 3. Threats (STRIDE)

### Spoofing (S)

**T-001: Credential Theft**

- **Likelihood:** High
- **Impact:** Critical
- **Risk Score:** 9
- **Attack Vector:** Phishing, credential stuffing
- **Mitigations:**
  - MFA required for all accounts
  - Rate limiting on login (5 attempts/15min)
  - Breach password detection
- **Residual Risk:** 3 (Low)

### Tampering (T)

**T-002: Token Modification**

- **Likelihood:** Medium
- **Impact:** High
- **Risk Score:** 7
- **Attack Vector:** Token tampering, replay attacks
- **Mitigations:**
  - HMAC signature on JWT
  - Short token expiry (15 min)
  - Refresh token rotation
- **Residual Risk:** 2 (Low)

### Information Disclosure (I)

**T-003: Sensitive Data Leakage**

- **Likelihood:** Medium
- **Impact:** High
- **Risk Score:** 7
- **Attack Vector:** Error messages, logs, API responses
- **Mitigations:**
  - Generic error messages
  - PII redaction in logs
  - HTTPS everywhere
- **Residual Risk:** 2 (Low)

## 4. Risk Summary

| Priority | Threats | Mitigated | Residual Risk |
| -------- | ------- | --------- | ------------- |
| P1       | 3       | 3         | Low           |
| P2       | 2       | 1         | Medium        |
| P3       | 1       | 0         | Medium        |

## 5. Recommendations

1. **Immediate (P1)**

   - Implement MFA
   - Add rate limiting
   - Deploy PII redaction

2. **Short-term (P2)**

   - Add DDoS protection
   - Implement RBAC auditing

3. **Long-term (P3)**
   - Security training for team
   - Penetration testing

## 6. Acceptance

- [ ] Security Team Approval
- [ ] Engineering Lead Approval
- [ ] Product Manager Approval
```

## Automated Threat Detection

```typescript
// scripts/detect-threats.ts
interface CodePattern {
  pattern: RegExp;
  threat: string;
  severity: "low" | "medium" | "high" | "critical";
}

const patterns: CodePattern[] = [
  {
    pattern: /eval\(/,
    threat: "Code injection via eval()",
    severity: "critical",
  },
  {
    pattern: /innerHTML\s*=/,
    threat: "XSS via innerHTML",
    severity: "high",
  },
  {
    pattern: /process\.env\./,
    threat: "Hardcoded environment variable",
    severity: "medium",
  },
  {
    pattern: /password|secret|key/i,
    threat: "Potential secret in code",
    severity: "high",
  },
];
```

## Best Practices

1. **Regular updates**: Quarterly threat model reviews
2. **Include stakeholders**: Security, Engineering, Product
3. **Document decisions**: Why threats accepted/mitigated
4. **Test mitigations**: Verify controls work
5. **Monitor residual risks**: Track over time
6. **Automate where possible**: Integrate into CI/CD

## Output Checklist

- [ ] Assets identified and classified
- [ ] Threats enumerated using STRIDE
- [ ] Attack vectors documented
- [ ] Mitigations defined for each threat
- [ ] Residual risk calculated
- [ ] Risk acceptance documented
- [ ] Monitoring plan created
- [ ] Threat model document generated
- [ ] Stakeholder approval obtained
- [ ] Review schedule set

© patricio0312rev · MIT · patricio0312rev/skills

Similar skills

All skills for Security →

From the same set148

The whole set →
component-scaffold-generator component-scaffold-generator builds the skeleton of a React or Vue component: typed props, variants, a test file, a Storybook story and JSDoc with an example. It asks for a name and props, then writes the files. CX Codex +1 272installs git-hygiene-enforcer git-hygiene-enforcer is a Claude Code skill for setting commit and branch conventions, preparing PR templates, and documenting review steps for a consistent Git workflow. CX Codex +1 271installs pr-template-builder pr-template-builder builds GitHub pull request, issue and discussion templates in .github: markdown skeletons plus YAML forms with required fields. CX Codex +1 271installs langchain-workflow-builder langchain-workflow-builder is a Claude Code skill with TypeScript patterns for LangChain Runnable sequences, branching chains, ReAct agents, and Redis chat persistence. CX Codex +1 271installs domain-model-boundaries-mapper domain-model-boundaries-mapper maps domain areas, module ownership, dependencies, and interfaces in a codebase. Useful when untangling a monolith or planning a domain-driven redesign. CX Codex +1 270installs react-hook-builder react-hook-builder generates production-grade custom React hooks in TypeScript for data fetching, forms, and local storage. CX Codex +1 269installs mcp-server-builder mcp-server-builder is a Claude Code skill for building MCP servers with tools, resources, and prompts. It activates on requests for an MCP integration or custom Claude tools. CX Codex +1 269installs error-handling-standardizer error-handling-standardizer is a skill that standardizes application errors across custom classes, HTTP responses, and structured logs for consistent API exception handling. CX Codex +1 269installs

Project sponsors

Companies that keep this analytics open