Threat Model: Security Design Review

    1

    This skill formalizes security architecture by applying Anderson's engineering principles to your design.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Threat Model: Security Design Review

    Example session with this skill installed

    Review the security design of the payouts service. The design docs, ADRs, API spec and our existing threat model are in this repo. How good is it, and what's wrong with it?

    • Read your context and instructions
    • Compiled the threat model

    A real, unedited Review-mode run of this skill on a seeded test repository: a fictional system built for the skill's eval, not a customer's.

    Payouts: security design review

    Mode: Review,

    System review tier (R1–R4).

    Calibration: high-assurance. The service moves money, and a payout cannot be recalled once it is sent (docs/architecture.md §Payout flow step 4).
    Evidence read: docs/architecture.md (rev 14, 2026-09-30), docs/threat-model.md (v1.0, 2025-05-14), ADR-0003 (2025-03-11), ADR-0005 (2025-04-20), ADR-0007 (2026-06-02), docs/admin-console.md, docs/security-controls.md, docs/runbook.md, api/openapi.yaml (v2.3.0). There is no code in the repo, so I could not check the implementation against the design. Anything that only the code or runtime can settle is marked 🔬.
    Rubric: threatmodel v1.0. This review changes nothing in the design. Treatment belongs to Design and Propose.


    Verdict

    Score: 1.2 / 10, band "Critical / unsafe". Gate: FAIL on all six conditions.

    The existing threat model is not usable. It is 17 months old and covers 2 of the 8 components. It declares the internal network "trusted" and out of scope, names no adversaries, and was written before the partner API (2026-02) and approval delegation (2026-06) existed. Those two additions are where most of the current risk sits.

    The design itself has a few strong mechanisms: the payment-file signing key is kept in KMS, the audit log is out of the engineers' reach, and the ledger is double-entry. But the controls that protect the money all depend on one mechanism each, and several of them have a weaker side path:

    Fraud scoring fails open (it skips the check when the scorer is down), and payouts under 5,000 USD are approved automatically. For most payouts, a slow scorer means no control at all.

    • The partner API can replace any merchant's payee and request payouts for any merchant_id. No document says where the system checks that the partner actually owns that merchant.
    • One ops manager can change a payee and approve the payout alone. They sign in with a password plus an SMS code, approve with one click, and can hand the approver role to anyone without sign-off from anyone else.
    • Every path for changing a payee is weaker than the merchant path. Changes in merchant-web need e-mail confirmation. Changes from the admin console after a phone call do not, and neither do changes from the partner API.

    3 Critical, 9 High, 4 Medium, 2 Low. 7 needs-data (🔬) flags.


    R1: Inventory

    System definition (people included)

    Actor / componentRoleSource
    MerchantRequests payouts, adds payees (with e-mail confirmation)architecture §Payees
    Partner (payment facilitator)Signs up merchants in bulk; requests payouts and replaces payees for a merchant_idREADME; openapi /partner/v1/*
    ops_agentRaises payouts for a merchantadmin-console §Roles
    Ops manager (payout_approver + payee_admin)Approves payouts of 5,000 USD or more; changes payees during support callsADR-0003
    Delegate (any user)Holds payout_approver for up to 30 days through self-service delegationADR-0007
    supportResets a merchant's password or MFA after asking knowledge-based questionsadmin-console §Support tools
    Risk teamPaged during business hours only when fraud-score is downrunbook
    BankReceives payment files; sends settlement webhooksADR-0005
    merchant-web, partner-api, admin-consoleInternet-facing edge (admin-console is internal but reachable through the load balancer)architecture §Trust
    payouts-svc, ledger-svc, fraud-score, bank-gateway, payouts-dbInternal; "trusted", with no service-to-service authenticationarchitecture §Trust

    Asset register

    #AssetClassOwner (stated?)Why an adversary wants it
    A1Merchant funds and balances (ledger)Moneynone stated (payments-platform owns the doc)Direct theft
    A2Payee bank detailsConfidential, integrity-criticalnoneRedirecting a payee is the cheapest way to steal a payout
    A3Payout approval decisionIntegritynoneGetting past the 5,000 USD gate
    A4Merchant accounts and MFAIdentitynoneAccount takeover leads to a payee change
    A5Staff identities (approvers, payee admins, support)IdentitynoneOne credential is enough to move money
    A6Partner API keysCredentialnoneAccess to any merchant (see BND-01)
    A7Bank payment-file signing key (KMS)KeynoneForged payment instructions
    A8Webhook HMAC shared secretKeynoneForged settlement status
    A9Payout state and audit logIntegrity / evidencesecurity accountHiding fraud; winning disputes
    A10Payout availabilityAvailabilitynoneExtortion; forcing the fail-open path
    A11Metadata (who is paid, how much, when)ConfidentialnoneAnswers to support's knowledge-based questions (see RES-02)

    The existing threat model lists only A1 and A2, with no owners.

    DFD (reconstructed from architecture.md with trust boundaries added; the source diagram draws none)

    flowchart LR
      subgraph TB0[Internet - untrusted]
        M[E1 Merchant]; P[E2 Partner]; O[E3 Ops staff]; C[E4 Caller to support]
      end
      subgraph TB1[Edge - load balancer]
        MW[P1 merchant-web]; PA[P2 partner-api]; AC[P3 admin-console]
      end
      subgraph TB2["Internal VPC - 'trusted', no service auth"]
        PS[P4 payouts-svc]; FS[P5 fraud-score]; LS[P6 ledger-svc]; BG[P7 bank-gateway]; DB[(D1 payouts-db)]
      end
      subgraph TB3[Bank]
        BANK[E5 Bank]
      end
      SEC[(D2 audit log - security account)]
      M -->|F1 session| MW
      P -->|F2 static API key| PA
      O -->|F3 password + SMS| AC
      C -.->|F4 phone, knowledge-based questions| AC
      MW -->|F5 none| PS
      PA -->|F6 none| PS
      AC -->|F7 none| PS
      PS -->|F8 none| FS
      PS -->|F9 none| LS
      PS -->|F10 ?| DB
      PS -->|F11 none| BG
      BG -->|F12 mTLS + KMS signature| BANK
      BANK -->|F13 HMAC, no freshness| BG
      BG -->|F14 none| PS
      PS --> SEC
    

    Boundary-crossing table

    FlowAuthenticationAuthorisation decision (where)ChannelValidationGap
    F1 Merchant → merchant-webSession cookienot stated (does the merchant own payee_id?)TLS, HSTSAmount recomputed server-side⚠️
    F2 Partner → partner-apiStatic API key (X-Api-Key)none stated (partner ↔ merchant_id)TLSnone statedBND-01
    F3 Ops → admin-consolePassword + SMS OTP, 12-hour sessionRBAC (4 roles)TLS—PRO-01, POL-01
    F4 Caller → supportThree knowledge-based questionssupport rolePhone—RES-02
    F5–F7 Edge → payouts-svcnonenot stated (is the approval state checked inside payouts-svc?)TLS—BND-02
    F8–F11, F14 InternalnonenoneTLS—BND-02
    F10 payouts-svc → DBnot stated—not stated—⚠️
    F12 bank-gateway → BankmTLS; file signed by a KMS keyBank-sidemTLS—🟢
    F13 Bank → bank-gatewayHMAC-SHA256 with a static shared secret—TLSNo timestamp or nonce; "latest status wins"PRO-03

    Crossings: 14, across 4 boundaries.

    Adversaries as documented

    None. threat-model.md has no adversary section. The table below is the reviewer's working model, used to grade severity:

    AdversaryGradeWhat they can obtain legitimatelyAttacks that scale
    AD1 Malicious or compromised partnerOrganised; they sign merchants up in bulkAn API key, merchant IDs, payout history for their merchantsReplace payees across their whole portfolio; split payouts to stay under 5,000 USD
    AD2 Fraudster taking over a merchant accountCommodity criminalPublic business address; leaked payout dataCalls to support; phishing
    AD3 Insider: ops manager, delegate or support agentSingle privileged insiderTheir roles; delegationChange a payee, then approve
    AD4 SIM-swapper targeting staffCommodity or organisedPhone-carrier social engineeringSMS OTP takeover of an approver
    AD5 Foothold in the VPC (e.g. a compromised edge app)SkilledNetwork reach to every internal serviceDirect calls to bank-gateway or payouts-svc
    AD6 Whoever triggers the fraud-score timeout (load, a fault, or AD1 flooding requests)Any—Payouts proceed with no score

    Serious hazards

    • H1: Money sent to an account the attacker controls. This is irreversible.
    • H2: Approval controls bypassed (threshold, approver independence).
    • H3: Payout or ledger state corrupted (double payout, a false "settled" or "failed").
    • H4: Staff or merchant identity takeover leading to H1.
    • H5: Loss of payout availability.

    Object counts (the score weights)

    scope 11 assets · adversaries 6 classes · boundaries 14 crossings · policy 10 protected operations (request payout ×3 paths, approve, change payee ×3 paths, delegate, reset MFA/password, resend) · protocols 8 exchanges · resilience 5 hazards.

    Total 54.


    R2: The existing threat model

    docs/threat-model.md v1.0 (2025-05-14) is stale (S24):

    • It predates the partner API (2026-02), ADR-0007 (2026-06) and architecture rev 14 (2026-09-30).
    • Its scope is merchant-web and payouts-svc only. admin-console, partner-api, bank-gateway, the webhook, fraud-score and every person except the merchant are out of scope.
    • It puts "internal services (trusted network)" explicitly out of scope, so the boundary that matters most was never modelled.
    • It applies STRIDE per component, not per boundary crossing. It names no adversaries, has no risk owners, no requirements and no re-run triggers.
    • Its 4 threats are all real but low value. The 4 mitigations are sound for what they cover (an HttpOnly/Secure cookie, recomputing the amount server-side).

    I treated it as evidence that an attempt was made, not as a model of the current system.


    R3: Findings (worst first)

    Confidence: ✅ decidable from the documents · ⚠️ proxy (silence or judgement) · 🔬 needs data. Severity is graded against A1/A2 (money and payee integrity) unless a finding says otherwise.

    Critical

    IDObjectAnti-patternConf.TheoryEvidence
    TM-BND-01F2 / F6: partner → PUT /partner/v1/merchants/{merchant_id}/payees and POST /partner/v1/payouts {merchant_id}Crossing with no authorisation decision; confused deputy✅ for the design (no ownership check is stated anywhere); 🔬 whether the code has oneS11, S12, S26api/openapi.yaml:18-38; architecture.md §Payout flow step 1; no partner↔merchant relation in any document

    Abuse path: A partner (AD1), or anyone holding a leaked partner key, calls PUT …/{merchant_id}/payees with an account they control. The partner path has no e-mail confirmation, unlike merchant-web (§Payees). They then call POST /partner/v1/payouts for amounts under 5,000 USD, which are approved automatically. The money is irreversibly sent. If ownership isn't checked, this works for

    any merchant on the platform, not only the partner's own. Even if it is checked, a partner can still drain its whole portfolio. A static key plus caller-supplied object IDs is the scaling attack (S6).

    IDObjectAnti-patternConf.TheoryEvidence
    TM-RES-01H1 / H2: fraud-score dependencyFail-open on a security dependency; single mechanism for a serious hazard✅S22architecture.md:49-53 ("the payout proceeds without a score"); runbook.md:3-5 ("no action needed out of hours")

    The fraud score is the

    only control on payouts under 5,000 USD: they are approved automatically, and a sent payout cannot be recalled. When fraud-score times out (800 ms) or is down, that control is gone. The only trace is a WARN log, and outside business hours no one is paged by design. Anyone who can make the scorer slow, including AD1 flooding the partner API (🔬 whether that load reaches fraud-score), switches off the fraud check for their own payouts. The degraded mode is weaker than the primary, and it happens at exactly the moment an attacker would choose. One failure leads to an irreversible loss, which is the Critical anchor.

    IDObjectAnti-patternConf.TheoryEvidence
    TM-POL-01Change payee + approve payout ≥ 5,000 USDSingle principal for the gravest actions; checker can change what they check✅S14, S25ADR-0003 §Decision: managers hold both payout_approver and payee_admin, may approve their own agent's payout, and "one person can handle a merchant's problem end to end"; architecture.md:59-61

    Abuse path: A single ops manager (AD3), or whoever controls that manager's password and SMS code (AD4), changes the merchant's payee during a "support call", has an agent raise the payout (or raises it with their own ops_agent rights, if they hold that role; 🔬), and approves it with one click. It is sent within 5 minutes. No second person is involved anywhere in the chain. The ADR lists this as a benefit ("one person end to end"). That is the clearest sign the separation-of-duty question was never asked.

    High

    IDObjectAnti-patternConf.TheoryEvidence
    TM-POL-02Delegation of payout_approverSelf-grantable role; circumventable rule✅S25, S14ADR-0007: delegate to "any other user", self-service, "no approval from security or HR". Recorded in the delegations table; no alert stated
    TM-POL-035,000 USD approval thresholdRule defeated by another feature: splitting a payout into several under-threshold ones⚠️ (no aggregate or velocity limit is mentioned anywhere)S25, S6architecture.md:52-53; ADR-0003
    TM-RES-02Merchant account recovery (F4)Weaker fallback: support verifies callers with knowledge-based questions✅S22, S16, S7admin-console.md:15-18. The questions use the address (public), the last payout amount (known to the partner and to anyone with merchant data) and the account-opening date. The merchant is e-mailed after the reset. The support role can reset password or MFA; whether one call can reset both, bypassing every factor, is 🔬. If it can, this is Critical
    TM-RES-03Payee change (A2)Weaker fallback / inconsistent paths: merchant-web requires e-mail confirmation; admin-console and partner-api require none. No cooling-off period between a payee change and a payout✅S22, S11architecture.md:57-61; openapi.yaml:32-38
    TM-BND-02F5–F11, F14 internal"Internal means trusted"✅S9, S10, S11architecture.md:39-41 "traffic between services behind the VPC needs no authentication"; threat-model.md:17-18. A foothold in any edge app (AD5) can call bank-gateway or payouts-svc directly. Whether this skips the approval state machine is 🔬
    TM-PRO-01F3 staff authentication for approvers and payee adminsSMS as the second factor for high-value actions✅S17, S5admin-console.md:4-5; 12-hour sessions
    TM-PRO-02Approval of payouts ≥ 5,000 USDSession approves "a transaction": a single click inside the session, not bound to the amount and payee on an independent channel✅S18ADR-0003 "single click"; payee changes are possible in the same session
    TM-PRO-03F13 / F14 settlement webhookReplayable requests: no timestamp or nonce; "applies the latest status it receives"; static shared secret with no rotation✅S17, S20, S19ADR-0005 §Decision; runbook.md:15-16. Anyone who can capture or resend a signed body (bank-side logs, a VPC foothold sending straight to payouts-svc via F14) can roll a payout's status backwards. Whether a "failed" status re-credits the ledger and so enables a double payout is 🔬
    TM-ADV-01Whole modelNo adversary model; insiders and partners omitted✅S5, S7threat-model.md: no adversary section; the partner and every staff role are absent

    Medium

    IDObjectAnti-patternConf.TheoryEvidence
    TM-SCO-01threat-model.mdModel older than the last boundary change; scope covers 2 of 8 components✅S24, S27v1.0 2025-05-14 vs partner-api 2026-02, ADR-0007 2026-06, arch rev 14 2026-09-30
    TM-SCO-02Asset register / system definitionOwnerless register; software-only system definition (staff, partners, support and recovery are missing from the model)✅S2threat-model.md:5-7
    TM-PRO-04Partner API keys (A6)No key lifecycle: static bearer keys with no stated scope, rotation, revocation or per-partner binding. A shared staging key is in use⚠️ (lifecycle is silent); ✅ (the shared key exists)S19, S20openapi.yaml:47. A credential of the kind "staging partner API key" is written in plaintext in docs/runbook.md:13. The value is not reproduced here; rotate it and move it to the secrets manager, don't just delete the line
    TM-RES-04Fraud-score outage responseMonitoring as a mitigation with no response✅S23runbook.md:3-5 (WARN log; business hours only)

    Low

    IDObjectAnti-patternConf.TheoryEvidence
    TM-BND-03POST /webhooks/settlementThe spec declares security: [], so the HMAC requirement in ADR-0005 isn't in the contract; generated clients and tests won't enforce it✅S27openapi.yaml:39-43
    TM-SCO-03Model notationNo element or threat IDs, no requirements traceability, no re-run triggers✅S24threat-model.md

    Needs-data flags (not scored)

    1. Whether partner-api or payouts-svc checks partner ↔ merchant_id ownership in code (BND-01).
    2. Whether a single support call can reset both password and MFA (RES-02, which would make it Critical).
    3. Whether a webhook "failed" or "returned" status after "settled" re-credits the ledger (PRO-03).
    4. Whether payouts-svc re-checks the approval state before handing off to bank-gateway, or whether bank-gateway will send any file it is asked to (BND-02).
    5. Whether attacker-generated load can push fraud-score past 800 ms (RES-01).
    6. Whether security groups restrict lateral reach inside the VPC, and whether payouts-db credentials are per-service (F10).
    7. Whether PITR backups are reachable with production credentials, and whether restores are rehearsed.

    What is working well (keep it)

    • 🟢

    The payment-file signing key is in KMS: it can't be exported and signing calls are logged (security-controls.md:5-6). Together with mTLS to the bank, this makes the outbound F12 crossing the strongest in the system.

    • 🟢 The audit log is append-only and shipped to a separate security account that payments-platform engineers cannot modify (security-controls.md:7-8). Evidence survives a hostile insider (S23).
    • 🟢 The ledger is double-entry, so there is a balancing invariant on money (S13 / Clark-Wilson).
    • 🟢

    The amount is recomputed server-side, and

    merchant payee changes need e-mail confirmation. The merchant path is the one well-designed path; the others should be held to it.

    • 🟢 TLS 1.2+ everywhere, including inside the VPC; HSTS on merchant-web.
    • 🟢 ADR-0003 states the intent ("a human looks at large payouts"), so the policy exists. What it lacks is an independent mechanism.

    R4: Scores

    Criteria are graded on p (the share of in-scope objects that satisfy them): 🟢 = 2 points, 🟡 = 1, 🔴 = 0. Base = Σ / (2 × criteria) × 10. Caps: Critical → 2.0, High → 6.0. A ⚠️ finding alone never grades a criterion 🔴.

    scope (11 assets; 8 criteria): owner + class 🔴 · reason an adversary wants it 🔴 · subject–action–object goals 🔴 · people and recovery flows in the definition 🟡 (in admin-console.md, absent from the model) · hazards eliminated by design 🔴 · TCB named 🔴 · four axes per control 🔴 · model validated against code/IaC 🔴 → 1/16 →

    base 0.6. Highest severity is Medium, so no cap.

    0.6

    adversaries (6 classes; 7 criteria): classes and grades 🔴 · legitimate access 🔴 · scaling attacks 🔴 · insiders 🔴 · abuse cases 🔴 · no reliance on user vigilance alone 🟡 ⚠️ (after-the-fact e-mail) · re-assessment trigger 🔴 → 1/14 →

    base 0.7, High cap 6.0 →

    0.7

    boundaries (14 crossings; 10 criteria): boundaries drawn 🔴 · authentication named 🔴 (5/14 non-"none") · authorisation decision 🔴 (1/14, F3 only) · channel + validation 🟡 · internal calls authenticated 🔴 · same authorisation on every path 🔴 (three payee paths) · cascade analysis 🔴 · no write-up from low integrity 🔴 (partner writes payees) · least privilege / deputies re-check 🔴 · one trust domain per component 🔴 (payouts-svc serves merchant, partner and staff with no boundary inside it) → 1/20 →

    base 0.5, Critical cap →

    0.5

    policy (10 operations; 8 criteria): stated model including tenancy 🔴 · certified procedures + invariant + trail 🟡 (double-entry and audit log; but "latest status wins" and a manual resend) · independent principals for irreversible actions 🔴 · break-glass logged and alerted 🟡 ⚠️ · roles scoped to context 🔴 (payee_admin covers any merchant) · safe defaults, exceptions time-bound 🔴 (fail-open; self-service delegation) · personal data purpose and retention 🟡 ⚠️ · no circumventable rule or self-grantable role 🔴 → 3/16 →

    base 1.9, Critical cap 2.0 →

    1.9

    protocols (8 exchanges; 8 criteria): fresh or signed-timestamped exchanges 🔴 · replay prevented 🔴 · approvals bound to the transaction 🔴 · key lifecycle 🔴 · credentials short-lived and revocable 🟡 ⚠️ · standard crypto, mode named 🟡 (HMAC-SHA256 named; constant-time comparison unstated) · CSPRNG 🟡 ⚠️ · TLS 1.2+, certificate automation 🟡 → 4/16 →

    base 2.5, High cap 6.0 →

    2.5

    resilience (5 hazards; 9 criteria): two mechanisms per hazard 🔴 (0/5) · fail-open/fail-closed stated 🔴 · fallback no weaker than primary 🔴 · backups isolated and rehearsed 🟡 ⚠️ · detections with an owner and response time 🔴 · audit evidence out of admins' reach 🟢 · disclosure and incident plan 🟡 ⚠️ · re-run triggers, model fresh 🔴 · risk owners 🔴 → 4/18 →

    base 2.2, Critical cap 2.0 →

    2.0

    scopeadversariesboundariespolicyprotocolsresilienceSystem
    0.60.70.51.92.52.01.2

    System = (11×0.6 + 6×0.7 + 14×0.5 + 10×1.9 + 8×2.5 + 5×2.0) / 54 = (6.6 + 4.2 + 7.0 + 19.0 + 20.0 + 10.0) / 54 = 66.8 / 54 =

    1.2. Uncapped mean 1.2; the Critical cap of 2.0 doesn't bind.

    Final: 1.2 / 10, band "Critical / unsafe".

    Severity tally: 3 Critical · 9 High · 4 Medium · 2 Low. 🔬: 7 of 54 objects = 13%.

    Hazard × mechanism matrix (as designed)

    HazardMechanism 1Mechanism 2Independent?
    H1 Money to an attacker's accountFraud score (fails open)Approval, only ≥ 5,000 USD (single principal)❌ Under 5,000 USD: one mechanism that switches off; over 5,000 USD: one person
    H2 Approval bypassRole check in admin-console— (self-service delegation, splitting)❌
    H3 State corruptionHMAC on the webhookDouble-entry ledger (doesn't prevent a status rollback)❌ (no freshness; "latest wins")
    H4 Identity takeoverPassword + SMS / session + MFAKnowledge-based recovery bypasses MFA❌ The fallback is weaker
    H5 AvailabilityFail-open fraud-scorePITR backupsAvailability is bought by giving up H1

    Gate (each condition)

    ConditionResultWhy
    Capped score ≥ 9.0❌1.2
    No open Critical or High❌3 Critical, 9 High
    Two independent mechanisms per serious hazard❌0 of 5
    Every crossing names authentication and an authorisation decision❌9 of 14 have no authentication; 13 of 14 have no stated authorisation decision
    Every risk has an owner and a treatment❌No risk register exists
    🔬 ≤ 10% of objects❌13% (7 of 54)

    Systemic issues

    1. Every money control rests on a single mechanism, and each has a weaker side door (S22, S25). Fraud scoring fails open. The threshold can be beaten by splitting payouts. Approval can be delegated to anyone. Payee changes have three paths, and only one has confirmation. Recovery uses knowledge-based questions. Each ADR made one control cheaper ("fast", "no queue", "merchants not blocked"), and no ADR asked which other feature reaches the same outcome.
    2. Convenience was chosen over separation of duty, and the ADRs record that as intended (S14). "One person can handle a merchant's problem end to end" (ADR-0003) and "self-service to keep it quick" (ADR-0007) are the opposite of the policy a payout system needs.

    The partner channel was added without a boundary or a model (S10, S26, S24). The partner API arrived in 2026-02, after the last threat model. It got a static key and caller-supplied merchant_ids, and it routes into the same "trusted" payouts-svc as the merchant and staff paths.
    4. The flat, trusted VPC means any edge compromise inherits the core's authority (S9, S11).
    5.

    The assurance loop is missing (S1, S24). No incentive owner for the fraud loss is stated, and the risk team is not paged out of hours. There are no re-run triggers, so the model froze while the architecture moved 14 revisions on.


    Handoff

    Reviewed payouts at architecture rev 14 / openapi 2.3.0 / threat-model v1.0: score

    1.2 (Critical / unsafe), gate

    fail on all six conditions.

    3 Critical (partner API with no authorisation on merchant_id; fraud-score fail-open on irreversible auto-approved payouts; a single manager who can both change a payee and approve),

    9 High.

    Next: Design to rewrite threat-model.md at high-assurance tier, covering all 8 components, the people, the partner trust domain, a threat tree for H1 and FMEA. Then

    Propose. Exploitability sets the order, so the fail-open on money (RES-01), partner payee replacement (BND-01) and manager self-approval (POL-01) need interim containment in the first window.

    Code-level checks go to

    appsec: the partner↔merchant ownership check, payouts-svc re-checking the approval state, webhook signature comparison and status ordering, and the support reset handler.

    hardening gets the crown jewels: the KMS signing key, the webhook secret, partner keys (rotate the staging key found in runbook.md:13), VPC segmentation and backup isolation.

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

    About this skill

    Stop guessing what could go wrong and start engineering dependable systems. This skill formalizes security architecture by applying Anderson's engineering principles to your design. It moves beyond basic checklists to evaluate the four pillars of dependability: policy, mechanism, assurance, and incentive.

    What it does

    • Architectural reviews audits existing designs, ADRs, or codebases against a scored security rubric.
    • Threat modeling generates comprehensive threat-model.md files including DFDs, STRIDE analysis, and threat trees.
    • Risk treatment produces sequenced plans in proposal.md to eliminate, mitigate, or transfer identified risks.
    • Trust boundary mapping reconstructs data flow diagrams and identifies every point where authentication and authorization must occur.
    • Traceability auditing ensures every security requirement traces directly to a specific threat and includes a corresponding test.

    How it works

    1. Calibrate the tier by declaring the system's impact level: Lightweight, Standard, or High-assurance.
    2. Execute a mode by selecting Review to audit, Design to create a new model, or Propose to sequence treatments.
    3. Reconstruct the model by inventorying assets, actors, and trust boundaries from documentation or source code.
    4. Evaluate findings against 27 specific security-engineering principles, assigning severity and confidence scores.

    Frameworks & tools

    This tool works with standard architecture artifacts including ADRs, OpenAPI/AsyncAPI specs, IaC (Terraform), and Mermaid diagrams. It supports output from existing tools like Pytm, Threagile, and Microsoft TMT.

    Why this beats prompting it yourself

    Generic prompts often miss the human element, such as support desk social engineering or recovery flow weaknesses. This skill enforces a strict scoring rubric and requires evidence-backed findings citing established security-engineering theory, preventing vague "make it secure" hallucinations.

    Use cases

    • Pre-build security design to catch architectural flaws before writing a single line of code.
    • Regulatory compliance audit for systems handling identity, keys, or financial transactions.
    • Architecture change review to assess how a new feature alters existing trust boundaries.

    Known limitations

    This skill analyzes design artifacts and code; it does not perform active penetration testing or live system probing. Findings are limited to the evidence provided in the repository or documentation.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Security.

    Does not perform live network scanning or dynamic application security testing. Restricted to static analysis of documentation, design files, and source code.

    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 buying a skill.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

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

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    Software
    Git

    Permissions

    Read Files
    Write Files
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    This skill transforms raw documentation, ADRs, or code into structured security artifacts like STRIDE analyses and DFDs, identifying architectural flaws that automated scanners often miss.

    The skill is compatible with any AI agent that supports file uploads or repository access, including ChatGPT, Claude, and GitHub Copilot, as long as it can process Markdown and code files.

    You receive the specialized 'threatmodel' configuration, a custom security-engineering rubric for scoring, and templates for generating industry-standard reports like `threat-model.md` and `proposal.md`.

    Setup is near-instant: simply import the skill into your agent and define your 'tier' (Lightweight, Standard, or High-assurance) to begin your first architectural review.

    No, this is a design-time tool; it analyzes architecture and code artifacts to find logic flaws and trust boundary issues without needing access to your production environment.

    New in Security