Blog / Strategy & Architecture

The Semantic Problem with “Zero Trust”

Zero Trust and Defense in Depth are strategic decisions. A strategy requires a diagnosis. The diagnosis requires a threat taxonomy. The industry doesn’t have one — and TLCTC exposes what that absence costs.

Bernhard Kreinz • • updated • Loading... • TLCTC v2.5
Abstract

“Zero Trust” and “Defense in Depth” are strategic decisions — GOVERN-level directives that constrain the entire control architecture. But a strategy requires a diagnosis: what threats are we addressing? This article decomposes Zero Trust through the TLCTC framework and Bow-Tie model, showing that without a causal threat taxonomy, these strategic labels are structurally empty — prescriptions without a diagnosis. Along the way, we map NIST SP 800-207’s tenets to specific generic vulnerabilities and reveal why the cybersecurity industry’s most prominent strategic concepts cannot be operationalized without the foundational layer it has never built.

Ask five CISOs what “Zero Trust” means and you will get six answers. One says it’s “never trust, always verify.” Another points to a ZTNA product. A third describes a network architecture. A fourth invokes micro-segmentation. The fifth says it’s a philosophy, not a product.

None of them are wrong. All of them are incomplete. And that incompleteness is not a communication problem — it is a structural problem. “Zero Trust” has no fixed position in any causal risk model. It floats across threat types, control functions, and Bow-Tie positions without being anchored to any one of them. In TLCTC terms, this is a textbook case of semantic diffusion: a label that has lost its structural identity because the industry never gave it one in the first place.

Let’s fix that by decomposing it.

Zero Trust is Not a Threat

“Zero Trust” does not name a generic vulnerability. It does not correspond to any of the 10 clusters. You cannot write an attack path that says #ZeroTrust → [SRE] — that notation is meaningless, because there is no exploitable weakness called “Zero Trust.” It fails the most basic TLCTC test: what was the cause-side condition that the attacker exploited?

This immediately tells us something important. Zero Trust is not a cause-side concept. It does not answer the question the framework is built to answer: “What generic vulnerability was exploited?” So whatever it is, it lives outside the 10 clusters.

TLCTC v2.5 makes this test sharper. The cause-side partition (core §3.5, rule R-SCOPE) sorts every risk event by three questions asked in strict order — is there an actor? did they intend it? were they entitled? — into four rows: Failure, Error in Use, Abuse of Rights, and Attack. Only the Attack row is cyber; only its steps take a cluster. “Zero Trust” answers none of the three questions. It is not a row, not a step, and not a cluster. It is a statement about how the defender arranges controls, which is a different kind of object altogether.

Zero Trust is Not a Single Control

This is where the semantic diffusion becomes visible. When vendors say “we deliver Zero Trust,” they typically bundle products that address fragments of multiple clusters — primarily #4 (Identity Theft) via continuous authentication, #1 (Abuse of Functions) via least-privilege enforcement, and #5 (Man in the Middle) via encrypted micro-segments. Some add #3 (Exploiting Client) via browser isolation and #7 (Malware) via execution restrictions.

But they rarely make this causal decomposition explicit. The buyer receives a product that “implements Zero Trust” without knowing which generic vulnerabilities are actually being reduced. In the TLCTC × NIST CSF 2.0 control matrix (10 clusters × 6 functions, 60 cells — Application paper §8.1), “Zero Trust” does not occupy a single cell. It scatters across multiple rows and columns simultaneously — which is precisely why it feels blurry. It is a label applied to a pattern that spans several structural positions, and nobody draws the map.

View High-Res
The Semantic Problem Zero Trust is sold as a monolith, floating above the actual threat taxonomy without a structural anchor. “ZERO TRUST” (Meta-Principle) Not a threat Not one control Not an outcome Not one BT side GOVERNmeta-principle
Figure 1: Zero Trust hovers above the threat taxonomy without a structural anchor — it is none of the standard TLCTC entities.

What Zero Trust Actually Is: A GOVERN-Level Strategic Decision

Through the TLCTC lens, “Zero Trust” is best understood as a strategic decision that belongs in the GOVERN (GV) function of the NIST CSF 2.0 framework. Specifically, it is a risk appetite statement that constrains the entire control architecture: minimize the blast radius of any single cluster realization by eliminating implicit trust at every domain boundary.

This matters because GOVERN is not optional decoration. NIST CSF 2.0 added GOVERN as the sixth function precisely because strategy must precede control selection. GV.RM (Risk Management Strategy) requires the organization to identify and prioritize threats before selecting controls. A cyber strategy — any cyber strategy — must answer the question: what are we defending against?

And this is where the industry’s approach to Zero Trust breaks down. Most organizations adopt ZT as a control architecture — they buy ZTNA products, deploy micro-segmentation, enforce MFA — without ever producing a causal threat analysis that justifies these specific controls. They jump from GOVERN directly to PROTECT, skipping the diagnostic step entirely. In TLCTC terms: they prescribe without diagnosing. The strategy sounds sophisticated, but it has no structural foundation — no explicit mapping from generic vulnerabilities to control objectives.

The Missing Step

A legitimate Zero Trust strategy would say: “We have identified clusters #1, #4, #5, #7, and #10 as our primary cause-side threats, and Confidentiality and Integrity Data Risk Events — [DRE: C], [DRE: I] — as our primary consequence-side risks. Our ZT architecture addresses these through the following control objectives per cluster, under PROTECT and DETECT on the cause side, and RESPOND and RECOVER on the consequence side.” — Nobody says this. Because nobody has the taxonomy to say it.

When you operationalize the GOVERN intent correctly, it decomposes into concrete control objectives — both PROTECT (prevention gates) and DETECT (continuous sensors) — across specific clusters. The meta-principle also extends to the consequence side (RESPOND and RECOVER), which is where most analyses stop noticing.

Decomposing ZT into Causal Control Objectives

View High-Res
Decomposing ZT into Causal Control Objectives (Cause Side) Each cluster receives a specific ZT control objective anchored to its generic vulnerability. GOVERN → #1 Abuse of FunctionsZT Control Objective:Least privilege, JIT access.Narrow legitimate scope.PR + DE #3 Exploiting ClientZT Control Objective:Browser isolation, sandboxing.Client-side containment.PR #4 Identity TheftZT Control Objective:Continuous authentication.No inherited network trust.PR + DE #5 MitMZT Control Objective:E2E encryption everywhere.Micro-segmentation.PR #7 MalwareZT Control Objective:App allow-listing, code signing.Execution restrictions.PR + DE #8 Physical AttackZT Control Objective:Physical location ≠ trust.LAN access ≠ elevated access.PR #10 Supply ChainZT Control Objective:Verify vendor at every ||...||.No implicit 3rd-party trust.PR + DE
Figure 2: Decomposing the meta-principle into actionable control objectives. PR = PROTECT, DE = DETECT. Each card targets a specific generic vulnerability.

Here is how each cluster-specific ZT control objective works:

  • Against #4 (Identity Theft): Every access request must be authenticated and authorized at the point of authentication — no inherited trust from network position. The generic vulnerability is the insufficient binding, at the point of authentication, between a presented credential and the authentic holder of the identity it claims, and the ZT directive says: make that binding continuous, not perimeter-gated. DETECT adds UEBA and impossible-travel detection to spot credential misuse.
  • Against #1 (Abuse of Functions): Enforce least-privilege and just-in-time access so that even a legitimately authenticated identity can only invoke the minimum necessary functions. This narrows the generic vulnerability — the inherent trust, scope, and complexity designed into software functionality and configuration — per session. Behavioral analytics serve as the DETECT layer for anomalous function usage.
  • Against #5 (Man in the Middle): Encrypt everything end-to-end, even inside the “trusted” network, because the architecture no longer assumes any communication path is inherently safe. This addresses the lack of sufficient control over the communication path by treating every segment as potentially hostile.
  • Against #3 (Exploiting Client): Browser isolation, application sandboxing, and Remote Browser Isolation (RBI) products all reduce the attack surface of client-side implementation flaws. This is a ZT control that is rarely labeled as such, but it embodies the same principle: don’t trust the client environment.
  • Against #7 (Malware): Application allow-listing, code signing enforcement, and sandboxed execution environments directly address #7’s generic vulnerability — the software environment’s designed capability to execute potentially untrusted foreign code. A ZT architecture that locks down identity but allows arbitrary code execution has a structural gap in cluster #7.
  • Against #8 (Physical Attack): Being “inside the building” or “on the corporate LAN” no longer grants access elevation. The generic vulnerability (physical accessibility of infrastructure) still exists, but ZT revokes the implicit trust traditionally derived from physical proximity.
  • Against #10 (Supply Chain): The “never trust, always verify” principle applies explicitly at ||[update][@Vendor→@Org]|| boundary crossings — and, per R-SUPPLY, at the Trust Acceptance Event, the moment a vendor artifact becomes authoritative inside your domain. SBOM validation, vendor posture assessment, and ZTNA enforcement at third-party access points all address the generic vulnerability that trust in third-party components and update channels can be subverted. This is arguably where “Zero Trust” is most literal: the trust being revoked is the implicit trust placed in the supply chain.

Domain Boundaries and Lateral Movement

The real structural value of Zero Trust becomes visible in TLCTC attack path notation. Consider a typical post-compromise lateral movement sequence:

#9 ||[human][@External→@Org]|| → #4 → #1 |[privilege][@user→@admin]| → #4 → #1

Read it left to right: a phishing lure crosses the human boundary into the organization (#9, a bridge cluster, so the ||…|| crossing is mandatory); the harvested credential is applied (#4); designed functions are abused to escalate (#1, with the v2.1 intra-system operator |[privilege]| recording the escalation); the newly gained admin credential is applied on the next host (#4 again — credential use is always #4, Axiom X); and functions are abused there (#1).

In a traditional perimeter model, once the attacker passes the first ||…|| crossing, subsequent → transitions encounter minimal resistance. The umbrella control assumes everything inside is trusted. Zero Trust attempts to insert both a PROTECT gate and a DETECT sensor at every arrow in the attack path — not just at the perimeter crossing @External→@Org.

In TLCTC language, this is the systematic tightening of enforcement at every transition — the responsibility-sphere crossings the notation marks with ||…||, the intra-system crossings it marks with |…|, and the plain → transitions where no boundary is recorded at all. Traditional perimeter security is an umbrella control with a very wide scope assumption — “everything inside the perimeter is trusted.” Zero Trust says: reduce the scope assumption of every umbrella control to near-zero, and compensate with more granular local controls.

View High-Res
Tightening Domain Boundaries Along the Attack Path Zero Trust puts a PR/DE gate at every → transition, not just at the perimeter. #9Social Eng. #4Identity Theft #1Abuse of Func. [SRE] || [Boundary] || || [Boundary] || || [Boundary] || Traditional perimeter: one gate at the front. Zero Trust: a gate at every arrow.
Figure 3: Enforcing boundaries at every step in the attack sequence. SRE = System Risk Event, type System Compromise (the pivot).

The Hidden Half: Zero Trust on the Consequence Side

Everything above covers the cause side (left side) of the Bow-Tie — PROTECT and DETECT controls that target specific clusters before system compromise. But this is only half the picture.

Zero Trust’s “assume breach” philosophy equally drives consequence-side controls — and the industry rarely acknowledges that these sit in a structurally different position.

The flagship example: data-at-rest encryption. This is universally listed as a core ZT pillar. But in TLCTC terms, encrypting stored data does not prevent any cluster from being exploited — it does not stop #4, #1, or any other cause-side threat. What it does is mitigate the Confidentiality Data Risk Event — [DRE: C], Loss of Confidentiality — after system compromise has already occurred. It sits on the right side of the Bow-Tie, in the RESPOND/RECOVER functions. It is a consequence-side control, not a preventive one.

Structural Insight

This is why ZT is semantically irreducible: it conflates cause-side controls (continuous auth → PROTECT against #4) with consequence-side controls (encryption at rest → mitigate [DRE: C] after the SRE) under the same label — without noticing they operate in different structural positions in the Bow-Tie.

Other consequence-side ZT controls include: network micro-segmentation to contain blast radius after compromise (RESPOND), automated isolation of compromised workloads (RESPOND), and immutable infrastructure patterns for rapid recovery (RECOVER). These are structurally valid controls — but they do not reduce generic vulnerabilities. They reduce the impact of successful exploitation. Calling them “Zero Trust controls” alongside cause-side controls like MFA is exactly the kind of category mixing that produces semantic diffusion.

One precision the v2.5 model adds: the pivot that “assume breach” assumes is the System Risk Event of type System Compromise — an actor holds capability over the system. The SRE’s other type, System Failure, has no actor and no cluster, and “assume breach” says nothing about it. Zero Trust is a strategy for the compromise pivot only.

View High-Res
Zero Trust Spans Both Sides of the Bow-Tie The industry conflates cause-side prevention with consequence-side mitigation under one label. CAUSE SIDE (PR / DE) Continuous auth (vs #4) Least privilege (vs #1) E2E encryption (vs #5) App allow-listing (vs #7) Vendor verification (vs #10) SRE System Compromise CONSEQUENCE SIDE (RS / RC) Data-at-rest encryption [DRE: C] Micro-seg containment (blast radius) Workload isolation (RS) Immutable infra / rebuild (RC) Both halves carry the “Zero Trust” label — but they operate in structurally different Bow-Tie positions.
Figure 4: Zero Trust controls mapped to both sides of the Bow-Tie. SRE = System Risk Event, type System Compromise (the pivot).

NIST SP 800-207 Through the TLCTC Lens

NIST SP 800-207 defines seven tenets of Zero Trust Architecture. When we map them to the TLCTC framework, something instructive happens: the tenets scatter across multiple clusters and CSF functions, confirming that even NIST’s own formalization cannot be pinned to a single structural position.

SP 800-207 TenetTLCTC Cluster(s)CSF FunctionBT Side
1. All data sources and computing services are resources#1, #8ID, GVBoth
2. All communication is secured regardless of network location#5PRCause
3. Access to resources is granted per-session#4, #1PRCause
4. Access determined by dynamic policy#4, #1PR, DECause
5. Enterprise monitors integrity of all assetsCross-clusterDE, IDBoth
6. Authentication/authorization are dynamic and strictly enforced#4PR, DECause
7. Enterprise collects maximum state informationCross-clusterDE, RSBoth

The mapping reveals two things. First, tenets 3, 4, and 6 are variations of the same structural idea: reduce #4 and #1 generic vulnerabilities through continuous, contextual access enforcement. NIST needed three tenets to express what TLCTC captures in two cluster × function assignments. Second, tenets 5 and 7 are not cluster-specific at all — they are DETECT and RESPOND directives that apply across the entire 10×6 matrix. This is the “GOVERN” character of Zero Trust made visible: it constrains how controls are deployed everywhere, rather than specifying a control for a particular location.

NIST’s Own Threat List Has No Taxonomy Either

Section 2 of SP 800-207 gives Zero Trust its tenets. Section 5 — “Threats Associated with Zero Trust Architecture” — gives it its threats. NIST enumerates seven. But it does exactly what the rest of the industry does: it lists them by scenario, never classifying them by cause. Run those seven through TLCTC and the document quietly proves the entire thesis of this article — on itself.

SP 800-207 §5 ThreatTLCTC Cluster(s)The Structural Critique
5.1 Subversion of ZTA Decision Process (compromise of PE/PA)#4 → #1 (+#2)Zero Trust’s own decision brain is an attack surface. The enforcer is in-scope for the same 10 clusters as everything it protects.
5.2 Denial-of-Service or Network Disruption (Mirai, route hijack, PE/PA offline)#6 (+#5)NIST names DoS as a top ZTA threat — the exact cluster ZT structurally cannot address. The coverage gap is admitted in NIST’s own text.
5.3 Stolen Credentials / Insider Threat (“phishing, social engineering… to obtain credentials”)#9 → #4 (+#1) — or no cluster (Abuse of Rights)NIST runs acquisition and use together. TLCTC’s credential duality (Axiom X, R-CRED) splits them cleanly: obtain via #9, apply via #4. And #9 is the second cluster ZT can’t touch. “Insider threat” is not a category either: an insider outside their grant is the Attack row like anyone else; an insider inside a genuine entitlement is Abuse of Rights — operational risk, no cluster, no SRE.
5.4 Visibility on the Network (encrypted traffic opaque to inspection)enables #7 (+#5)ZT’s own encryption tenet (Tenet 2) degrades DETECT against malware command-and-control. A blind spot the architecture creates for itself.
5.5 Storage of System and Network Information (telemetry + policy store become targets)#2, #4, #1The state information Tenet 7 mandates collecting becomes the attacker’s reconnaissance jackpot. The control generates the target.
5.6 Reliance on Proprietary Data Formats / Solutions (vendor lock-in)— (no cluster)This is not a threat. It is a resilience and governance concern with no exploitable generic vulnerability — mis-filed under “Threats.” The cause-side partition would file a vendor outage in the Failure row: operational risk, no actor, no cluster.
5.7 Non-person Entities in ZTA Administration (“induce or coerce an NPE”; impersonate the agent)#1, #4Manipulating or impersonating the AI/automation that runs the policy plane — the agentic frontier, and again a cause-side story TLCTC can name.

Three structural facts fall out of this table, and each sharpens the critique rather than softening it.

1. The enforcer is not exempt (5.1, 5.5, 5.7)

“Never trust, always verify” is a rule about resources. But the Policy Engine and Policy Administrator — the components that do the verifying — are themselves resources. SP 800-207 §5.1 concedes this directly: a compromised PA “could allow access to resources that would otherwise not be approved.” In TLCTC terms, subverting the control plane is a textbook #4 → #1 path: steal an administrator identity (#4), then abuse the legitimate configuration functions of the PE (#1). The trust brain sits above the data plane it governs, and nothing in the “Zero Trust” label tells you to point the 10 clusters back at it. The architecture that abolishes implicit trust rests on a component that is implicitly trusted.

View High-Res
Who Verifies the Verifier? SP 800-207 §5.1: subverting the ZT decision process is a #4 → #1 path against the control plane. Attacker @External CONTROL PLANE — “the component that enforces never-trust” Policy Engine (PE)decides access Policy Admin (PA)configures paths #4 #1 steal admin identity → abuse config functions governs ↓ DATA PLANE PEP → Resource PEP → Resource PEP → Resource The architecture that abolishes implicit trust rests on a component that is implicitly trusted.
Figure 5: The control-plane recursion. Subverting the Policy Engine / Policy Administrator (SP 800-207 §5.1) is a #4 → #1 attack path aimed at the very component that enforces “never trust.”

2. NIST’s threat list lands on the clusters ZT cannot cover (5.2, 5.3)

The next section of this article shows that Zero Trust has no structural reach into #6 (Flooding) or #9 (Social Engineering). NIST’s own threat catalogue arrives at the same two clusters independently. §5.2 devotes several paragraphs to DoS and DDoS against the PEP and PA — naming the Mirai botnet by name — which is #6 aimed squarely at the single point of failure ZT introduces. §5.3 opens with attackers using “phishing, social engineering, or a combination of attacks to obtain credentials,” which is #9 feeding #4. The same section folds “insider threat” into the heading, and the v2.5 partition shows why that label cannot carry weight: it is a mixture of two rows — Attack (insider outside their grant, classified like any outsider) and Abuse of Rights (insider inside a genuine entitlement, operational risk, no cluster) — that answer to two different control regimes. The two clusters ZT structurally cannot address are precisely the two NIST felt compelled to warn about. The coverage gap is not our inference — it is corroborated in NIST’s own document.

3. One “threat” is not a threat at all (5.6)

§5.6, “Reliance on Proprietary Data Formats or Solutions,” describes vendor lock-in: interoperability friction, switching cost, the danger of being “locked into a subset of providers.” NIST itself notes this “risk is not unique to ZTA.” It is real — but it is a resilience and governance concern, not a threat. There is no generic vulnerability an attacker exploits, no cause-side condition, no cluster. Ask the partition’s three questions and it never reaches the Attack row: a vendor that fails or walks away is the Failure row, operational risk. It belongs in GOVERN and in supply-chain risk management, not in a threats section. And yet there it sits, filed alongside genuine cause-side threats like credential theft and DoS.

The Thesis, Demonstrated in NIST’s Own Text

Without a cause-based taxonomy, even the authoritative document cannot reliably tell a threat from a non-threat. §5.6 files a governance concern under “Threats” because there is no structural test to catch the category error. This is the Kreinz Thesis in miniature: the industry enumerates, but it does not diagnose — and enumeration without a cause-based classifier cannot even keep its own categories clean. TLCTC supplies the missing test: what generic vulnerability does the attacker exploit? Apply it to §5.6 and the answer is “none” — which is exactly why it does not belong in a list of threats.

So NIST’s Section 5 is not a counterexample to this article — it is a case study for it. Seven entries, and TLCTC classifies six of them onto specific clusters, exposes one as a mis-filed non-threat, and along the way shows that the framework’s own control plane and its two structural blind spots are hiding in plain sight. The threats section of the definitive Zero Trust document is itself a taxonomy waiting to be written.

What Zero Trust Does Not Address

The decomposition also reveals coverage gaps that are rarely discussed in ZT literature:

  • #9 (Social Engineering): Zero Trust architectures have essentially no direct control against #9. You cannot “always verify” a human whose psychological factors are being exploited. Phishing awareness training and procedural verification are the controls for #9’s generic vulnerability — and they are not part of any ZT architecture specification. This is a structural blind spot, not a marketing omission.
  • #2 (Exploiting Server): Server-side implementation flaws (buffer overflows, injection, logic errors) are addressed by secure coding and patching, not by ZT architectural controls. ZT can limit the blast radius after a #2 exploitation (consequence side), but it does not reduce the generic vulnerability itself.
  • #6 (Flooding Attack): DDoS mitigation is capacity planning, rate limiting, and CDN distribution — none of which follow from the “never trust, always verify” principle. The generic vulnerability, finite capacity limitations inherent in any system component, sits outside ZT’s structural reach.

This does not make Zero Trust incomplete by design — it means it was never intended to be a comprehensive threat coverage strategy. It is a design constraint on a subset of the threat landscape, and the TLCTC decomposition makes visible exactly which subset.

The Deeper Problem: Strategy Without a Threat Taxonomy

Zero Trust is not the only strategic concept suffering from this structural vacancy. Defense in Depth has the same problem — and the same cause.

Defense in Depth says: deploy multiple layers of controls so that no single failure leads to compromise. Zero Trust says: assume every layer might fail and verify at every transition. Both are valid GOVERN-level directives. Both constrain how controls are deployed across the architecture. And both are routinely adopted as “strategies” without ever specifying what threats the layers or verification points are meant to address.

This is the structural gap the cybersecurity industry has normalized. A CISO presents a “Defense in Depth strategy” with seven layers of controls. A board approves a “Zero Trust transformation roadmap.” But neither document contains a threat taxonomy. Neither maps controls to generic vulnerabilities. Neither specifies which clusters are addressed at which layer, or which attack paths the architecture is designed to interrupt. The strategy has no diagnosis underneath it.

The Kreinz Thesis Applied

Control-first regulation is logically impossible — a prescription without a diagnosis. The same logic applies to control-first strategy. “We implement Zero Trust” and “We practice Defense in Depth” are prescriptions. The diagnosis — “these are the generic vulnerabilities we are reducing, mapped to these clusters, under these CSF functions” — is almost universally absent. Not because organizations are lazy, but because the industry has never provided a stable, cause-based threat taxonomy to populate the diagnosis with.

This is the fundamental circularity: NIST CSF 2.0 correctly places GOVERN first and requires threat identification (ID.RA) before control selection (PR). But ID.RA has no standardized threat taxonomy to reference. MITRE ATT&CK provides techniques, not a strategic threat classification. STRIDE mixes causes with outcomes. ENISA’s threat landscape categories change year to year. So organizations skip the diagnostic step and jump straight to strategic labels — “Zero Trust,” “Defense in Depth,” “Assume Breach” — that sound like strategies but are structurally empty without the threat taxonomy that would give them operational meaning.

TLCTC fills that gap. With 10 clusters mapped to generic vulnerabilities, and since v2.5 a cause-side partition that says exactly which risk events those clusters apply to, a GOVERN-level decision like “Zero Trust” can be decomposed into specific control objectives per cluster per CSF function. Without it, the strategy remains a label. This is not a theoretical concern — it is the reason two organizations can both claim to “implement Zero Trust” while having entirely different control architectures, covering entirely different threat clusters, with no way to compare or audit them.

Why the Blurriness is Structurally Inevitable

The reason “Zero Trust” can never be semantically sharp is now clear. It is not positioned at any single node in the Bow-Tie. It is a meta-principle — a GOVERN-level directive that constrains how PROTECT and DETECT controls are deployed across multiple clusters simultaneously, and how RESPOND and RECOVER controls limit damage after compromise. It spans both sides of the pivot point. In TLCTC terminology:

  • It is not a threat (not a cause-side noun).
  • It is not a single control (not one cell in the 10×6 control matrix).
  • It is not an outcome (not a consequence-side concept).
  • It is not a row of the cause-side partition (it answers none of actor, intent, entitlement).
  • It is not even confined to one side of the Bow-Tie — it straddles the SRE pivot.

It is a design constraint on the control architecture — a statement about how seriously you take domain boundaries, responsibility spheres, and the assumption that any → transition in an attack path might succeed.

Practical Consequence: The Questions That Should Be Asked

“If a CISO says ‘we’re implementing Zero Trust,’ the TLCTC-informed follow-up question is: Which clusters does this target, under which CSF functions, with what control objectives — and are you addressing both sides of the Bow-Tie?”

If they cannot answer that, they are buying a label, not executing a strategy. The same test applies to Defense in Depth: which clusters does each layer address? Where are the structural gaps? Which attack paths can still traverse all layers without encountering a relevant control?

These are not unreasonable questions. They are the questions that GOVERN requires and that any mature risk management framework assumes have been answered before control selection begins. The fact that most organizations cannot answer them is not a failure of those organizations — it is a failure of the cybersecurity industry to provide the foundational taxonomy that makes the answers possible.

This is the Kreinz Thesis in its sharpest form: the industry has spent decades building control frameworks, compliance checklists, and strategic labels on top of a foundation that skips threat identification entirely. Zero Trust is the most visible symptom. Defense in Depth is another. Every regulation that mandates controls without identifying threats is another. The prescription is elaborate. The diagnosis is missing.

TLCTC exists to provide that diagnosis. With it, “Zero Trust” stops being a marketing term and becomes an auditable, decomposable architectural constraint — one that can be mapped to specific generic vulnerabilities, evaluated for coverage gaps, and compared across organizations. Without it, “Zero Trust” remains what it has been for the last decade: a label that means whatever the person using it needs it to mean.

References

  1. 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 R-SCOPE; §4 cluster definitions and generic vulnerabilities; §7.6 Data Risk Event refinement tree. tlctc-whitepaper.html
  2. Kreinz, B. Applying the Top Level Cyber Threat Clusters (TLCTC v2.5 Application), 2026. §8 TLCTC × NIST CSF 2.0 control matrix. tlctc-application.html
  3. Kreinz, B. Functions and Rights: Why One Is a Threat Cluster and the Other Is Not, tlctc.net, 2026. tlctc-functions-vs-rights.html
  4. NIST SP 800-207, Zero Trust Architecture (August 2020)
  5. NIST Cybersecurity Framework 2.0 (February 2024)
BK

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).