The rules

wyrm analyze evaluates a small, data-driven STRIDE catalogue over the model graph. Each rule is a set of predicates AND-ed together; when they all hold for an element, it fires a finding. The catalogue is plain YAML — adapted from OWASP pytm — so you can grow it without recompiling.

Catalogue

WYRM-T001 critical Information Disclosure

Sensitive data crosses a trust boundary in cleartext. A dataflow carrying confidential data leaves one trust zone for another without transport encryption, exposing it to interception on the wire.

Fires on a dataflow when: crossesTrustBoundary · notEncrypted · carriesSensitiveData (confidentiality ≥ 70).

↳ Enforce TLS (or mTLS between services) on this flow; tag it tls/https once encrypted.

WYRM-T002 high Tampering

Unencrypted flow across a trust boundary. Traffic leaving a trust zone without encryption can be read or modified in transit, enabling tampering even when the payload is not itself sensitive.

Fires on a dataflow when: crossesTrustBoundary · notEncrypted.

↳ Terminate the flow over TLS and verify server (and ideally client) identity.

WYRM-T003 high Information Disclosure

Internet-facing component handling sensitive data. A component in a low-trust (internet-exposed) zone processes or stores confidential data, making it a high-value target for direct compromise.

Fires on a component when: lowTrustZone (trustRating ≤ 30) · carriesSensitiveData (confidentiality ≥ 70).

↳ Move sensitive processing to a higher-trust zone, or add strong authN/Z and input validation at the edge.

WYRM-T004 high Elevation of Privilege

Datastore without an authentication boundary. A datastore sits in a low-trust zone. Datastores reached without a hardened auth boundary invite privilege escalation and bulk data theft.

Fires on a component when: componentKindIn (database / datastore / data-store) · lowTrustZone (trustRating ≤ 40).

↳ Place the datastore in a private zone; require authenticated, least-privilege access only.

WYRM-T005 medium Spoofing

External entity flow lacks authentication. A cross-boundary flow moves data of note but the model records no proof of peer identity, so either endpoint could be impersonated (spoofed).

Fires on a dataflow when: crossesTrustBoundary · carriesSensitiveData (confidentiality ≥ 40).

↳ Authenticate both ends of the flow (tokens, mutual TLS) and record the control as a mitigation.

WYRM-T006 high Elevation of Privilege

Standing human access to sensitive data. A human identity holds standing (manually provisioned) access to confidential data — a persistent attack surface where a lost credential or a former team member is enough.

Fires on an identity component when: hasTag provisioning=manual · carriesSensitiveData (confidentiality ≥ 70).

↳ Move to just-in-time / approval-based access (provisioning=jit) and scope to least privilege.

WYRM-T007 high Elevation of Privilege

Broadly-exposed high-privilege identity. A high-privilege service account / workload identity can reach a large pool of resources (5+). One compromise yields broad lateral movement — it concentrates blast radius.

Fires on an identity component when: hasTag privilege=high · accessFanOut ≥ 5 (outgoing dataflows).

↳ Split into scoped identities per workload, grant least privilege, add workload-identity conditions + monitoring.

T006/T007 read facets you annotate on an identity component (provisioning, privilege, and its access edges via flows) — see annotations. IAM is ~99% human-supplied context; wyrm init --exclude iam keeps it out of the auto-generated baseline.

WYRM-T008 high Elevation of Privilege

Internet-facing compute reachable without authorization. An exposed service handling sensitive data records no authorization control — whoever reaches it is trusted.

Fires on a component when: componentKindIn (web-service/process/api) · lowTrustZone ≤ 30 · carriesSensitiveData ≥ 40 · lacksControl authz.

↳ Put authN/Z in front (IAP, oauth2-proxy, an API gateway) and record the control.

WYRM-T021 medium Repudiation

Sensitive cross-boundary flow without audit logging. A flow moving data of note across a boundary records no logging control, so actions across it can't be attributed or investigated afterward.

Fires on a dataflow when: crossesTrustBoundary · carriesSensitiveData ≥ 40 · lacksControl logging.

↳ Enable access/audit logging on both ends (LB logs, VPC flow logs, app audit trail).

Control-absence noise floor: a lacksControl{X} finding scores its full severity only when the model annotates control X somewhere (proving the convention is in use). If nothing in the model asserts X, the finding can't tell "provably absent" from "never modelled" and is floored to low — so control-absence rules never flood a partially-annotated model.

The predicate vocabulary

PredicateReadsTrue when
crossesTrustBoundarydataflowsource and destination sit in different trust zones
notEncrypteddataflowno tls/mtls/https/encrypted tag or secure protocol/attribute
carriesSensitiveDataeithertouches an asset whose confidentiality ≥ the rule's threshold
componentKindIncomponentthe component's type is one of the listed kinds
lowTrustZonecomponentits zone's trustRating ≤ the rule's max
hasTagcomponentcarries attribute key (present) or key=value (exact) — e.g. provisioning=manual
accessFanOutcomponentis the source of at least min dataflows (how many resources an identity reaches)
lacksControleitherrecords no control of a family (authz, authn, hardened, ratelimit, resilience, backup, signing, integrity, waf, logging) — in its attributes/tags or a linked mitigation. Floored to low unless the model uses that control elsewhere

How a mitigation changes a finding

Findings aren't final. A mitigation that lists an element in its appliesTo down-ranks the findings on it — riskReduction values sum, and the total decides the outcome:

addresses scopes a mitigation to specific rule ids, so — for example — a WAF can down-rank an edge-exposure finding (T003) without muting an encryption finding (T002) on the same element. A downgraded finding shows its original severity, so nothing is hidden.

Residual risk. The inverse is the signal a scanner can't give: a high/critical finding with no mitigation on record at all. wyrm flags these as residual — in the report line, the GUI badge, and a residual property on the SARIF result — and counts them in the summary. A weak mitigation that's too small to downgrade still clears the flag: an attempt is on record. Residual findings are where a threat model earns its keep — sort them to the top.

Add your own rules

Point analyze at a custom catalogue — it fully replaces the bundled one, so copy the built-ins you want to keep:

wyrm analyze --rules .threatmodel/rules.yaml

A rule is just data. Add a new entry with an id, stride, severity, a target (dataflow or component), a list of when predicates, a description, and a mitigation string. CI re-validates the catalogue against its schema on every change.

Export the findings

Take the findings with you — as SARIF 2.1.0 (GitHub code scanning and most SAST tooling ingest it) or a portable YAML/JSON list:

wyrm analyze --format sarif -o wyrm.sarif    # GitHub code scanning
wyrm analyze --format yaml  -o findings.yaml # portable list
wyrm analyze --format json                   # to stdout (also: --json)

In the GUI, the findings panel has Export SARIF / Export YAML buttons that write next to the model. SARIF results carry the rule id, severity (error/warning/note + a security-severity score), STRIDE, and a location pointing at the element in the .otm.yaml — so wyrm findings show up alongside your other scanners in the Security tab.

# CI: upload to GitHub code scanning
- run: wyrm analyze --format sarif -o wyrm.sarif --fail-on critical
- uses: github/codeql-action/upload-sarif@v3
  with: { sarif_file: wyrm.sarif }