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.
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:
- ≥ 100 — the finding is resolved and drops out of the report.
- 70–99 — severity drops two rungs (e.g. Critical → High → Medium).
- 40–69 — severity drops one rung.
- < 40 — recorded but too weak to move the needle.
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 }