
An educational analysis of how endpoint detection and response platforms instrument the operating system, and why understanding that telemetry model matters for defensive professionals.
| Topic | Endpoint detection and response (EDR) architecture and the sensor-to-console telemetry pipeline |
| Category | Defensive architecture analysis |
| Primary Use | Understanding EDR sensor design, telemetry sources, and detection logic to strengthen detection engineering in authorized environments |
| Safe Use | Educational analysis for defenders and authorized security teams operating their own endpoints and detection labs |
| Telemetry Note | The article itself concerns telemetry: what EDR sensors collect, where it flows, and how defenders can validate coverage |
Endpoint detection and response platforms occupy a peculiar position in modern security architecture: they are simultaneously the most heavily deployed defensive control in enterprises and the most studied offensive target outside of the operating system itself. This essay is a defensive, educational walkthrough of how EDR products are actually built — where their sensors sit, what data they collect, how that data becomes detections, and why adversaries invest so much effort in understanding them. The goal is architectural literacy for authorized security teams, not an operator's manual.
Start with the sensor, because everything else in the EDR stack depends on it. A sensor is a privileged software agent installed on each endpoint — typically a Windows service running as SYSTEM, a kernel driver, or on Linux a daemon with equivalent access. Most commercial products use a layered design: a user-mode service handles orchestration, policy enforcement, and communication with the cloud console, while a kernel-mode component — often registered as an ETW consumer, a minifilter for file system visibility, or a network filter driver — captures events that user mode cannot see reliably. The split matters because each layer has different visibility and different failure modes, and detection coverage gaps frequently trace back to which layers a vendor chose to instrument.
The single most important telemetry source on modern Windows is Event Tracing for Windows, the kernel-level tracing framework that providers like Microsoft-Windows-Kernel-Process, Microsoft-Windows-Threat-Intelligence, and Microsoft-Windows-DotNETRuntime expose. When a process is created, a thread injects into another process, a driver is loaded, or a .NET assembly is loaded via reflection, ETW providers emit structured events that EDR sensors subscribe to. Alongside ETW, sensors parse kernel callbacks — PsSetCreateProcessNotifyRoutine for process creation, ObRegisterCallbacks for handle operations — and consume classic sources like Sysmon style event logging, AMSI content inspection for script and PowerShell interpretation, and file system filter events. The result is a firehose: a single busy endpoint can generate tens of thousands of events per minute, most of them entirely benign.
That volume explains the next architectural stage: the local pipeline. Raw kernel events are buffered, normalized into a vendor schema — process GUIDs rather than PIDs, canonical file paths, signature status — and enriched locally before anything leaves the machine. Enrichment might mean checking file reputation caches, hashing binaries, correlating a process creation with its parent chain, or evaluating a local rules engine that can block without a round trip to the cloud. This local decision tier is critical: it is what allows an EDR to quarantine a file within milliseconds of an observed behavior, and it is also where defenders should focus when tuning false positives, because behavior that gets filtered locally never reaches an analyst's queue.
From the sensor, telemetry flows to a cloud backend — the console that detection engineers and incident responders actually interact with. Architecturally this tier does the heavy correlation: joining process trees across hosts, matching behavioral patterns against detection rules, running retrospective searches over months of stored telemetry, and applying threat intelligence feeds. The retrospective capability is quietly one of the most powerful features of the platform category. Because raw events are retained, when a new indicator or technique becomes known, defenders can search historical telemetry for activity that was invisible at the time it occurred. This is why EDR coverage questions — did we log that registry path, did we capture that binary's hash — are questions about telemetry retention and schema, not just about detection rules.
How does an event become a detection? Most products combine several engines. Signature and indicator matching handles known-bad hashes, domains, and mutual exclusion keys. Behavioral analytics look for patterns: an office application spawning a scripting interpreter, credential access via unusual LSASS handle requests, mass file encryption behavior. Machine learning models score sequences of events. Finally, detection-as-code pipelines let vendors push new logic to sensors continuously. For detection engineers, the practical implication is that EDR efficacy is uneven across technique categories — commodity malware is heavily covered, while novel living-off-the-land abuse of signed binaries may generate no alerts at all, leaving only the raw telemetry as evidence.
Now to the uncomfortable half of the topic: why attackers study all of this. Publicly documented research — from vendor reports, conference talks, and the general discourse around evasion techniques — describes a persistent cat-and-mouse dynamic. Broadly, adversary efforts fall into categories that are useful for defenders to understand at a conceptual level: attempting to evade telemetry generation, attempting to blind sensors, blending into legitimate activity, and abusing the trust relationships the platform itself relies on. Understanding that these categories exist — without reproducing the specifics — helps defenders ask better questions of their vendors and design compensating visibility.
The defensive response to each category is instructive. If telemetry evasion is a concern, the answer is layered sources: an EDR that relies on a single ETW provider has a single point of failure, so mature programs add independent audit pipelines — Sysmon, native Windows security auditing, ETW-based collections, egress visibility from the network side. If sensor tampering is a concern, the answer is monitoring the sensor itself: agent health checks, alerting on service stop or driver unload events, and treating EDR self-telemetry as a high-value detection surface. If blending in is a concern, the answer is baselining: knowing what normal powershell.exe usage looks like in your estate makes anomalous usage stand out regardless of whether it triggers a vendor rule.
There are genuine architectural limits worth acknowledging honestly. EDR products compete for the same kernel interfaces attackers study, which means visibility and evasion research target the same substrate. Coverage of non-Windows platforms historically lags, with Linux and macOS telemetry often shallower. And heavy reliance on cloud connectivity means that offline endpoints degrade to whatever local rules exist — a real consideration in segmented OT and industrial environments. None of these limits invalidate the platform category, but they shape where defenders should invest in redundant tooling.
For authorized security teams, the practical takeaways are concrete. Validate coverage regularly through purple-team exercises in lab environments, mapping observed telemetry against a framework like MITRE ATT&CK to find blind spots. Review vendor detection logic where transparent, and ask hard questions about telemetry schema and retention — because during an incident, the raw event stream matters more than the alert stream. Monitor the sensors themselves as crown-jewel assets. And treat public evasion research not as a menu of attacks but as a free audit of your architecture: every technique category documented publicly is a prompt to ask which of your visibility layers would still see the underlying behavior.
The broader lesson is that EDR is not a product you install and forget but an instrument you tune. Its sensors see remarkably deeply into the operating system, its pipelines make that visibility searchable and retrospective, and its weaknesses are as well studied by adversaries as its strengths are marketed by vendors. Defenders who understand the architecture — the drivers, the ETW providers, the local rules engine, the cloud correlation tier — are in a far better position to detect the adversary who understands it too. That literacy, not any single tool or rule, is what this essay aims to support.
Educational analysis for authorized security professionals. Use only in controlled, authorized environments.
Related coverage
0 comentários:
Post a Comment
Note: Only a member of this blog may post a comment.