Framework Description Model (FDM)
Frameworks are classified by their primary purpose
| Type | Description |
|---|---|
| BEHAVIOR | Describes adversary tactics, techniques, and behavior |
| DEFENSIVE | Outlines countermeasures, hardening strategies, and defense-in-depth |
| COMPLIANCE | Captures regulatory controls and obligations |
| ASSESSMENT | Used in security assessments, threat modeling, and red/purple team testing |
| TAXONOMY | Defines abstract categories or logical groupings |
🌐 Global Conventions
The Framework Description Model (FDM) follows strict structural and formatting rules to ensure consistency across different frameworks and tools.
🧱 Structure & Hierarchy
- All frameworks are modeled as a strict tree. The root represents a globally unique framework namespace (e.g.,
MITRE-ATTCK). - Each item in the tree is a Node, and nodes are referenced using structured paths.
- Frameworks must have:
- Minimum depth:
1(top-level nodes are at depth 1;nodesis optional, so an empty framework also validates) - Maximum depth:
10(enforced by the@MaxFrameworkDepthvalidation, default10)
- Minimum depth:
📁 Path Conventions
| Path Type | Format Example | Description |
|---|---|---|
| Local Path | /TA0001/T1566/001 | Path inside a single framework (version and root inferred) |
| Absolute Path | MITRE-ATTCK~V17.1/TA0001/T1566/001 | Fully-qualified path including root and version |
| Absolute Agnostic Path | MITRE-ATTCK~/TA0001/T1566/001 | Absolute path that always resolves to the latest version of a node (resolved by api-mfs, not by NodePath; see below) |
| Version Format | V1, V1.0.2, V1.0.2-beta | In an absolute path: V followed by up to three dot-separated numbers and an optional -suffix |
- Paths must use
/as the only separator — no trailing slashes. - Path segments must match:
^[A-Z0-9-]{2,30}$ - Absolute paths require a version with a
Vprefix (for exampleV17.1). A frameworkversionsuch as2024.07is still valid on the framework itself. The patterns are in the validation rules.
Paths are validated in com.esprofiler.models.common.Constraints:
PATH_LOCAL_REGEX:^(?:/[A-Z0-9-]{2,30}){1,10}$PATH_ABSOLUTE_REGEX:^(?<root>[A-Z0-9-]{2,30})~(?<version>V[0-9]+(?:\.[0-9]+){0,2}(?:-[A-Za-z0-9-]+)?)(?<local>(?:/[A-Za-z0-9-]{2,30}){1,10})$PATH_VERSION_REGEX(the frameworkversionfield, looser than the version inside an absolute path):^(?=.{2,30}$)[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*$
🔁 When to Use Version-Agnostic Paths (~)
Version-agnostic absolute paths (e.g. MITRE-ATTCK~/TA0001/T1566/001) are designed for scenarios where the most current structure of a node is desired, regardless of framework version.
| Use Case | Use Version-Agnostic Path |
|---|---|
| Threat modeling | ✅ |
| Capability mapping | ✅ |
| Persistent relationships | ✅ |
| Static reports or audits | ❌ Use version-specific |
| Version-pinned exports | ❌ Use version-specific |
NodePathdoes not parse version-agnostic paths:PATH_ABSOLUTE_REGEXrequires a version. The~form is handled in api-mfs (PathParser), which resolves it to the latest framework version.Think of
~like a "latest" tag in Docker — it always points to the most up-to-date structure of a node.
🏷️ Naming Conventions
- Node labels (e.g.,
TA0001) must match:^[A-Z0-9-]{2,30}$ - Node names (e.g.,
Initial Access) must:- Be between 2 and 100 characters
- Match:
^[\p{L}0-9&\/.,_()"' -]{2,100}$(letters of any script, digits, and& / . , _ ( ) " ', space and-)
📝 Descriptions & Metadata
- All descriptions support markdown format and must be between:
- 20–20,000 characters
- Frameworks may define up to 100 authors (each author
nameup to 100 characters) - Nodes may define up to 100 external references (
references)
🔗 Relationship Inheritance & Summarization
- Relationships defined at a node are inherited downwards by all children and descendants.
- Summarization must work in both directions:
- 🔼 Upwards: Relationships from ancestors should be visible at each node
- 🔽 Downwards: Relationships defined on children/descendants should also be summarized at their parents
📎 Examples
- A risk linked to
/TA0001applies to all children like/TA0001/T1566/001 - When viewing
/TA0001/T1566, summaries include risks from its parent (TA0001) and its children (001,002, etc.)
✅ These conventions ensure that frameworks are strictly validated, consistent, and query-efficient for real-time use in applications, APIs, and analytics platforms.
🔎 Why This Matters
This model enables you to store external relationships (e.g., risk, compliance, CVEs) in a flat table, and still perform meaningful joins against a branch of the tree.
SELECT * FROM risk_mapping WHERE node_id IN (lookup.getBranch("/TA0001/T1566"))
🌲 Tree-Structured Frameworks
Frameworks are modeled as hierarchical trees of Nodes. Each node:
- Has a unique label (e.g.
TA0001,T1566) - May have children, forming branches
- Can be referenced via structured paths
Example
MITRE-ATTCK~V17.1
├── TA0001 (Initial Access)
│ ├── T1566 (Phishing)
│ │ ├── 001 (Spearphishing Attachment)
│ │ └── 002 (Spearphishing Link)
📌 Node Paths & Identifiers
Framework nodes are uniquely referenced using path strings, supported by the NodePath class:
| Type | Example | Use Case |
|---|---|---|
| Local Path | /TA0001/T1566/001 | Internal lookup within a framework |
| Absolute Path | MITRE-ATTCK~V17.1/TA0001/T1566/001 | Globally resolvable path with version control |
| Absolute Latest Path | MITRE-ATTCK~/TA0001/T1566/001 | Globally resolvable path that always targets the latest framework version |
Each path maps to a hashed Location (NodePath.Location). Hashes are 32-bit xxHash (seed 0) of the local path (version and root are not part of the hash), so the same local path gives the same IDs in every framework version.
| Field | Description |
|---|---|
self | Hash of the node's full local path (e.g. /TA0001/T1566) |
parent | Hash of the direct parent's path; for a top-level node it equals base (and self) |
base | Hash of the top-level node (first path segment) the node sits under, used to group base branches |
family | Hash of / plus the node's own label, shared by every node with that label (e.g. all /.../001) |
chain | Hashes of every path prefix from the top-level node down to and including the node itself (an IntList) |
depth | Number of path segments (top-level nodes are 1) |
⚡ The PathLookup Engine
What is it?
PathLookup (com.esprofiler.models.common.PathLookup) is a high-performance, hash-indexed traversal and lookup engine that provides:
- 🔍 Branch lookup: The node itself plus all of its descendants
- 🔁 Ancestor lookup: All parents up to the top-level node (excluding the node itself)
- 🧒 Child lookup: Direct children
- 🧬 Family lookup: All nodes with the same label
- 🍃 Leaf lookup: All terminal nodes (no children)
- ⚡ Efficient dynamic and precomputed operation
Why It Matters
FDM nodes may be referenced externally in a flat relational table — such as risk mappings, compliance controls, or CVE links.
To retrieve all applicable relations for a branch (e.g. a tactic), we can use the PathLookup to:
- Retrieve all node identifiers (
inthash IDs) - Use these in a fast
WHERE id IN (...)query
🔑 This decouples the hierarchical framework structure from flat external mappings while maintaining high-speed query resolution.
✅ Supported Lookup Methods
Using com.esprofiler.models.common.PathLookup:
| Method | Description | Return Type |
|---|---|---|
getBranch(path) | 🎯 The node itself 🔽 All descendants (downwards). Ancestors are not included; use getAncestors for those | IntArrayList |
getAncestors(path) | 🔼 All parent nodes up to the top-level node (excludes the node itself) | IntArrayList |
getChildren(path) | 👶 Immediate children (1 level down only) | IntArrayList |
getFamily(path) | 🧬 All nodes in the framework sharing the same label (family group) | IntArrayList |
getLeafNodes() | 🍃 All leaf (terminal) nodes in the entire framework | IntArrayList |
getLeafNodes(path) | 🍃 All leaf nodes within the subtree of the provided path | IntArrayList |
getLocation(path) | 🧭 Returns the hashed Location object for a given path (String only) | NodePath.Location |
getBranch, getAncestors, getChildren, getFamily and getLeafNodes(path) each accept either a local path String or a NodePath. Unknown paths return an empty list. PathLookup also provides getLeafNodesObjects(), getAbsolute(path), getLocal(path) and isValidNodePath(path).
🚀 Example Use Cases
1. Get all external mappings for a technique and its children
SELECT * FROM mapping_table WHERE node_id IN ( ... getBranch("/TA0001/T1566") ... )
2. Find all risk scores related to a node's family
SELECT * FROM risk_scores WHERE node_id IN ( ... getFamily("/TA0001/T1566/001") ... )
3. Summarize all child findings for a tactic
SELECT * FROM findings WHERE node_id IN ( ... getChildren("/TA0001") ... )
4. Extract all unmapped leaf nodes
-- Get leaves not present in external mapping
SELECT * FROM framework_nodes fn
LEFT JOIN mapping_table m ON fn.node_id = m.node_id
WHERE m.node_id IS NULL
AND fn.node_id IN ( ... getLeafNodes() ... )
🧠 Precomputed vs. Dynamic Lookup
| Mode | Description |
|---|---|
| Precomputed | Caches every node's branch at init for instant getBranch lookup — best for static or filtered views |
| Dynamic | Traverses the tree on each getBranch request — ideal when memory is critical or branches change |
The boolean only controls the branch cache. The children, ancestor, family and node indexes are always built at construction.
You can instantiate PathLookup in either mode. The dropdown has an example and estimated timings for a framework of about 1,500 nodes.
PathLookup lookup = new PathLookup(framework, true); // precomputed
Example performance estimates
In typical JVM environments with ~1,500-node frameworks:
| Lookup Type | Precomputed Time | Dynamic Time |
|---|---|---|
getBranch() | ~0.005 ms | ~0.3–2.0 ms |
getAncestors() | ~0.005 ms | ~0.01–0.05 ms |
getLeafNodes() | ~0.01 ms | ~0.5–2.5 ms |
These are estimated times based on similar fastutil-optimized lookups and JVM performance — actual timings may vary depending on hardware, JVM tuning, and framework size.
Node State
Each node within a framework has a defined state indicating whether it is currently active and should be used, or whether it has been deprecated or replaced by newer framework nodes. To support this, every node includes a state field. If no value is provided, the state defaults to ACTIVE.
The state field is a polymorphic object:
- ACTIVE (default) — the node is active and should be used.
- DEPRECATED — the node will be removed in a future version.
- REPLACED — the node has been replaced by one or more other nodes, for example when one node is split for more granularity. The
replacementfield is a set of localNodePaths (1 to 100 entries, each must be a local path).
ACTIVE (default)
{
"type": "ACTIVE"
}
DEPRECATED
{
"type": "DEPRECATED"
}
REPLACED
{
"type": "REPLACED",
"replacement": [
"/TA0001/T1566"
]
}
📌 Developer Integration Summary
Built on fastutil for high-performance primitive collections
Uses 32-bit xxHash for consistent, compact ID mapping
Designed for frameworks with 10K+ nodes (design target; the library enforces no node-count limit)
Supports absolute and local path access
A full Cyber Kill Chain example and the field reference are in the dropdowns. The production Cyber Kill Chain FDM (prod-files/lockheed-martin/cyber-kill-chain/fdm_lm-ckc.json in data-fdm-converter) uses the root LHM-CKC, with phases PH-01 to PH-07 and the six courses of action as children of each phase.
RECON shows every node field, including a child node (DET) under nodes.
model: FDM:1.0.0
root: CYBER-KILL-CHAIN
version: V1.0.0
type: BEHAVIOR
privacy: PUBLIC
name: Cyber Kill Chain
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
licence: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
description: The Cyber Kill Chain® framework is part of the Intelligence Driven Defense® model for identification and prevention of cyber intrusions activity. The model identifies what the adversaries must complete in order to achieve their objective. The framework was created by Lockheed Martin as a model for defending computer networks based on military concepts.
authors:
- name: Lockheed Martin Corporation
website: https://www.lockheedmartin.com/
meta:
tags:
- SECURITY
- DEFENSE
- INTRUSION
nodes:
- node: RECON
name: Reconnaissance
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: The first stage of the Cyber Kill Chain involves the attacker identifying and researching the target. This includes harvesting email addresses, conference information, social relationships, and other information about the target organization. Attackers use various techniques such as social engineering, open-source intelligence (OSINT), and scanning tools to gather information about potential vulnerabilities and entry points.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/detection/detecting-adversary-reconnaissance-38160
- https://attack.mitre.org/tactics/TA0043/
meta:
tags:
- SECURITY
- DEFENSE
- INTRUSION
state:
type: ACTIVE
nodes:
- node: DET
name: Detect
description: In the Reconnaissance phase, adversaries inevitably generate noise while probing infrastructure or searching open sources. The Detect course of action focuses on identifying these pre-attack signals, such as scanning patterns in web logs or mentions of the brand in threat intelligence feeds.
- node: WEAPON
name: Weaponization
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: In the weaponization phase, attackers create a deliverable malicious payload to exploit the target's vulnerability. This often involves coupling an exploit with a backdoor into a deliverable payload, such as creating a malicious PDF document, Microsoft Office file, or other file format that contains the exploit code. This stage typically occurs with no direct interaction with the victim, often using automated tools to create the weaponized deliverable.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/malicious/weaponization-modern-malware-37950
- https://attack.mitre.org/techniques/T1587/
- node: DELIVERY
name: Delivery
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: The delivery stage involves transmitting the weaponized payload to the target. Common delivery vectors include email attachments, websites, USB drives, and other media. Phishing emails remain one of the most common delivery mechanisms, where attackers send emails that appear legitimate but contain malicious attachments or links. This is the point where the attacker's exploit is actually introduced to the victim's environment.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/phishing/phishing-attack-vectors-36142
- https://attack.mitre.org/tactics/TA0001/
- node: EXPLOIT
name: Exploitation
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: Once delivered, the exploitation stage begins when the weaponized payload is triggered, exploiting a vulnerability in the operating system, application, or server to execute code on the victim's system. This could involve exploiting software vulnerabilities, misconfigurations, or even human vulnerabilities through social engineering. The exploitation allows the attacker to gain a foothold in the target environment by executing the malicious code.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/detection/detecting-exploits-vulnerability-37352
- https://attack.mitre.org/tactics/TA0002/
- node: INSTALL
name: Installation
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: During the installation phase, the malware installs a backdoor or other persistent access mechanism on the victim's system. This allows the attacker to maintain access to the system even if the initial vulnerability is patched or the system is restarted. Common techniques include installing remote access trojans (RATs), rootkits, or other malware that can evade detection while providing persistent access to the compromised system.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/malicious/malware-persistence-mechanisms-39960
- https://attack.mitre.org/tactics/TA0003/
- node: COMMAND
name: Command and Control
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: In the Command and Control (C2) phase, the malware establishes a communication channel back to the attacker, allowing them to remotely control the compromised system. This typically involves outbound communication to attacker-controlled servers, often disguised as legitimate traffic to evade detection. C2 channels can use various protocols and techniques, including HTTP/HTTPS, DNS tunneling, steganography, or social media platforms, to blend in with normal network traffic while enabling the attacker to issue commands and exfiltrate data.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/detection/detecting-command-control-activity-38412
- https://attack.mitre.org/tactics/TA0011/
- node: ACTIONS
name: Actions on Objectives
createdOn: 2023-01-01T00:00:00Z
modifiedOn: 2023-01-01T00:00:00Z
description: The final stage of the Cyber Kill Chain is where attackers achieve their ultimate goals. This could include data exfiltration, data destruction, encryption for ransom, or using the compromised system as a launching point for further attacks. In this phase, attackers may move laterally through the network, escalate privileges, maintain persistence, and conduct internal reconnaissance to identify valuable assets. The specific actions taken depend on the attacker's motivations, which could be financial gain, espionage, sabotage, or other objectives.
url: https://www.lockheedmartin.com/en-us/capabilities/cyber/cyber-kill-chain.html
references:
- https://www.sans.org/reading-room/whitepapers/detection/detecting-data-exfiltration-39580
- https://attack.mitre.org/tactics/TA0010/
Framework fields:
| Field | Required | Constraints |
|---|---|---|
model | Yes | FDM: followed by a semantic version, e.g. FDM:1.0.0 |
root | Yes | Must match ^[A-Z0-9-]{2,30}$ |
version | Yes | 2-30 characters, dot-separated letters, digits and hyphens |
type | Yes | One of: BEHAVIOR, DEFENSIVE, COMPLIANCE, ASSESSMENT, TAXONOMY |
privacy | Yes | One of: PRIVATE, PROTECTED, PUBLIC |
name | Yes | 2-100 characters |
description | Yes | 20-20,000 characters |
createdOn, modifiedOn | No | ISO 8601 timestamps |
url, licence | No | Valid URLs |
authors | No | Up to 100, each with a name (up to 100 characters) and an optional email and website |
meta.tags | No | Up to 20 tags |
nodes | No | The top-level nodes |
Node fields:
| Field | Required | Constraints |
|---|---|---|
node | Yes | The node label, must match ^[A-Z0-9-]{2,30}$ |
name | Yes | 2-100 characters |
description | Yes | 20-20,000 characters |
createdOn, modifiedOn | No | ISO 8601 timestamps |
url | No | Valid URL |
references | No | Up to 100 URLs |
meta.tags | No | Up to 20 tags |
state | No | Defaults to ACTIVE, see Node State |
nodes | No | Child nodes |
Universal Framework Mapper Vision
Why ESProfiler is moving to a single framework engine that models any framework as a tree, and what it enables.
Relationship Definition Model (RDM)
The Relationship Definition Model (RDM) defines a standardized structure for expressing relationships between entities and framework nodes. It creates a consistent vocabulary for mapping capabilities, controls, or intelligence to taxonomic frameworks.

