<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Alan Conlon on Medium]]></title>
        <description><![CDATA[Stories by Alan Conlon on Medium]]></description>
        <link>https://medium.com/@azure.alanconlon?source=rss-c3359b6bd79b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*OgbhJUWs6KlbwK5x</url>
            <title>Stories by Alan Conlon on Medium</title>
            <link>https://medium.com/@azure.alanconlon?source=rss-c3359b6bd79b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 18:06:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@azure.alanconlon/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Hugo on Cloudflare Pages: From Laptop to Live]]></title>
            <link>https://medium.com/@azure.alanconlon/hugo-on-cloudflare-pages-from-laptop-to-live-87802fd81ac8?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/87802fd81ac8</guid>
            <category><![CDATA[static-site]]></category>
            <category><![CDATA[hugo]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[cloudflare]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 00:00:04 GMT</pubDate>
            <atom:updated>2026-11-17T18:32:05.455Z</atom:updated>
            <content:encoded><![CDATA[<p>At the end of <a href="https://alanconlon.com/posts/starting-a-hugo-site/">the last part</a> you had a Hugo site building on your own machine, live-reloading at localhost:1313, and visible to precisely nobody. This part fixes that. By the end of it the site is on the internet, on your own domain, over HTTPS, and set up so that everything you do from then on deploys itself. There are two setup steps that catch almost everyone, and I&#39;ll flag both as we hit them, because I hit them too.</p><p>The shape of what we’re building: your site lives in a GitHub repository, Cloudflare Pages watches that repository, and every time you push a change, Pages runs Hugo and publishes the result. Push to deploy. Once it’s wired up you mostly forget it’s there.</p><h3>Get the site into GitHub</h3><p>Your site is a folder of text files, which is exactly what git is built for. If you’ve avoided git until now, this is a gentle place to start, because VS Code gives you the whole thing through a panel and you never have to touch the command line if you don’t want to.</p><p>Open your site folder in VS Code. Before you commit anything, one file matters: .gitignore. Hugo builds your finished site into a folder called public, and that folder does not belong in the repository. It&#39;s generated output, Cloudflare rebuilds it on every deploy, and committing it just means a pile of noise in your history and, worse, the chance of editing the built copy of a file by mistake instead of the source. I know that last one bites because it bit me: I once spent a while confused about why an edit wasn&#39;t showing up, and it was because there were two copies of the file and I was editing the wrong one. So put public/ in .gitignore before your first commit and save yourself that afternoon.</p><pre>public/<br>resources/<br>.hugo_build.lock</pre><p>Then, in VS Code’s Source Control panel (the branch icon in the sidebar), you initialise the repository, stage your files, write a commit message, and commit. Create an empty repository on GitHub, private is fine, mine is, and VS Code will offer to publish your local repository straight to it. That’s your source of truth now, backed up and versioned.</p><h3>Wire up Cloudflare Pages</h3><p>In the Cloudflare dashboard, go to Workers &amp; Pages and create a Pages project connected to your GitHub repository. This is where the first real gotcha lives, so slow down for the build settings.</p><p>Set the build command to hugo and the output directory to public. Straightforward. But here&#39;s the one that&#39;ll waste an hour if you miss it: Cloudflare&#39;s build image ships with whatever Hugo version it was last updated to (0.147 on the current image, far older on legacy ones), and it can change underneath you. An older Hugo can build a modern site wrong or fail outright, and the error won&#39;t say the version is the problem. Pin the version explicitly. Add an environment variable called HUGO_VERSION set to whatever version you&#39;re building with locally (check with hugo version). Mine&#39;s set to a specific number, not left to chance, and it&#39;s the single most important build setting on the page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rUAYd9P_rlNdKOhs.png" /></figure><p><em>Pin HUGO_VERSION or Cloudflare builds with a museum piece.</em></p><p>Save it and Cloudflare runs its first build. If the settings are right, a minute or two later your site is live at a your-project.pages.dev address. That URL is ugly and temporary, but seeing it work means the pipeline is sound.</p><h3>Point your domain at it</h3><p>The pages.dev address proves it works; your own domain makes it yours. In the Pages project, under custom domains, add your apex domain ( example.com) and the www version. If your DNS is already on Cloudflare, this is nearly automatic, Cloudflare adds the records and sorts the certificate itself.</p><p>Add both the apex and www, and let one redirect to the other so you&#39;ve got a single canonical home rather than two versions of the site competing. I send www to the bare domain; plenty of people do it the other way, either is fine as long as you pick one. HTTPS you don&#39;t have to think about at all: Cloudflare issues and renews the certificate automatically, and forces HTTP over to HTTPS for you. That last part matters more than it looks, and it&#39;ll make a confusing cameo in a later part <em>(coming soon)</em> when Search Console &quot;reports&quot; the HTTP-to-HTTPS redirect as though it were a fault. It isn&#39;t. File that away.</p><h3>Now you have a deploy pipeline</h3><p>Here’s the part that makes the whole setup worth it. From now on, the loop is: edit a post in VS Code, commit, push. Cloudflare sees the new commit, runs Hugo, and your change is live in a minute or two. No uploading files, no FTP, no “which version is on the server” confusion. The repository is the site; pushing is publishing.</p><p>It’s worth doing one deliberate test to prove it to yourself. Change something small, a word on the homepage, commit it in VS Code, push, and watch the Deployments list in Cloudflare Pages show a new build appear and go green. Once you’ve seen that happen, you trust it, and you stop thinking about deployment as a separate step at all.</p><h3>What’s not done yet</h3><p>You’ve got a live, self-deploying site on your own domain over HTTPS, which is the milestone. What you don’t have yet is much of a site: no real content structure, no design of your own, and none of the harder edges sorted, the security headers, the scheduling, the caching behaviour. Those are the next parts.</p><p>The next one <em>(coming soon)</em> is content: how Hugo organises posts, how front matter works, and how tags and series get their own pages without you building them. That’s where the site stops being a technical exercise and starts being a place you actually write.</p><p>I write about security, Azure, data, and the practical side of running things. More at <a href="https://alanconlon.com/">alanconlon.com</a>, or connect on <a href="https://www.linkedin.com/in/alanconlon">LinkedIn</a>.</p><p><em>Originally published at</em><a href="https://alanconlon.com/"><em> alanconlon.com</em></a><em>, where I post practical security, Azure and data write-ups every other Tuesday.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87802fd81ac8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hunting Impossible Travel in Sentinel with KQL]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@azure.alanconlon/hunting-impossible-travel-in-sentinel-with-kql-5517741fecdb?source=rss-c3359b6bd79b------2"><img src="https://cdn-images-1.medium.com/max/1600/0*X1PFCznizNTuKNIY.png" width="1600"></a></p><p class="medium-feed-snippet">Here&#x2019;s a sign-in pattern that should never happen. An account authenticates from Dublin at nine in the morning, then from S&#xE3;o Paulo forty&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@azure.alanconlon/hunting-impossible-travel-in-sentinel-with-kql-5517741fecdb?source=rss-c3359b6bd79b------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@azure.alanconlon/hunting-impossible-travel-in-sentinel-with-kql-5517741fecdb?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/5517741fecdb</guid>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[microsoft-sentinel]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[kql]]></category>
            <category><![CDATA[identity]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 00:00:53 GMT</pubDate>
            <atom:updated>2026-11-03T07:38:49.309Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Starting a Site with Hugo: Own the Place You Write]]></title>
            <link>https://medium.com/@azure.alanconlon/starting-a-site-with-hugo-own-the-place-you-write-65890d140a62?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/65890d140a62</guid>
            <category><![CDATA[hugo]]></category>
            <category><![CDATA[cloudflare]]></category>
            <category><![CDATA[static-site]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 00:00:03 GMT</pubDate>
            <atom:updated>2026-11-17T07:52:15.559Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Starting a Site with Hugo: Own the Place You Write" src="https://cdn-images-1.medium.com/max/1024/1*Z_UQ83wY5eVLh9vuGb7HTA.png" /></figure><p>Everywhere you write online, you’re renting. Most of the time that’s fine. I syndicate to Medium and Dev.to myself, and they bring readers my own site never would. But the platform decides who sees your work, how it looks and what the rules are next year, and none of that is yours to change. The landlord can always change the locks.</p><p>So this series is about building the place you do own: the site everything else points back to, on a stack that costs nothing and answers to nobody but you. This first part is the why and the first ten minutes, getting Hugo running on your own machine so you’ve got something to look at. Later parts put it on the internet, make it look like yours, and lock it down.</p><h3>Why static, and why this stack</h3><p>The site you’re reading is built with Hugo, kept in a GitHub repository, and hosted on Cloudflare Pages. Three pieces, each doing one job. Hugo turns a folder of Markdown files into a finished website. GitHub holds that folder and its history. Cloudflare Pages watches the repository, runs Hugo whenever it changes, and serves the result to the world.</p><p>The word doing the heavy lifting is <em>static</em>. A static site is just files, HTML, CSS, images, generated ahead of time and handed to the browser as-is. There’s no database, no server-side code running on each request, no admin login sitting on the public internet waiting to be brute-forced. Compare that to WordPress, which is a database and a pile of PHP and a plugin ecosystem you have to keep patched or watch get compromised. A static site has almost no attack surface, because there’s almost nothing running. For anyone who spends their day thinking about attack surface, that alone is a decent reason.</p><p>The other reasons are ordinary and add up. It’s genuinely fast, because serving a pre-built file from a CDN is about the quickest thing the web does. It’s free at this scale, Cloudflare Pages doesn’t charge for a personal site’s traffic. And because the whole thing is text files in git, you get version history for free, you can see every change you ever made, and nothing important lives anywhere you can’t back up with a git clone.</p><figure><img alt="The three-piece stack: Hugo builds the site from Markdown, GitHub stores the source and its history, Cloudflare Pages runs Hugo and serves the result on a fast CDN." src="https://cdn-images-1.medium.com/max/1024/0*hE_rgNa1XsRpFGFG.png" /></figure><p><em>Three pieces, one job each. Nothing running that an attacker can knock on.</em></p><h3>Get Hugo on your machine</h3><p>Hugo is a single binary, which is part of its charm, there’s no runtime to install alongside it, no dependency tree to manage. Install it however your platform prefers: brew install hugo on a Mac, winget install Hugo.Hugo.Extended on Windows, or your package manager of choice on Linux.</p><p>One thing that catches people, so get it right now and save yourself a confusing afternoon: install the <em>extended</em> edition. Many themes rely on features only the extended edition has, such as SCSS processing, and the error you get when you hit that wall doesn’t say “you installed the wrong Hugo”, it says something oblique about a missing feature. The winget line above already grabs the extended build; on other platforms, check the version string after installing with hugo version and confirm the word extended is in there.</p><p>That command is also your first sanity check. If hugo version prints something, you&#39;re ready. If it doesn&#39;t, the install didn&#39;t take, and there&#39;s no point going further until it does.</p><h3>Scaffold a site and see it running</h3><p>Now the satisfying bit. Create a new site:</p><pre>hugo new site mysite<br>cd mysite</pre><p>That drops a folder structure in front of you, and it’s worth a five-second tour because these are the folders you’ll live in. content is where your Markdown posts go. layouts is where the templates live, the HTML that wraps your content. static is for files served as-is, and assets for files that go through Hugo&#39;s pipeline. hugo.toml is the site&#39;s configuration. Nearly empty for now, all of it, which is exactly why a fresh Hugo site shows you nothing when you first run it.</p><p>Run it anyway:</p><pre>hugo server</pre><p>Open the address it prints, usually localhost:1313, and you&#39;ll see a blank page. That blank page is the win. It means Hugo is installed, the site is building, and the local server is live-reloading, change a file and the browser refreshes itself. You now have a working development loop on your own machine, disconnected from the internet, where you can break things freely.</p><p>It’s blank because you’ve got no content and no theme yet. That’s the next two things to sort, and it’s where the first real decision lands.</p><h3>Themes, or roll your own</h3><p>Hugo has a large gallery of ready-made themes. Drop one in, point your config at it, and you’ve got a designed site in minutes. For getting started, that’s a completely reasonable path, and I’d not talk anyone out of it for a first site.</p><p>I rolled my own instead, a handful of my own templates rather than someone else’s theme, and I’d gently argue it’s worth doing eventually even if not on day one. A theme is someone else’s decisions about how your site looks and works, and the day you want to change something specific, you’re reverse-engineering a stranger’s code. Your own layouts are usually simpler than a general-purpose theme, because they only have to do what <em>your</em> site does, not everything every site might want. That’s a later part of this series, though. For now, if you want to see something other than a blank page today, grab a theme and move on.</p><h3>Where this goes next</h3><p>At this point you’ve got Hugo installed and a site building locally, which is further than most people who mean to start a blog ever get. It’s still trapped on your laptop, though, localhost is a site with an audience of one.</p><p><a href="https://alanconlon.com/posts/hugo-site-go-live/">The next part</a> takes it live: a GitHub repository as the source of truth, Cloudflare Pages wired up to build from it, your own domain pointed at it, and HTTPS handled automatically. That’s the step where it stops being a folder on your machine and becomes a place on the internet with your name on it. The place you own.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon/"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65890d140a62" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Break-Glass Accounts: The Ones You Hope You Never Use, Done Properly]]></title>
            <link>https://medium.com/@azure.alanconlon/break-glass-accounts-the-ones-you-hope-you-never-use-done-properly-2dc0d55a381c?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2dc0d55a381c</guid>
            <category><![CDATA[identity]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[microsoft-entra-id]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 06 Oct 2026 00:00:33 GMT</pubDate>
            <atom:updated>2026-10-31T09:46:01.838Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Break-Glass Accounts: The Ones You Hope You Never Use, Done Properly" src="https://cdn-images-1.medium.com/max/1024/1*NfWx9ShfkbGv8vt15zoIQg.png" /></figure><p>Every guide to Conditional Access, MFA and identity hardening opens with the same instruction: set up break-glass accounts first. Then it moves on, as if the accounts themselves were the easy part. They are not. A break-glass account done carelessly is worse than none at all, because it gives you the comfort of a safety net while quietly being a hole in the floor. This is the unglamorous detail of getting them right.</p><p>A break-glass account, sometimes called an emergency access account, exists for one moment: the day everything else locks you out. A Conditional Access policy goes wrong and nobody can sign in. Your federated identity provider falls over and takes SSO with it. MFA infrastructure has an outage and every normal login is stuck at the second factor. In each case you need a way back into the tenant that doesn’t depend on the thing that broke. That is the entire job. The account earns its existence maybe once in its life, and on that day it is the most important account you own.</p><h3>Why the obvious version is wrong</h3><p>The instinct is to make an admin account, give it a strong password, and call it your break-glass. That misses the point in a few ways at once, and each one is a way the account fails you at exactly the wrong moment.</p><p>If it depends on MFA and your MFA is what’s broken, it’s useless the day you need it. If it’s tied to a named person, it’s unusable when that person has left or is unreachable at 3am. If it’s subject to the same Conditional Access policies as everyone else, the policy that locked out the tenant locks it out too, which defeats the whole purpose. And if it’s an everyday admin account you also use for real work, it accumulates the same risk exposure as any other account while being held to less scrutiny.</p><p>Getting break-glass right is really about deliberately breaking each of those dependencies.</p><h3>What does a proper break-glass account look like?</h3><p>Cloud only. The account should be created directly in Entra ID, not synced from on-premises Active Directory. If it came from on-prem and your sync or your domain controllers are what failed, the account fails with them. Cloud-native means it survives an on-prem outage, and stays clear of <a href="https://alanconlon.com/posts/hybrid-cloud-security-gaps/">the identity seam in a hybrid setup</a>.</p><p>Not tied to a person. It belongs to the organisation, not to Alan or to whoever holds the admin role this quarter. No personal email in its recovery, nothing that walks out the door when someone resigns. Two accounts, not one, so a problem with either still leaves you a way in.</p><p>Excluded from Conditional Access. Every policy you create should carve these accounts out. This is the part people forget, and it is the part that matters most, because the entire scenario you are guarding against is a <a href="https://alanconlon.com/posts/conditional-access-without-lockout/">Conditional Access policy gone wrong</a>. An account still subject to that policy goes down with the ship.</p><p>A very long passphrase, stored offline. Because the account has to work when your normal MFA might not, its password is doing more of the security work than usual, so it should be long, random, and genuinely secret. Split it if you like, half known to one trusted person and half to another, so no single individual can use it alone. Store it somewhere physical and secure, a sealed envelope in a safe is not old-fashioned here, it’s appropriate. It must be retrievable in a crisis without depending on the systems that might be down.</p><p>Global Administrator, and nothing less. This is the one account where you do want the top role, because the emergencies it exists for often require fixing tenant-wide configuration. It’s the deliberate exception to least privilege, justified precisely because it’s otherwise so tightly controlled and so heavily watched. Every other admin role belongs behind just-in-time activation.</p><h3>The exclusion from MFA is where people get nervous</h3><p>There’s an obvious tension. You exclude the account from Conditional Access and you’re cautious about MFA dependencies, but an unprotected Global Admin account is exactly what every attacker dreams of. Both things are true, and the resolution is to compensate with a different control rather than protect the account the normal way: watch it like nothing else in your tenant.</p><p>Microsoft has settled part of that tension. Since mandatory MFA arrived for the Azure, Entra, Intune and Microsoft 365 admin portals, emergency accounts must complete MFA too, and there’s no exclusion. So give each one a FIDO2 security key, or certificate-based authentication, that no other admin account uses. Store the key physically with the credentials. It survives the outages you’re guarding against, it satisfies the enforcement, and it still keeps the account out of your Conditional Access policies. The principle holds: the account’s protection must not depend on the systems it exists to rescue you from.</p><h3>Watching them is the actual security control</h3><p>An account that bypasses your policies is only safe if any use of it is impossible to miss. So the compensating control for all that deliberate exposure is alerting. Every single sign-in to a break-glass account should raise an immediate, loud, high-priority alert to whoever runs security, because in normal operation these accounts are never used. A break-glass sign-in is, by definition, either a real emergency or an intruder, and both demand that someone looks right now.</p><p>This is straightforward to build. In Sentinel, an analytics rule watching SigninLogs for those specific account names, set to fire on any successful sign-in, gets you there. Because the expected rate of use is zero, you don&#39;t need a clever threshold. One sign-in is the signal.</p><pre>SigninLogs<br>| where UserPrincipalName in (&quot;breakglass1@yourtenant.onmicrosoft.com&quot;,<br>                              &quot;breakglass2@yourtenant.onmicrosoft.com&quot;)<br>| where ResultType == &quot;0&quot;<br>| project TimeGenerated, UserPrincipalName, IPAddress,<br>    Location = tostring(LocationDetails.city), AppDisplayName</pre><p>Wire that to notify immediately, not to batch into a daily digest. The whole value is in the speed of the response.</p><h3>Test them, or you don’t really have them</h3><p>Here is the part almost everyone skips. An emergency access account you have never signed into is a theory, not a control. You do not want the first time you use it to be during the actual crisis, discovering then that the password in the safe is wrong, or the account expired, or the alert never fired. Test them on a schedule, quarterly is reasonable. Retrieve the credentials the proper way, sign in, confirm the account works and has its access, confirm your alert fired, then reset the password and put it back. That drill turns a hopeful arrangement into one you can actually rely on.</p><p>None of this is difficult. It’s a handful of accounts and an afternoon of care. But it’s the kind of care that’s easy to defer forever because the payoff is invisible right up until the one day it’s the only thing that saves you. When an identity lockout does come, the organisations that get through it calmly are the ones that set these up properly and then checked that they worked. Clever tooling has very little to do with it.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2dc0d55a381c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hunting Password Spray in Sentinel: One Password Against a Thousand Doors]]></title>
            <link>https://infosecwriteups.com/hunting-password-spray-in-sentinel-one-password-against-a-thousand-doors-1c69ed05cb6c?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c69ed05cb6c</guid>
            <category><![CDATA[identity]]></category>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[kql]]></category>
            <category><![CDATA[microsoft-sentinel]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 22 Sep 2026 00:00:00 GMT</pubDate>
            <atom:updated>2026-10-31T09:52:29.837Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Hunting Password Spray in Sentinel: One Password Against a Thousand Doors" src="https://cdn-images-1.medium.com/max/1024/1*Gl2d4DHoSZGzIInsfj6_Vg.png" /></figure><p>Everyone pictures a password attack as hammering one account: thousands of guesses against a single login until something gives. That’s brute force, and it’s easy to catch, a pile of failures on one account trips any lockout worth its salt. Password spray is the smarter cousin, and it’s built specifically to slide under exactly that defence.</p><p>The trick is to flip the ratio. Instead of many passwords against one account, spray tries one password, a common one, Winter2026! or the company name with a number, against many accounts. One attempt each, or two, spread across hundreds of users. No single account sees enough failures to lock, so smart lockout never fires, and the attacker only needs one person in the whole directory to have picked the guessable password. In an organisation of any size, someone always has.</p><p>It’s a numbers game, and the numbers favour the attacker. Which is exactly why it’s still one of the most common ways in, and why it’s worth being able to see.</p><h3>What does password spray look like in the sign-in logs?</h3><p>Because spray inverts the ratio, it inverts the shape in the logs too. Brute force is a tall spike on one account. Spray is a wide, shallow smear: one source touching a great many distinct accounts, each only once or twice, in a short window. That breadth is the tell. Ordinary failed sign-ins are scattered across the day and across sources; spray is one origin reaching for dozens or hundreds of different usernames in minutes.</p><p>The failures land in SigninLogs with a result code, and the one that matters here is 50126, the code for an invalid username or password. That&#39;s the bad-guess code, the one a wrong password produces.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*c5oHJSnaOy7Id0lu.png" /></figure><p><em>Brute force is tall and narrow. Spray is wide and shallow. Count the distinct users, not the attempts.</em></p><h3>Look before you detect</h3><p>Same discipline as <a href="https://alanconlon.com/posts/sentinel-kql-primer/">the primer</a> and every post since: look at the raw failures in your own tenant before you try to be clever, because you can’t tell an attack from a busy Monday until you’ve seen a normal one.</p><pre>SigninLogs<br>| where TimeGenerated &gt; ago(7d)<br>| where ResultType == &quot;50126&quot;<br>| take 20</pre><p>Run that, read the rows. You’ll see the ordinary background of fat-fingered passwords and stale cached credentials on people’s phones. Note what a normal source looks like, one user, from one IP, failing a couple of times and then succeeding. That’s the baseline the attack has to stand out from.</p><h3>Now count the breadth</h3><p>The detection isn’t “how many failures”, it’s “how many <em>different accounts</em> from one source”. So we count distinct users per IP inside a time window:</p><pre>SigninLogs<br>| where TimeGenerated &gt; ago(1d)<br>| where ResultType == &quot;50126&quot;<br>| summarize<br>    DistinctUsers = dcount(UserPrincipalName),<br>    Attempts = count()<br>    by IPAddress, bin(TimeGenerated, 1h)<br>| where DistinctUsers &gt;= 15<br>| sort by DistinctUsers desc</pre><p>Read it as a sentence. Take the last day of bad-password failures, count the distinct users and total attempts per IP per hour, and show me any source that failed against fifteen or more different accounts in a single hour. dcount is the operator doing the real work: it counts <em>distinct</em> users, which is the breadth that separates spray from one person locked out of their own account. That user fails fifteen times against one username; a sprayer fails once against fifteen usernames. Same fifteen failures, completely different dcount.</p><p>The threshold of fifteen is a starting point, not gospel. Your baseline from the first query is the guide, a big tenant with a chatty VPN egress might need it higher, a small one lower. Tune it to your own noise.</p><h3>The refinement that turns a hunt into an incident</h3><p>A source spraying and failing is an attack attempt. A source that sprayed and then, somewhere in the same window, <em>succeeded</em> against one of those accounts is a breach in progress, because it means one of the guessed passwords was right.</p><pre>let Lookback = 1d;           // how far back to look<br>let Threshold = 15;          // distinct accounts before a source counts as spraying<br>let SprayIPs = SigninLogs<br>    | where TimeGenerated &gt; ago(Lookback)<br>    | where ResultType == &quot;50126&quot;<br>    | summarize DistinctUsers = dcount(UserPrincipalName), FirstSpray = min(TimeGenerated) by IPAddress<br>    | where DistinctUsers &gt;= Threshold;<br>SigninLogs<br>| where TimeGenerated &gt; ago(Lookback)<br>| where ResultType == &quot;0&quot;<br>| join kind=inner SprayIPs on IPAddress<br>| where TimeGenerated &gt; FirstSpray       // only successes after the spray began<br>| project TimeGenerated, UserPrincipalName, IPAddress,<br>    DistinctUsers, Location, AppDisplayName<br>| sort by TimeGenerated desc</pre><p>Two ideas you’ll recognise from <a href="https://alanconlon.com/posts/hunting-mfa-fatigue-kql/">the MFA fatigue hunt</a>. let names the set of spraying IPs, the sources that failed broadly. Then join matches those same IPs against <em>successful</em> sign-ins (ResultType == &quot;0&quot;), and FirstSpray keeps only the successes that came after the spray began. What falls out is the list that matters: an account that logged in successfully, after the spray started, from an IP that was spraying the rest of your directory. That&#39;s not a coincidence you explain away. That&#39;s the one they got. The one exception is a shared NAT or VPN egress IP, which can still match, so check the source before you call it.</p><p>If that query returns a row, treat it as compromise: revoke the sessions, reset the credential, and check what that account touched before you do anything else.</p><p>Both spray queries are in <a href="https://github.com/alanconlon/kql-hunting-queries/tree/main/queries/password-spray">the free queries repo</a>, commented and with the thresholds pulled out as let values at the top.</p><h3>What it misses</h3><p>Honesty about the gaps, as always. The big one is distributed spray: an attacker who sprays from a botnet, a different IP per account, defeats the per-IP count entirely, because no single source touches enough users to cross the threshold. Catching that needs a different angle, counting the breadth per <em>password</em> or per <em>time window across all sources</em> rather than per IP, and it’s a harder, noisier hunt. This query catches the common, cheap version, the one source spraying away, which is still most of what you’ll see.</p><p>It also leans on 50126 specifically, and a spray that trips smart lockout will start throwing 50053 instead, so a truly patient attacker pacing under the lockout stays on 50126 and a clumsy one shifts codes. Worth watching both. And none of it helps if the sprayed account had no MFA behind the password, which is the real lesson underneath the query: spray works because a password on its own is still a single point of failure. Blocking legacy authentication with <a href="https://alanconlon.com/posts/conditional-access-without-lockout/">Conditional Access</a> takes away the endpoints where that&#39;s still true.</p><h3>Promote it slowly</h3><p>You know the routine. Run it in the logs for a week or two, watch what it flags, learn which of your egress IPs are just busy rather than hostile, tune the threshold and window, and only then wire the refinement query into a scheduled analytics rule that alerts on a spray-then-success. The broad count is for hunting; the join is for paging someone.</p><p>Password spray has been the opening move in more breaches than almost any other technique, and it survives entirely on the gap between “one account’s lockout” and “the whole directory’s failure rate”. Close that gap by counting breadth instead of depth, and the wide shallow smear that was invisible to per-account defences lights right up.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon"><em>LinkedIn</em></a><em>. This is part of an ongoing KQL Hunting series: if you’d rather start from working detections than a blank query bar, my </em><a href="https://alanconlon.gumroad.com/l/kql-hunting-pack"><em>KQL Hunting Pack</em></a><em> is 12 ready-to-run queries covering exactly this kind of hunting.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c69ed05cb6c" width="1" height="1" alt=""><hr><p><a href="https://infosecwriteups.com/hunting-password-spray-in-sentinel-one-password-against-a-thousand-doors-1c69ed05cb6c">Hunting Password Spray in Sentinel: One Password Against a Thousand Doors</a> was originally published in <a href="https://infosecwriteups.com/">InfoSec Write-ups</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 DAX Mistakes That Quietly Break Your Power BI Reports]]></title>
            <link>https://medium.com/@azure.alanconlon/5-dax-mistakes-that-quietly-break-your-power-bi-reports-53e83ac948d0?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/53e83ac948d0</guid>
            <category><![CDATA[dax]]></category>
            <category><![CDATA[power-bi]]></category>
            <category><![CDATA[data-analytics]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 00:00:44 GMT</pubDate>
            <atom:updated>2026-10-31T09:48:11.433Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="5 DAX Mistakes That Quietly Break Your Power BI Reports" src="https://cdn-images-1.medium.com/max/1024/1*_27xZOMVuo0-tWIA5c2D5g.png" /></figure><p>The worst DAX bugs don’t throw errors. The formula validates, the report refreshes, everything looks fine, and the number is just wrong. No red squiggle, no warning, nothing pointing you at the cause. You usually find out when someone in a meeting taps the screen and asks why that figure doesn’t match the source.</p><p>I’ve lost more hours to that kind of silent failure than to any actual error message. Here are the five that catch people most often, and what to do instead.</p><h3>Reserved keywords as variable names</h3><p>DAX won’t let you name a variable after a reserved word or an existing table. Some names, such as Date and Value, also clash with function names. That makes formulas hard to read and easy to break.</p><p>The fix is dull and it works: prefix every variable with a lowercase v. vStatus, not Status. Once it&#39;s a habit you stop thinking about it.</p><pre>VAR vStatus = SELECTEDVALUE(&#39;Table&#39;[Status_Column])<br>VAR vClass  = SELECTEDVALUE(&#39;Table&#39;[Class_Column])<br>RETURN<br>    IF(ISBLANK(vStatus), &quot;Unknown&quot;, vStatus)</pre><h3>Chains of = comparisons instead of a list membership check</h3><p>When you want to check whether a value is one of several options, a chain of vType = &quot;Express&quot; || vType = &quot;Priority&quot; comparisons is the obvious move. It&#39;s long, it&#39;s easy to get wrong, and = treats a BLANK as equal to 0 or &quot;&quot;. Use a list membership check instead.</p><p>vType IN {&quot;Express&quot;,&quot;Priority&quot;,&quot;Same-Day&quot;} and CONTAINSROW(vList, vType) do the same thing. Both use strict comparison, so a BLANK won&#39;t match 0 or &quot;&quot;. Pick one and keep the list in a variable:</p><pre>VAR vList = {&quot;Express&quot;, &quot;Priority&quot;, &quot;Same-Day&quot;}<br>RETURN<br>SWITCH(TRUE(),<br>    CONTAINSROW(vList, vType), &quot;Fast&quot;,<br>    &quot;Standard&quot;<br>)</pre><p>The list lives in one place, and adding a value is a one-line change.</p><h3>Not handling blanks before you compare</h3><p>Blanks cause more wrong-but-not-broken results than anything else here. A check like vStatus = &quot;Active&quot; does something unhelpful when vStatus is blank, and the row ends up in the wrong bucket without a word of warning.</p><p>Catch blanks first, before any other comparison:</p><pre>SWITCH(TRUE(),<br>    ISBLANK(vStatus), &quot;No Status&quot;,   -- blanks first, always<br>    vStatus = &quot;Active&quot;, &quot;Live&quot;,<br>    &quot;Other&quot;<br>)</pre><p>Make that your opening branch and everything below it can assume it’s working with a real value. Most of my classification logic starts this way now, out of pure self-preservation.</p><h3>Using SELECTEDVALUE in the wrong place</h3><p>In a calculated column, reference the column directly. The row context gives you the current row.</p><pre>VAR vRevenue = &#39;Sales&#39;[Revenue]</pre><p>SELECTEDVALUE() is for measures. There it reads what the filter context, such as a slicer or a matrix row, has narrowed to. It returns BLANK when more than one value is in play. Use it in a calculated column and it sees the whole column, so you get BLANK on every row. It&#39;s the usual reason a formula works fine as a measure but breaks as a column.</p><h3>Dividing without DIVIDE()</h3><p>The classic. [Covered] / [Total] works perfectly right up until Total is zero. Then the visual quietly shows Infinity or NaN instead of a number.</p><p>DIVIDE() exists for this exact reason:</p><pre>RETURN DIVIDE(vCovered, vTotal)</pre><p>It handles the zero gracefully: blank by default, or a value you nominate. I can’t think of a good reason to use the / operator directly in a measure, except dividing by a constant (say / 100). There Microsoft recommends /, because it can&#39;t fail and it&#39;s faster.</p><h3>How do you stop DAX failing silently?</h3><p>None of these fixes are clever. They’re careful. Assume values can be blank. Assume a list needs a real membership check. Assume division will hit zero eventually, because it will. Good DAX is mostly defensive DAX. You’re writing for the messy data you’ll actually get, not the clean data someone promised you in the kickoff meeting.</p><p>These silent failures are also a common reason two measures or visuals in the same report disagree. When your Power BI metrics conflict, check these five first.</p><p>Get these into muscle memory and the whole silent-failure category mostly goes away. That’s a decent chunk of your week back.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53e83ac948d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hunting MFA Fatigue in Sentinel: Building the Detection One Line at a Time]]></title>
            <link>https://medium.com/@azure.alanconlon/hunting-mfa-fatigue-in-sentinel-building-the-detection-one-line-at-a-time-5dacb7aa4a28?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/5dacb7aa4a28</guid>
            <category><![CDATA[threat-hunting]]></category>
            <category><![CDATA[kql]]></category>
            <category><![CDATA[mfa]]></category>
            <category><![CDATA[microsoft-sentinel]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 25 Aug 2026 08:31:01 GMT</pubDate>
            <atom:updated>2026-10-31T09:49:26.030Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Hunting MFA Fatigue in Sentinel: Building the Detection One Line at a Time" src="https://cdn-images-1.medium.com/max/1024/1*skZjOH7bGCEN7SR3OI1e4g.png" /></figure><p>MFA fatigue is the attack that works because people are tired. The attacker already has the password, usually from a phishing kit or a credential dump, and MFA is the only thing left in the way. So they hammer it. Push notification after push notification, sometimes at two in the morning, until the person on the other end approves one just to make their phone shut up. That single tap is the whole breach. It’s how some of the most publicised compromises of the last few years started, and there’s nothing exotic about it. It’s a denial-of-patience attack.</p><p>The good news is that it’s loud. An attacker bombing someone with MFA prompts leaves a very recognisable shape in your sign-in logs, and you can find it with the same handful of KQL operators from the primer. This post builds that detection from nothing, one line at a time. If you haven’t read <a href="https://alanconlon.com/posts/sentinel-kql-primer/">the primer</a>, it’s the place to start; this one assumes you know what a pipe does.</p><h3>What does MFA fatigue look like in SigninLogs?</h3><p>Every MFA prompt that gets denied or times out lands in SigninLogs with a result code. The one that matters here is 500121, which is Entra&#39;s code for an MFA challenge that failed: the user declined it, ignored it, or it timed out. One of those on its own is nothing. Someone fat-fingered a prompt or left their phone in the kitchen.</p><p>The attack shape is different: a burst of them, against one account, in a short window. Ten denied prompts in fifteen minutes isn’t someone making tea. That clustering is the entire detection.</p><h3>Start by looking, not detecting</h3><p>Same discipline as always. Before writing anything clever, look at what the failures actually look like in your own tenant:</p><pre>SigninLogs<br>| where TimeGenerated &gt; ago(7d)<br>| where ResultType == &quot;500121&quot;<br>| take 20</pre><p>Run that and read the rows. You’ll see who’s failing MFA in an ordinary week, which apps trigger it, and roughly how often it happens when nothing is wrong. That baseline matters, because the difference between noise and an attack is volume against time, and you can’t judge volume until you’ve seen normal.</p><h3>Now add the shape</h3><p>The attack is a cluster, so we count failures per user inside small time windows. bin() chops time into buckets, and summarize counts inside them:</p><pre>SigninLogs<br>| where TimeGenerated &gt; ago(1d)<br>| where ResultType == &quot;500121&quot;<br>| summarize FailedPrompts = count() by UserPrincipalName, bin(TimeGenerated, 15m)<br>| where FailedPrompts &gt;= 8<br>| sort by FailedPrompts desc</pre><p>Read it as a sentence. Take the last day of sign-ins, keep only failed MFA challenges, count them per user per fifteen-minute window, and show me anyone with eight or more in a single window. That’s the whole detection, and it’s five lines.</p><p>The threshold is yours to tune. Eight in fifteen minutes is a reasonable starting point, but your baseline from the first query is the real guide. Set it low enough to catch a determined attacker, high enough that the person with a flaky Authenticator setup doesn’t set it off every morning.</p><h3>The refinement that makes it serious</h3><p>Here’s the version worth promoting to an analytics rule, and the thinking behind it. A burst of denied prompts is suspicious. A burst of denied prompts followed by a success is the actual disaster, because it means the bombing worked. Someone got tired and tapped approve.</p><pre>let Failures = SigninLogs<br>    | where TimeGenerated &gt; ago(1d)<br>    | where ResultType == &quot;500121&quot;<br>    | summarize FailedPrompts = count(), LastFail = max(TimeGenerated)<br>        by UserPrincipalName<br>    | where FailedPrompts &gt;= 8;<br>SigninLogs<br>| where TimeGenerated &gt; ago(1d)<br>| where ResultType == &quot;0&quot;<br>| join kind=inner Failures on UserPrincipalName<br>| where TimeGenerated &gt; LastFail<br>| project UserPrincipalName, FailedPrompts, LastFail,<br>    SuccessAt = TimeGenerated, IPAddress, Location, AppDisplayName</pre><p>Two new ideas, both small. let names a query so you can reuse it, here the set of accounts that got bombed. Then join matches those accounts against successful sign-ins (ResultType == &quot;0&quot;) that happened after the last failure. What comes out is the list you actually care about: accounts that were hammered and then let someone in, with the IP, location and app of the sign-in that got through.</p><p>If that query ever returns a row, stop hunting and treat it as an incident: that account needs its sessions revoked and its credentials reset before you finish your coffee.</p><p>Both queries from this post are in <a href="https://github.com/alanconlon/kql-hunting-queries/tree/main/queries/mfa-fatigue">the free queries repo</a>, commented line by line, with the window and threshold set as let values you can change.</p><h3>What it misses, because every detection misses something</h3><p>Honesty about the gaps is what separates a detection you trust from one you hope about. This one won’t see an attacker who paces themselves below your threshold, and it won’t catch number-matching bypasses or token theft, which don’t generate denied prompts at all. It also assumes push MFA; if you’ve already moved to phishing-resistant methods for privileged accounts, whole classes of this attack stop applying to those users, which is rather the point of moving.</p><p>None of that makes the query less worth running. It means this is one detection, not a strategy. The strategy is number matching turned on, phishing-resistant MFA for the accounts that matter most, enforced through <a href="https://alanconlon.com/posts/conditional-access-without-lockout/">Conditional Access</a>, and this query watching for the accounts still on push.</p><h3>Promote it slowly, same as always</h3><p>Run it in the logs for a week or two first. Watch what it catches, tune the threshold and the window to your tenant, and only then wire it into a scheduled analytics rule with an automation that flags the account. The rule you understand at 2am is the rule that was built slowly at 2pm. That was true in <a href="https://alanconlon.com/posts/sentinel-kql-primer/">the primer</a> and it doesn’t stop being true when the attack gets a scarier name.</p><p>The wider lesson is the one worth keeping. Good detections are rarely clever. This one is a count, a threshold and a join, and it catches an attack that has embarrassed some very large organisations. The gap was never the difficulty of the query. It was that nobody had opened the logs and asked.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon"><em>LinkedIn</em></a><em>. This is part of an ongoing KQL Hunting series: if you’d rather start from working detections than a blank query bar, my </em><a href="https://alanconlon.gumroad.com/l/kql-hunting-pack"><em>KQL Hunting Pack</em></a><em> is 12 ready-to-run queries covering exactly this kind of hunting.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5dacb7aa4a28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Many SCUs Does Security Copilot Actually Need? Sizing Capacity Without the Bill Shock]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://infosecwriteups.com/how-many-scus-does-security-copilot-actually-need-sizing-capacity-without-the-bill-shock-f641f0344ebe?source=rss-c3359b6bd79b------2"><img src="https://cdn-images-1.medium.com/max/1600/1*Rp1TAwZeOPvuCkMy_yKkdQ.png" width="1600"></a></p><p class="medium-feed-link"><a href="https://infosecwriteups.com/how-many-scus-does-security-copilot-actually-need-sizing-capacity-without-the-bill-shock-f641f0344ebe?source=rss-c3359b6bd79b------2">Continue reading on InfoSec Write-ups »</a></p></div>]]></description>
            <link>https://infosecwriteups.com/how-many-scus-does-security-copilot-actually-need-sizing-capacity-without-the-bill-shock-f641f0344ebe?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f641f0344ebe</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[microsoft-copilot]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 08:31:01 GMT</pubDate>
            <atom:updated>2026-10-31T09:54:08.425Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Setting Up Microsoft Security Copilot: Capacity, Roles, and the Defaults That Bite]]></title>
            <link>https://medium.com/@azure.alanconlon/setting-up-microsoft-security-copilot-capacity-roles-and-the-defaults-that-bite-3b9f016ed0d7?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b9f016ed0d7</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[security-copilot]]></category>
            <category><![CDATA[microsoft-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 08:31:01 GMT</pubDate>
            <atom:updated>2026-10-31T09:49:57.445Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Setting Up Microsoft Security Copilot: Capacity, Roles, and the Defaults That Bite" src="https://cdn-images-1.medium.com/max/1024/1*ckhqoLUYdeej7cDCAOH-yA.png" /></figure><p>Before you do anything with Security Copilot, check whether it’s already running. If your organisation is on Microsoft 365 E5 or E7, Microsoft may well have provisioned it for you, quietly, as part of the licence. It turns up with a monthly allocation of compute and a set of default roles already attached, and most people don’t notice until someone opens the portal and starts poking around. That “it’s already on” moment is exactly when the setup matters most, because the defaults are not what you’d choose if you’d sat down and thought about it.</p><p>I’ll leave the incident-investigation side for another day. The bit nobody walks you through is the enablement and the permissions, and that’s the bit that actually decides whether this thing is safe to have switched on.</p><h3>Is Security Copilot already turned on in your tenant?</h3><p>The licensing splits into two camps, and which one you’re in changes everything about setup.</p><p>If you’re on Microsoft 365 E5 or E7, Security Copilot is included and auto-provisioned. You get an allocation of Security Compute Units, the compute that powers it, scaled to your licence count: 400 units a month for every 1,000 paid user licences, up to a ceiling of 10,000. That allocation resets every month and doesn’t roll over, so unused capacity just evaporates. Nothing to buy, nothing to stand up. It’s on.</p><h3>What do you need before provisioning Security Copilot capacity?</h3><p>If you’re not on E5 or E7, none of that applies. You provision the compute yourself, which means an Azure subscription and someone with the right roles to create the capacity. That’s Azure Contributor or Owner on the subscription or resource group, plus Security Administrator or higher in the tenant. You also need to buy at least one provisioned SCU. Different starting line entirely, so confirm your licence position before you follow any guide, including this one. Half the confusion online comes from people following E5 steps without an E5 licence, or the reverse.</p><h3>What you’re actually paying for: compute units</h3><p>Security Copilot runs on Security Compute Units, or SCUs. On E5 or E7 they come from the included monthly allowance, and none of this section’s buying decisions apply. If you’re buying standalone, they come in two flavours. Provisioned capacity is always-on. You decide how many units to keep warm, and you pay for them by the hour whether Copilot does a single thing or sits idle all weekend. Overage is the opposite: on-demand units that kick in when you exhaust the provisioned ones, billed only when used.</p><p>The gotcha is the provisioned side. It’s billed hourly on what you’ve reserved, not on what you consume, so an oversized always-on allocation is money quietly leaving the building. If you’re just standing it up to have a look, Microsoft’s own recommendation is modest: three provisioned units with overage set to unlimited. On the standalone route you can’t go lower than one provisioned unit, though. Microsoft requires a minimum of one, so there’s no running purely on overage. One unit with overage on top is the cheapest way to trial it.</p><p>Provisioning the capacity needs more than a credit card. You’ll want Azure Contributor or Owner on the subscription or resource group, plus Security Administrator or higher in the tenant. The usage dashboard keeps ninety days of history, and it’s where you go to see what’s actually being consumed before you decide how much to reserve. Look at real usage first, size the capacity second. There’s a whole post on <a href="https://alanconlon.com/posts/security-copilot-scu-sizing/">sizing SCUs without overpaying</a>.</p><h3>The default depends on when you deployed</h3><p>Copilot Contributor isn’t a Microsoft Entra role. Security Copilot has its own two platform roles, Owner and Contributor, that live inside Copilot and only govern access to the platform itself. Who gets Contributor out of the box is the part that has changed, and it’s worth knowing which era your tenant belongs to.</p><p>New instances now default to the Recommended Microsoft Security roles group: a bundle that grants Contributor access only to users who already hold security-relevant Entra roles. That’s a sensible middle ground, and if you’re standing Copilot up fresh, it’s what you’ll get.</p><p>Older instances are a different story. Earlier deployments defaulted to granting Copilot Contributor to every user in the tenant through the built-in Everyone group, and existing customers who have that assignment keep it until someone removes it. So the day-one check is simple: open Role assignment and look at what’s actually there. If the Everyone group is still assigned, remove it and replace it with either the recommended roles bundle or a scoped group of the people who should genuinely have access. One wrinkle to know before you act: once the Everyone group is removed, it can’t be assigned again, so this is a one-way door (a good one, but a door).</p><p>If you do use your own groups, note that Security Copilot only supports role-assignable groups, and assign roles to groups rather than individuals. It’s less to manage and far easier to review six months later.</p><h3>Copilot inherits permissions, it doesn’t grant them</h3><p>This is the part that reassures people once they understand it, and trips them up before they do. Security Copilot uses on-behalf-of authentication, which means it can never see more than the signed-in user can already see. It has no privileges of its own. It borrows yours.</p><p>So Contributor access gets someone onto the platform, but it gets them no data. To actually pull Sentinel incidents, the user still needs a Sentinel role like Microsoft Sentinel Reader. To see devices and policies through the Intune connection, they need an Intune role. Defender is the same. The real scoping of what Copilot can touch happens in the underlying products, through their normal RBAC, not in Copilot’s own settings. That’s a good thing. It means your existing least-privilege model carries straight through.</p><p>It also means you should resist a tempting shortcut. Granting someone Security Administrator hands them Copilot Owner access automatically, but it also gives them a pile of tenant-wide security permissions that have nothing to do with Copilot. Microsoft says this plainly, and they’re right: don’t hand out a privileged role just to get someone into Copilot. Put the person in the scoped group instead.</p><h3>Owners, and why PIM belongs here</h3><p>A handful of Entra and Purview roles inherit Copilot Owner automatically: Global Administrator and Security Administrator as you’d expect, but also Billing Administrator, Intune Administrator and Compliance Administrator. A Billing Admin silently holding Copilot Owner is exactly the kind of default worth knowing about. Owner can manage capacity, plugins, workspaces and roles, so it’s worth knowing exactly who holds it by inheritance rather than by design.</p><p>For those high-privilege roles, this is textbook territory for Privileged Identity Management. Make them eligible rather than permanently assigned, require activation, and you shrink the standing pool of people who can reconfigure the platform down to nobody until somebody actually needs it. While you’re in Owner settings, turn on Logging audit data in Microsoft Purview, and make sure auditing is switched on in Purview itself. You’ll want those logs long before you think you need them.</p><h3>How do you set up Security Copilot workspaces?</h3><p>If you’re running more than one team or region, workspaces let you carve capacity up and right-size it per team, each backed by its own compute. If your tenant was set up automatically through E5 or E7, a default workspace was created for you, so it’s already there whether you’ve looked at it or not.</p><p>If you’re provisioning yourself, the first-run setup in the Security Copilot portal walks you through it:</p><ol><li>Pick the Azure subscription that will pay for the capacity.</li><li>Pick or create a resource group.</li><li>Give the capacity a name.</li><li>Choose the prompt evaluation location.</li><li>Set the number of provisioned SCUs, and decide on overage.</li><li>Link the capacity to your workspace.</li></ol><p>The rollout that works is the unexciting one. Start with a small provisioned allocation, even a single unit, a tightly scoped access group, owners locked behind PIM, audit logging on, and the underlying product RBAC doing the real gatekeeping. Watch the usage dashboard for a couple of weeks. Then, and only then, widen access and tune the capacity to what you’ve actually seen.</p><p>The interesting work, the investigations and the promptbooks, comes after all this. But none of it is safe or sensible until the boring part is done properly. Get the capacity sized, get the Everyone group out of Contributor, and let your existing permissions model do its job. That’s the whole setup, and it’s almost entirely things you already know how to do.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b9f016ed0d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conditional Access: Getting It Right Without Locking Yourself Out]]></title>
            <link>https://medium.com/@azure.alanconlon/conditional-access-getting-it-right-without-locking-yourself-out-5fc09b59f525?source=rss-c3359b6bd79b------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fc09b59f525</guid>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[conditional-access]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Alan Conlon]]></dc:creator>
            <pubDate>Tue, 14 Jul 2026 08:31:00 GMT</pubDate>
            <atom:updated>2026-10-31T09:50:24.580Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Conditional Access: Getting It Right Without Locking Yourself Out" src="https://cdn-images-1.medium.com/max/1024/1*8yU7TCPvyIXTBFbB_dPvnw.png" /></figure><p>Almost everyone who has run Entra ID for any length of time has a Conditional Access story, and it usually ends badly. Someone builds a sensible-looking policy, flips it straight to On, and within the hour the service desk is lighting up. Or worse: the person who built it can no longer sign in to turn it off. Conditional Access is one of the most powerful controls you have, and one of the easiest to hurt yourself with.</p><p>The mistakes are predictable, though. The same handful come up again and again, and none of them are exotic. Here are the ones worth knowing before you go near a production tenant.</p><h3>Break-glass accounts first, and exclude them from everything</h3><p>This is the one that saves you, so do it before anything else. You need at least two emergency access accounts: cloud-only, each with its own FIDO2 key or certificate (mandatory MFA applies to them too), not tied to any individual, and excluded from every Conditional Access policy you ever create.</p><p>The reasoning is blunt. Conditional Access can lock out everyone, and that includes you. A policy that demands a compliant device or a particular authentication method can, if it’s wrong, leave nobody able to sign in to switch it off. The break-glass accounts are your way back in. People skip this because it feels paranoid, right up until the afternoon it’s the only thing standing between them and a support ticket to Microsoft.</p><p>Exclude them from everything, then watch them like a hawk. Alert on every sign-in, because an account that bypasses all your controls is exactly what an attacker would love to find. There’s more on <a href="https://alanconlon.com/posts/break-glass-accounts/">setting break-glass accounts up properly</a>, including the alert query.</p><h3>How do you roll out a policy without locking everyone out?</h3><p>Report-only mode is the single best habit in Conditional Access, and the one most people skip because they’re in a hurry. A new policy set to report-only is evaluated against every sign-in and logged, but it doesn’t actually enforce anything. You get to see precisely who it would have blocked, and what it would have demanded, before it can do any damage.</p><p>Leave it there for a week or two and read the sign-in logs. You’ll nearly always find something you didn’t expect: a service account authenticating in a way you’d forgotten about, a group of users on a platform the policy quietly catches, a legitimate workflow you were about to break. Fix those first. Only then flip it to On.</p><p>The temptation to skip this is strongest exactly when you shouldn’t, when the policy feels obvious and low-risk. Those are the ones that bite.</p><h3>Block legacy authentication: the high-value policy you’re putting off</h3><p>If you do nothing else this year, block legacy authentication. Older protocols that predate modern auth, basic auth endpoints, legacy mail clients speaking POP, IMAP or SMTP AUTH, have no way to perform an MFA challenge. Conditional Access still sees them, but a policy that requires MFA can never be satisfied by them. Unless you block them outright, a password alone gets through. This is exactly why <a href="https://alanconlon.com/posts/hunting-password-spray-kql/">password spray attacks</a> still work in 2026: attackers deliberately target the legacy endpoints because they know MFA won’t be in the way.</p><p>The reason people delay is that they’re not sure what still depends on it, and they’re afraid of breaking something. Which is fair. So this is another one for report-only first: switch on a block-legacy-auth policy in report-only, watch what gets caught, chase down whatever’s still using it, and migrate it. The boring legwork is the actual job here. The policy itself takes thirty seconds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YttTXMmSCgLbPVyi.png" /></figure><p><em>Report-only turns “I don’t know what’ll break” into a list of names.</em></p><h3>“All users, all apps” is a bigger blast radius than it looks</h3><p>It’s tempting to scope a policy to everyone and everything because it feels thorough. Sometimes that’s right. Often it’s how you catch the one account or workload you really shouldn’t have.</p><p>Think about the blast radius before you save. Who is genuinely in scope, and what happens to the edge cases: the guests, the service principals, <a href="https://alanconlon.com/posts/hybrid-cloud-security-gaps/">the accounts synced from on-premises</a>, the break-glass accounts, the one team with a workflow that doesn’t fit the rule? Scope deliberately, exclude what needs excluding, and know what you’re aiming the thing at. A precise policy you understand beats a broad one you’re nervous about.</p><h3>Don’t build forty policies you’ll never understand again</h3><p>Conditional Access estates rot the same way permissions do. Someone adds a policy for a one-off project, names it “Test 3,” and never removes it. A year later there are thirty-odd policies, several overlapping, a couple contradicting each other, and nobody fully sure what the live behaviour actually is.</p><p>Keep the set small and name them so a stranger could read the list and understand your intent: who, what, and the condition, right there in the name. Review them on a schedule, because they will drift, and the drift is invisible until an incident forces you to read every one. The hard part isn’t technical, it’s the discipline to delete the policy nobody remembers creating.</p><h3>Test it before you trust it</h3><p>Microsoft gives you a What-If tool that simulates how your policies apply to a given user, app and condition. Use it. It costs nothing and it’ll show you interactions between policies you wouldn’t spot by reading them one at a time: the two that combine to block someone, or the exclusion that quietly cancels the control you thought you’d applied.</p><p>Between What-If and report-only logs, you’ve no real excuse to be guessing. A Conditional Access policy you haven’t tested is a policy you’re hoping about, and hope isn’t a control.</p><h3>What good Conditional Access looks like</h3><p>Good Conditional Access means a small set of policies you understand, can explain, and can stand over at 2am when something fires, rather than the most policies. Build them slowly, roll them out in report-only, exclude your way back in, and document what each one is for. None of it needs cleverness, just care, and care counts for a lot when one wrong toggle can lock out the building.</p><p><em>I write about security, Azure, data, and the practical side of running things. More at </em><a href="https://alanconlon.com/"><em>alanconlon.com</em></a><em>, or connect on </em><a href="https://www.linkedin.com/in/alanconlon"><em>LinkedIn</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fc09b59f525" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>