How to run a threat model that changes architecture decisions: the four questions, data flows and trust boundaries, and what to add to STRIDE once an LLM can call tools.
Contents · 11 sections
Picture a familiar kind of threat model. There's a data flow diagram from the kickoff, a spreadsheet of STRIDE rows with "Medium" in the risk column, and a link to both from a wiki page nobody has opened since. The system has changed three times since then. Nothing in the architecture is different because the model exists, and nobody can point to a decision it informed.
The team didn't skimp on effort. The model was built to exist, so it became a document. A model built to answer "which way do we build this?" has to change something, or tell you in writing that the design was already fine. The OWASP Top 10:2025 pairs Insecure Design's two-place fall with "noticeable improvements in the industry related to threat modeling", and the A06 page calls for "more use of threat modeling". It doesn't say what kind, and a diagram nobody opens prevents nothing.
This piece takes the method apart and puts it back together around decisions. It follows the four questions from the Threat Modeling Manifesto, uses OWASP's cheat sheet to pick a technique per question, and then hits the place where the classic tools run out: an LLM feature that reads untrusted text and can call a tool. Then it models one realistic web app end to end, an SPA with an OAuth backend-for-frontend, a third-party analytics script and a retrieval chatbot with one write tool, and records for every threat what design decision it changed, or why it changed none. It's part 3 of a series on reading security standards; part 1 covered what the OWASP Top 10 measures, and why a ranking of categories can't prioritize your system. This is the tool that can.
A threat model is worth the decisions it changes
The Threat Modeling Manifesto defines the activity in one line: "analyzing representations of a system to highlight concerns about security and privacy characteristics." It's deliberately method-agnostic. What it does commit to is a set of values written in the Agile Manifesto's "this over that" format, and two of them are the thesis of this piece: "a culture of finding and fixing design issues over checkbox compliance" and "continuous refinement over a single delivery."
The Manifesto is also explicit about where the output goes. Threats, it says, inform "decisions that you might make in subsequent design, development, testing, and post-deployment phases." Its principles add that "dialog is key to establishing the common understandings that lead to value, while documents record those understandings, and enable measurement." The document is a record of a conversation that changed something. It is not the product.
The most useful part, for anyone running design reviews, is the list of anti-patterns. There are four, and I'll use them at the end to review this piece's own case study:
- Hero Threat Modeler. Threat modeling shouldn't depend on one person's "innate ability or unique mindset"; everyone can do it.
- Admiration for the Problem. Analysis that never reaches "practical and relevant solutions."
- Tendency to Overfocus. Losing the big picture by exaggerating attention on adversaries, assets or techniques.
- Perfect Representation. Chasing one ideal diagram, when "multiple threat modeling representations" may each show different problems.
The working group behind it has since published a Threat Modeling Capabilities catalog, and its "Acting on Threat Models" area reads like a checklist for the gap I described in the opening. It asks for a "Definition of Done" for threat modeling outputs, and for outcomes that "influence the implementation or operational workflows", for example by guiding testing. A model whose outputs don't reach a backlog, a test or a decision record fails that capability by definition.
The four questions are the method's spine
The Manifesto frames all threat modeling as 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?
They show up nearly word for word across OWASP. The Threat Modeling Cheat Sheet calls them "the foundation for the four major phases" of its process, which it names application decomposition, threat identification and ranking, mitigations, and review and validation. The OWASP community page calls them the "Four Question Framework" (it shortens the last one to "Did we do a good job?"), and LINDDUN's home page uses them for privacy too, citing the Manifesto.1
I find it most useful to read each question as producing one artifact, because that's what makes the model checkable:
| Question | What it produces | Who consumes it |
|---|---|---|
| What are we working on? | A model with trust boundaries, scoped to a pending decision | Everyone in the session |
| What can go wrong? | A list of threats, each tied to an element or flow | The response step |
| What are we going to do about it? | One response per threat, plus decision records | Backlog, ADRs, tests |
| Did we do a good enough job? | Review against criteria, and tests that verify mitigations | CI, the next session |
The rest of this piece is those four rows, in order, with the LLM problem dropped into row two.
The diagram exists to find trust boundaries
The cheat sheet's system modeling section names data flow diagrams as "arguably the most common approach", and asks that whatever you draw gives "a clear view of trust boundaries, data flows, data stores, processes, and the external entities." Of those five, trust boundaries carry the analysis. OWASP's older, step-by-step Threat Modeling Process page defines the boundary shape as marking "any location where the level of trust changes", and says entry and exit points define a trust boundary. Threats cluster where data crosses one.
As of 18 October 2026 that process page is titled "Threat Modeling Process (Historical)", but it's still the most detailed decomposition walkthrough OWASP has, with entry points, exit points, assets and trust levels each given IDs for cross-referencing. Its scoping step carries two cautions. "Assets" are often "out of scope for a project, and are a distraction." And for teams that threat model every story, the approach it credits to Tarandach, "decompose the application" becomes meaningless. Both points push toward the same practice: model the part of the system a decision touches.
The Manifesto's second principle says the same thing in its own words. Threat modeling "must align with an organization's development practices and follow design changes in iterations that are each scoped to manageable portions of the system." Not the whole system. The portion the change touches.
The case study system
Here's the system I'll model for the rest of the piece. It's a hypothetical, assembled from patterns this track covers one by one:
- A single-page app served from
app.example.com. - An OAuth backend-for-frontend (BFF) on the same site. Per RFC 10017, section 6.1 (Best Current Practice, published August 2026), the BFF is a confidential OAuth client, keeps access and refresh tokens server-side in a cookie-based session, and forwards API requests with the right token attached.
- An identity provider acting as the authorization server.
- An API (the resource server) that stores projects, documents and chat conversations.
- A third-party analytics script, loaded into the SPA's pages with a
<script>tag. - A retrieval chatbot: user questions go to the API, which retrieves chunks from a vector store of workspace documents, sends them with the question to an external LLM provider, and streams the answer back as rendered Markdown.
- One write tool the model can call:
send_summary, which emails a summary of the conversation.
Fig. 1 shows the diagram. Watch what happens to the boundaries as the flows go in.
Three of the boundaries are the classic ones: the internet between browser and BFF, the vendor boundary to the identity provider, and the vendor boundary to the LLM provider. Two are less obvious and both turn out to matter more.
The first is the boundary that isn't there. The analytics script and the SPA run in the same origin, so the diagram's instinct to draw a box around "third-party code" is wrong. RFC 10017 is blunt about what code in your origin can do: "malicious JavaScript code has the same privileges as the legitimate application code" (section 5). The BFF keeps tokens out of the browser, which defeats token theft, but the RFC notes that malicious code "is able to send requests to the BFF from within the user's browser" (section 6.1). Its description of that scenario, Proxying Requests via the User's Browser, says it's "commonly accepted that this scenario cannot be stopped or prevented by application-level security measures." So the honest diagram shows a dashed line between SPA and analytics, labelled "no boundary", and that line generates threats.
The second is the boundary around the model. I'll come back to it, because it's where STRIDE starts to run out.
Cloud changes the shapes, not the method
The cheat sheet adds a cloud threat modeling section that says traditional techniques "like STRIDE or DFDs" often need adapting for shared responsibility models, managed services and APIs, multi-tenant and identity federation concerns, and dynamic infrastructure such as IaC, serverless and containers. In the case study, the vector store and LLM provider are managed services, and the IdP is federation. In practice that means two extra questions per managed box: which controls does the provider own, and where does our configuration of it live? A vector store's tenant isolation might be the provider's job; the filter your query passes to it is yours.
Pick the technique by the question you're asking
With a model in hand, the second question, "what can go wrong?", needs prompts. STRIDE is the default, and the cheat sheet explains why it works: each category is "a violation of a desirable security attribute", and its threat identification table pairs them:
| STRIDE category | Violates |
|---|---|
| Spoofing | Authentication |
| Tampering | Integrity |
| Repudiation | Accounting |
| Information disclosure | Confidentiality |
| Denial of service | Availability |
| Elevation of privilege | Authorization |
The instruction that comes with it is the part teams skip: "Use STRIDE's six categories as prompts while reviewing the system model." Prompts, not a form to fill in. You walk the diagram, element by element or interaction by interaction, ask each of the six questions, and write down what the team finds, with the component, flow or boundary it affects.
STRIDE is a good default for components and flows. It's a poor fit for other questions, and the cheat sheet now has a selection table that says so. It tells you to "start with STRIDE for a technical design, and select another technique when the scope requires a different view":
| When you need to analyze | Consider |
|---|---|
| Security threats in a technical design | STRIDE |
| A high-value attacker goal or multi-step attack | Attack trees |
| Abuse of a valid workflow or business rule | Misuse or abuse cases |
| Privacy properties and harms | LINDDUN |
| Application threats with business impact | PASTA |
| Organization-wide risk to critical assets | OCTAVE |
| Application and operational threats across many teams | VAST |
The sentence under that table is the best advice in the cheat sheet: "Do not add techniques only to make the model appear comprehensive. State why each technique fits the scope and record any concerns it does not address." That's the Perfect Representation anti-pattern turned into a rule. Use more than one view when different questions need them, and say what each one is for.
In the case study, three techniques earn their place. STRIDE per element covers the components. One attack tree covers the single goal the business would care about most, someone reading another user's chat history. And LINDDUN covers the analytics script, because its main risks aren't security failures at all.
LINDDUN asks what STRIDE can't
LINDDUN, from the DistriNet group at KU Leuven, is a privacy threat framework first published in 2010. Its acronym is seven threat types, and the threat types page defines each in a line:
- Linking: associating data items or user actions to learn more about an individual or group.
- Identifying: learning the identity of an individual through leaks, deduction or inference.
- Non-repudiation: being able to attribute a claim to an individual.
- Detecting: deducing someone's involvement through observation, without reading the data itself.
- Data disclosure: excessively collecting, storing, processing or sharing personal data.
- Unawareness and unintervenability: insufficiently informing, involving or empowering people in the processing of their data.
- Non-compliance: deviating from security and data management best practices, standards and legislation.
Two things stand out for engineers who know STRIDE. Non-repudiation is a threat in LINDDUN and a property you want in STRIDE, so the same audit log can be a security control and a privacy harm at once. And LINDDUN's home page says it "follows the same principles" as STRIDE and starts from the same system model, so you can run both in parallel on one diagram. It comes in three flavors: GO (a card deck for lean, cross-team sessions), PRO (systematic, per DFD interaction) and MAESTRO (built on an enriched, threat-specific system description; the page says "More info coming soon").2
STRIDE runs out where text becomes action
Walk STRIDE over the chatbot and something odd happens. Spoofing, tampering and the rest still apply to the API, the BFF and the stores. But the LLM box doesn't behave like a process with inputs and outputs, because there's no reliable way to say which of its inputs are instructions.
The clearest statement of why is a December 2025 post on the UK NCSC's blog, Prompt injection is not SQL injection (it may be worse), by Dave Chismon, the NCSC's CTO for Architecture.3 It's an argument on an official blog, written in the first person, not formal NCSC guidance, and I'll treat it that way. His point is that mitigations for SQL injection or XSS enforce a separation between data and instructions, as parameterized queries do. "Under the hood of an LLM, there's no distinction made between 'data' or 'instructions'; there is only ever 'next token'." So prompt injection "may never be totally mitigated" the way SQL injection can be.
He proposes a better frame: treat the LLM as an "inherently confusable deputy". A classical confused deputy is a privileged component coerced into acting for a less-privileged attacker, and it can be fixed. An LLM can't, he argues, so "rather than hoping we can apply a mitigation that fixes prompt injection, we instead need to approach it by seeking to reduce the risk and the impact." And for systems that call tools, the impact becomes "whatever the worse case scenario would be of giving an attacker direct access to those tools/APIs." The design response he recommends is "deterministic (non-LLM) safeguards that constrain the actions of the system, rather than just attempting to prevent malicious content reaching the LLM."
For a threat modeler, that moves the trust boundary. In a classic DFD, you'd draw it where untrusted input enters: the retrieved documents arriving in the prompt. That boundary still exists, but you can't enforce anything at it, because no filter reliably separates a document from an instruction. The boundary you can enforce is around what the model's output is allowed to reach. That's the red line in Fig. 1: around send_summary and whatever it can touch, not around the prompt.
ATLAS is the technique catalog for this box
STRIDE gives you six prompts. For the model box, you want something closer to MITRE ATT&CK: a catalog of what attackers have actually done. That's MITRE ATLAS. As of 18 October 2026, the latest data release in the ATLAS changelog is v2026.09, dated 14 September 2026, with 16 tactics, 120 techniques, 88 sub-techniques, 40 mitigations and 73 case studies. ATLAS publishes roughly monthly (v2026.07 and v2026.08 came out on 31 July and 31 August), so check the version when you cite it. That release added agent-specific techniques, among them Discover AI Agent Runtime Capabilities (AML.T0133) and Crafted AI Assistant Links (AML.T0131).4
The techniques that matter for the case study, with their names as the v2026.09 data file gives them:
- AML.T0051.001, LLM Prompt Injection: Indirect. Prompts arrive through "a separate data channel that the LLM or AI agent ingests, such as text or multimedia pulled from documents, emails, databases or websites."
- AML.T0070, RAG Poisoning. Malicious content placed in data a retrieval system indexes, to contaminate later results.
- AML.T0053, AI Agent Tool Invocation. Using access to an agent to invoke the tools it has.
- AML.T0086, Exfiltration via AI Agent Tool Invocation. Write-capable tools invoked to carry data out, encoded into "the tool's input parameters", with sending emails as the first example.
- AML.T0077, LLM Response Rendering. Getting the model to emit a reference to external content, such as an image, that the client fetches when it renders the response, carrying private data to an attacker's server.
- AML.T0133, Discover AI Agent Runtime Capabilities. Asking the agent what it can do, and inferring its tools from what succeeds or is refused.
ATLAS also lists mitigations, and several read like design decisions rather than filters. AML.M0030, Restrict AI Agent Tool Invocation on Untrusted Data, recommends restricting tool invocation "when untrusted data enters the LLM's context", and "for high consequence actions, consider always requiring user confirmation." AML.M0037, AI Agent Authority Expansion Controls, says such controls "should be implemented outside the AI agent and should not rely solely on system prompts, model alignment, or the agent recognizing that an action is out of scope." Both agree with the NCSC argument: constrain what the system does, deterministically, outside the model.
Elevation of privilege becomes reachable capability
Put those together and one STRIDE category changes meaning. Classic elevation of privilege asks: can a caller get an authorization they weren't granted? For an LLM component, the better prompt is: which tool capability is reachable from untrusted text? If any document a stranger can put into the retrieval index can end up in a context where the model may call send_summary, then for threat modeling purposes the stranger can call send_summary. The NCSC post quotes a rule of thumb from a discussion between Simon Willison and Baibhav Bista: "when an LLM processes information from a party, the privileges it has drops to that of the party."
So for LLM features, I enumerate in this order: tools and the data each can reach; then every source of text that can enter a context where those tools are available; then, last, the prompts. The prompts are the least stable part of the system and the part you can enforce least.
Seven of eleven threats changed the design
Here is the STRIDE-per-element pass on the case-study system, plus the ATLAS labels on the model box, with the design decision each threat changed. The last column routes each one to the part of this track that covers the mitigation in depth. I've kept the threats that changed nothing, because the record of why they changed nothing is part of the output.
| # | Element | Threat | Label | Design decision | Covered in |
|---|---|---|---|---|---|
| T-01 | Analytics script | Vendor script (or a compromise of it) calls the BFF from the user's page and reads conversations | STRIDE I, E | Changed: no third-party script runs in the app origin; analytics moves to server-side events | Third-party scripts and document privilege |
| T-02 | BFF | Cross-site request makes the BFF act for the user | STRIDE S | No change: the BFF pattern already requires CSRF defences (RFC 10017 §6.1.3.3) | CSRF |
| T-03 | API /conversations/:id |
Signed-in user reads another user's conversation by changing the ID | STRIDE I, E | Changed: every conversation query is scoped by owner in the data layer, not in the route | Broken access control |
| T-04 | Vector store | Retrieval returns chunks from another user's private documents | STRIDE I | Changed: partition the index by workspace, filter by document ACL in the retrieval query | Broken access control |
| T-05 | Vector store | A workspace member uploads a document with hidden instructions | ATLAS AML.T0070, AML.T0051.001 | No change at ingestion (it can't be filtered reliably); the cut moves to T-06 and T-07 | Prompt injection |
| T-06 | Chat renderer | Model output includes an image URL carrying data to an attacker's server | ATLAS AML.T0077 | Changed: the renderer drops remote images; CSP img-src set to 'self' |
Exfiltration through rendering |
| T-07 | send_summary |
Injected instructions make the model email history to an outside address | STRIDE E; ATLAS AML.T0053, AML.T0086 | Changed: recipient comes from the session; model controls only the body; confirmation once untrusted content is in context | Agent least privilege |
| T-08 | LLM provider | Prompts and retrieved documents leave for a vendor | STRIDE I | Transfer: contractual, residual risk documented and owned | Not covered |
| T-09 | Chat API | Expensive prompts exhaust the model budget | STRIDE D | Changed: per-user rate and token limits, documented as resource-demanding functionality | Failing safely |
| T-10 | Tool calls | Nobody can tell which documents were in context when a tool fired | STRIDE R | Changed: log tool calls with the IDs of retrieved chunks in context | Logging that detects |
| T-11 | Browser | Infostealer malware on the device copies the session cookie | STRIDE S | Accept, with an owner and review date; out of reach of app code | Stolen session cookies |
Seven of the eleven rows say Changed. That ratio isn't a target; it's what this system produced. A few of the rows deserve more than a table cell.
T-01: the analytics script was the biggest decision
The analytics script is the threat that's easiest to miss without drawing the "no boundary" line. With a BFF, a script in the origin can't steal tokens, but per RFC 10017 it can send the same requests the app sends, and the BFF will attach the user's tokens for it. On the chat page, that's every conversation the user has.
There are three ways to respond, and each is a different design. You can accept it, which means trusting the vendor and their build pipeline with your users' chat history. You can mitigate it in the page, with a strict CSP and integrity checks, which shrinks what can load but still runs whatever loads with full privilege. Or you can eliminate it: no third-party script runs in the app origin at all. I picked elimination. Product analytics move to events the API emits server-side, and if a vendor's client-side script is truly needed, it goes in a sandboxed frame on a separate origin. Sandboxed iframes are Baseline widely available, since January 2018 per webstatus.dev (checked 18 October 2026), so this needs no fallback.
<!-- The vendor script runs on another site, and the sandbox gives it
an opaque origin on top. It can't read the app's DOM, storage or
cookies, and its requests to the BFF are cross-site, so the BFF's
CSRF defences (T-02) apply to them. -->
<iframe
src="https://analytics-frame.example.net/collect.html"
sandbox="allow-scripts"
title="Analytics"
hidden
></iframe>Leaving out allow-same-origin matters. Per MDN's iframe reference, without that token the frame's content "is treated as being from a special origin that always fails the same-origin policy." MDN also warns that combining allow-scripts and allow-same-origin on a same-origin frame lets the framed document remove its own sandbox. The page then sends coarse events to the frame with postMessage, and decides itself what crosses.
T-04 and T-05: the vector store is two threats with opposite answers
The vector store produced two threats that look alike and resolve in opposite ways. T-04, cross-user retrieval, is an access-control bug, and it has a deterministic fix: filter by the requester's permissions in the query that hits the index, so a chunk the user can't read never reaches the model. That's ordinary authorization, and ASVS treats it as such. ASVS 5.0 requirement 8.1.1, at Level 1, asks that authorization documentation define "rules for restricting function-level and data-specific access based on consumer permissions and resource attributes." The retrieval path is a data access path, so it needs those rules too.
T-05, a poisoned document from a legitimate workspace member, has no fix at that point. The member is authorized to upload it; the victim is authorized to retrieve it; the text is a valid document. Per the NCSC argument, no filter reliably separates its instructions from its content. So the threat model records "no change at ingestion" and sends the problem downstream, to the capabilities the injected text could reach. That's T-06 and T-07.
This is the pattern I'd most like readers to take away. For an LLM feature, a threat you can't cut where it starts gets cut where it would take effect.
T-07: take the dangerous parameter away from the model
The obvious first version of send_summary lets the model choose the recipient. It's the natural way to write a tool, and it's the broken version.
// Broken: the model controls where the data goes.
// Any text in context, including a retrieved document,
// can steer `to` towards an attacker's address.
export const sendSummaryTool = {
name: 'send_summary',
description: 'Email a summary of this conversation.',
input_schema: {
type: 'object',
properties: {
to: { type: 'string', format: 'email' },
body: { type: 'string' }
},
required: ['to', 'body']
}
} as const;With this definition, T-07 is the attack in AML.T0086 almost word for word: sensitive data encoded into a tool's input and sent "to an adversary-controlled location". The fix removes the parameter the attacker needs. The recipient comes from the authenticated session, the model controls only the body, and once untrusted content is in the context the call needs the user's confirmation, as ATLAS AML.M0030 suggests.
interface Mailer {
send(msg: { to: string; subject: string; text: string }): Promise<void>;
}
interface Session {
userId: string;
verifiedEmail: string;
}
interface TurnContext {
// True once any retrieved document or tool result is in context
untrustedContentPresent: boolean;
userConfirmed: boolean;
}
export const sendSummaryTool = {
name: 'send_summary',
description: 'Email a summary of this conversation to the signed-in user.',
input_schema: {
type: 'object',
properties: { body: { type: 'string', maxLength: 4000 } },
required: ['body'],
additionalProperties: false
}
} as const;
export async function runSendSummary(
input: { body: string },
session: Session,
turn: TurnContext,
mailer: Mailer
) {
if (turn.untrustedContentPresent && !turn.userConfirmed) {
return { status: 'needs_confirmation' as const };
}
// The recipient comes from the session, never from model output.
// Plain text only: no HTML, so no remote images load on open.
await mailer.send({
to: session.verifiedEmail,
subject: 'Your conversation summary',
text: input.body
});
return { status: 'sent' as const };
}It type-checks with tsc --strict --noEmit on TypeScript 5.9.3, the version this site builds with; I checked it on 18 October 2026. Three things changed, and each comes from the threat model rather than from the prompt. The tool's reach shrank from "any address on the internet" to "the person already reading the conversation", so the worst case of a successful injection is the user emailing themselves. The confirmation is a deterministic gate outside the model, the kind of control AML.M0037 describes: implemented outside the agent, with approval gates among its examples. And plain text closes the email variant of T-06: an HTML summary with an attacker's image URL would leak data the moment the user opened it.
In a retrieval chatbot, untrustedContentPresent is true on almost every turn, so in practice the tool always asks. That's the cost, and it's the right one for a write tool. If the confirmation prompt becomes a click-through, the model has done its job by surfacing the trade-off; the product decision of whether the tool is worth that friction belongs to someone with a name.
T-08 and T-11: changing nothing still needs an owner
Two threats ended as transfer and accept, and the cheat sheet's response section is strict about what those mean. It lists Adam Shostack's four responses: mitigate, eliminate, transfer and accept. It warns that risk transfer "does not itself reduce the likelihood or harmful consequences of an event", so you document "who owns the remaining controls and residual risk." Accepting is for when nothing else is acceptable "given business requirements or constraints." The OWASP process page adds that an acceptance should "document who has chosen to accept the risk."
T-11 is the infostealer case. Malware on the user's device that copies cookies is out of reach of anything the SPA or BFF can do. Browser-level session binding exists, but it's a different decision with its own trade-offs, and it gets its own piece later in this track. So the record says: accepted, named owner, reviewed in six months. That's still an output. It tells the next session what was considered and why it was left.
LINDDUN decides what the analytics events may carry
Moving analytics server-side fixed the security threat, but it didn't answer the privacy question of what the events should contain. That's what LINDDUN is for, and the threat types page even uses this case as its data disclosure example: a website using "third party tracking and analytics services" transfers personal data "to external parties."
Walking the seven types over a proposed event schema gave these results:
- Linking. A stable user ID on every event lets the vendor tie sessions together. Decision: send a per-workspace pseudonymous ID, rotated, and never the email.
- Identifying. Page URLs on the chat route include conversation titles, which users write. Decision: send route templates (
/chat/:id), never paths. - Detecting. The mere event "used the assistant" on a health or legal workspace says something. Decision: no per-feature events for workspaces flagged as sensitive.
- Data disclosure. The proposed schema included the question text "for product insight". Decision: removed.
- Unawareness and unintervenability. Users weren't told. Decision: listed in the privacy notice, with an opt-out per workspace.
- Non-repudiation and Non-compliance produced nothing new beyond what T-10's logging decision already needs: what's logged about a user's actions is itself personal data, so the tool-call log gets a retention limit.
That last point is the place where the two frameworks pull against each other. STRIDE's repudiation threat says log more; LINDDUN's non-repudiation threat says that log is evidence about a person. Running both on the same diagram is how you notice. ASVS 14.1.1 asks that all sensitive data be "identified and classified into protection levels," and 14.1.2 asks for documented protection requirements per level, including retention and how the data is logged. The LINDDUN pass is how those classifications get filled in for a new data flow.
One attack tree, four branches, three cuts
STRIDE per element is good at breadth. It's bad at showing how small steps combine into an outcome someone would pay for. The cheat sheet recommends attack trees for exactly that, "a high-value attacker goal or multi-step attack": start with the goal and decompose "the alternative or required paths to reach it."
The goal I picked is the one the business would lose sleep over: read another user's chat history. It decomposes into four OR branches, each an AND of steps:
- Run code in the victim's origin: compromise the analytics vendor's script, then have it call the BFF's conversation endpoints with the victim's session (T-01).
- Inject through retrieval: plant a document in a shared workspace (AML.T0070), wait for the victim's question to retrieve it (AML.T0051.001), then get the model to send the history out, either through
send_summarywith the attacker's address (AML.T0086) or through an image URL in the rendered answer (AML.T0077) (T-05 to T-07). - Use your own session against the API: change a conversation ID (T-03), or query the vector store for chunks you shouldn't see (T-04).
- Steal the victim's session: infostealer on their device (T-11).
Fig. 2 shows the tree and the design decisions landing on it.
The tree makes two things visible that the table doesn't. First, the cheapest path to the goal before the redesign wasn't prompt injection. It was branch 1, a third-party script added for a marketing dashboard, which needs no knowledge of the chatbot at all. Second, the injection branch can only be cut at its last step. The first two steps are things legitimate users do every day. That's the inherently confusable deputy argument, drawn as a tree.
The decision record links the threat to the change
A threat that changed the design needs a pointer to the change, or the next person to touch send_summary will "simplify" it by adding a to parameter back. A short architecture decision record per changed threat, with the threat ID in it, is enough:
# ADR-0012: send_summary takes its recipient from the session
Status: accepted
Threats: T-07 (STRIDE E; ATLAS AML.T0053, AML.T0086), T-06 (email variant)
Model: threat-model/chat.md, revision of the "write tool" session
## Context
The model can be steered by any retrieved document (T-05). A recipient
chosen by the model is therefore chosen by whoever wrote that document.
## Decision
The tool has no recipient parameter. It sends plain text to the
session's verified address. It requires user confirmation once
untrusted content is in context.
## Consequences
Users can't send summaries to colleagues from the chat. Product accepted
this; sharing goes through the existing share dialog, which runs the
normal authorization checks.
## Verified by
test/tools/send-summary.test.tsThe "Consequences" section is where a threat model shows it changed something real. Somebody lost a feature, and a named person agreed to it.
A model stays alive by being checked
The fourth question, "did we do a good enough job?", is where most threat models stop being maintained. The cheat sheet's review and validation section lists the review questions, and two of them are what turn a document into an engineering artifact: "For each identified threat, has a response strategy been agreed upon?" and "Can the agreed upon mitigations be tested?"
The standards have moved the same way. NIST's SSDF 1.1 (SP 800-218) has two tasks for this.5 PW.1.1 is "use forms of risk modeling - such as threat modeling, attack modeling, or attack surface mapping." PW.1.2 is "track and maintain the software's security requirements, risks, and design decisions", with examples that include recording the response to each risk and periodically re-evaluating approved exceptions. The cheat sheet cites PW.1.2 for the same point.
ASVS 5.0 went further and made documentation verifiable. Its notes for users of 4.0 explain that "documented security decisions" are "an evolution of earlier requirements related to policy application and threat modeling in version 4.0", now "explicitly defined as documentation requirements, making them clear, actionable, and verifiable." Several land squarely on threat model outputs. 8.1.1 is the authorization rules from T-03 and T-04. 15.1.3 asks that documentation identify "time-consuming or resource-demanding" functionality and how to prevent a loss of availability from overusing it, which is T-09's LLM budget. 15.1.5 asks that documentation highlight where "dangerous functionality" is used. Part 2 of this series, on ASVS 5.0 as an engineering spec, turns requirements like these into tests.
A threat register can fail the build
If the threat model's outputs are verifiable, verify them. Keep the threat list as data next to the code, and let a small script check the rules the cheat sheet states in prose: every threat has a response; every mitigation has a decision record and something that verifies it; every acceptance has an owner and a review date that hasn't passed.
[
{
"id": "T-07",
"title": "Injected document makes the model email chat history out",
"element": "tool:send_summary",
"labels": ["STRIDE:E", "ATLAS:AML.T0053", "ATLAS:AML.T0086"],
"response": "mitigate",
"decision": "docs/adr/0012-summary-recipient-from-session.md",
"verifiedBy": ["test/tools/send-summary.test.ts"]
},
{
"id": "T-11",
"title": "Infostealer on the user's device copies the session cookie",
"element": "browser",
"labels": ["STRIDE:S"],
"response": "accept",
"owner": "platform-lead",
"reviewBy": "2027-04-01",
"rationale": "Out of reach of app-level controls."
}
]import { readFile } from 'node:fs/promises';
import { existsSync } from 'node:fs';
const threats = JSON.parse(
await readFile('threat-model/threats.json', 'utf8')
);
const today = new Date().toISOString().slice(0, 10);
const problems = [];
for (const t of threats) {
if (t.response === 'mitigate' || t.response === 'eliminate') {
if (!t.decision || !existsSync(t.decision)) {
problems.push(`${t.id}: decision record missing`);
}
if (!t.verifiedBy?.length) {
problems.push(`${t.id}: nothing verifies the mitigation`);
}
for (const path of t.verifiedBy ?? []) {
if (!existsSync(path)) problems.push(`${t.id}: ${path} not found`);
}
} else if (t.response === 'accept' || t.response === 'transfer') {
if (!t.owner) problems.push(`${t.id}: no named owner`);
// ISO dates compare correctly as strings
if (!t.reviewBy || t.reviewBy < today) {
problems.push(`${t.id}: review date missing or passed`);
}
} else {
problems.push(`${t.id}: no response recorded`);
}
}
if (problems.length > 0) {
console.error(problems.join('\n'));
process.exit(1);
}
console.log(`${threats.length} threats, each with a response`);I ran it with Node 24.18 from the root of a scratch repository holding those two files, as node threat-model/check-threats.mjs. With the ADR and test files absent it exits 1 and prints T-07: decision record missing and T-07: test/tools/send-summary.test.ts not found; once they exist, it prints 2 threats, each with a response and exits 0. All paths resolve against the working directory, so run it from the repository root. It doesn't check that the test tests the right thing, only that the link exists. That part is review, and it's the reason the cheat sheet says the model "must be reviewed by all stakeholders, not just the development or security teams."
The expiry on acceptances is the bit teams usually leave out, and SSDF's PW.1.2 example asks for it: re-evaluate approved exceptions periodically. A risk accepted in April 2026 under one set of browser capabilities may have a cheap mitigation by April 2027. A date that fails the build is how that review actually happens.
Re-run on triggers, not on a calendar
The last piece is keeping the model in step with the system. The OWASP community page lists events after which updating the model "is advisable": a new feature is released, a security incident occurs, or there are architectural or infrastructure changes. The A06 page asks for threat modeling in refinement sessions, looking "for changes in data flows and access control or other security controls."
For the case-study system, I'd make the triggers concrete enough that a pull request template can ask about them:
- A new trust boundary: a new vendor, a new service, a new origin, or a third-party script on any page.
- A new data class in an existing flow: something personal or sensitive starting to move where it didn't before.
- A new tool for a model, or a new source of text in a context where tools are available.
- A security incident in the system or one of its dependencies.
Fig. 3 shows how that plays out over five releases of the case-study system.
Most releases don't trip a trigger, and that's the point. The Manifesto's principle of iterations "scoped to manageable portions of the system" only works if most iterations are small. Adding the write tool was the release that turned a read-only chatbot into a deputy with something to be confused about. That's the one the model has to catch.
The evidence measures analysis, not outcomes
I'd like to tell you threat modeling has been shown to reduce production vulnerabilities. I couldn't find a study that shows it, and the closest work measures something narrower.
The first study is a replication of a controlled experiment comparing two STRIDE variants, Mbaka and Tuma (arXiv preprint, 2022). It compared STRIDE per element with STRIDE per interaction on productivity and precision. The paper body gives the population: 45 Computer Science master's students in a course the experimenters taught, working in pairs on a home monitoring system, with about 20% from a security background and most new to secure design techniques. The original study had 110 students. Like the original, it found no significant difference between the variants in precision or productivity. Unlike the original, the per-interaction teams did somewhat better, though not significantly, which the authors say "negates the claim that this technique is more suitable for expert analysts."
The second is an industrial case study, Tuma, Sandberg, Thorsson, Widman and Scandariato (arXiv preprint, 2019). It compared risk-last analysis (STRIDE per element: find all threats, then rank them) with a risk-first variant, eSTRIDE, which starts from asset and risk analysis. The participants were industrial experts from the automotive domain, and the abstract says the authors "consciously trade the amount of participants for a more realistic simulation." The paper body puts that at two teams, seven people in total, a six-hour analysis session and nine hours of transcribed recordings. They found no difference in the productivity and timeliness of finding high-priority threats. But the risk-first team "found twice as many high-priority threats" and discussed feasibility in more detail, while the risk-last team found more medium- and low-priority threats and finished early.
Both are honest about their limits, and both have the same one: they measure the analysis, not what happens to the software afterwards. Productivity, precision and timeliness tell you whether a technique finds threats an expert would agree with. They don't tell you whether the system shipped with fewer defects. The industrial study is suggestive for the "scope by decision" advice in the next section, since starting from what matters found more of what matters, but seven people in two teams is a case study, not a result.
And the claim that started this piece, that the industry improved at threat modeling, is an inference. The Top 10:2025 introduction says A06 "slides two spots" as two other categories "leapfrog it", and that "we have seen noticeable improvements in the industry related to threat modeling." As part 1 of this series showed, a rank can move because of re-bucketed CWEs, different contributors, changed weights or the survey. A two-place drop is not a measured effect of threat modeling.
So the case for threat modeling rests on a design argument, not on outcome data: it's the only step in the lifecycle that looks at the architecture before the architecture is expensive to change. I find that argument convincing. It's also the reason a model has to change decisions to be worth anything. If it doesn't, the argument doesn't apply.
Scope by decision, and model capabilities before prompts
Here's how I'd run it, starting tomorrow.
Scope by decision. Start a session by writing down the decision it informs: "should send_summary take a recipient?", "can the analytics script stay on the chat page?". Model only what that decision depends on. Time-box it. If the session ends without changing, confirming or explicitly accepting something, it was a meeting, not a threat model.
Choose a technique per question. STRIDE per element for components and flows. An attack tree for the one goal the business would lose sleep over. LINDDUN when personal data moves, especially to a third party. Say in the record why each technique is there and what it doesn't cover, as the cheat sheet asks.
Draw the boundaries that aren't there. Same-origin third-party scripts, shared vector indexes, and a model with tools all look like boundaries on a whiteboard and aren't. Draw them dashed and ask what crosses.
For LLM features, enumerate capabilities first. List every tool and every piece of data each one can reach. Then list every source of text that can enter a context where those tools are available. Prompts come last. Use ATLAS IDs for the threats so they stay comparable across systems and over time.
Take dangerous parameters away from the model. Recipient, account, amount, URL: anything that decides where data or money goes should come from the session or a deterministic policy, not from model output. Put a confirmation outside the model on any write once untrusted text is in context.
Make the outputs fail a build. Keep the threat list as data, link each mitigation to a decision record and a test, and give each acceptance an owner and an expiry. Run the check in CI.
Re-run on triggers. New trust boundary, new data class, new tool, incident. Put the four questions in the pull request template for changes that trip one.
And review your own model against the Manifesto's anti-patterns. This one fails the first: one author built it without the people who own each box, which is the Hero Threat Modeler pattern exactly. Treat it as the input to a session with those people, not the output. It does better on the other three. Every threat has a response (not Admiration for the Problem). The analysis spent more time on an analytics script than on prompt wording (not Tendency to Overfocus). And it uses three representations, a diagram, a table and a tree, each for a stated reason (not Perfect Representation).
What we don't know
Whether threat modeling reduces shipped defects. I found no peer-reviewed study that links threat modeling to fewer production vulnerabilities. The two studies above are arXiv preprints. Crossref lists a 2021 Journal of Systems and Software article by Tuma and colleagues, Finding security threats that matter: Two industrial case studies, which looks like an extended, peer-reviewed version of the second; I couldn't open its text, so I cite the preprint's numbers. I found no peer-reviewed version of the replication. Both measure analysis proxies. The 2015 descriptive study of STRIDE by Scandariato, Wuyts and Joosen in Requirements Engineering, which the replication paper cites, sits behind a login and I couldn't open it, so I haven't cited its results. A study that tracked defects found after release in systems designed with and without threat modeling would settle this; I don't know of one.
How much of A06's drop is real. OWASP's attribution to threat modeling is the maintainers' reading of a rank change. As of 18 October 2026, the repository's 2025/Data folder holds only a README and two sample submissions. Without the dataset, nobody outside the project can separate a change in practice from a change in data.
Whether capability-first modeling holds up as defences improve. The NCSC argument is that prompt injection may never be fully mitigated. If a future model architecture enforced an instruction and data boundary, the trust boundary could move back toward the input. I've seen no evidence of that as of October 2026, and the NCSC post was published on 8 December 2025 with no update shown on the page as of 18 October 2026.
How stable the ATLAS IDs are. ATLAS renames and restructures as it grows: per the changelog, the July 2026 release moved three separate "publish poisoned" techniques (datasets, models and agent tools) under one new parent technique. A threat register that stores ATLAS IDs needs the version next to them. I also couldn't confirm the technique pages on atlas.mitre.org, which render client-side; the names and IDs here come from the v2026.09 data file.
Whether the confirmation step works. ATLAS AML.M0030 and the send_summary design both rely on a user confirming a tool call. I know of no published measurement of how often users approve confirmations they should refuse in assistant interfaces. If that rate is high, the confirmation is a speed bump, and the recipient-from-session decision is doing all the work.
Notes
-
OWASP's community pages moved: as of 18 October 2026,
owasp.org/www-community/Threat_Modelingredirects tocommunity.owasp.org/Threat_Modeling. ↩︎ -
The two sources spell one LINDDUN type differently. The home page lists "Unawareness"; the threat types page and the OWASP cheat sheet use "Unawareness and Unintervenability". I've used the longer name, since it matches the definition. ↩︎
-
The page's byline gives him that title; the sign-off at the end of the post reads "NCSC Technical Director for Platforms Research". I've used the byline. ↩︎
-
A small date mismatch: the changelog dates v2026.09 to 14 September 2026, while the
modified-dateinside the data file is 15 September 2026. ↩︎ -
NIST published a draft of SP 800-218 Rev. 1, SSDF version 1.2, on 17 December 2025. Its comment period closed on 30 January 2026, and as of 18 October 2026 the CSRC page still lists only the draft, so I cite the final 1.1. ↩︎
References
- Threat Modeling Manifesto. Threat Modeling Manifesto working group>. Accessed .
- Threat Modeling Capabilities. Threat Modeling Manifesto working group>. Accessed .
- Threat Modeling Cheat Sheet. OWASP Cheat Sheet Series>. Accessed .
- Threat Modeling (community page). OWASP>. Accessed .
- Threat Modeling Process (Historical). OWASP>. Accessed .
- A06:2025 Insecure Design. OWASP>. Accessed .
- Introduction - OWASP Top 10:2025. OWASP>. Accessed .
- Prompt injection is not SQL injection (it may be worse). UK National Cyber Security Centre (blog, Dave Chismon)>. Accessed .
- MITRE ATLAS data repository (atlas-data). MITRE>. Accessed .
- MITRE ATLAS data CHANGELOG. MITRE>. Accessed .
- MITRE ATLAS data v2026.09 (ATLAS-2026.09.yaml). MITRE>. Accessed .
- LINDDUN privacy threat modeling. DistriNet, KU Leuven>. Accessed .
- LINDDUN privacy threat types. DistriNet, KU Leuven>. Accessed .
- A replication of a controlled experiment with two STRIDE variants (preprint). arXiv (Winnie Mbaka, Katja Tuma)>. Accessed .
- Finding Security Threats That Matter: An Industrial Case Study (preprint). arXiv (Katja Tuma, Christian Sandberg, Urban Thorsson, Mathias Widman, Riccardo Scandariato)>. Accessed .
- Finding security threats that matter: Two industrial case studies (Crossref record). Crossref (Journal of Systems and Software, vol. 179, 2021)>. Accessed .
- ASVS 5.0: Changes for users of 4.0. OWASP>. Accessed .
- ASVS 5.0 V8 Authorization. OWASP>. Accessed .
- ASVS 5.0 V14 Data Protection. OWASP>. Accessed .
- ASVS 5.0 V15 Secure Coding and Architecture. OWASP>. Accessed .
- NIST SP 800-218, Secure Software Development Framework (SSDF) Version 1.1. NIST>. Accessed .
- SP 800-218 Rev. 1 (Draft), Secure Software Development Framework (SSDF) Version 1.2. NIST CSRC>. Accessed .
- RFC 10017: OAuth 2.0 for Browser-Based Applications. IETF / RFC Editor>. Accessed .
- OWASP Top 10 repository, 2025/Data folder. OWASP Top 10 project>. Accessed .
- <iframe>: The Inline Frame element (sandbox attribute). MDN>. Accessed .
- Sandboxed iframes. Web Platform Status (webstatus.dev)>. Accessed .
- Content-Security-Policy: img-src directive. MDN>. Accessed .