In this section

Defender for Endpoint on Windows Server, Linux and macOS: Telemetry, Tier 0 Servers and Cross-Platform Hunting

Module 0

Introduction

Most of what this module has read came from Windows laptops, because that is where most of the estate's records are.

The estate also has Windows servers, a Linux web server facing the internet and a Mac, and each of them runs a different sensor, sends a different amount of evidence and needs controls the laptops do not. Treating them as larger or stranger laptops is the mistake Module 8 is written against.

This lesson measures what each platform sends, then reads one record from each kind of device that only makes sense once that measurement is known. The question for every device is the same: if something happened here, would the records show it?

1. Windows laptopsprocess, network, file, registry and device events2. Windows serversthe same sensor, used very differently3. Linuxa separate agent with its own event provider4. macOSa separate agent that needs extensions and permissions approved

One portal, four sensors, four different amounts of evidence.

The figure is the shape of the problem. One portal shows all four kinds of device, but behind it are different agents with different event sources, and an engineer has to know which records each one can produce before reading meaning into what it did not produce.

01

Four Platforms, Four Amounts of Evidence

What each kind of device sends

Counting each device's records in the main device tables, and grouping devices by the platform the inventory gives them:

union
    (DeviceProcessEvents | summarize Process = count() by DeviceName),
    (DeviceNetworkEvents | summarize Network = count() by DeviceName),
    (DeviceLogonEvents | summarize Logon = count() by DeviceName),
    (DeviceEvents | summarize Other = count() by DeviceName)
| summarize Process = sum(Process), Network = sum(Network),
    Logon = sum(Logon), Other = sum(Other) by DeviceName
| join kind=inner (DeviceInfo
    | summarize arg_max(Timestamp, OSPlatform) by DeviceName) on DeviceName
| summarize Devices = dcount(DeviceName), Process = sum(Process),
    Network = sum(Network), Logon = sum(Logon), Other = sum(Other) by OSPlatform
| order by Process desc

The record counts for each platform, largest first:

OSPlatform         Devices  Process  Network  Logon  Other
-----------------  -------  -------  -------  -----  -----
Windows11          16       9573     5959     1760   3684
WindowsServer2022  2        1        0        168    32
Linux              1        0        35       0      16
macOS              1        0        0        0      9

The 16 Windows laptops sent 9573 process records between them, about 598 each, plus network, logon and device events in the thousands. The two inventoried Windows servers sent 1 process record between them. The Linux web server sent network records and device events but no process records at all. The Mac sent 9 device events and nothing else.

Some of that difference is honest. A server that runs one service and is rarely logged on to starts far fewer processes than a laptop someone uses all day. But zero is not a small number.

A Linux server running a web application, a scheduled scan and an operating system starts processes constantly, and a Mac in daily use does the same. When a platform sends none, the sensor is not collecting them, or not sending them, and every hunt that needs them returns nothing on that device.

That is the first rule of this lesson: before reading silence from a device, measure what the device can say. The query above is the measurement, and it belongs beside lesson 0.2's coverage check in any estate report. A device that is onboarded and Active but sends no process events is covered in name only.

The inventory alone would never show this. Every one of these devices is Onboarded, and every one but the old Hargreaves entity is Active. Onboarding status says the agent is installed and reporting; it does not say what the agent is reporting about. Two devices with the same status can differ by thousands of records, and the difference is exactly the evidence an investigation would need.

There is also a reason this matters more for these platforms than for the laptops. Attackers know which devices are watched least. An internet-facing Linux server and a directory synchronization server are both high-value and both quiet, and this lesson finds the same two devices at the center of two of the estate's intrusions.

Module 8 takes each platform in turn, starting with the servers.

02

The Tier 0 Server

Sync credentials read, and no endpoint alert

SRV-NGE-MCR-AAD01 is the server that synchronizes the directory with Entra ID, which is why lesson 0.2 found it in its own Tier 0 device group. It sent very few records in the period. Every one of them that is not a scheduled scan, with the alert that followed:

union
    (DeviceLogonEvents | where DeviceName == 'SRV-NGE-MCR-AAD01'
    | project Timestamp,
        Record = strcat('logon ', AccountName, ' from ', RemoteDeviceName)),
    (DeviceProcessEvents | where DeviceName == 'SRV-NGE-MCR-AAD01'
    | project Timestamp,
        Record = strcat('process ', FileName, ' by ', AccountName)),
    (DeviceEvents | where DeviceName == 'SRV-NGE-MCR-AAD01'
        and ActionType == 'PowerShellCommand'
    | project Timestamp, Record = strcat('command ',
        tostring(parse_json(AdditionalFields).Command))),
    (AlertInfo | where Title startswith 'Directory synchronization'
    | project Timestamp, Record = strcat('alert from ', ServiceSource))
| project Time = format_datetime(Timestamp, 'MM-dd HH:mm:ss'), Record
| order by Time asc

The logon, the commands and the alert, in time order:

Time            Record
--------------  -----------------------------------
03-07 14:14:06  logon svc-admin from NE-THOMPSON-LT
03-07 14:18:33  process powershell.exe by svc-admin
03-07 14:18:33  command Import-Module
03-07 14:18:34  command Get-AADIntSyncCredentials
03-07 14:35:00  alert from AAD Identity Protection

On 7 March svc-admin logged on over the network from NE-THOMPSON-LT. Four minutes later PowerShell, hidden and without a profile, imported AADInternals and ran Get-AADIntSyncCredentials, a command that reads the credentials the synchronization service uses. About seventeen minutes after the command, Entra ID Identity Protection alerted on the directory synchronization account signing in from an unfamiliar location.

The endpoint sensor recorded every step. It raised nothing. The first alert came from the identity side, after the credentials had been taken and used.

On a laptop, a hidden PowerShell session loading a known offensive toolkit would be one signal among thousands; on a Tier 0 server that runs one service and is logged on to a handful of times a month, it is the only process in the period, and it should never have needed a built-in alert to be noticed.

That is the server lesson in one record. Servers are quieter than laptops, so anything on them stands out, and the controls that suit them are stricter: application control that permits only what the server's role needs, administrative logons only from privileged workstations, and custom detections for the handful of commands that should never run there.

Module 8 starts with server security architecture and domain controller protection for exactly this kind of host.

Note where the logon came from: NE-THOMPSON-LT, three days before the intrusion lesson 0.1 walked through on the same laptop. An administrative account used from an ordinary laptop is itself a finding for a Tier 0 server, because it means the server's protection is only as good as the laptop's. Privileged access workstations exist so that Tier 0 is administered only from devices held to Tier 0's standard.

There is a detection lesson here too. A custom detection that alerts on any process on this server outside its known service accounts would have fired on the one record above, and on nothing else in the month. On a quiet server, a narrow rule like that costs almost nothing in noise, which is exactly why servers deserve rules a laptop could never carry.

03

Linux, Facing the Internet

A server that reports connections but not processes

WEB-NGE-MCR-01 is the internet-facing Linux server from lessons 0.5 and 0.7. Everything it sent in the period, grouped by kind:

union
    (DeviceNetworkEvents | where DeviceName == 'WEB-NGE-MCR-01'
    | summarize Records = count()
        by Kind = 'network', Detail = InitiatingProcessFileName),
    (DeviceEvents | where DeviceName == 'WEB-NGE-MCR-01'
    | summarize Records = count()
        by Kind = 'device event', Detail = ActionType),
    (DeviceProcessEvents | where DeviceName == 'WEB-NGE-MCR-01'
    | summarize Records = count()
        by Kind = 'process', Detail = FileName)
| order by Records desc

The server's records, grouped by kind and largest first:

Kind          Detail                  Records
------------  ----------------------  -------
network       node                    34
device event  AntivirusScanCompleted  15
network       curl                    1
device event  AntivirusDetection      1

Network connections from node and curl, scheduled scans and the one antivirus detection. No process records. The sensor reports running version 101.24082.0004 with OS version 22.04, it is Onboarded and Active, and it sends no record of anything starting on the machine.

That changes what the earlier lessons could say about this server. Lesson 0.5 knew the coin miner was started by node only because the antivirus detection names its parent. Lesson 0.7 knew the server reached a known-bad address because network records exist.

How the attacker got from the web application to a shell, what else they ran and whether they are still there cannot be answered, because the records that would answer it were never sent.

On Linux, Defender for Endpoint gathers its extra events through a supplementary event provider. Microsoft's eBPF page describes the eBPF sensor as the default on supported agent versions, with Netlink as the fallback when eBPF is disabled or unsupported on a kernel; Netlink still captures process events but not file or socket events.

AuditD, the older provider, is no longer supported on current agent versions. Module 8's Linux lessons cover deploying the agent, checking which provider is active, and adding Sysmon for Linux where the estate needs more. For this server, the first job is finding out why the process records stop at nothing.

Being internet-facing raises the stakes. The inventory marks this server as reachable from the internet, which is where the attacker came from, and the one device on the estate where process records would have shown the initial access is the one that sends none.

A web server's first sign of compromise is usually its web application starting something it never should, a shell or a downloader, and that is a process record.

The scans and the detection show what does work: the antivirus engine on the server is running and acting, as lesson 0.5 found. Protection and telemetry are separate parts of the agent, and on this server one is working while the other is not. A health check that confirms only the first will report the server as fine.

04

The Mac

A sensor that reports only scans

NE-WEBB-MBP is the Mac whose scans lesson 0.5 found stopping on 9 March. The platform count already showed what else it sent: 9 device events, all of them scans, and no process, network or logon records at all, while the inventory reported its sensor as Active. Everything it sent, by kind:

DeviceEvents
| where DeviceName == 'NE-WEBB-MBP'
| summarize Records = count(), FirstSeen = min(Timestamp), LastSeen = max(Timestamp)
    by ActionType
| project ActionType, Records,
    FirstSeen = format_datetime(FirstSeen, 'MM-dd HH:mm'),
    LastSeen = format_datetime(LastSeen, 'MM-dd HH:mm')

The Mac's records, by kind, with the first and last of each:

ActionType              Records  FirstSeen    LastSeen
----------------------  -------  -----------  -----------
AntivirusScanCompleted  9        03-01 16:55  03-09 16:55

One kind of record, scheduled scans, and the last one on 9 March. For a device someone uses every day, that is not a quiet machine; it is a sensor that has never described the machine at all.

On a Mac the agent depends on the operating system's permission system more than on any setting in Defender. Microsoft's macOS policy page lists three things a managed deployment has to approve in advance: the endpoint security and network system extensions, the network filter, and Full Disk Access.

The page's reason is that Defender can then operate without prompting the user. On an unmanaged Mac or one where a profile was removed, those approvals depend on whoever is sitting at it.

The records here cannot say which approval is missing. They say that the agent is talking to the service, that scans ran until 9 March, and that nothing describing what the Mac did has ever arrived. Each of those is consistent with an agent that is installed and reporting health but not permitted to watch the system.

Module 8's macOS lesson covers deploying the profiles, checking the agent's own health report, and the records that should appear once it is working.

The Mac also shows why platform is not a detail in reporting. An estate dashboard counting onboarded, Active devices counts this Mac as covered. A dashboard counting devices that sent process events in the last day would not. Only the second one tells the truth about whether an intrusion on this machine would be seen.

Macs are often a small part of an estate and managed separately from the Windows fleet, which is a poor combination for a control that depends on approvals. The fix is rarely technical. It is a management profile deployed to every Mac, a check that the agent's records arrive, and a conversation with the device's owner when they stop.

05

One Hunt, Every Platform

What a cross-platform query can and cannot say

The device tables are shared across platforms, so one hunt can cover all of them. Every connection on the estate to the two known-bad addresses from earlier lessons, with the platform of each device:

DeviceNetworkEvents
| where RemoteIP in ('185.234.89.112', '45.137.21.88')
| summarize Connections = count() by DeviceName, RemoteIP,
    Process = InitiatingProcessFileName
| join kind=inner (DeviceInfo
    | summarize arg_max(Timestamp, OSPlatform) by DeviceName) on DeviceName
| project DeviceName, OSPlatform, RemoteIP, Process, Connections
| order by DeviceName asc

The devices that reached either address, with their platform:

DeviceName      OSPlatform  RemoteIP        Process         Connections
--------------  ----------  --------------  --------------  -----------
NE-THOMPSON-LT  Windows11   185.234.89.112  rundll32.exe    8
NE-THOMPSON-LT  Windows11   185.234.89.112  powershell.exe  1
WEB-NGE-MCR-01  Linux       45.137.21.88    node            34
WEB-NGE-MCR-01  Linux       45.137.21.88    curl            1

The hunt finds NE-THOMPSON-LT reaching 185.234.89.112 from PowerShell and rundll32, and the Linux web server reaching 45.137.21.88 from node and curl. One query, two platforms, two separate intrusions, which is the point of a shared schema: Module 8's unified hunting lesson builds on it. The same column names, RemoteIP and InitiatingProcessFileName, mean the same thing on Windows and Linux, so the hunt needed no platform-specific logic to find both.

The processes are worth reading as well. On the laptop it was PowerShell and rundll32, the scripting host and a system binary used to run attacker code. On the server it was node, the web application's own runtime, and curl. Each platform's attacker uses what the platform already has, which is why a hunt by destination finds both where a hunt by process name would find only one.

Now read what the result does not contain. The Mac is absent, but the Mac sends no network records, so its absence means nothing. The Windows servers are absent, and they send no network records either. The result is a statement about the laptops and the Linux server, and about no other device on the estate, however complete it looks.

That is the habit Module 8 asks for in every cross-platform query: state its reach before stating its result. A hunt that returns two devices out of twenty has searched only the devices that could have answered, and on this estate that is the laptops and one server. Reporting it as "no other device contacted these addresses" would be a claim the records cannot support.

The fix is to put the reach in the query. Joining the hunt to the list of devices that sent any network records in the period, and reporting the devices that could not have answered alongside the ones that did, turns an incomplete answer into an honest one.

Module 8's unified hunting lesson builds that pattern for every table, so that each hunt reports the devices it covered and the devices it could not see.

The same applies to file, registry and logon tables. Each platform sends a different subset, and a query against any one table inherits that table's reach. The question is never only what the query found, but where it could have looked.

06

What Module 8 Builds On It

Servers, Linux and cross-platform

The estate's platforms, by what each can say:

What each platform can say on this estate

Silence means different things

Windows laptops

about 598 process records each: the full picture

SRV-NGE-MCR-AAD01

the theft of the sync credentials, recorded and not alerted

WEB-NGE-MCR-01

connections and scans, no processes: how the miner arrived is unrecorded

NE-WEBB-MBP

scans only, and none since 03-09

Module 8 starts with server security architecture and works through domain controllers, SQL, IIS and file servers and the hardening benchmarks that apply to them. It then deploys Defender for Linux, covers eBPF detection and Sysmon for Linux, and turns to macOS. It finishes with hunting across every platform, virtual desktops and multi-session hosts, and one intrusion followed across four platforms.

Each finding here has a home there. The Tier 0 server belongs to the domain controller and server architecture lessons, because a directory synchronization server is protected like a domain controller. The Linux server belongs to the Linux deployment and eBPF lessons, which start by checking what the agent sends.

The Mac belongs to the macOS lesson and its profiles. And the hunt that missed half the estate belongs to the unified hunting lesson, which makes every cross-platform query state its reach.

The order matters for an engineer planning the work. The servers come first because a Tier 0 server holds the keys to the directory, and its theft on this estate led straight to the identity side. The Linux server comes next because it faces the internet. The Mac comes after, because it is one device; its fix is a profile rather than a project.

What Module 8 builds

Module 8

8.1 to 8.4

server security architecture, domain controllers, SQL, IIS and file servers, hardening

8.5 to 8.7

Defender for Linux deployed, eBPF detection, Sysmon for Linux

8.8 and 8.9

macOS endpoint security, and hunting across every platform

8.10 and 8.11

VDI and multi-session hosts, and four platforms in one intrusion

The habits to carry into it are the ones this lesson used. Measure each device's telemetry before reading its silence. Treat a quiet server's few records as the most important ones on the estate, not the least. Find out which event provider a Linux agent is using before trusting a hunt there. Check a Mac's approvals before trusting its health. And state a cross-platform query's reach alongside its result.

Each of those turns a finding here into a check that can be repeated, and Module 8 builds the checks. None of them needs a new product; they need the agents already installed to be configured and verified per platform.

Do

Practice

Decide whose silence you can trust
prepared evidence

The prepared evidence below is the record count per device for every server, the Linux web server and the Mac, with two laptops for comparison.

Decide which devices could not record a process at all, which one recorded an attack that no endpoint alert covered, and what a hunt that misses the Mac says about it. Each answer comes with its reasoning, so check it against the rows rather than only the choice.

Read each row for what the sensor sends before reading what it found. A zero in the process column means the device could not have shown a process starting, whatever ran there. A small number on a server can still hold the most important record on the estate.

Keep the two laptops in view as the baseline. They are what a working sensor on an ordinary device sends in a month, and every other row is a departure from that baseline that needs an explanation: a server's role, a Linux agent's event provider, a Mac's approvals.

Where no explanation exists, the row is a gap in coverage, and it belongs in the same report as lesson 0.2's unonboarded server.

Then run the platform query on this page by device instead of by platform, and list every onboarded device with fewer than ten process records in the period. On this estate the list is short, and every device on it needs a reason.

Finally, add DeviceFileEvents to the hunt and see which platforms appear in it at all. A table that only one platform contributes to is a table whose silence says nothing about the others, and knowing which tables those are is the start of every cross-platform investigation on this estate.

Four platforms appear in one portal and send four different amounts of evidence. The Tier 0 server recorded the theft of the sync credentials without an endpoint alert, the Linux server sends connections but no processes, and the Mac sends only scans. A hunt is only as wide as the narrowest sensor it covers, and every report built on one should say plainly how wide that was.

The next lesson puts every control family from this module on one page and asks which gaps to close first.