A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT&CK

summary

The gist

Mapping observed system behavior to standardized frameworks like MITRE ATT&CK is essential for threat-informed defense…

In short

The research developed Trace2ATT&CK, a pipeline that automatically maps low-level kernel events to MITRE ATT&CK techniques. It uses eBPF to collect telemetry, builds a provenance graph to show attack relationships, and creates compact command graphs for LLMs. This method shows that system behavior can be classified directly from host data without manual threat intelligence.

Key concepts

eBPF
A technology used to collect deep, kernel-level events on a Linux system. It allows the system to observe exactly what commands are being executed by processes in real-time, providing the raw data needed for attack reconstruction.
Provenance Graph (PG)
A directed graph structure that maps out how different entities (like processes and commands) relate to each other during an attack. It preserves the causal history of an event, allowing analysts to trace the entire sequence from entry point to final action.
Command-Graph Representation
A simplified, weighted version of the attack sequence derived from raw telemetry. This representation reduces redundancy by normalizing commands, making it small enough to fit into an LLM's context window while retaining essential causal relationships for classification.

Terminology used across episodes

This episode discusses

The paper

A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT&CK · Read on arXiv

Matteo Lupinacci, Luigi Arena, Francesco Blefari, Angelo Furfaro

University of Calabria

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: I'm Nadia.

Elias: And I'm Elias, here with Priya.

Nadia: We're looking at the paper: "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT&CK".

Elias: Here's the gist of the paper. Mapping observed system behavior to standardized frameworks like MITRE ATT&CK is essential for threat-informed defense, but remains largely manual The authors present a methodology that collects kernel-level events via eBPF, correlates attacker commands into a provenance graph, and derives compact graph representations suitable for LLM-based reasoning This methodology offers a different perspective from CTI-based approaches by observing and classifying attacker behavior directly from the system itself The proposed approach is validated using the Linux Atomic Red Team tests The paper introduces Trace2ATT&CK, an end-to-end pipeline that implements the methodology for automatic mapping of kernel-level host telemetry to MITRE ATT&CK tactics and techniques This pipeline combines eBPF-based telemetry collection, attacker-session anchoring, provenanceaware attack reconstruction, command–event correlation, and the extraction of raw and compressed weighted commandgraph representations for downstream LLM-based reasoning The process involves four stages: (1) kernel-level telemetry collection via eBPF, (2) PG construction in a graph database build with neo4j, (3) commandsequence extraction and graph serialization using custom Cypher query, and (4) LLM-based ATT&CK classification using either pure LLM prompting or RAG.

Nadia: Data Representation and Correlation The core of the approach is the Provenance Graph (PG), which preserves causal relationships between system entities, enabling analysts to trace attack entry points and reconstruct scenarios with high-level semantics The PG is defined as a directed graph G = (V, E) where V ⊆ P ∪ C ∪ F is the set of nodes, and E = Ø t ∈T Rt ∩ (V ×V) is the set of edges The authors use a process-centric community as the analytical unit for attack reconstruction, capturing activity concentrated around master processes Furthermore, they derive two weighted command graph representations: a Full weighted command graph preserving original instances and a Compressed weighted command graph reducing redundancy by normalizing commands.

Elias: Classification Paradigms and Evaluation The methodology supports two complementary LLM paradigms for classification: pure LLM prompting and Retrieval-augmented generation (RAG) RAG operates by dynamically retrieving relevant ATT&CK technique descriptions from a local Chroma vector store to provide factual context to the LLM, which has been shown to reduce hallucination without requiring fine-tuning The evaluation tests the system on 347 Linux Atomic Red Team tests using locally deployed open-weights LLMs Results show that RAG consistently improves ATT&CK mapping performance over pure prompting, while provenance graph substantially outperforms raw telemetry.

Nadia: Key Findings and Limitations The evaluation demonstrated that the choice of command-graph representation significantly affects classification quality, with the compact command-graph representation avoiding failure modes seen with full provenance graphs under context limits Furthermore, taxonomy-grounded prompting consistently yields higher scores across all models and settings compared to base LLM prompting The results also indicate that the finer-grained sub-technique attribution capability is more dependent on observing the complete adversarial procedure, as performance on failed attacks widens substantially at this level.

Title and authors: Nadia: So we're talking about this paper today, "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT andCK." It looks like it tackles that big problem where mapping system behavior to things like MITRE ATT andCK is supposed to be automated but actually still requires a lot of manual work.

Elias: Exactly. The title tells us the core idea: they are using a graph-based approach to connect low-level kernel events, which is kernel telemetry, directly to those established attack frameworks. It points out that current methods mostly rely on Cyber Threat Intelligence reports, which is second-hand information about attacks already happened <ref:2609.12841#pg2>.

Priya: And from a data perspective, the paper seems focused on how to take that massive volume of low-level kernel system calls and turn it into something usable for automated classification. I wonder what the actual signal is in all that raw telemetry <ref:2609.12841#pg2>.

Nadia: Right. The summary says they collect kernel events using eBPF, build a provenance graph to track attacker commands, and then create compact graph representations that LLMs can use for reasoning <ref:2609.12841#pg1>. It’s about moving from raw data to a structured representation for the AI to digest.

Elias: They are building this Provenance Graph, which they define as a directed graph where the nodes are things like processes and commands, and the edges show the causal relationships between them <ref:2609.12841#pg1>. This structure is supposed to preserve those causal links so you can trace how an attack started.

Priya: Tracking causality in a graph sounds powerful for reconstructing scenarios, but what kind of data are they feeding into this? Is it just system calls, or are there other things being tracked that might introduce noise <ref:2609.12841#pg2>?

Nadia: They specifically mention building a process-centric community as the unit for attack reconstruction, which means they’re focusing on activity clustered around master processes <ref:2609.12841#pg1>. They also derive two types of weighted command graph representations: a full one and a compressed one that reduces redundancy <ref:2609.12841#pg1>.

Elias: That compression part is interesting, because it’s designed to reduce the size of the graph without losing the essential attack information, making it suitable for things like LLM reasoning <ref:2609.12841#pg1>. It moves away from just looking at every single raw event.

Priya: I’m thinking about what that means for trust. If we can't see all the raw kernel calls, and we are relying on this graph representation to map to ATT andCK, how do we know if the mapping is accurate or if it’s missing something critical <ref:2609.12841#pg3>?

Title and authors: Nadia: The paper addresses that by showing they use two different ways for the LLM to classify things: either pure prompting or retrieval augmented generation, which is RAG <ref:2609.12841#pg3>. RAG lets the LLM look up specific ATT andCK descriptions from a local vector store to give it factual context <ref:2609.12841#pg3>.

Elias: And they found that RAG tends to improve the mapping performance over just pure prompting, which is interesting because it suggests external knowledge retrieval helps ground the classification <ref:2609.12841#pg3>.

Priya: So, what are the actual results on this? I need to know if this graph approach actually beats what we have right now when we test it against real attack scenarios <ref:2609.12841#pg2>.

Nadia: They validated the system by testing it on three hundred forty-seven Linux Atomic Red Team tests, which is a good set of standardized tests five. The results showed that RAG consistently improved ATT andCK mapping performance over pure prompting <ref:2609.12841#pg3>.

Elias: But they also found something specific about the graph structure itself. They noted that the compact command-graph representation was key because it avoided failure modes seen with the full provenance graphs when context limits were hit <ref:2609.12841#pg3>.

Priya: That makes sense from a measurement standpoint. If you feed a model too much data, it gets confused, so reducing redundancy seems like a practical engineering solution for keeping the inference usable <ref:2609.12841#pg3>.

Nadia: They also found that taxonomy-grounded prompting yields higher scores across all models and settings compared to just base LLM prompting <ref:2609.12841#pg3>. And they also pointed out that getting the finer-grained sub-technique attribution capability really depends on observing the entire adversarial procedure <ref:2609.12841#pg3>.

Elias: So, when you look at the numbers, they used Hit Rate at K, Mean Reciprocal Rank at K, and Normalized Discounted Cumulative Gain at K to measure how good the system was doing <ref:2609.12841#pg3>. These metrics help quantify the performance of the classification system <ref:2609.12841#pg3>.

Priya: I’m interested in what they said about successful versus failed attacks too. Does the system still provide useful information even when an attack doesn't fully execute, like during triage? <ref:2609.12841#pg3>.

Nadia: Yes, the results also indicated that technique-level triage remains useful even when the underlying attack does not fully execute <ref:2609.12841#pg3>. That means this isn't just for catching successful breaches, it helps with early warning too.

Title and authors: Elias: So the conclusion is that this method makes automated mapping from kernel-level telemetry operationally viable without compromising data confidentiality, which is a big deal <ref:2609.12841#pg3>. It bridges that gap between low-level host evidence and high-level threat classification.

Priya: So what does this mean for us on the ground? If we can automate this mapping from kernel events, it means we can get faster, more consistent attribution than just reading through manual CTI reports <ref:2609.12841#pg2>.

Nadia: That’s the point. We are moving from a labor-intensive process to something that uses local inference over graph-based behavioral descriptions <ref:2609.12841#pg3>. The compact command graphs are specifically what keeps the context budget manageable for local models <ref:2609.12841#pg3>.

Elias: And the frontier model validation confirmed that this whole pipeline is sound, suggesting the limitation wasn't really in the method itself but maybe just in how big of a model we were using to run it locally <ref:2609.12841#pg3>.

Priya: Before we wrap up, I think the real value here is that RAG seems particularly helpful for disambiguating those subtle behavioral variants, which is where things get fuzzy in the real world <ref:2609.12841#pg3>.

Nadia: It really does. So to summarize "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT andCK," we have a system that takes kernel events via eBPF, builds a provenance graph of attacker commands, and uses compact graph representations with RAG or taxonomy prompting to map them to MITRE ATT andCK techniques <ref:2609.12841#pg1>.

Elias: The core idea is using a process-centric community for reconstruction and deriving weighted command graphs, one full and one compressed, for LLM reasoning <ref:2609.12841#pg3>. It shows that this approach can reliably infer MITRE ATT andCK techniques from kernel-level telemetry via LLM reasoning over those reconstructed provenance graphs <ref:2609.12841#pg1>.

Priya: And it seems the compact command graphs are the key to reliable local inference because they never exceed the context budget and thus always yield a usable candidate list <ref:2609.12841#pg3>.

Nadia: It’s a solid methodology that connects low-level host evidence to high-level threat classification without needing massive, centralized analysis platforms for every single event <ref:2609.12841#pg2>.

Elias: So the implication is that this kind of local inference over graph-based behavioral descriptions can make automated ATT andCK mapping from kernel-level telemetry operationally viable <ref:2609.12841#pg3>.

Priya: It’s a step towards making threat intelligence more immediate and less reliant on slow, retrospective report analysis <ref:2609.12841#pg2>.

Nadia: That’s what we have with this paper, "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT andCK." We’ll keep watching how these eBPF and graph methods evolve in the coming months.

The paper's summary: Nadia: So, we're looking at this paper, "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT andCK." Essentially, they've figured out a way to take raw data from the Linux kernel—the actual system calls—and turn it into something we can map directly onto the MITRE ATT andCK framework.

Elias: It tackles that manual mapping problem, right? The authors use eBPF to collect those kernel events, build this whole Provenance Graph, and then they derive two kinds of weighted command graphs for the Large Language Model to reason over.

Priya: So it's moving away from just looking at raw logs and building a structured causal map instead. They define the graph where nodes are things like processes or commands, and edges show how they relate to each other.

Nadia: Exactly, that Provenance Graph preserves the causal relationships, which means you can actually trace the whole attack entry point and reconstruct what happened with high-level meaning. They focus their analysis around a community of processes, which is where the attacker's activity is usually concentrated.

Elias: And they generate these weighted command graphs—one full one keeping every single instance, and another compressed one that reduces redundancy by normalizing the commands. That compression part is key for making it fit into what an LLM can handle without running out of memory.

Priya: I'm thinking about what this means for trust, though. If we rely on this graph representation to classify something as a specific MITRE technique, how do we know that mapping is actually correct? What kind of data are they feeding into the classification step?

Nadia: They use two paths for the Large Language Model to do the classification. One is just pure prompting, and the other is Retrieval Augmented Generation, or RAG. RAG lets them dynamically pull in descriptions of specific ATT andCK techniques from a local vector store to give the Large Language Model factual context.

Elias: The results show that RAG actually performs better than just pure prompting when it comes to mapping things out. It seems like having that external knowledge retrieval helps ground the classification and reduces errors or hallucination.

Priya: That’s helpful, but they also showed that the choice of graph representation matters a lot for the final quality. They found that the compact command graph representation avoids certain failures you see when you use a full provenance graph, especially when context limits are being hit.

Nadia: And they didn't just stop there; they tested it on three hundred forty-seven Linux Atomic Red Team tests. The results confirmed that RAG consistently improved their mapping performance over pure prompting, and the Provenance Graph itself was much better than just using raw telemetry data.

Elias: They also found that when you use taxonomy-grounded prompting—basically giving the model specific categories to stick to—you get higher scores across all models and settings compared to just a base Large Language Model prompt. That suggests structure helps the inference process a lot.

Priya: So, what does this mean for someone on the ground who isn't deep in graph theory? Does this actually translate into something useful for threat hunting or defense right now?

Nadia: It means that local inference over these graph-based behavioral descriptions can make automated mapping from kernel-level telemetry operationally viable. They are bridging that gap between seeing low-level host evidence and getting a high-level threat classification.

Elias: The authors conclude that the compact command graphs are really what make reliable local inference work because they stay under the context budget, so they always give you a usable candidate list for the model to pick from.

Priya: It’s a step toward making threat intelligence more immediate and less reliant on slow, retrospective report analysis. It moves the analysis closer to the actual event happening on the system.

Nadia: That's what this paper presents: a pipeline that collects system calls via eBPF, reconstructs attacker process trees into a provenance graph, and uses those compact command graphs with RAG or taxonomy prompting to map them to MITRE ATT andCK techniques.

Elias: The core idea is using a process-centric community for reconstruction and deriving those weighted command graphs, one full and one compressed, for the Large Language Model to reason over. It shows that this approach can reliably infer MITRE ATT andCK techniques from kernel-level telemetry via LLM reasoning over those reconstructed provenance graphs.

Priya: The implication is that we can get faster, more consistent attribution than just reading through manual CTI reports because the system does the heavy lifting of structuring the evidence for us.

Nadia: So to sum up, this method uses eBPF to collect kernel events, builds a Provenance Graph of attacker commands, and then uses those compact graphs with RAG or taxonomy prompting to map them to MITRE ATT andCK techniques. It’s a solid methodology that connects low-level host evidence to high-level threat classification without needing massive centralized analysis platforms for every single event.

Elias: The frontier model validation confirmed the soundness of this whole pipeline, indicating that the limitation wasn't really in the method itself but maybe just in how big of a model you were using to run it locally.

Priya: It’s a step toward making threat intelligence more immediate and less reliant on slow, retrospective report analysis because you can get insights directly from the kernel activity.

The paper's improvements: Tom: So, we’re looking at how this paper suggests improving their method for mapping kernel telemetry to MITRE ATT andCK. It seems like they aren't just presenting a single system, but a whole way to make the process more robust and accurate.

Nadia: Right, so they are suggesting ways to get better results than just running the pipeline as it currently stands on test cases. They’re talking about making sure the output is trustworthy for actual defense work.

Elias: They point out that having different ways to classify the LLM—pure prompting versus Retrieval Augmented Generation—is a way to improve things, right? It’s like giving the model a reference book instead of just letting it guess.

Priya: That makes sense from a measurement standpoint. If RAG helps ground the classification, then we need to look at how that affects our Hit Rate and Mean Reciprocal Rank scores on those tests. Does it give us a bigger bump?

Nadia: The paper shows that RAG consistently yields better ATT andCK mapping performance over just using pure prompting across all their models. It seems like providing that factual context is genuinely beneficial for the classification accuracy.

Elias: And they also have some thoughts on the graph structure itself, specifically about the command-graph representations. They’re suggesting that choosing a compact representation is key because it avoids those failure modes you see when you use a full provenance graph under strict context limits.

Priya: So, they are saying that by reducing redundancy in the graph—by normalizing commands—you keep the system working reliably even when the model can't read everything at once. That’s a practical engineering fix for limited context windows.

Nadia: Exactly, and they also mention that taxonomy-grounded prompting performs better than just using a base Large Language Model prompt in all their settings. It’s about giving the model a better starting point for what kind of technique to look for.

Elias: And they flag that getting really fine-grained sub-technique attribution depends heavily on observing the entire adversarial procedure, meaning you need to see more of the attack chain than just a snapshot.

Priya: So, while RAG and good graph compression help with overall accuracy, they also remind us that if you want to be super precise about a tiny detail in an attack, you still need a very complete view of the entire flow.

Nadia: That’s the trade-off they're highlighting: improving general mapping versus achieving super granular sub-technique detail. It shows where the method stops being perfect and starts requiring more comprehensive data.

Elias: It suggests that as we build these systems, we need to think about both those different classification strategies and how to manage the data structure efficiently for local inference.

Priya: Before we wrap this up, what does all this mean for someone who only listens to the show? It means that automated mapping from kernel events is getting closer to being a reliable tool, but we still need those refinements in context management and classification strategy.

Conclusion: Nadia: So we’re wrapping up our talk on "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT andCK." To recap, they show how collecting kernel events via eBPF, building a process-centric provenance graph, and deriving weighted command graphs lets an AI map low-level host evidence to MITRE ATT andCK techniques.

Elias: Basically, it’s about bridging the gap between raw system calls and high-level threat classification using that structured graph data for reasoning. It moves the whole process from manual analysis to something automated.

Priya: Before we go, I want to ask what this really means for us in terms of privacy and measurement. Does this method actually show us what we need to know about an attack, or is it just creating a complex way to look at the same data?

Nadia: It does show us the causal flow. The provenance graph preserves those relationships between entities, which is crucial for understanding entry points in an attack. It’s not just raw noise; it's structured evidence that tells a story about the adversary.

Elias: They showed that using Retrieval Augmented Generation for the Large Language Model gives you better results than pure prompting. So, if we use this methodology, we should probably lean into RAG to get those more accurate mappings.

Priya: I agree with Elias on that point about grounding the model in external descriptions. It seems like a necessary step to ensure the AI isn't just guessing based on its training data when it sees a new sequence of commands.

Nadia: And they pointed out that using those compact command graphs is what keeps things stable for local inference, because it never exceeds the context budget, so you always get a usable candidate list. That’s the practical engineering win here.

Elias: It does sound promising for making automated mapping operationally viable without needing massive centralized systems just to analyze every single kernel event stream.

Priya: So, to summarize, we have a methodology that uses eBPF and graph databases to connect low-level host telemetry to MITRE ATT andCK techniques using RAG or taxonomy prompting. It’s a solid structure for when you can’t afford to store every raw data point.

Nadia: That’s the core of "A Graph-Based Approach for Mapping Kernel-Level Telemetry to MITRE ATT andCK." It connects the low-level evidence directly to high-level threat classification.

Elias: The implication is that we can get faster, more consistent attribution because we are using local inference over graph descriptions instead of relying solely on slow, retrospective report analysis.

Priya: I think it’s a step toward making threat intelligence more immediate and less reliant on slow report analysis because you get insights directly from the kernel activity.

Nadia: Exactly. We're moving toward systems where the mapping itself is automated and grounded in observable system behavior rather than just relying on what someone else told us happened.

Elias: It’s a good foundation for future work, though I wonder what happens when we try to scale this up to much larger systems or different operating environments.

More episodes

← Home