Blog / Framework & Concepts

The Kill Chain Fallacy: Why Process is Not Taxonomy

The Cyber Kill Chain® revolutionized how we analyze incident timelines, but relying on it for Risk Management is a strategic error.

TL
TLCTC Team
• • updated • Loading read time... • TLCTC v2.6
Film No. 24: The Cyber Kill Chain (6:37, English captions). Lockheed Martin's model tells you when, not why: that is why you can run an incident on it, but not a control regime. Keep the chain and give it a second axis. The earlier film, The Chain and Its Links, walks one intrusion both ways.
Key Insight

To understand risk, we must distinguish the "When" (Kill Chain) from the "What" and "Why" (TLCTC).

For over a decade, the Cyber Kill Chain (CKC) has been the de facto standard for describing cyber intrusions. It provides a linear narrative: Reconnaissance → Weaponization → Delivery → Exploitation → Installation → C2 → Actions on Objectives. While invaluable for operational incident response, the CKC fails to answer the fundamental question of Risk Management: What is the underlying cause of the compromise?

Within the TLCTC framework, the Kill Chain is a process model, not a threat taxonomy. It answers one question very well: where in the intrusion are we? It leaves a second one open: what was exploited at this step? Attempting to use the phases for categorization creates ambiguity that breaks risk registers and attack path analysis. The fix is not to replace the Kill Chain, but to classify every step by its cause.

1. Why the Kill Chain Fails at Categorization

Effective Risk Management requires clear, non-overlapping categories rooted in causality. TLCTC enforces this through two axioms:

  • Axiom III (Causes, Not Outcomes): Threat clusters sit on the cause side of the Bow-Tie model and must not be conflated with outcomes such as "data breach" or "service outage."
  • Axiom VI (non-overlap): For every generic vulnerability there is one threat cluster; every attack step exploits exactly one generic vulnerability and maps to exactly one cluster.

The Kill Chain categorizes by phase of time, not by nature of the vulnerability exploited. Consider the CKC phase "Exploitation." To a risk manager, this label is insufficient. Exploitation of what?

CKC View — Phase: Exploitation

The attack is in the "Exploitation" phase. This tells us when it is happening (after Delivery, before Installation), but nothing about the nature of the threat or the control required.

TLCTC View — Cause: Vulnerability-Specific

TLCTC distinguishes what is being exploited, resolved by the R-ROLE rule:

  • #2 Exploiting Server — A code flaw on the server side (component accepts inbound requests).
  • #3 Exploiting Client — A code flaw in the browser or client application (component consumes external content).
  • #1 Abuse of Functions — Misuse of legitimate logic (no code flaw, no Foreign Executable Content).

And sometimes nothing in the code is exploited at all. A user persuaded to enable a macro lets foreign code run exactly as designed: that is #9 → #7, with no #2 or #3 in between. The Kill Chain still files it under "Exploitation."

The Consequence: If you categorize risks by Kill Chain phases, you cannot align controls. Controls for #2 (WAF, input validation, secure server-side coding) are entirely different from controls for #3 (browser isolation, client patching, sandboxing) or #1 (least privilege, logic constraints, function restrictions). Risk Management requires causal precision, which only a cause-oriented taxonomy provides.

2. The Problem with Attack Path Notation

The Kill Chain describes a sequence of stages, but modern attacks are sequences of causes. An attack path notation must describe the mechanics of each hop, not just the fact that a hop occurred.

In the CKC, "Delivery" is a phase. But how was the payload delivered? Was it via email (#9 Social Engineering — human vulnerability), a USB drive (#8 Physical Attack — physical access), or a compromised software update (#10 Supply Chain — third-party trust)? Each of these exploits a fundamentally different generic vulnerability and requires different controls. One phase, three causes.

In TLCTC, these three clusters — #8, #9, and #10 — are classified as bridge clusters: their generic vulnerabilities reside outside the software domain (physical, human, third-party) and commonly serve as responsibility-sphere transition pivots in attack paths.

Example: The "Phishing to Ransomware" Path

CKC Description:

Delivery → Exploitation → Installation → C2 → Actions on Objectives

TLCTC Notation (v2.6):

TLCTC Sequence
#9 ||[human][@External→@Org]|| →[Δt=24h] #7 + [DRE: C] →[Δt=5m] #4 →[Δt=15m] #1 →[Δt=2m] #7 + [DRE: Ac]

Reading the TLCTC path step by step:

  1. #9 (Social Engineering) ||[human][@External→@Org]||: A phishing email persuades a user to open the attachment and enable its macro — the human vulnerability. As a bridge cluster, #9 carries the attack across the boundary from the external sphere into the organization.
  2. →[Δt=24h] Velocity annotation: about a day passes between delivery and the click — time in which reporting, mail-filter retro-hunts and analyst triage still work.
  3. #7 (Malware) + [DRE: C]: The macro launches a loader. Foreign code runs as designed — no code flaw was exploited, so there is no #3 step and the Kill Chain's "Exploitation" box is empty. Per R-EXEC, #7 is recorded at the execution moment. The loader collects stored passwords: per R-CRED, credential acquisition belongs to the enabling step (#7) and is recorded as a confidentiality event, [DRE: C]. It also calls home — but command and control is a capability of malware already running, not a new step.
  4. →[Δt=5m] Five minutes from loader to login (VC-3: Operational).
  5. #4 (Identity Theft): The stolen password logs in. Per Axiom X and R-CRED, credential application is always #4, separate from its acquisition.
  6. →[Δt=15m] Fifteen minutes to the push (VC-3).
  7. #1 (Abuse of Functions): The administrator's own deployment tool pushes a file to every server — a designed function used for the attacker's purpose, no flaw involved.
  8. →[Δt=2m] Two minutes to encryption (VC-3).
  9. #7 (Malware) + [DRE: Ac]: The ransomware executes on each server. The deployment (#1) enables the execution (#7), so the order is known and the notation is sequential, #1 → #7, never a parallel group. [DRE: Ac] marks the outcome: the data is still present but unusable. Per Axiom III, the outcome is recorded as an event and does not change the cluster.

Where the Kill Chain sees one box at the end — Actions on Objectives — the path sees three causes, #4 → #1 → #7, each with its own control. And the path carries time: fifteen minutes from login to push is not a job for a ticket queue. It needs automation.

Why TLCTC is superior: The CKC notation is generic and phase-bound. The TLCTC notation is a precise blueprint of the attack path that maps directly to specific generic vulnerabilities (Axiom VI) with temporal context (Axiom IX: Δt measures velocity) — enabling direct alignment to controls at each step.

3. Integration into Risk Management (The Bow-Tie)

Risk Management relies on the Bow-Tie model: Threat (Cause) → Event → Consequence (Effect). The Kill Chain mixes these elements:

  • "Actions on Objectives" (Phase 7) mixes causes and outcomes. Ransomware running on your servers is a cause (#7); the data left unusable is an event ([DRE: Ac]); data leaving the company is a loss of confidentiality ([DRE: C]) attached to the step that caused it. Axiom III requires strict separation.
  • "Weaponization" (Phase 2) happens on the attacker's own machines. Nothing of yours is exploited, so there is no step to classify — that is the job of threat intelligence.
  • "Reconnaissance" (Phase 1) mostly reads what is already public: no step. Only when the attacker probes your systems (#1) or talks your people into telling (#9) does a step begin.
  • "Command and Control" (Phase 6) is no separate cause. The beacon calling home is a capability of malware that is already running (still #7); relaying commands through a legitimate cloud service is abuse of a function (#1).

TLCTC aligns perfectly with the left side (Cause) of the Bow-Tie:

  • For every generic vulnerability, there is exactly ONE threat cluster (Axiom VI).
  • This enables a clean 10×6 control matrix when mapped to the six NIST CSF 2.0 functions (Govern, Identify, Protect, Detect, Respond, Recover): sixty cells, where the Kill Chain's course-of-action matrix sorts controls by phase. See NIST CSF × TLCTC.

You can build a risk register based on #4 Identity Theft (generic vulnerability: insufficient binding, at the point of authentication, between a presented credential and the authentic holder of the identity it claims) or #2 Exploiting Server (generic vulnerability: server-side implementation flaws enable unintended behavior). You cannot build one based on "Reconnaissance" — because it describes when something happens, not what is wrong with your system.

4. The Verdict: Complementary, Not Competitive

Does this mean the Cyber Kill Chain is useless? Absolutely not. The two models serve different purposes and should be used as complementary layers in a comprehensive strategy.

The Synthesis: Use the Cyber Kill Chain for Operational Timeline Analysis and TLCTC for Strategic Threat Categorization and Risk Management.

How They Fit Together (Intelligence-Driven Defense)

When analyzing a campaign using the Kill Chain, use TLCTC to define the specific mechanics at each phase:

CKC Phase TLCTC Mapping Notes
Reconnaissance No step (passive) · #1 or #9 (active) Reading public information exploits nothing of yours. Probing your systems is #1; eliciting information from your people is #9.
Weaponization No step Happens on the attacker's own infrastructure; nothing of yours is exploited. A threat-intelligence topic, not a cluster.
Delivery #9, #8, #10, or #5 Depends on delivery mechanism: phishing (#9 — bridge/human), USB drop (#8 — bridge/physical), compromised update (#10 — bridge/third-party), network injection (#5 — MitM).
Exploitation #2 or #3 — or no step If a code flaw is exploited, R-ROLE decides: server-role → #2, client-role → #3. If a user is persuaded to run code (macro, attachment), nothing is exploited: the path goes #9 → #7.
Installation #7 Foreign Executable Content runs via the designed execution capability. Per R-EXEC, #7 is recorded at every execution moment.
C2 No new step (#7) · #1 via cloud relay The beacon is a capability of malware already running — part of its #7 step. Relaying commands through a legitimate cloud service is #1.
Actions on Objectives Several causes + DREs Credential use (#4), deployment through admin tools (#1), flooding (#6), ransomware execution (#1 → #7). The same cause turns up in other phases too: stolen credentials at the front door are #4 as well. Outcomes are DRE tags, never steps: [DRE: C], [DRE: I], [DRE: A], refined e.g. to [DRE: Ac] for encrypted data.

Velocity Classes Add Operational Precision

TLCTC defines four Velocity Classes (Axiom IX) that describe the defender's feasible response mode — a dimension the Kill Chain cannot express:

Velocity Class Typical Δt Primary Defense Mode
VC-1: Strategic Days → Months Log retention, threat hunting, strategic monitoring
VC-2: Tactical Hours SIEM alerting, analyst triage, guided response
VC-3: Operational Minutes SOAR/EDR automation, rapid containment, prebuilt playbooks
VC-4: Real-Time Seconds → ms Architectural controls, circuit breakers, rate limits, automatic isolation
The Kill Chain says break a link. The path says which link, and how fast.

If a critical transition is VC-3 or faster, purely human response is structurally insufficient. Controls must be automated or architectural. This is a structural truth the Kill Chain cannot surface because it has no temporal dimension between phases.

Key Takeaways for the CISO

  • Stop using the Kill Chain to structure your Risk Register. It describes time, not risk.
  • Start using TLCTC to categorize threats based on the generic vulnerability exploited (cause-oriented). Each of the 10 clusters maps to a single generic vulnerability, enabling precise control alignment.
  • Use TLCTC notation (#X →[Δt] #Y) to map Attack Paths, providing a precise definition of how trust boundaries are crossed and how fast the attacker progresses. Annotate with DRE tags to separate outcomes from causes.
  • Integrate the two: Use the CKC to tell the story of the attack timeline, and TLCTC to define the technical reality of the attack mechanics — including velocity, domain boundaries, and control requirements at every step.
  • The phase tells you where to watch. The cause tells you what to fix.

Document References

  1. Kreinz, B. Top Level Cyber Threat Clusters (TLCTC), Core Paper v2.6 — axioms, R-EXEC, R-CRED, R-ROLE, DRE refinement tree, velocity classes
  2. Kreinz, B. TLCTC Application Paper v2.6, §12 Harmonizing threat-modeling methods & standards
  3. Hutchins, E. M., Cloppert, M. J., Amin, R. M. Intelligence-Driven Computer Network Defense Informed by Analysis of Adversary Campaigns and Intrusion Kill Chains (Lockheed Martin, 2011)
  4. A Threat-Driven Approach to Cyber Security (Lockheed Martin, 2019)