Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    STRIDE Analyzer

    1

    From code to a prioritized security remediation plan: STRIDE threat modeling for repos, monorepos and multi-repos, with file:line evidence.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    2 usesSecurity scanned
    STRIDE Analyzer

    STRIDE Analyzer

    Example session with this skill installed

    Run a STRIDE analysis on the current repository and generate a prioritized remediation plan in the docs folder.

    • Read your context and instructions
    • Compiled the stride analyzer
    • Generated the data export

    I have completed the STRIDE analysis for the repository. I identified the stack (Node.js, PostgreSQL, Redis) and mapped 4 distinct data flows crossing trust boundaries.

    Security Analysis Summary

    The analysis identified 8 open threats, including 2 high-priority (P0/P1) issues related to unencrypted internal flows and missing input validation on the public API gateway.

    Threat Inventory (threats.json)

    IDTitlePrioritySTRIDELocation
    T-001Plaintext Credential ExposureP0Information Disclosuresrc/auth/service.ts:42
    T-002SQL Injection via SearchP1Tamperingsrc/db/query.ts:115
    T-003Missing Rate LimitingP2Denial of Servicesrc/api/gateway.ts:12
    T-004Insecure Cross-Service AuthP1Spoofingconfig/env.yaml:08

    System Model (system-model.mmd)

    graph LR
        subgraph External
            User((User))
        end
        subgraph Production_VPC
            Gateway[API Gateway]
            Auth[Auth Service]
            DB[(PostgreSQL)]
        end
        User -- HTTPS --> Gateway
        Gateway -- HTTP --> Auth
        Auth -- TCP --> DB
    

    Remediation Plan Highlights

    Phase 1 (Immediate): Implement parameterized queries in src/db/query.ts and encrypt internal service-to-service communication.

    Phase 2 (Short-term): Deploy rate limiting on the API Gateway and rotate the leaked credentials in the auth service.

    Next steps

    1. Review the full report at docs/threat-model/2023-10-27/threat-model.md.
    2. Import threats.csv into your Jira or GitHub Issues backlog.
    3. Run the remediation tasks listed in remediation-plan.md.

    threats.csv

    CSV · data export

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Turn any codebase into a professional, evidence-based threat model — and a remediation plan your team can actually execute.

    What it does

    • Detects the system and stack with a local, read-only inventory script: languages, frameworks, datastores, messaging, Terraform, Kubernetes, Docker, CI/CD, API specs, endpoints, risky patterns, redacted secrets and cross-repo links.
    • Models the architecture: assets, actors, data-flow diagram (Mermaid), trust boundaries and entry points.
    • Finds threats with evidence: STRIDE-per-element plus stack-specific catalogs for Node, Python, Java/Spring, Go, .NET, Rails, PHP, frontend frameworks, REST/GraphQL/gRPC, databases, Kafka/RabbitMQ/SQS, Docker, Kubernetes, AWS/GCP/Azure, GitHub Actions/GitLab/Jenkins, mobile and LLM apps. Every threat cites file:line or is explicitly marked as a hypothesis — no generic filler.
    • Prioritizes: likelihood × impact → P0–P3, plus effort (S/M/L) so quick wins come first.
    • Plans remediation in phases with acceptance criteria and a verification step (test, SAST rule or CI check) for every task.

    Outputs threats.json (validated source of truth), threat-model.md, remediation-plan.md, threats.csv (import into Jira, Linear or GitHub Issues) and system-model.mmd.

    Built for real teams

    • Per-project .threatmodel.yml for deployment context, assets, trust assumptions, accepted risks and false positives — decisions are versioned and persist across runs thanks to stable threat fingerprints.
    • Documented, versioned JSON contract so other tools and skills can enrich the model without breaking it.
    • Built-in validator: checks references, risk math, priorities, that every piece of evidence points to a real file and line, and that no secret leaks into the report.

    Safe by design Static analysis only. The scripts use the Python standard library, make no network requests, install nothing and never print secret values.

    Who it's for AppSec and security engineers, tech leads and architects, DevSecOps teams, and startups preparing for ISO 27001, SOC 2 or customer security reviews.

    Example prompts

    • "Threat model this repository"
    • "Run a STRIDE analysis of these three services and give me a remediation plan"
    • "Review the security design of this monorepo"

    Reports are written in the user's language (or the one set in .threatmodel.yml). Requires Python 3.8+.

    Static analysis only. No active exploitation or runtime testing. Large monorepos (>5 repos) require service-by-service processing. Requires Python 3 for utility scripts.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    2 uses

    Times used to date

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Network Access

    The scripts contain regular expressions that DETECT secrets and dangerous code patterns (e.g. private-key headers, AWS key prefixes, eval(, child_process, os.system). They are static detection rules used by the inventory and validator, not secrets or executable payloads. The scripts only read the folders passed as arguments, write only the output files named by the user, use the Python standard library, and make no network calls.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The analyzer supports any language but performs best with major frameworks like Python, JavaScript/TypeScript, and Go. It uses a YAML-based configuration to define custom assets and trust boundaries, allowing it to adapt to unique architecture patterns.

    Unlike generic LLM prompts, this skill enforces a strict JSON schema for findings and assigns persistent IDs to every threat. This ensures that the evidence is tied to specific code paths and that you won't get duplicate alerts for the same issue across different analysis runs.

    The Stride Analyzer focuses on static code analysis and architecture mapping. It does not perform dynamic penetration testing, network fuzzing, or active exploitation of your live environment.

    You will receive the core analysis suite, the YAML configuration templates for your repository, and the schema-based reporting engine. It also includes the integration tools needed to export findings into Mermaid diagrams for documentation and CSVs for your project management tools.

    For massive monorepos, we recommend a service-by-service analysis rather than scanning the entire codebase at once. This ensures the AI maintains a high level of precision and stays within token context limits for complex data-flow mapping.

    Yes, by generating evidence-based threat models and structured remediation plans, this skill provides the documented proof of security design required for SOC2, ISO 27001, and other common compliance frameworks.

    New in Security