How to read a Microsoft Entra Sign-In Like an Investigator
23 minAudio
A Microsoft Entra sign-in log is more than a simple success or failure. In this episode, Alex and Maya examine how to read a sign-in event as an evidence trail, connecting identity, authentication, client and protocol, device, location, application, resource, Conditional Access, risk, status, error information, and correlation identifiers. The discussion focuses on an evidence-first investigation approach: start with the exact sign-in event, understand what actually happened during authentication, identify the policies and requirements that applied, and connect the available evidence before reaching a conclusion. The episode also examines how the same sign-in data can be used proactively to identify patterns such as legacy authentication, repeated failures, Conditional Access anomalies, unusual device activity, and suspicious risk signals. The central lesson is straightforward: don't just ask whether the sign-in succeeded. Ask what story the sign-in event tells you. This episode is based on the Support Engineering Blog article “Microsoft Entra Sign-In Logs Explained: A Field Guide for Administrators and SOC Teams”, including its sign-in event model, investigation guidance, worked example, and supporting diagrams. Chapters 00:00 - Read the Sign-In Differently 02:16 - Status, Errors, and Authentication 06:20 - Client, Device, and Location 08:40 - Application, Resource, and Policy 11:56 - Conditional Access and Session Controls 13:01 - Case Study: MFA Succeeded, Access Failed 15:24 - The Evidence-First Investigation 19:24 - From Troubleshooting to Threat Hunting Learn more: The full technical article, references and supporting resources are available through the Support Engineering Blog.
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
You are listening to Support Engineering Weekly. You know, it's a pretty universal experience for anyone working in IT or security. You're sitting there just staring at a Microsoft, and to sign in log, and the pressure is completely on. Oh yeah. Usually because a VIP user is locked out and the clock is ticking. Exactly. And the log gives you one incredibly unhelpful, incredibly stressful word, just failure. Right. It's just the worst.
And the temptation to just, you know, jump to the very first conclusion that pops into your head is overwhelming. You just want to reset their password to move on. Before we get too far into why that's a terrible idea though, I'm Alex. And I'm Maya. Thank you all for joining us on the steep dive today. Yeah. Thanks for being here. So returning to that failure log, it's so easy to just assume, right? It is entirely human nature to want that quick fix, especially when, you know, the ticketing queue is just backing up. We see a failure and our brains immediately construct the simplest narrative like they
must have typed their password wrong, right? Or maybe they ignored a multi factor authentication prompt on their phone. But if you're managing a modern cloud environment, relying on that single word is essentially operating blindfolded. So to take off that blindfold, we are diving into a stack of your sources today. We've got official Microsoft entry documentation, some battle tested SOC investigation playbooks and several real world case studies you all share. It's a really great mix of theory and actual practice.
It really is. And our mission for this deep dive is to completely transform how you read an ultra sign in log. We want to move you away from just, um, staring at a wall of disconnected data fields. Yeah. Instead, we're going to look at it as a forensic evidence trail or reconstruct the exact timeline of an access decision. So you can understand precisely who signed in, how they did it, where they came from, what they were trying to access, and ultimately the real mechanical reason why the system allowed or blocked them. Because building that timeline is really the only way to genuinely secure an environment.
If you're just guessing at the root cause based on a single field, you aren't actually troubleshooting. You're just playing a very stressful game of IT whack a mole. Exactly. Okay, let's unpack this. Every investigation has to screw somewhere. And for the vast majority of people, they look straight at that status field. Sure. I mean, it's front and center on the dashboard. Right. It's success or failure. But our sources are practically screaming at us that this is where the most dangerous operational assumptions are made. Because the status field is really just the door into your investigation.
When you see failure, you have to internalize just how ambiguous that categorization is in a zero trust architecture. Right. It could mean so many things. Yes. A failure could mean invalid credentials. Sure. But it could also mean an incomplete MFA challenge. It could mean the user's laptop missed a critical Windows update and suddenly, you know, fell out of compliance. Wow. Just from a missed update. Yeah. Or it could be an expired session token or even a back end database issue that has nothing to do with the user's identity. It's a symptom, right?
Not a diagnosis. Treating that status field as a diagnosis is honestly like looking at a check engine light on your car's dashboard. Oh, that's a good way to put it. Right. It tells you something is fundamentally wrong. You wouldn't take the car to a mechanic and tell them to like replace the entire engine just because the light turned on. I hope not. You plug in an OBD2 diagnostic scanner to read the specific codes, right? To find out if it's a misfiring cylinder or just a loose gas cap. And Microsoft Entra provides those exact diagnostic codes right next to the status.
They're labeled as error codes and they are your OBD2 scanner in this scenario. Okay. So how do we read them? For example, if you pull error pun 50126, that points you directly toward a credential mismatch. So that's our misfiring cylinder. Exactly. But if you see error code 5303, you're going down a completely different troubleshooting path. That code tells you a conditional access policy explicitly blocked the request. Okay. Wait. So if I get the code, why isn't that just the end of the story? If the scanner says it's a misfiring cylinder, I go fix the cylinder.
If the error code says 53003, why can't I just say, ah, conditional access blocked it and closed the ticket? Because the error code only tells you which system through the flag. It doesn't tell you why the system through it. To use your car analogy, you know the cylinder misfired, but you don't know if it's because of a bad spark plug, a faulty fuel injector or like a timing issue. Oh, I see. And identity management, knowing that conditional access intervened is just the beginning. You still have to figure out which specific policy was triggered and what condition the
user failed to meet. If you stop at the error code, you have a category of failure, but you're missing the root cause. So once we know the check engine light is on and we have our preliminary diagnostic code, the next logical step is to really lift the hood. Exactly. We need to figure out who or what tripped that alarm. That means looking at how the request was authenticated and where it originated. And this is where we shift our focus to the client application, the protocol being used and the authentication details. And I just, I cannot stress enough how much more valuable the actual sequence of these
authentication steps is compared to just looking at the final requirement. Yeah, I'm looking at the SOC playbooks in our sources and they spend a huge amount of time on this. For a listener who just wants to know if the user got in, why does the mechanical sequence of the authentication matter so much? Because the sequence tells you what the user or the attacker actually experienced. A lot of administrators will just ask, was MFA required for this login? Right. Which seems like a logical question. It does, but it's the wrong question. The better question is what mechanically happened at each step of the handshake.
The authentication details will map this out. Did the password succeed, but then the user actively hit decline on their phone's authenticator app. Oh, interesting. Or did the password succeed, but the system couldn't even prompt for MFA because the token was invalid. Those both end in an MFA failure status, but one is a user error and the other is a potential system misconfiguration. And the logs also show us the client and the protocol, which completely changes the context, right? The sources make this massive distinction between modern authentication and legacy protocols.
It's a huge distinction. Knowing whether a sign in came from a modern web browser using OAuth 2.0, or if it was an automated script, trying to connect using a legacy protocol like IMP or POP is critical. Let's break down why that is. Well, legacy protocols were designed decades ago, long before multi-factor authentication even existed. Mechanically, an IMAP connection simply does not know how to render a pop-up window to ask a user for a six-digit code. So if you enforce MFA on a legacy connection, it doesn't just gracefully prompt the user.
No, it just crashes into a wall and failed. That explains why attackers love them so much. If they have a stolen password, they try to bypass the MFA prompt entirely by using a protocol that can't even understand the prompt. Exactly. Okay, so we figured out how maybe they used a stolen password and a legacy script. Now I'm immediately wondering, where on earth is this script firing from? The logs give us location contexts like the IP address in the city. But I have to push back a bit on how trustworthy this is. Okay, go ahead.
The attacker is routing their traffic through a VPN or a proxy server. Doesn't that make the IP address and location fields basically useless? It's a very common trap to view that data is useless, but you have to shift your perspective on what UNTRA is actually logging. You're completely right that VPNs and proxies mask the physical location of the keyboard. Right. But UNTRA isn't a GPS tracker. The IPG location is merely a signal for the network identity that the system evaluated at the exact moment of the request.
So it's not about where the person physically is. It's about what network the system thinks it's talking to. Precisely, if your organization's conditional access policies are built to implicitly trust a specific corporate VPN IP address, then seeing that specific IP in the log explains the sister's behaviors. Exactly. It explains why the policy allowed the access, even if the user's physical body is sitting in a coffee shop in like another country. It provides contextual evidence for the mathematical access decision. That reframes it perfectly.
So we know how they authenticated and we know the network identity they presented to the system, but knowing all of that still doesn't explain the final access decision. Not fully. We need to know what they were trying to access and why the rules reacted the way they did. And looking at the logs, there's a distinction here between the application and the resource. I would just assume those were two words with the exact same thing. They are fundamentally different and confusing them will send you down a massive rabbit hole. Think of the application as the front door.
It's the client interface. This might be the Microsoft Teams app on your desktop or a specific web portal. The resource on the other hand is the backend service actually holding the data you want to touch. It might be the SharePoint backend or a specific API. So the application is the window and the resources, the vault inside the building. That's a really great way to visualize it. And what often happens is that the front door opens perfectly fine. The application loads, it connects and the user thinks everything is working. Right. They see the interface.
But when that application tries to query the backend resource, the vault, the request fails because the resource has much stricter access controls. If you only look at the application field in the log, you will see a successful connection and be incredibly confused as to why the log ultimately ends in a failure when the user tries to say load a file. Okay. Here's where it gets really interesting. When we start looking at those tricked access controls, this ties directly into conditional access and the documentation in our sources points out this wildly counterintuitive fact.
Oh, I know where you're going with this. Yeah. You can look at a conditional access policy in the log. See the word success written in bright green and the overall sign in can still be entirely blocked. How can a policy successfully evaluate a request and still result in a blocked user? To understand that, you have to understand how conditional access actually processes rules. It is not a single sequential gateway where you pass one guard and you're in. It's a stack of independent filters and it evaluates all of them simultaneously. Okay.
Let's say policy a dictates if you are outside the corporate network, you must use multi-factor authentication. The user provides their MFA token policy a evaluates the claim sees the token and logs a success. So the user passed that specific filter. Correct. But at the exact same millisecond policy B is running policy B dictates you can only access the specific financial backend resource from a corporate managed compliant device. Oh, if the user is trying to check their email from their personal unmanaged iPad, policy
B evaluates that device claim and logs a failure. So even though policy A was a complete success, the overall access decision is a block because policy B introduced an unmet requirement into the equation. It's a true zero trust model. Every single filter in the stack has to pass independently or the entire request gets caught in the net. Exactly. And this is where we get into combined grant controls. Organizations will often require MFA and require a compliant device. Passing one isn't enough. And untruth risk signals feed into the stack too, right?
Oh, absolutely. If the system detects impossible travel like a user logging in from New York and then attempting a login from London 10 minutes later, it elevates the user's risk score. That elevated score can trigger an entirely different hidden conditional access policy that requires a password reset. Wow. Okay. And the sources also bring up authentication context and session restrictions here. Yes. So authentication context is brilliant. Say the user gets into the app fine, but then they try to do something sensitive like download a restricted HR report.
Right. The system can dynamically step up the requirements right then and there. It might demand a stronger authentication strength. Wait, what does authentication strength mean in this context? Is it MFA just MFA? Not anymore. Authentication strength separates say a standard text message code from a FIDO2 security key. The policy might say, you got in with a text message. Fine. But to download this HR data, you need a phishing resistant FIDO2 key. Oh, that makes sense. And session restrictions. That's when the policy dictates how long the access is good for or if the user has to
reauthenticate every time they open the browser. So the app might work, but a session restriction policy forces them to sign in again anyway, which brings us back to the core philosophy of our sources. You have to read the entire story. If you only look at policy A, you'll think the system is broken because it says success, but the user is blocked. Exactly. Let's ground this theory. Walk step by step through one of the specific case studies provided in our sources. It's the MFA succeeded, but blocked mystery. A classic. This scenario perfectly proves why we have to synthesize all these separate fields, or
we will confidently draw the exact wrong conclusion. So set it up for us. Okay. It's a textbook investigation scenario. A user opens a ticket because they cannot access SharePoint. You pull up their sign and log. The status field proudly displays failure and it hands you error code 53003, which we know from our OBD2 scanner analogy means conditional access blocked the request. Yes. Now a rushed tier one support technician might see the failure. Assume the user simply fumbled their multi factor authentication and to send them a generic
email telling them to reset their authenticator app. Right. Because that's usually the easiest guess. But if we actually lift the hood and look at the authentication details, the log shows something completely different. It shows the MFA actually succeeded. Yeah. The password was correct and the authenticator app successfully generated and validated the token. So MFA is definitively not the problem. We keep moving down the evidence trail, right? We check the device information section of the log and we notice the device is marked with a status of non compliant. Yes.
This is where your biometric metaphor comes in handy. Yeah. So this user passing the MFA check is like passing a rigorous biometric retina scan at the front doors of a highly secure building. This system knows exactly who they are. Right. But then they get tackled by the security guards in the lobby. Why? Because they aren't wearing the required visitor badge. The biometric check worked flawlessly, but the environmental context failed. To confirm this, we check the conditional access section of the log. We see that a specific policy evaluated to failure and the log explicitly lists the
unmet requirement as require compliant device. The true story completely changes when you read the fields together. Yeah. If you had stopped at the failure status and guessed it was an MFA issue, you would have wasted hours on the phone having the user reinstall apps on their phone. Absolutely. When the mechanical reality is that their laptops, mobile device management agent probably just failed to sync or maybe they missed a required security patch rendering the device non compliant. The problem was the posture of the machine, not the identity of the user. Solving a mystery like that is incredibly satisfying.
It really is. But if you are an IT professional responsible for protecting an environment with tens of thousands of logins a day, you can't handcraft a bespoke investigation for every single failure. No, you'd never sleep. Right. This detective work has to become a repeatable, scalable operational habit. And the sources outline an evidence first troubleshooting model based on an 18 check administrator checklist to do exactly that. Yes, the 18 check list. Now 18 checks sound like a lot, but they cover every base we've discussed.
You can logically group them into four main buckets so you aren't just memorizing a massive list. Oh, good. Because 18 to three AM is tough. Exactly. So first you define the actor who attempted it, what client did they use and what protocol was involved. Second, you define the action. What application were they opening and what back end resource were they actually targeting? Got it. Actor than action. Third, you assess the environment. What was the location context? What was the device posture? And were there any elevated risk signals? Finally, you look at the decision.
What was the status? Which conditional access policies applied? What were the unmet requirements and what are the correlation IDs? Wait, stop right there. Correlation IDs. The sources mentioned them toward the end of the checklist, but for someone who hasn't spent years digging through Azure architecture, how does a random string of alphanumeric characters actually help me piece together an attack? Okay. Think of a correlation ID like a restaurant order ticket. Okay. When you place a complicated order, the waiter takes it and writes it on ticket number 45.
That ticket goes to the kitchen for the food, to the bartender for the drinks and to the cashier for the bill. Right. If your drink comes out wrong, the manager doesn't just yell into the void. They look for ticket number 45 at the bar to see what happened. In Entra, a single sign-in request might touch a dozen different back-end microservices. The correlation ID is the ticket number attached to that specific request. Oh, that makes so much sense. So if you were trying to figure out why a database query failed after a successful login, you search the logs across all your systems for that exact correlation ID to trace the
requests journey. That makes the invisible architecture so much easier to visualize. But what about when we want to make changes? Like if we figure out a policy is wrong, we don't just change it and pray, right? Never just change it and pray. The checklist explicitly includes validation mechanisms before you make production changes. Specifically, the report-only mode and the what-if tool. How did those fit in? If you're building a new policy based on your investigation, you put it in report-only mode first. It evaluates sign-ins but doesn't actually block anything so you can check the logs to
see what would have happened. And the what-if tool lets you simulate a login. You punch in the user, the app, the IP, and it tells you exactly which policies will trigger. So it's basically a sandbox for your security rules. Exactly. It prevents you from accidentally locking up the CEO while you're trying to fix it to your one issue. Good call. So what does this all mean? I'm putting myself in the shoes of our listeners. It's a high pressure, 3 a.m. outage. The CEO is locked out of a critical financial file. Am I supposed to mentally recite these four buckets and all 18 points while my phone is
blowing up? Not at all. And the sources are very clear on this. The 18 check model is a mental framework. It is not a rigid procedure you have to execute sequentially every single time. Thank goodness. The secret to fast troubleshooting is starting with the specific question you want to answer. If your question is why did the policy engine block this? Co, you skip the location and the client and jump straight to the conditional access policies and the unmet requirements. Right. Your question is did they even type the right password before failing? Co, you jump straight to the authentication details.
You only interrogate the fields that are relevant to the question you were asking. It's about being deliberate with your attention rather than being overwhelmed by data. And once you master that targeted approach, the sources reveal a massive operational shift. You stop just reacting to broken login tickets and you start using these exact same logs to proactively hunt for threats. The logs you use to fix a CEO's iPad are the exact same forensic logs a security operations center uses to hunt for nation state actors.
The only difference is the scale. Because at that level, you're looking for behavioral patterns, not just single events. Yes. You zoom out from individual failures and look at the aggregate trends. For example, are we suddenly seeing a massive spike in successful sign-ins using legacy protocols like IMAP coming from infrastructure we don't recognize? That would be bad. That is a massive red flag that someone is bypassing modern security controls. Or are we seeing a user who normally has zero issues suddenly generating 50 MFA user-declined events in the span of 10 minutes followed by a single success?
Let's mechanically break that down because the source is called an MFA fatigue attack. How does that actually work? It exploits human psychology rather than software vulnerabilities. The attacker has the user's password. They trigger the login, which sends an MFA push notification to the user's phone. Okay. And the user declines it naturally. Right. But the attacker immediately triggers it again and again and again, the user's phone is buzzing relentlessly during dinner or in the middle of the night. Oh, that sounds awful. It is. And eventually out of sheer annoyance or confusion, the user hits approve just to make the phone
stop buzzing. In the logs, you see a massive string of failures culminating in a success, which tells you the identity has been compromised. You can also hunt for sudden widespread changes in device compliance, right? If an entire department suddenly throws non-compliant errors, it could mean a benign but broken update rolled out. Sure. But it could also mean something much more malicious is actively tampering with the endpoint security agents on those machines, trying to blind the system before an attack. Exactly.
The ultimate goal of log analysis isn't to elect more data. It is to identify the patterns within the data that actually deserve human investigation. This has been incredibly eye opening. If we synthesize everything from our sources today, the ultimate takeaway is that an intrasign in log is not a binary switch of success or failure. It is the complex nuanced story of an access decision. And you must read it in order to comprehend that story. You identify WHO the identity is, how they attempted to authenticate, where the network
requests originated, what specific back-end resource they were targeting, WHOY the Stack Policy Engine reacted the way it did, what the final result was, and how to correlate that event across the broader architecture. The most effective investigators don't just ask if a sign-in succeeded, they ask what mechanical story the event is trying to tell them. Absolutely. It completely changes how you look at that dashboard. You stop seeing a wall of text and start seeing a timeline. But I want to leave you with a final forward-looking question to mull over as you head back to your own environments.
Oh, I like this one. We spent this entire deep dive talking about how to spot abrupt, noisy blocks, a non-compliant device, a failed password, or a barrage of MFA prompts. But what happens when an attacker slowly and deliberately mimics a user's normal routine over a period of months? If the risk signals shift so gradually that they never trip a static conditional access block, how do you spot a slow-moving anomaly in a sea of success logs before it's too late? That's the real challenge.
You've been listening to Support Engineering Weekly from the Support Engineering Blog. For the full articles, references, and technical resources from today's discussion, visit the URL blog.sadhan.ch. Until next week, keep troubleshooting, keep learning, and keep engineering. Thank you for listening to Support Engineering Weekly. This podcast is available on Spotify, Apple Podcast, YouTube, and other major podcast platforms. Follow the show on your preferred platform and never miss an episode.
What happens when a routine network maintenance operation triggers a failure deep inside a cloud provider's authentication infrastructure? In this week's episode, Alex and Maya investigate how a seemingly isolated...
How can a routine network capacity upgrade trigger a global cloud outage - and why can the very systems designed to protect availability make the failure worse? In this Support Engineering Weekly bonus episode, Alex and...
Microsoft 365 administrators deal with information from several places: the Microsoft 365 Roadmap, Message Center, and Service Health. But knowing where to find an update is only part of the challenge. The real question...
A server under pressure fails its health checks. Automated traffic management removes it from service, pushing even more load onto the remaining infrastructure. What was designed to protect the system becomes part of...
Microsoft Project Online is approaching retirement - or, in this case, its retirement date has already passed. But replacing a project management platform is not as simple as moving tasks from one product to another. In...