In this section

Defender for Endpoint Tamper Protection, Exclusion Drift and Compliance with Conditional Access

Module 0

Introduction

A protection setting is a claim made in a console. Whether it is true on a given device depends on three things the console does not show: whether the setting reached the device, whether something else changed it afterwards, and whether anyone can switch it off.

Module 3 of this course is about making configuration hold, and about tying a device's state to what that device is allowed to reach, so that a laptop that has drifted out of policy cannot reach company data until it is fixed.

This lesson reads the estate's records for each of those questions. Two attempts to switch protection off on a laptop were refused, and the records say so. An antivirus exclusion spread across eight laptops over three weeks without passing through any policy, and the records say that too. And the sign-in logs say whether a device's compliance decides anything, or is only written down.

1. Intendedthe policy as written, in Intune or Group Policy2. Deliveredthe setting arrives on the device, unless another source conflicts3. Holdingtamper protection refuses local attempts to change it4. Driftingchanges outside the policy, made where nobody reviews them5. Deciding accesscompliance read by Conditional Access, or only recorded

Configuration as Module 3 treats it: a chain from intent to the device, each link a place it can fail.

The figure is the chain Module 3 works along: intent, delivery, holding, drift and access. Each section below reads one link of it in the estate's data, and the last section sets out what Module 3 builds on it.

01

A Setting That Held

Two attempts refused by tamper protection

Tamper protection is the Defender setting that refuses changes to security settings made on the device itself, such as a local PowerShell command or a registry edit, even by an administrator. When it refuses one, the sensor records a TamperingAttempt event. The estate has two:

DeviceEvents
| where ActionType == 'TamperingAttempt'
| extend F = parse_json(AdditionalFields)
| project Time = format_datetime(Timestamp, 'yyyy-MM-dd HH:mm'), DeviceName,
    Target = tostring(F.Target), Status = tostring(F.Status)

Both records are from the same laptop, a minute apart, and both say the attempt was refused:

Time              DeviceName     Target                     Status
----------------  -------------  -------------------------  -------
2026-03-07 19:41  NE-COLLINS-LT  ExclusionPath              Blocked
2026-03-07 19:40  NE-COLLINS-LT  DisableRealtimeMonitoring  Blocked

The first attempt, at 19:40, ran Set-MpPreference from PowerShell to turn real-time monitoring off. The second, a minute later, tried to add the user's Games folder as an antivirus exclusion. Both came from the same PowerShell session on NE-COLLINS-LT, a Sales laptop, in the evening, and both have Status Blocked: the setting held.

Read the pair for intent before deciding what it means. A user who wants a game to stop being scanned and an attacker who wants malware to stop being scanned issue the same two commands, in the same order. The records cannot tell those apart, and that is the point of tamper protection: it does not need to.

It refuses the change whoever asks, and leaves the question of why to a person reading the records afterwards. Both the PowerShell session's account and the laptop's user are in the records, so the follow-up is a conversation, not an investigation: a person asks why, and either the answer is a game or the laptop is part of an incident.

That is also why tamper protection belongs early in Module 3's rollout sequence rather than at the end. Every control the later modules configure can be undone by the same kind of command, and an estate that configures carefully without tamper protection has configured something that any administrator session can switch off in a line of PowerShell.

The engineer's job is to make sure the refusal happens on every device, and to have a report that shows these records when it does.

A device with tamper protection off produces no such record when its protection is switched off, because nothing refuses the change, so the absence of tamper events proves nothing on its own. The proof is the device's own report of its tamper protection state, which Module 3 checks alongside the events.

02

A Change That Did Not Need to Get Past Anything

An exclusion that spread outside any policy

Exclusions are the other half of the story. An antivirus exclusion tells the engine not to scan a path, a process or a file type, and every exclusion is a place a file can sit unexamined. The estate's records show one exclusion path, added again and again:

DeviceEvents
| where ActionType == 'ExclusionAdded'
| extend Path = tostring(parse_json(AdditionalFields).Path)
| summarize Devices = dcount(DeviceName), FirstAdded = min(Timestamp),
    LastAdded = max(Timestamp) by Path

Summarized by path, the additions come down to one folder:

Path              Devices  FirstAdded           LastAdded
----------------  -------  -------------------  -------------------
C:\Autodesk\Temp  8        2026-02-17 17:38:06  2026-03-10 15:47:26

One folder, C:\Autodesk\Temp, excluded on 8 laptops. The day-by-day record shows how it spread:

DeviceEvents
| where ActionType == 'ExclusionAdded'
| project Day = format_datetime(Timestamp, 'yyyy-MM-dd'), DeviceName
| order by Day asc

In date order, each addition and the laptop that received it:

Day         DeviceName
----------  --------------
2026-02-17  NE-THOMPSON-LT
2026-02-21  NE-ASHWORTH-LT
2026-02-27  NE-SHARMA-LT
2026-03-02  NE-BENNETT-LT
2026-03-04  NE-KHAN-LT
2026-03-05  NE-WILLIAMS-LT
2026-03-06  NE-MORRIS-LT
2026-03-09  NE-LEWIS-LT
2026-03-09  NE-MORRIS-LT
2026-03-10  NE-THOMPSON-LT

10 additions over three weeks, one laptop at a time, and two laptops, NE-MORRIS-LT and NE-THOMPSON-LT, twice each, as if the fix had been applied again when the first copy seemed not to work. Unlike the attempts on NE-COLLINS-LT, these were applied.

The records do not say through which channel, and that is itself the finding: an exclusion that arrives device by device is not coming from a policy that somebody reviewed and scoped. A policy would have arrived on its target group in one change.

The exclusion nobody reviewed

Drift

Path

C:\Autodesk\Temp, a temporary folder

Spread

8 laptops, 10 additions, between 17 February and 10 March

Purpose

a design application, which most of these users do not run

In a policy

no: added device by device

The folder is a temporary folder named for a design application, and the laptops it reached belong to users in Finance, Sales, Engineering and Information Security; nothing in the records says those users run the application. Whatever the reason for the first one, the later ones look like a fix copied to each laptop that raised a ticket, which is how exclusions commonly spread.

The two repeat additions support that reading: a fix applied a second time is what a ticket reopened looks like. Module 3 covers where settings come from when several management channels can set them, and Module 5 makes the case that an exclusion list is a target an attacker looks for, which a temporary folder excluded on most laptops plainly is.

An attacker who finds that exclusion on a laptop has a folder where any file is skipped by the scanner, and every laptop in this list offers the same folder, which turns one discovery into a technique that works across the estate.

Reviewing exclusions is therefore not housekeeping: it is removing a place to hide. The query above is the start of that review, and it takes seconds to run on any estate.

03

Holding Is Not the Same as Correct

What the two records together say

Put the two sections side by side and they say something more useful than either alone. On NE-COLLINS-LT, a change made in a local PowerShell session was refused. On eight other laptops, an exclusion was applied. Tamper protection did its job in the first case.

In the second, the change either came through a channel tamper protection accepts, which is what an administrator's managed change usually is, or arrived where protection did not apply. Either way, holding the configuration is not the same as the configuration being right. The two are separate checks, and an estate passes one without the other more often than it passes both:

Held, and right, are two checks

Two questions

NE-COLLINS-LT

a local change refused: the setting held

Eight laptops

a change applied outside any reviewed policy: the setting drifted

Technical check

tamper protection on, one management channel, device state matching policy

Governance check

every exclusion with an owner, a reason, a scope and a review

The table is the reason this module keeps the two apart. A review that asks only whether settings hold will pass this estate; one that also asks whether they are right will not.

That distinction shapes how Module 3 approaches the work. Making settings hold is a technical problem with a technical answer: tamper protection on every device, settings delivered from one management channel so they do not conflict, and a check that the device's actual state matches the policy.

Making settings right is a governance problem: every exclusion has an owner, a reason and a scope, and changes go through a review that can say no. An estate needs both, and most estates build the first and assume the second.

The governance half also has a record: the change ticket, the policy's version history and the review that approved it, none of which Defender holds, which is why Module 3 treats configuration as something documented outside the console as well as set inside it.

The records support both checks. A weekly query for TamperingAttempt events says whether anyone is trying to undo protection, and on which devices. A weekly query for ExclusionAdded events says whether exclusions are arriving outside the reviewed policy, and the shape of the result, one device at a time or a whole group at once, says which kind of change it was.

An engineer who runs both finds the problem this estate has within the first week it appears, rather than after the folder has been excluded on most of the laptops.

Module 3's lesson on measuring what the controls cost uses the same records for a third purpose: counting the tickets an over-strict setting creates, which is what pushes people to copy an exclusion from laptop to laptop in the first place.

04

Is Compliance Deciding Anything?

Sign-ins from devices that are not compliant

Intune marks each managed device compliant or not against a compliance policy: encryption on, protection on, a minimum operating system version, and the like.

That mark is only worth something if it is used, and the place it is used is Conditional Access, which can refuse a sign-in from a device that is not compliant. Entra ID records the device's state on every sign-in, so the estate's successful sign-ins can be split by it:

SigninLogs
| where ResultType == 0
| extend Device = parse_json(DeviceDetail)
| summarize SignIns = count(), Users = dcount(UserPrincipalName)
    by Compliant = tostring(Device.isCompliant)
| order by SignIns desc

Split by the device's compliance state, the successful sign-ins divide like this:

Compliant  SignIns  Users
---------  -------  -----
false      5524     88
true       2341     16

2341 successful sign-ins from compliant devices, by 16 users: the estate's managed laptops. 5524 from devices Entra ID did not mark compliant, by 88 users. Entra ID recorded none of those devices as managed, and most of the sign-ins carry no operating system detail at all, which is what a browser on a machine the estate does not own looks like. All of them reached company applications.

SigninLogs
| where ResultType == 0
| where tostring(parse_json(DeviceDetail).isCompliant) == 'false'
| summarize SignIns = count() by AppDisplayName
| top 5 by SignIns

The applications those non-compliant sign-ins reached, the five most used first:

AppDisplayName                SignIns
----------------------------  -------
Office 365 Exchange Online    679
Office 365 SharePoint Online  659
Microsoft Office 365          458
Microsoft Teams               434
Exchange Online               414

SharePoint, Office, Teams and Exchange: exactly the data an attacker who has a user's password wants. They are also the applications a user reaches from a phone or a home computer every day, which is why requiring a compliant device for them is the hardest Conditional Access decision in the module and the one most worth measuring first.

Compliance is recorded on every one of these sign-ins and decides none of them. In 25 sign-ins across the whole period Conditional Access did refuse access, which shows that policies exist; it does not show that any of them require a compliant device for the applications that matter.

The blocked sign-ins come from compliant and non-compliant devices alike, which is what a policy based on something other than the device, such as location or the application, looks like.

This is the gap Module 3 closes. A compliance policy that marks devices without a Conditional Access policy that reads the mark is reporting, not control. The engineering work is to decide which applications require a compliant or managed device, to roll that requirement out without locking out the people who legitimately use other devices, and to measure what it costs before it is enforced.

The sign-in records above are the measurement: the same query, filtered to the applications a new policy would cover, says how many sign-ins and how many people it would refuse on its first day, before anyone is refused.

05

Order Matters

Why Module 3 starts with the rollout sequence

The three findings in this lesson have the same root cause. Each control was introduced on its own: tamper protection on some devices, exclusions as tickets arrived, compliance policies without the access rule that would make them matter. None of them is wrong in isolation, and together they leave an estate whose settings can drift, whose exclusions are unowned and whose compliance mark decides nothing.

Module 3 therefore begins with the rollout sequence: the order in which controls are introduced so that each one is in place before the next depends on it. In outline, for the controls this lesson read:

1. Tamper protection on every deviceso every later setting holds2. One management channel per settingso the device state is predictable3. Compliance policiesmarking devices against a standard4. Conditional Access in report-onlyrecording what it would refuse, and the cost5. Conditional Access enforcedring by ring, with the cost measured

The rollout sequence in outline: each step in place before the next depends on it.

The figure reads top to bottom, and each step answers the failure the step before would otherwise cause. Measured against it, this estate is partway down the list:

This estate, against the sequence

Where it stands

Tamper protection

refusing local changes on NE-COLLINS-LT; coverage elsewhere unproven

One channel

no: an exclusion arriving device by device

Compliance

recorded on every sign-in

Conditional Access

refusing 25 sign-ins, while 5524 succeeded from devices not marked compliant

Two steps are done or partly done, and the two that make compliance matter are not. That is a common place for an estate to stall, because the first two steps cost the users nothing visible and the last two change what they can reach. The sequence exists so that stall is a decision somebody takes, with its cost written down, rather than where the work happened to stop.

Tamper protection comes early, because every later setting depends on it holding. Settings are delivered from one channel before they are tightened, because a conflict between Group Policy and Intune makes the device's state impossible to predict. Compliance policies come before the Conditional Access rules that read them, and those rules start in report-only mode, which records what they would have refused, before they refuse anything.

The sequence is also about who absorbs the cost. Every control that refuses something refuses some legitimate work too, and the first person to find out is a user who then raises a ticket. A rollout that measures that cost, ring by ring, finds the problems while they are small. One that does not ends up with exclusions copied laptop to laptop, which is where this lesson's second section began.

The records in this lesson are the ones that make the sequence checkable: tamper events show whether settings hold, exclusion events show whether changes stay inside the policy, and sign-in records show whether compliance decides access. Each is one query, and each belongs in the report that tells an engineer whether the rollout is working.

06

What Module 3 Builds On It

Deployment, compliance and Conditional Access

Module 3 starts with that rollout sequence, then tamper protection and controlled configuration, then the conflicts between Group Policy, Intune and the Defender configuration service provider that decide which setting actually lands on a device. It builds compliance policies that enforce rather than report, the Windows compliance baseline and its counterparts on macOS, iOS and Android, and the Conditional Access policies that make compliance decide access.

What Module 3 builds

Module 3

3.1 to 3.3

the rollout sequence, tamper protection, and conflicts between Group Policy, Intune and the Defender CSP

3.4 to 3.6

compliance policies that enforce, the Windows compliance baseline, macOS, iOS and Android

3.7 to 3.9

enforcing compliance through Conditional Access, baselines that overlap, remediating devices

3.10 to 3.11

measuring what the controls cost, and a sixteen-week rollout

It ends with security baselines and the policies that overlap them, remediating devices that fall out of compliance, measuring what the controls cost the people who use the devices, and a sixteen-week rollout in which a date nobody planned for changed the sequence. Each of those lessons uses records like the ones above to say whether a change worked.

None of them assumes a setting holds because the console says so. The sixteen-week case study is worth reading for its failures as much as its result: the sequence slipped where a dependency was missed, and the records showed it before the users did.

That is the use of every query in this lesson: not to report after the fact, but to see a rollout going wrong while it can still be corrected, one ring at a time.

The habits to carry into it are the ones this lesson used. Treat a setting as a claim until a record on the device confirms it. Read tamper events as proof that protection held, and exclusion events as the place configuration drifts. Ask of every exclusion who owns it and which policy it lives in. And ask of every compliance mark which access decision reads it.

Add one more: when a change arrives device by device, assume it came from a ticket queue rather than a design, and find the ticket.

The ticket says what problem the change solved, and the problem usually has a better answer than an exclusion: an updated application, a narrower path or a process exclusion scoped to one group. Module 3's remediation lesson is about finding those answers, and Module 5 returns to exclusions in the antivirus context.

Do

Practice

Separate what held from what drifted
prepared evidence

The prepared evidence below is every change to antivirus configuration recorded on the estate's laptops from 5 March: the exclusions added and the tampering attempts refused. Decide which were refused, which were applied, and what a configuration review should do first. Each answer comes with its reasoning, so check it against the rows rather than only the choice.

The two kinds of record sit in one list in time order on purpose: in a real report they would, and the skill is reading the ActionType and the Detail together rather than either alone.

Notice that the refused changes and the applied ones are not on the same laptops, which is one more reason not to read a single device's records as a picture of the estate. Then write, in one sentence each, what you would tell the owner of NE-COLLINS-LT and the person who added the exclusions, because a configuration review ends in conversations as well as in policy changes.

Then run the exclusion query on this page without its summary, and add the laptops' device groups from DeviceInfo with a join on DeviceId. If the exclusion were meant for the people who run the design application, which group would you scope it to, and how many of the laptops that have it would lose it?

Configuration holds when tamper protection refuses local changes, and it stays right only when every change goes through a reviewed policy. The records say which happened: tampering attempts with their status, exclusions arriving device by device. Device compliance is only control when Conditional Access reads it, and on this estate most successful sign-ins came from devices that were not compliant.

The next lesson moves from configuration in general to the first preventive control in detail: attack surface reduction rules, and why every one of them starts in audit. The audit records it reads are the same kind as the ones this lesson ended with: evidence of what a control would do, gathered before it does it.