Threat Modeling with STRIDE: A Practical Introduction

Threat Modeling with STRIDE: A Practical Introduction

6 min read6 views

Super AdminSuper Admin

Threat modeling is the habit of asking "what could go wrong?" before an attacker answers the question for you. STRIDE is one of the most widely taught ways to structure that question, and it appears in CISSP, CySA+ and secure software development material.

Rather than just listing the six letters, this article applies them to a small hypothetical system so you can see how the method works in practice.

What threat modeling is for

A threat model is a structured description of a system, the threats against it and the decisions made about those threats. Its value lies in timing. A design flaw found on a whiteboard costs a conversation; the same flaw found in production costs an incident, a patch and possibly a disclosure.

A common way to frame any threat modeling exercise is four questions:

  • What are we working on?
  • What can go wrong?
  • What are we going to do about it?
  • Did we do a good enough job?

STRIDE is a tool for the second question. It gives you six categories to check systematically, so the analysis does not depend on whoever happens to be in the room remembering the right attack.

The six STRIDE categories

Each STRIDE threat is the violation of a specific security property. Learning the pairs is the single most useful thing you can do for exam questions on this topic.

STRIDE threats and the properties they violate
ThreatProperty violatedExampleTypical mitigation
SpoofingAuthenticationLogging in with stolen credentials; a fake service impersonating a real oneStrong authentication, MFA, mutual TLS between services
TamperingIntegrityAltering a price in a request; modifying data at restInput validation, digital signatures, MACs, access controls on data
RepudiationNon-repudiationA user denies having made a transaction and no evidence existsSecure, tamper-evident audit logs; digital signatures
Information disclosureConfidentialityVerbose error messages; unencrypted traffic; over-broad API responsesEncryption in transit and at rest, least privilege, data minimization
Denial of serviceAvailabilityFlooding a login endpoint; exhausting a database connection poolRate limiting, quotas, redundancy, autoscaling
Elevation of privilegeAuthorizationA normal user reaching admin functions; a flaw allowing code executionServer-side authorization checks, least privilege, sandboxing
Two people planning together beside a laptop and paperwork
Photo: Unsplash

Walking through a hypothetical login service

Hypothetical scenario. A team is building a login service for a web application. Users sign in through a browser; requests pass through an API gateway to an authentication service, which checks a user database, issues a session token stored in a session cache and sends password reset emails through an external email provider. Here is how the team applies STRIDE.

Step 1: Define the scope

The team agrees the model covers sign-in, sign-out and password reset. Account registration is out of scope for this session and noted for later. Writing the scope down prevents the discussion drifting and makes it obvious what has not yet been analysed.

Step 2: Draw the data flow diagram

A data flow diagram uses a small set of elements: external entities (the user, the email provider), processes (the gateway, the auth service), data stores (the user database, the session cache) and data flows between them. Crucially, it marks trust boundaries, the lines where data passes between zones of different trust, such as from the internet into the gateway or from the auth service out to the email provider. Most interesting threats sit on those boundaries.

Step 3: Apply STRIDE to each element

The team walks through every element and flow, asking which categories apply. Not every category applies to every element type: a data store, for example, is mainly exposed to tampering, information disclosure and denial of service. Findings include:

  • Spoofing: credential stuffing against the login endpoint; a reset link that can be guessed.
  • Tampering: a client modifying the user identifier in the reset request.
  • Repudiation: no record of which address requested a password reset.
  • Information disclosure: the login form reveals whether an email address is registered; session tokens appear in logs.
  • Denial of service: unlimited reset requests flooding a victim's inbox and the email quota.
  • Elevation of privilege: a session token that encodes a role the client could alter.

Step 4: Rate and prioritize

Not every finding deserves equal effort. The team rates each threat by likelihood and impact on a simple scale and sorts the list. Some teams use formal schemes such as CVSS for vulnerabilities or older approaches like DREAD; the important point is consistency, so that the ranking means something.

Step 5: Decide how to respond

For each threat the team chooses to mitigate, eliminate (remove the feature), transfer or accept the risk, with acceptance recorded and signed off by the owner. Here they add MFA and rate limiting, make reset tokens long, random, single-use and short-lived, return the same message whether or not an account exists, keep role information server-side, mask tokens in logs and record reset requests in an audit log.

Step 6: Validate

Finally, the team checks that each mitigation was actually built and tested, turns key threats into test cases and schedules a review whenever the design changes. A threat model that is never revisited slowly turns into fiction.

A quick STRIDE checklist

Use this list when reviewing any design, whether a microservice, an API or a cloud workload:

  • Have all trust boundaries been drawn and labelled?
  • Does every entry point authenticate the caller, and how?
  • Is data integrity protected in transit and at rest?
  • Are security-relevant actions logged in a way users cannot alter?
  • Could any response, error or log reveal more than it should?
  • Is every expensive operation rate limited or quota bound?
  • Is authorization enforced on the server for every privileged action?
  • Has each accepted risk got a named owner and a review date?

STRIDE on the exam

Questions typically either give an example and ask for the STRIDE category, or name a category and ask which security property it threatens. A good trick is to translate the attack into its effect. "An attacker modifies a log entry to hide their activity" is tampering, because integrity was violated, even though the motive was repudiation. Read carefully: if the scenario says a user denies an action and there is no proof, that is repudiation.

Be ready, too, to distinguish STRIDE from other models: PASTA is a risk-centric, seven-stage methodology, and attack trees decompose a single attacker goal into the ways it could be reached. OWASP maintains community guidance on the practice at owasp.org.

Conclusion

STRIDE turns "think like an attacker" into a repeatable checklist. Draw the system, mark the trust boundaries, ask the six questions of every element and record what you decide. Memorize the six threat-to-property pairs and you will handle most exam questions on the topic; practise the method on a real design and you will find flaws long before anyone else does.

0.0 (0 ratings)
Share:

38 international certifications

Which certification are you preparing for?

Question banks, flashcards and mock exams built on each exam's official outline.

Browse certifications

Discussion (0)

No discussion here yet — be the first to comment.

Please sign in to join the discussion.

See all posts