EntraGoat: a deliberately broken Entra ID tenant you deploy yourself

A tenant that is broken on purpose, in a black-box format

EntraGoat is a deliberately vulnerable Microsoft Entra ID infrastructure for security professionals. The description frames the whole thing in one line: deploy real-world identity misconfigurations and privilege escalation paths in your own tenant, then practise exploiting them in a safe, black-box CTF format.

The design choice that makes it different from a slide deck is that the misconfiguration is real. Rather than describing an overprivileged app registration, the project creates one in an actual tenant, with actual Graph API objects behind it, and then asks the participant to find it. The person learning cannot read the setup script and cheat, because the exercise is presented as black box.

That design has a cost the reader should be clear about. Nothing here runs against somebody else's identity provider. The whole environment is yours, which means you need a tenant you can afford to break, and that is exactly the constraint the README states. A test or trial tenant with a Global Administrator is a prerequisite, not a suggestion.

The audience is security professionals and the teams that train them, from identity administrators who need to feel the failure modes to detection engineers who need to know what the attacker sees. The three things it offers per scenario, a setup script, a cleanup script and a solution walkthrough, are the three things a training exercise needs, and the presence of a hidden flag makes it usable as a capture-the-flag exercise rather than only as a walkthrough.

The project is from Semperis, a vendor working on identity security, and it has been presented at Black Hat USA 2025, DEF CON 33, BSides Frankfurt 2025, SEC-T 0x11, Black Hat SecTor 2025, Black Hat Europe 2025 and Black Hat Asia 2026, which tells you where the audience is.

Six challenges that escalate from ownership to certificates

The challenge list is the curriculum, and the difficulty labels give the intended order: three Beginner, one Intermediate and two Advanced.

Scenario 1, Misowned and Dangerous, is Owner's Manual to Global Admin, and it deals with the same territory as the project's own blog post on service principal ownership abuse. If you own an app registration or a service principal, the ownership itself is a path to a privileged role, and no credential has to be stolen for that to work.

Scenario 2, Graph Me the Crown (and Role), is the app-only Graph permissions path, matching the blog post on exploiting app-only Graph permissions in Entra ID. The technique is that an application's permissions are granted to the application rather than to a user, so a token acquired for the app can carry directory-wide rights.

Scenario 3, Group MemberShipwreck, is group membership, which is the mundane mechanism behind a great many real escalations: adding a principal to a group that holds a role is a legitimate administrative action with a privileged result.

Scenario 4, I (Eligibly) Own That, moves to Intermediate and picks up the eligibility angle on ownership. Scenario 5, Department of Escalations, is Advanced and deals with administrative units, since restricting who can administer a subset of the directory is exactly the kind of control whose misconfiguration produces a lateral path to tenant-wide privilege.

Scenario 6, CBA (Certificate Bypass Authority), is Root Access Granted, and it is the certificate-based authentication abuse path covered by another of the project's blog posts. It is the hardest scenario on the list and it targets the modern pivot away from passwords.

The progression is coherent. Ownership, then application permissions, then group membership, then eligibility rules, then delegated administration, then certificates. Each step is a different corner of Entra ID administration, so a team running the whole set covers a spread of identity attack surface rather than one technique repeatedly.

Three ways to run it, and only one needs a browser toolchain

Setup starts with two prerequisites: a Microsoft Entra ID test or trial tenant with a Global Administrator, and the Microsoft Graph PowerShell SDK. Everything the project does to the tenant goes through Graph, so that module is not optional.

Option A is the recommended path, a PowerShell GUI, and it needs no Node.js:

git clone https://github.com/Semperis/EntraGoat && cd EntraGoat
Install-Module Microsoft.Graph -Scope CurrentUser -Force
.\Start-EntraGoat.ps1

The README notes that this route requires Windows with WPF, and it works on PowerShell 5.1 and later as well as PowerShell 7 and later. The GUI is a desktop application, with zoom shortcuts on Ctrl+Plus, Ctrl+Minus and Ctrl+0, and the screenshots show a home view and a challenge view, along with separate terminal output for setup and cleanup.

Option B is a web interface, and it does pull in a Node.js toolchain:

git clone https://github.com/Semperis/EntraGoat && cd EntraGoat
Install-Module Microsoft.Graph -Scope CurrentUser -Force
cd frontend && npm install && npm start

That one serves the interface on a local port:

http://localhost:3000

Option C skips the interfaces entirely and runs the scenario scripts by hand, which is what you want when you are scripting a training session:

cd scenarios
.\EntraGoat-Scenario1-Setup.ps1

All three share the same first two steps, cloning the repository and installing the Graph module for the current user with force, so the difference is only in how you drive the scenarios afterwards.

Setup, cleanup and solutions are separate directories

The repository layout shows how the pieces are kept apart. scenarios/ holds the per challenge setup scripts, solutions/ holds the walkthroughs, cleanups/ holds the teardown scripts, and EntraGoatGUI/ is the desktop application that fronts all of it. The frontend/ directory is the web interface, docs/ holds the documentation, and attackpathimages/ and assets/ hold the images used to draw attack paths.

The cleanup scripts deserve more attention than they usually get. A lab that creates a service principal, an app registration, group memberships and certificate credentials in your directory leaves those objects behind unless something removes them, and a training environment that leaves an attacker-like object in a tenant is a liability for whoever administers that tenant next. The README lists a cleanup script for every scenario, and the terminal output screenshots show setup and cleanup side by side, which suggests the workflow is expected to be script, practise, then undo.

The solution walkthroughs are also present per scenario, and each challenge carries a hidden flag. That combination, a flag to check and a walkthrough to read afterwards, is what makes the format usable both as an individual practice session and as a facilitated exercise where a facilitator holds the solutions back.

The documentation directory also has a getting started guide, and the README points at it for detailed setup instructions, which is where you should look before running anything in a tenant you care about.

MIT licensed, with a disclaimer that defines the boundary

The licence is MIT, with the LICENSE file in the repository root, and the README carries a disclaimer that says the project is for educational and authorised testing only, that you should use a dedicated test tenant, and that the authors assume no liability for misuse.

Read that disclaimer as a technical constraint rather than a legal formality. The project is designed to create, in a live Entra ID directory, exactly the objects that a real attacker creates when escalating privilege. In a production tenant, those objects can be used against other applications, against conditional access policies and against other tenants through app consent. The mitigation the project offers is procedural: a throwaway tenant, and the cleanup scripts.

The blog posts published alongside the repository fill in the reasoning for each scenario, with write-ups on what EntraGoat is, on getting started with the lab, and on the three techniques the scenarios cover, service principal ownership abuse, app-only Graph permissions and certificate-based authentication abuse. Those write-ups are the teaching material, and they exist separately from the exercises, so a facilitator can point people at the exercise first and the write-up later.

On the state of the repository itself: it is not archived, there are no GitHub releases, and the last push was on 2026-05-06. There is no version tag to pin and no changelog to read, so a trainer who has run the scenarios once has no documented way to tell what changed since, other than the commit history.

A self-deployed lab against a managed CTF platform

There are two other ways to train people on Entra ID misconfiguration, and the difference in approach is worth being explicit about.

The first is a self-built lab, which is what EntraGoat essentially automates. You stand up a tenant, you create the vulnerable objects, and the trainee breaks them. The advantage is realism: the same Graph API objects, the same role definitions and the same certificate workflows that exist in production, exercised against a live directory. The cost is that the lab is only as good as the tenant you provision, the licensing you hold for that tenant, and the hours your admin spends resetting it, and the trainee has to be given Global Administrator, which is a privilege most organisations do not hand out casually.

The second is a managed CTF platform, where the target infrastructure is provided and the participant only attacks. Nothing has to be created, nothing has to be cleaned up, and the exercise can be repeated across a cohort without an admin in the loop. The price is that the target is a re-creation rather than the real thing, so the participant learns the platform's approximation of Entra ID rather than Entra ID.

EntraGoat sits in the first camp and pushes toward the boundary: the environments are real, the challenges are small and hand authored, six of them, and the difficulty ladder is short. For a team that wants a repeatable exercise on ownership abuse or app-only permissions, that combination of realism and a known length is exactly the trade they are making. For a curriculum that needs broader coverage, the scenario directory is the place to extend, since the setup script, cleanup script, solution and flag structure is consistent across all six.

Editorial conclusion

Adopt EntraGoat if you train identity security engineers and want them to practise Entra ID privilege escalation against a tenant they can actually break, with the option of cleaning up after each scenario. Do not run it against a production tenant, because the README requires a dedicated test or trial tenant, and do not adopt it as an assessment platform, since there is no scoring service, the challenges end at six, and the repository publishes no GitHub releases, so the last push on 2026-05-06 is the only version marker you get. Before your first session, create a throwaway tenant with a Global Administrator, install the Microsoft.Graph PowerShell module, and read docs/getting-started.md so you know how the setup and cleanup scripts behave before you point them at anything.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Semperis/EntraGoat on GitHub