The line between #1 Abuse of Functions and #2/#3 Exploiting Server/Client is the place where the core paper admits analysts still need judgment. A recurring suggestion is to redraw it as inside the boundary versus outside the boundary. The suggestion is right, and it is also what the framework already does — but only once you say whose boundary. TLCTC v2.5 draws one envelope around the actor: what an accountable grantor entitled them to do (R-SCOPE). The #1/#2/#3 line is a second envelope drawn around the component: what its maker intended it to do. #1 stays inside the maker’s envelope; #2 and #3 leave it. This post states the two-envelope picture, turns the second envelope into a counterfactual test, and shows the two cases where the test needs a rider.
The question arrives in several forms. A developer asks why a missing authorization check on an API is #1 when a missing bounds check on the same API is #2. A SOC analyst asks why SSRF is #1 when it so obviously looks like “exploiting the server”. A risk manager asks whether “the attacker stayed within what the system allowed” is the real discriminator. All three are asking the same thing: is there a boundary here, and which side of it is #1?
There is. There are two, in fact, and the reason the question feels unresolved is that the framework has so far named only one of them.
The Envelope TLCTC Already Draws
Since v2.5 the cause side is partitioned before any cluster is assigned. R-SCOPE asks three questions in strict order — is there an actor, did they intend the outcome, did an accountable grantor confer an entitlement covering this action — and only an intended, unentitled action enters the Attack row where the ten clusters apply. An intended action inside the entitlement is Abuse of Rights: operational risk, no cluster, no System Risk Event, the consequence chain starting at the Data Risk Event.
That is an envelope. It is drawn around the actor, by a grantor, and it is made of entitlements: access rights, roles, mandates. The core paper is careful that it is not an actor test — it never asks who the actor is, only whether the action fell inside what someone with authority conferred. Call it the grantor’s envelope.
What it does not do is separate #1 from #2 and #3. Everything outside the grantor’s envelope is an attack; R-SCOPE then hands over to a single follow-up question — was an implementation flaw required? — and that question is the one people find fuzzy.
The Envelope It Draws Without Naming
Look at what “implementation flaw required” is actually testing. #1’s generic vulnerability is the inherent trust, scope, and complexity designed into software functionality and configuration. The word doing the work is designed. The attacker’s advantage lies entirely within behaviour the component was built to exhibit; the component did exactly what its maker meant it to do, and that was enough. #2 and #3 are the opposite case: implementation flaws enable unintended behavior. The attacker needs the component to do something its maker never intended.
That is a second envelope. It is drawn around the component, by its maker, and it is made of intended behaviour. Call it the maker’s envelope. #1 is an attack that stays inside it. #2/#3 is an attack that leaves it, and R-ROLE then says which of the two by the role of the component relative to the attacker.
| Grantor’s envelope | Maker’s envelope | |
|---|---|---|
| Drawn around | the actor | the component |
| Drawn by | an accountable grantor | the designer / implementer |
| Made of | entitlements: rights, roles, mandates | intended behaviour: the specification, honoured by the code |
| Inside it | Abuse of Rights — operational risk, no cluster | #1 Abuse of Functions |
| Outside it | Attack row — a cluster applies | #2 / #3 per R-ROLE |
| Rule | R-SCOPE | #1, #2, #3 boundary tests; R-ROLE |
| Lever | segregation of duties, mandate limits, supervision | #1: narrow the scope; #2/#3: fix the code |
The two envelopes nest. Every attack is outside the grantor’s envelope by definition. Within that, an attack that stays inside the maker’s envelope is #1, and an attack that leaves it is #2 or #3. The support agent who edits a region parameter in the URL is outside their grant (attack) but inside the API’s design (#1). The same agent who sends a malformed parameter that overflows a buffer is outside both (#2). Kweku Adoboli, booking fictitious hedges with valid inputs inside his mandate, is inside both — and therefore not a cluster at all.
Turning the Envelope into a Test
The #10 boundary test is the framework’s cleanest: remove the third-party trust relationship, and if the attack still succeeds the step was never #10. The maker’s envelope gives #1, #2 and #3 a test of the same shape:
Hold the implementation to its specification. If the component had behaved exactly as its maker intended, would this step still succeed? Yes → #1. No → #2 or #3 per R-ROLE.
This is not a new discriminator. It is the existing “implementation flaw required?” question rephrased as a counterfactual, which is what makes it operational: the analyst no longer has to decide what counts as a flaw in the abstract, only whether the exploit survives a correct implementation. SQL injection does not survive parameterised queries — the component was never meant to compile attacker text into a query — so #2. A workflow that can be driven out of sequence because nobody wrote the state machine (CWE-841) survives any implementation of what was written, so #1. A registration function that happily enrols a population it was never meant for is doing precisely what it was built to do, so #1 at enrolment and, per R-CRED, no #4 afterwards.
Why Not Call It “Boundary”
Because the word is already taken three times over. In TLCTC notation ||[context][@A→@B]|| is a domain boundary crossing, required for the bridge clusters #8, #9 and #10. |[sandbox][@renderer→@os]| is an intra-system boundary, an observability annotation that by R-INTRA-7 never changes classification. And the per-cluster falsification conditions in the core paper are literally called boundary tests. Adding “within boundary / out of boundary” as a fourth sense would guarantee the term means nothing.
There is a worse risk. “Within the boundary” reads, to most people, as inside the organisation or inside the network — insider versus outsider, internal versus bridge topology. Axiom IV exists to stop exactly that reading from leaking into classification. The envelope that matters for #1 is the component’s design, and a remote attacker with no account can sit inside it just as easily as an employee can.
So: two envelopes, named by who draws them. Inside the grant and inside the design are questions with different owners, different levers and different registers, and they should not share a noun.
Two Places the Test Needs a Rider
A flaw in the guard around an intended function. SSRF where the URL allowlist can be bypassed. An authentication function whose comparison is wrong. Here a defect genuinely exists, and a naive reading of the counterfactual says “fix the allowlist and the exploit fails, so #2”. The framework says #1, and the CWE decision tree already encodes why: when the defective logic is itself a security control, the step is anchored in the component that delivers the advantage, not the guard that failed. The fetch function reaches the cloud metadata endpoint; the allowlist bug only unlocks the door. This is the same move R-CHANNEL makes for a missing certificate check (#5, not #2) and R-FLOOD for a missing rate limit (#6, not #2). The rider reads: apply the counterfactual to the function whose behaviour produces the advantage, not to the control in front of it.
Design defects that ship as logic. A defective state machine in silicon is #2/#3 under R-SUBSTRATE. A missing workflow check in a web application is #1. Both are “design” problems, so “design versus implementation” is not the cut, and the maker’s envelope only explains the difference if intended is read as the shipped behaviour matches what the maker meant, not as a design document exists. The silicon does something its designers did not mean it to do; the web application does exactly what its designers meant, which was too much.
What This Changes, and What It Does Not
Nothing in the dictionary. #1, #2 and #3 keep their definitions, attacker’s views and generic vulnerabilities verbatim; the nineteen rules stand; every published attack path classifies the same way. The two-envelope picture is a way of reading what v2.5 already says, and the counterfactual is a sharper wording of a boundary test that already exists. It belongs, if anywhere, in the core paper’s Section 4 as one added sentence per cluster and a small table beside the R-SCOPE grid in Section 3.5 — an editorial patch, not a version.
What it does change is the conversation. The next time someone asks whether “inside versus outside the boundary” would separate #1 from #2 and #3, the answer is no longer “it depends on what you mean by flaw”. It is: whose envelope? The grantor’s decides whether there is an attack at all. The maker’s decides whether the attack used the system as built or broke it. Two questions, two owners, and the taxonomy turns on both.
References
- Kreinz, B. A Cause-Oriented Cyber Threat Taxonomy: The Top Level Cyber Threat Clusters Framework (TLCTC v2.5 Core), 2026. §3.5 cause-side partition and the #1 / Abuse of Rights table; §4 cluster definitions and boundary tests for #1, #2, #3; §6 R-SCOPE, R-ROLE, R-CHANNEL, R-FLOOD, R-SUBSTRATE, R-CRED; §8 limitations. tlctc-whitepaper.html
- Kreinz, B. Functions and Rights: Why One Is a Threat Cluster and the Other Is Not, tlctc.net, 2026. tlctc-functions-vs-rights.html
- Kreinz, B. Spectre Is Not a Physical Attack, tlctc.net, 2026. On R-SUBSTRATE and defects that ship in silicon. spectre-is-not-a-physical-attack.html
- TLCTC MITRE CWE Mapping, decision tree Q2 guard and Q9. cwe-explorer.html
- MITRE CWE-841 Improper Enforcement of a Behavioral Workflow; CWE-918 Server-Side Request Forgery (SSRF).
Opinions are the author’s own. Cite TLCTC properly when re-using definitions. Licensed under Creative Commons Attribution 4.0 International (CC BY 4.0).