Breaking Entra: Identity Attacks You Can Recreate
Jonathan Elkabas
Overview
In the rapidly evolving landscape of cloud security, Microsoft Entra ID (formerly Azure Active Directory) stands as a critical control plane for countless organizations. Jonathan Elkabas's talk, "Breaking Entra: Identity Attacks You Can Recreate," at Wild West Hackin' Fest @ Mile High, delves into the often-overlooked vulnerabilities within this pervasive identity platform. The presentation dissects real-world attack paths leveraged by sophisticated threat actors and penetration testers, emphasizing that while "identity is the new perimeter" is a widely accepted truth, its implications are dangerously incomplete without a deep understanding of non-human identities.

Key moments
- 0:00 Introduction: Breaking Entra and Entra Goat
- 4:00 Unpacking the 'identity is the new perimeter' problem
- 14:00 Real-world case study: Midnight Blizzard on Microsoft
- 19:00 Introducing Entra Goat: The vulnerable Entra ID lab
- 26:00 Entra Goat Scenario 1: Owning dangerous app to Global Admin
- 39:00 Entra Goat Scenario 6: Advanced CBA bypass via CA upload
- 44:00 Mitigation strategies: Educate, emulate, and harden Entra ID
Breaking Entra: Identity Attacks You Can Recreate
Speakers: Jonathan Elkabas
Conference: Wild West Hackin' Fest @ Mile High
YouTube: https://www.youtube.com/watch?v=VoqdBa-WWC0
Overview
In the rapidly evolving landscape of cloud security, Microsoft Entra ID (formerly Azure Active Directory) stands as a critical control plane for countless organizations. Jonathan Elkabas's talk, "Breaking Entra: Identity Attacks You Can Recreate," at Wild West Hackin' Fest @ Mile High, delves into the often-overlooked vulnerabilities within this pervasive identity platform. The presentation dissects real-world attack paths leveraged by sophisticated threat actors and penetration testers, emphasizing that while "identity is the new perimeter" is a widely accepted truth, its implications are dangerously incomplete without a deep understanding of non-human identities.
Elkabas systematically exposes the "Entra ID jungle" – a complex environment rife with misconfigurations, sprawling permissions, and forgotten identities that create fertile ground for attackers. He argues that the vast majority of identities are non-human, such as service principals, managed identities, and the newly introduced agent IDs, and these are precisely where organizations are most vulnerable. To combat this, Elkabas introduces Entra Goat, a deliberately vulnerable lab environment designed to allow security professionals to safely deploy, practice, and understand these sophisticated attack techniques firsthand.
The core message is clear: understanding Entra ID's intricacies, particularly its non-human components, is paramount for both offense and defense. By providing a practical, hands-on platform, Entra Goat empowers individuals to move beyond theoretical knowledge and gain real-world experience in identifying and exploiting critical misconfigurations, thereby fostering a more robust security posture against the identity-centric attacks of today.
Background
▶ Watch: Introduction: Breaking Entra and Entra Goat (0:00)
The mantra "identity is the new perimeter" has permeated security discourse, signifying a shift from network-centric defenses to securing access and authentication. However, as Jonathan Elkabas highlights, this framing, while fundamentally correct, is often misinterpreted and dangerously incomplete. The common perception of "identity" typically revolves around human users logging in with usernames and passwords. This narrow focus overlooks the overwhelming majority of identities within modern cloud environments, which are non-human.
Elkabas underscores this critical oversight with compelling statistics from Microsoft's own 2024 state of multi-cloud security report. The report reveals a stark reality: for every human identity, there are approximately 10 workload identities in an average organization, a ratio that skyrockets to 1:50 for small and medium-sized businesses. This means over 80% of identities in 2024 were non-human, even before the massive shift towards AI. Compounding the problem, over 50% of the 209 million identities identified in the report were classified as "super identities"—a term Elkabas humorously rebrands as "super duper ultra mega pro max identity" due to their alarming definition: "A user or workload identity that has access to all permission and all resources across your entire cloud estate." Furthermore, a staggering 98% of all combined human and workload identity permissions are never actually used, creating an expansive "playground for attackers" rather than a secure perimeter.
To properly understand this attack surface, Elkabas meticulously breaks down the various types of non-human identities in Entra ID:
- Service Principals (Enterprise Applications): These are the identities behind applications that inherit permissions and roles to perform actions. They encompass Microsoft first-party apps, gallery apps from the marketplace, and custom applications deployed by organizations. They facilitate authentication and SSO.
- Managed Identities: Designed for service-to-service communication without managing credentials, these come in two forms:
- System-assigned: Tied to a specific Azure resource (e.g., a VM, Kubernetes instance, App Service, Azure Function). Azure manages their credentials internally.
- User-assigned: Can be shared across multiple resources, offering more flexibility.
- Agent Identities (new): A recent addition, these are associated with services like Copilot and Azure AI front-end. They utilize service principals behind the scenes, behaving much like applications. An Agent Identity Blueprint initiates Agent Identity Blueprint Principals, which then create Agent IDs, allowing multiple instances of the same agent ID across a tenant for use in various SaaS applications (e.g., Teams, M365 apps).
- (Less relevant for attack paths, but mentioned): Legacy apps without app registration and social IDPs for B2C scenarios.
The sheer volume and complexity of these overlapping identity types create what Elkabas vividly describes as the "Entra ID jungle." This "jungle" is characterized by:
- Over-provisioned permissions and graphic periscopes (referring to permissions beyond what's truly needed).
- Privileged groups bloated with inactive or unnecessary accounts.
- Forgotten identities with excessive roles, secrets, or certificates.
- Low-privileged users controlling critical applications or groups tied to directory roles.
- Chained roles through service principals.
Microsoft's report further quantifies this chaos: 58% of organizations are exposed to at least one attack path, 7% are exposed to more than 1,000 attack paths, and the average organization faces 351 attack paths. These statistics, coming directly from the product owner, underscore the pervasive nature of identity-related misconfigurations and the urgent need for a more comprehensive approach to Entra ID security.
Key Findings
▶ Watch: Real-world case study: Midnight Blizzard on Microsoft (14:00)
The central discoveries and contributions of Jonathan Elkabas's talk revolve around demystifying the complex attack surface within Microsoft Entra ID and providing a practical means to understand it. The key findings can be summarized as follows:
- Non-Human Identities are the Primary Attack Surface: The talk unequivocally establishes that the vast majority of identities in Entra ID are non-human (service principals, managed identities, agent IDs), and these are disproportionately targeted by attackers. Organizations' focus on human user security often leaves this expansive and highly privileged attack surface exposed.
- Entra ID's Complexity Breeds Misconfiguration: The intricate nature of Entra ID, with its numerous identity types, permission models, and overlapping features, creates an environment ripe for misconfigurations. These misconfigurations are not edge cases but are prevalent, with Microsoft's own data indicating hundreds of attack paths in an average organization.
- Legitimate Features are Abused for Privilege Escalation: Many seemingly benign or intended features within Entra ID, such as application ownership, eligible roles (via PIM), and certificate-based authentication (CBA), can be chained and exploited by attackers to escalate privileges from low-level access to full tenant compromise.
- App-Only Authentication Bypasses User-Centric Defenses: A recurring theme is the ability of attackers to leverage secrets or certificates tied to service principals to authenticate in an "app-only context." This bypasses common user-centric protections like Multi-Factor Authentication (MFA) and conditional access policies, making it a highly effective method for persistence and lateral movement.
- Real-World Attacks Leverage These Exact Paths: The Midnight Blizzard breach on Microsoft itself serves as a stark example that sophisticated state-sponsored attackers (APT29) are exploiting these very misconfigurations—specifically, privileged service principals—to achieve high-value objectives like reading executive emails. This validates the practical relevance of the attack paths discussed.
- Entra Goat as an Essential Learning and Validation Tool: The creation and presentation of Entra Goat is a significant contribution. It provides an open-source, deliberately vulnerable, and interactive lab environment that allows defenders and attackers alike to safely and repeatably experience, learn, and validate these complex Entra ID attack paths. This hands-on approach is crucial for translating theoretical knowledge into practical defensive strategies.
In essence, Elkabas highlights that Entra ID is a critical battleground where misconfigurations are the norm, legitimate features can be weaponized, and non-human identities are the most vulnerable targets. Entra Goat offers a much-needed platform to navigate this "jungle" and build practical skills to defend against these pervasive threats.
Technical Deep Dive
▶ Watch: Introducing Entra Goat: The vulnerable Entra ID lab (19:00)
Jonathan Elkabas provides a comprehensive technical deep dive into the vulnerabilities and attack paths prevalent in Microsoft Entra ID, illustrating how seemingly minor misconfigurations can lead to full tenant compromise. He anchors this discussion with a real-world case study and then presents Entra Goat, a hands-on laboratory for replicating these attacks.
The Midnight Blizzard Attack: A Real-World Blueprint
Elkabas uses the Midnight Blizzard (APT29/CozyBear) attack on Microsoft as a prime example of identity-based exploitation. This incident, which aimed to access executive emails, followed a remarkably straightforward, yet effective, chain:
- Password Spray: APT29 initiated a broad password spray attack against Microsoft's tenant.
- Legacy Account Compromise: They successfully compromised a legacy test account that was not protected by Multi-Factor Authentication (MFA). This highlights the danger of outdated or poorly secured accounts.
- Privileged Legacy Application Access: The compromised test account had access to a legacy application with elevated privileges. Crucially, the service principal behind this application in Microsoft's corporate tenant was highly privileged. Elkabas clarifies that an application registration's secret can grant access to the service instance wherever it's installed, allowing cross-tenant access if configured.
- Malicious OAuth App Consent & Impersonation: The attackers created a privileged account, granted consent to a malicious OAuth application, and then authenticated as the service principal associated with this malicious app. This allowed them to read executive mailboxes.
Elkabas emphasizes the lack of sophistication in the overall chain: a low-privilege user compromise leading to a privileged service principal, which then facilitated access to sensitive data. He notes that this exact attack path is mirrored in Entra Goat Scenario #2, demonstrating its practical relevance and ease of recreation.
Entra Goat: The Deliberately Vulnerable Lab
To enable hands-on learning, Elkabas introduces Entra Goat, an open-source, deliberately vulnerable, and "dirty" Entra ID environment. It's designed as a Capture The Flag (CTF)-style lab to simulate real-world misconfigurations and attack paths. Inspired by other "Goat" projects (WebGoat, Azure Goat), Entra Goat fills a critical gap for Entra ID education.
Key features of Entra Goat:
- Interactive and Story-Driven: Each scenario begins with a realistic backstory (e.g., how low-privilege access was gained, as direct brute-forcing is not allowed by Microsoft).
- Progressive Difficulty: Includes three beginner-friendly, one intermediate, and two advanced scenarios.
- PowerShell Solutions: All solutions and deployment scripts are written almost entirely in PowerShell, providing practical, actionable commands for enumeration and exploitation.
- Learning Aids: Scenarios come with mission outlines, step-by-step hints, setup/cleanup scripts, and full solution walkthroughs.
- Cost-Effective: Running Entra Goat is "around nothing" as Microsoft charges based on resources, not identities, making it accessible for extensive practice.
Entra Goat Scenario Walkthroughs
Elkabas then walks through six distinct attack scenarios implemented in Entra Goat, showcasing various exploitation techniques:
Scenario 1: Misowning Dangerous Owning a Mental to Global Admin
- Attack Path: Abuses legitimate application ownership.
- Details: The attacker starts as an owner of a service principal (application). As an owner, they can add a secret to the service principal. Authenticating with this secret establishes an app-only context, effectively bypassing MFA and other user-centric defenses. If this service principal happens to have a highly privileged role, such as Privileged Authentication Administrator (PIA), the attacker can then reset the password of any user in the tenant, including a Global Administrator. This highlights how a legitimate administrative feature can be weaponized.
Scenario 2: Low Access User with Flash Certificate
- Attack Path: Exploits a compromised certificate tied to a service principal.
- Details: The attacker gains access to a compromised certificate that is registered as a key credential property for a service principal. This certificate allows authentication without interactive input or MFA, again leveraging an app-only authentication path. The service principal in this scenario has the
appRoleAssignment.ReadWrite.Allpermission. The attacker uses this permission to grant the service principal theRoleManagement.ReadWrite.Directorypermission. After refreshing the token, the attacker can then grant any role to any identity, ultimately granting themselves Global Administrator privileges and resetting the GA password.
Scenario 3: Low Privilege User Owner of a Group with App Admin Role
- Attack Path: Chaining group ownership to application administration privileges.
- Details: The attacker starts as a low-privileged user who owns a specific group. This particular group has the Application Administrator (App Admin) role. By adding themselves to this group (as an owner can do), the attacker inherits the App Admin role. With App Admin privileges, they can add a secret to any service principal in the tenant. The challenge then becomes identifying which service principal to target. The attacker enumerates service principals, looking not for direct strong roles or permissions, but for one that is a member of a privileged group. Once such a service principal (e.g., "Identity Management Portal") is identified, a secret is added, and the attacker authenticates as it to reset the Global Admin password.
Scenario 4: Eligible Owner/Role (PIM)
- Attack Path: Abusing Privileged Identity Management (PIM) eligible roles and ownership.
- Details: This scenario introduces the concept of eligible roles/ownership, meaning the user doesn't have the privilege directly but can activate it. The attacker, starting as a low-privilege user, discovers they are an eligible owner of a group (e.g., "Application Operation Team"). They activate this ownership (via PIM API or UI), add themselves to the group, and then discover the group has an eligible App Admin role. Activating this role grants them App Admin privileges. The rest of the chain mirrors Scenario 3: add secret to a privileged service principal (found by enumerating group memberships), authenticate, and reset the Global Admin password.
Scenario 5: Custom Role + Administrative Unit (AU)
- Attack Path: Combining custom roles with Administrative Units (AUs) for targeted privilege escalation.
- Details: This complex scenario involves multiple eligible assignments. The attacker is an eligible member of an "HR support team" group, which has a custom role assigned. This custom role grants a specific action,
microsoft.entra.identity.user.basic.update, allowing the modification of any user's properties. Simultaneously, the attacker is an eligible owner of another group, "regional HR coordinator," which manages a specific Administrative Unit (AU) and possesses the Privileged Authentication Administrator (PIA) role over users within that AU. The combined attack involves using the custom role to update the Global Administrator's properties, effectively propagating the GA user into the target AU. Once the GA is within the AU, the attacker activates their ownership of the "regional HR coordinator" group, adds themselves, and can then reset the Global Admin's password using the PIA role scoped to the AU.
Scenario 6: Certificate-Based Authentication (CBA) Bypass
- Attack Path: Exploiting chained service principal ownership and CBA policy manipulation to impersonate a Global Admin.
- Details: The scenario begins with a cleartext password for a service principal named
legacy automation service. This service principal is an owner of another service principal (a configuration possible via API, though not the UI, for automation). The attacker authenticates as the first SP, adds a secret to the second SP, and then authenticates as the second SP. This second SP hasOrganization.ReadWrite.Allpermission, which allows uploading a Certificate Authority (CA) certificate to the tenant. - A critical hurdle: Certificate-Based Authentication (CBA) is initially disabled on the tenant. However, the attacker's initial user account is a member of a group with the Policy Administrator role. This role allows them to enable CBA for the tenant and, importantly, change its authentication strength from single-factor to multi-factor (required for admin logins).
- With CBA enabled and configured, the attacker proceeds: they create a self-signed CA certificate, then use this CA to sign a certificate for the Global Administrator user. They upload the root CA to the tenant, effectively turning it into an Identity Provider (IDP). Finally, they use the signed admin certificate to perform a passwordless login and impersonate the Global Administrator. This intricate chain demonstrates a multi-stage attack bypassing several security controls.
These scenarios vividly illustrate that Entra ID's complexity, combined with the power of non-human identities and the ability to chain seemingly disparate privileges, creates a rich environment for sophisticated attacks.
Demo / Proof of Concept
▶ Watch: Entra Goat Scenario 6: Advanced CBA bypass via CA upload (39:00)
The entire talk, particularly the latter half, serves as a comprehensive demonstration and proof of concept for the Entra Goat environment and the attack paths it simulates. While Jonathan Elkabas did not perform a live, real-time hacking demonstration during the presentation, he meticulously walked the audience through the design, functionality, and specific scenarios within Entra Goat.
Entra Goat itself is the Proof of Concept (PoC). It's an open-source, deliberately vulnerable, and dirty lab environment that is designed to be deployed by users in their own test tenants. Elkabas showed screenshots and explained the interactive interface of Entra Goat, which presents each scenario with a backstory, hints, and a flag submission mechanism. He stressed that the project provides the PowerShell scripts for both deploying the vulnerable configurations and for executing the attack steps, allowing users to experience the entire chain firsthand. This hands-on, repeatable environment serves as a powerful demonstration of how the discussed misconfigurations can be exploited and how attackers can navigate from low-level access to full tenant compromise. The fact that real-world attacks, like the Midnight Blizzard breach, are directly mirrored in Entra Goat scenarios further validates its effectiveness as a practical PoC.
Defensive Implications
▶ Watch: Mitigation strategies: Educate, emulate, and harden Entra ID (44:00)
The insights gleaned from Jonathan Elkabas's presentation and the Entra Goat project offer critical defensive implications for organizations securing their Microsoft Entra ID environments. Elkabas summarizes these actions under the mantra: "Educate, Emulate, and Harden."
- Educate:
- Understand Common Attacks: Defenders must actively learn about the prevalent Entra ID attack paths and misconfigurations. This goes beyond generic security awareness to a deep technical understanding of how identities, roles, and permissions interact.
- Invest in People, Not Just Tools: Elkabas strongly advocates for investing in security practitioners, researchers, and defenders. Tools (XDR, EDR, etc.) are only as effective as the people operating them. Human expertise in understanding, detecting, and responding to identity attacks is paramount.
- Emulate:
- Simulate and Reproduce Attacks: Organizations should actively simulate and reproduce identity attacks within safe, isolated environments. Entra Goat is explicitly designed for this purpose, allowing teams to generate logs, test custom detections, and validate their incident response playbooks against realistic scenarios.
- Validate Detections and Responses: Regular emulation helps ensure that existing security tools and team processes are capable of identifying and mitigating these specific attack chains. This continuous feedback loop is crucial for improving overall security posture.
- Harden:
- Enforce PIM Everywhere: Implement Privileged Identity Management (PIM) for all administrative roles and critical group memberships. This ensures that elevated privileges are granted just-in-time and just-enough, reducing the window of opportunity for attackers.
- Conditional Access Policies: Deploy robust Conditional Access policies to enforce strict controls based on user, device, location, and application context.
- MFA for Everyone: Enforce Multi-Factor Authentication (MFA) for all users, regardless of their privilege level. This is a fundamental control that significantly raises the bar for attackers, even against low-privileged accounts.
- Improve Telemetry and Playbooks: Develop comprehensive telemetry to log relevant Entra ID activities and create detailed incident response playbooks specifically tailored for identity-based compromises. Being prepared to catch and respond to attacks as they happen is vital.
- Prioritize Attack Paths by Risk: Given the average organization faces hundreds of attack paths, it's essential to prioritize them based on risk. Identify Tier 0 assets (critical identities, applications, or groups) whose compromise would lead to catastrophic impact, and focus hardening efforts there first.
- Leverage Free Entra ID Tools: Utilize open-source and free tools for assessing Entra ID security posture. Elkabas mentions:
- Purple Knight: A tool for identifying indicators of exposure and compromise in Entra ID (Elkabas contributed to its indicators).
- Zero Trust Assessment by Microsoft: An open-source assessment tool.
- My Estelle: Another open-source tool available on GitHub.
By embracing these defensive strategies, organizations can move beyond a superficial understanding of "identity as the perimeter" to actively protect their Entra ID environments against the sophisticated and often subtle attack techniques demonstrated.
Key Takeaways
- Non-Human Identities are the Primary Attack Surface: The vast majority of identities in Entra ID are non-human (service principals, managed identities, agent IDs), and these are the most common vectors for privilege escalation and tenant compromise.
- Entra ID's Complexity Fosters Misconfigurations: The "Entra ID jungle" – characterized by sprawling permissions, bloated groups, and overlapping identity types – creates numerous exploitable misconfigurations that are prevalent across organizations.
- Legitimate Features are Weaponized: Core Entra ID functionalities like application ownership, PIM-eligible roles, and certificate-based authentication can be abused by attackers to chain privileges and bypass traditional security controls.
- App-Only Authentication Bypasses MFA: Attacks often leverage secrets or certificates to authenticate in an "app-only context," bypassing user-centric defenses such as Multi-Factor Authentication (MFA) and conditional access.
- Entra Goat is a Critical Learning Tool: The open-source Entra Goat lab environment provides a safe, repeatable, and hands-on platform for security professionals to practice, understand, and validate real-world Entra ID attack paths.
- Defensive Strategy: Educate, Emulate, Harden: Effective defense requires continuous education on attack techniques, active emulation to test detections and responses, and comprehensive hardening including PIM, MFA for all, robust telemetry, and risk-based prioritization of attack paths.
About the Speaker(s)
Jonathan Elkabas is a security expert with a deep focus on Microsoft Entra ID (formerly Azure Active Directory) security. He is the creator of Entra Goat, an open-source, deliberately vulnerable lab environment designed to help security professionals understand and practice Entra ID attack paths. His passion for Capture The Flag (CTF) challenges and hands-on learning drives his work to make complex Entra ID security concepts accessible to a wider audience. Elkabas has also contributed to other prominent security tools, specifically mentioning his involvement in developing indicators of exposure and compromise for Purple Knight, a widely used tool for assessing Entra ID security posture. His expertise lies in identifying and articulating the real-world attack techniques used against cloud identity platforms, and translating that knowledge into practical, actionable insights for both offensive and defensive security teams.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Elkabas cuts through the 'identity is the new perimeter' marketing fluff to target the actual attack surface: non-human identities. The attack primitives aren't novel, but releasing Entra Goat gives defenders a desperately needed sandbox to chain Service Principal abuses and CBA bypasses without torching a production tenant.
Heather Calloway (CISO) — STRONG ACCEPT
This talk exposes the reality of modern Entra ID environments: non-human identities vastly outnumber human users and operate completely outside standard MFA controls. Elkabas breaks down the exact service principal attack paths used in the Midnight Blizzard breach and provides a free, deployable lab to train defense teams. It is a necessary reality check for any organization that believes securing human credentials equals securing the perimeter.
→ Top-rated talks at Wild West Hackin' Fest @ Mile High 2026