How We’ve Gone Completely Phishing-resistant (And So Can You!)
Eric Woodruff
Overview
In his CypherCon talk, "How We’ve Gone Completely Phishing-resistant (And So Can You!)," Eric Woodruff, Chief Identity Architect at Semperis, delved into the often-overlooked vulnerabilities lurking within Software-as-a-Service (SaaS) application integrations, particularly those leveraging Entra ID (formerly Azure Active Directory) as their identity provider (IDP). Dubbing the current state a "Swiss cheese of SaaS identity security," Woodruff highlighted a significant gap in an organization's security posture that extends beyond the well-researched confines of Azure and Microsoft 365. This talk, framed as a "purple team" perspective, bridges the offensive and defensive strategies crucial for securing the sprawling ecosystem of SaaS applications.

Key moments
- 2:00 Swiss cheese of SAS identity security problem
- 10:50 Entra app owner abuse: Global Admin elevation
- 16:00 SAML response manipulation to impersonate users
- 22:00 nOAuth vulnerability: Email keying for impersonation
- 30:00 Multi-IDP bypass: Circumventing Entra security
- 34:00 Enterprise defense: Closing the Google authentication gap
- 40:00 Detection challenges and future of SAS security
The Swiss Cheese of SaaS Identity Security: Plugging the Holes in Your Entra ID Integrations
Speakers: Eric Woodruff, Chief Identity Architect, Semperis, Microsoft MVP Security
Conference: CypherCon
YouTube: https://www.youtube.com/watch?v=rhayRIBqoQQ
Overview
In his CypherCon talk, "How We’ve Gone Completely Phishing-resistant (And So Can You!)," Eric Woodruff, Chief Identity Architect at Semperis, delved into the often-overlooked vulnerabilities lurking within Software-as-a-Service (SaaS) application integrations, particularly those leveraging Entra ID (formerly Azure Active Directory) as their identity provider (IDP). Dubbing the current state a "Swiss cheese of SaaS identity security," Woodruff highlighted a significant gap in an organization's security posture that extends beyond the well-researched confines of Azure and Microsoft 365. This talk, framed as a "purple team" perspective, bridges the offensive and defensive strategies crucial for securing the sprawling ecosystem of SaaS applications.
The core problem, as Woodruff articulates, is that while much security research focuses on securing the IDP itself, the "grey area" between the IDP and the SaaS application (or service provider) remains largely unexamined and exploited. Organizations routinely integrate hundreds of SaaS applications with Entra ID for Single Sign-On (SSO), Conditional Access (CA), and Multi-Factor Authentication (MFA). However, misconfigurations, developer oversight, and vendor design choices in this interstitial space create numerous attack paths that can bypass robust IDP security controls, leading to privilege escalation, data breaches, and complete circumvention of corporate security policies.
This talk is critical for any organization relying on Entra ID for identity management across its SaaS portfolio. Woodruff exposes practical, low-effort attack vectors that can lead to significant compromise, demonstrating how seemingly innocuous configurations or standard vendor features can become potent tools for attackers. By shedding light on these hidden vulnerabilities, the talk serves as a stark reminder that true phishing resistance and comprehensive identity security demand vigilance not just within the IDP, but across the entire, complex fabric of integrated cloud applications.
Background
▶ Watch: Swiss cheese of SAS identity security problem (2:00)
The modern enterprise landscape is characterized by its heavy reliance on SaaS applications, with many organizations utilizing hundreds of these services. While Entra ID (or other IDPs like Okta) provides a centralized mechanism for authentication and authorization, integrating these applications introduces a complex security surface. Traditional security research has extensively covered vulnerabilities within Azure and Microsoft 365, but the security posture of individual SaaS applications and, more critically, the interfaces and trust relationships between the IDP and these applications, often receive less scrutiny.
Woodruff emphasizes this "grey area" — the nebulous space between the identity provider and the service provider where subtle misconfigurations or inherent design choices can lead to significant security weaknesses. This problem exists because:
- Delegation and Convenience: IDPs often provide roles like "owner" to delegate management of application registrations, intending to simplify administration but inadvertently creating powerful attack paths.
- Developer Oversight: Developers, under pressure to deliver functionality, may not fully adhere to stringent OpenID Connect (OIDC) or SAML standards, leading to exploitable implementations.
- Vendor Design for Adoption: SaaS vendors prioritize ease of adoption, often supporting multiple identity providers or local authentication methods that can bypass enterprise IDP controls designed for security.
- Measurement Difficulty: The security implications in this grey area are notoriously hard to measure and detect because they often involve actions that either occur outside the IDP's logging purview or require complex correlation of disparate logs.
Woodruff references Push Security's SaaS Attack Matrix as a valuable resource for understanding these vulnerabilities, aligning some of his findings with their framework. The existence of such a matrix underscores the growing recognition of SaaS-specific attack vectors, moving beyond traditional network or endpoint security concerns to address the unique challenges of cloud identity.
Key Findings
▶ Watch: SAML response manipulation to impersonate users (16:00)
Eric Woodruff's presentation unveiled several critical vulnerabilities and attack vectors stemming from the intersection of Entra ID and SaaS applications, which collectively undermine an organization's security posture:
- Tenant Administration Abuses (Entra Application Owner Role): The prevalent practice of assigning the "owner" role to application registrations or service principals in Entra ID creates a direct attack path. This role lacks granular controls and Privileged Identity Management (PIM) integration, allowing a compromised non-privileged user to gain full control over the associated application, including the ability to manage credentials and manipulate authentication responses.
- SAML Claims Transformation for Impersonation: Owners of SAML-integrated applications can manipulate SAML claims transforms within Entra ID. This allows an attacker to alter attributes in the SAML response, effectively impersonating any other user within the connected SaaS application, bypassing its internal authorization checks.
- Developer-Derived Abuses (nOAuth Vulnerability): This vulnerability, first published by Descope in June 2023, arises from developers improperly implementing OpenID Connect (OIDC). Specifically, vulnerable SaaS applications key user identities off mutable attributes like email addresses rather than immutable pairwise identifiers (
subjectandissuer). This enables cross-tenant attacks where an attacker, knowing only a victim's email, can authenticate as that victim from an "evil tenant," gaining access to the SaaS application and potentially pivoting into integrated Microsoft 365 resources (e.g., Exchange Online). Microsoft views this as a developer responsibility, making it exceptionally difficult to detect or defend against from the IDP side. - Vendor-Derived Abuses (Multi-IDP Support Bypass): Many SaaS applications support authentication from multiple identity providers (e.g., Microsoft, Google, local accounts). This convenience feature can be abused. An attacker can create a Google account using a victim's corporate email address and then authenticate to the SaaS application via Google, completely bypassing Entra ID's Conditional Access (CA), MFA, and sign-in logging. The SaaS application often "merges" these identities based on the email address, treating them as the same user.
- Local Authentication Bypass: Even when SSO is configured, some SaaS applications retain the option for users to create and use local usernames and passwords. This provides another direct bypass of all Entra ID security controls, allowing access to potentially sensitive data stored within the SaaS platform without any IDP oversight.
These findings collectively illustrate a significant blind spot in enterprise security, where the focus on securing the core IDP infrastructure can inadvertently leave the perimeter wide open through integrated applications.
Technical Deep Dive
▶ Watch: nOAuth vulnerability: Email keying for impersonation (22:00)
Woodruff's talk provided several technical deep dives into the mechanics of these abuses, primarily focusing on Entra ID and its interactions with SaaS applications.
Entra ID Application Ownership and Privilege Escalation
The core of several abuses lies in the misunderstanding and misuse of application ownership within Entra ID.
- App Registration vs. Service Principal: Woodruff clarified the distinction: an app registration is the developer's blueprint, defining what an application needs (e.g.,
Calendars.Read). A service principal is the security object in a tenant where permissions are actually granted and which appears in audit logs. There's a one-to-one relationship in a single-tenant app, but multi-tenant apps have one app registration in the developer's tenant and service principals in each consuming tenant. - The Problem with Owner: Microsoft pushes assigning "owner" to app registrations/service principals for delegation. However, this role grants broad, non-granular permissions, allowing the owner to manage credentials (secrets/certificates) on the object. Crucially, it lacks Privileged Identity Management (PIM) integration and is not treated as a privileged role by Entra ID's admin protection.
- Privilege Escalation Scenario (Nester Wilk Example):
- An attacker (Nester Wilk) gains ownership of a service principal.
- This service principal has a highly privileged permission, such as
RoleManagement.ReadWrite.Directory. This permission allows assigning any user to any role in Entra ID without PIM or other checks. Woodruff identifies this as one of "six to twelve" highly privileged permissions attackers love. - Nester, a regular user with no assigned roles, connects to Microsoft Graph using credentials he created on the owned service principal.
- He enumerates Entra ID, finds the
Global Administratorrole, and identifies his own object ID. - He then uses the
RoleManagement.ReadWrite.Directorypermission to update the list of Global Admins, adding himself. - Result: Nester becomes a Global Administrator.
- Detection Challenge: Entra ID audit logs can take 10-15 minutes to hit a SIEM, providing a significant window for attackers.
SAML Claims Transformation
SAML-based SSO is widely used, and misconfigurations here are potent.
- SAML Flow: A user browses to a SaaS app (Service Provider, SP), gets a SAML request, passes it to Entra ID (IDP), authenticates, and receives a SAML response (proxied through the client) from Entra ID, which the SP uses to grant access.
- Claims Transform Abuse (Nester and ServiceNow):
- Nester, as owner of the ServiceNow service principal in Entra ID, accesses its SAML configuration.
- He creates a claims transform rule. This rule states: "If the incoming username (UPN) is Nester's, then instead emit the UPN of Alex Wilbur (an admin in ServiceNow)."
- When Nester signs into ServiceNow, Entra ID processes his authentication, applies the claims transform, and sends a SAML response indicating the user is Alex Wilbur.
- ServiceNow, seeing Alex Wilbur's UPN, grants Nester Alex's administrative privileges.
- Detection Challenge: Configuring this claims transform is not visible in Entra ID audit logs because it's not a Graph API configuration. Detection requires manually inspecting application configurations, which is rarely done regularly.
nOAuth Vulnerability (OpenID Connect Misimplementation)
This cross-tenant attack highlights a fundamental flaw in how some SaaS applications handle OIDC.
- Standard OIDC: When Eric signs into a compliant SaaS app, an ID token is generated. This token contains various attributes, including
subject(an immutable pairwise identifier unique to the user and client) andissuer(the IDP). The SaaS app stores this information and reliably identifies Eric every time based on these immutable identifiers. - nOAuth Vulnerable OIDC:
- A vulnerable SaaS application keys user identity off a mutable attribute like the email address.
- An "evil tenant" user creates an account with their UPN (e.g.,
[email protected]) but sets their email address attribute to the victim's (e.g.,[email protected]). This is possible because guest users' email addresses are mutable in Entra ID if they don't have an Exchange mailbox. - When the evil user signs in, an ID token is generated. The SaaS app receives this token, sees
[email protected]as the email, and matches it to the existing[email protected]user in its database. - Result: The evil user gains access to Eric's account in the SaaS application.
- OAUTH Token Pivot: If the vulnerable SaaS app also requests delegated permissions (e.g.,
Mail.Read) and obtains an access token and refresh token for Microsoft 365 services, the attacker can then use the existing, legitimate refresh token to continuously obtain access tokens and act on behalf of the victim within Microsoft 365 (e.g., send emails from the victim's mailbox). - Detection/Defense: This is nearly impossible to detect or defend against from the enterprise tenant's perspective, as the attack originates from an external "evil tenant" and leverages a flaw in the SaaS vendor's OIDC implementation. Microsoft considers it a developer problem.
Multi-IDP and Local Authentication Bypass
These are vendor-derived abuses that exploit convenience features.
- Multi-IDP Bypass (Adobe/Lucid Example):
- Many SaaS apps (e.g., Adobe Cloud, Lucid) offer "Sign in with Microsoft," "Sign in with Google," etc.
- A user (or attacker) signs into Lucid with their corporate Entra ID account, establishing an identity.
- The attacker then creates a Google account using the same corporate email address.
- When signing into Lucid, the attacker chooses "Sign in with Google."
- Lucid, seeing the same email address, "merges" or correlates these two sign-ins to the same user object.
- Result: The attacker has now bypassed Entra ID, including Conditional Access, MFA requirements, and sign-in logging. Defender for Cloud Apps proxies (which rely on CA) are also bypassed.
- Local Authentication Bypass (Monday.com Example):
- Even if SSO is configured, some SaaS apps (e.g., Monday.com) allow users to set or reset a local password.
- An attacker compromises a user's local password for Monday.com (or creates one if none exists).
- The attacker logs in directly to Monday.com with the username and local password.
- Result: Complete bypass of Entra ID security controls (CA, MFA, logging) to access potentially sensitive project data within Monday.com.
- Detection Challenge: Similar to multi-IDP, these bypasses occur entirely outside the Entra ID security perimeter, making detection through Entra ID logs impossible.
Demo / Proof of Concept
▶ Watch: Enterprise defense: Closing the Google authentication gap (34:00)
Woodruff's presentation included several compelling demonstrations of these attack vectors, illustrating the ease and impact of exploitation.
- Privilege Escalation via Entra Application Owner Role:
- Scenario: Nester Wilk, a non-privileged user, is shown to be the owner of a "privileged application" (a service principal) in Entra ID. This application has the
RoleManagement.ReadWrite.Directorypermission. - Demonstration: Nester uses PowerShell and Microsoft Graph to connect to Entra ID via the owned service principal's credentials. He first enumerates global administrators. Then, he executes commands to add himself to the
Global Administratorrole. - Outcome: Nester, initially a regular user, successfully elevates his privileges to Global Administrator within the Entra tenant with minimal effort. The speaker noted that audit logs might take 10-15 minutes to register this, providing a window for attackers.
- SAML Claims Transform Impersonation in ServiceNow:
- Scenario: Alex Wilbur is an administrator in ServiceNow, while Nester is a regular user with no privileges. Nester is the owner of the ServiceNow service principal in Entra ID.
- Demonstration:
- First, Alex logs into ServiceNow, demonstrating his admin capabilities (e.g., enumerating users).
- Then, Nester logs in, showing his limited user view.
- Nester, as the owner of the ServiceNow service principal, navigates to the SAML configuration within Entra ID, specifically to the "claims" section. He creates a claims transform rule that replaces his UPN (
nester@...) with Alex Wilbur's UPN (alex@...) in the outgoing SAML response. - Nester signs out and signs back into ServiceNow.
- Outcome: Despite logging in as Nester, the ServiceNow application grants him Alex Wilbur's administrative privileges because the SAML response, altered by the claims transform, asserts his identity as Alex. This configuration change is not logged in Entra ID audit logs.
- nOAuth Vulnerability and Microsoft 365 Pivot:
- Scenario: An unidentified SaaS application is vulnerable to nOAuth and has delegated
Mail.Readpermissions to access Microsoft 365 (e.g., Exchange Online). An attacker has created an account in an "evil tenant" with their email address set to the victim's corporate email. - Demonstration: The attacker signs into the vulnerable SaaS application using their "spoofed" email. The application, keying off the email address, grants the attacker access to the victim's account within the SaaS app. Because the application holds an existing refresh token for the victim's Microsoft 365, the attacker can then use the SaaS app's functionality to send an email from the victim's legitimate Microsoft 365 mailbox to another user within the organization.
- Outcome: The attacker successfully impersonates the victim within the SaaS application and leverages its integrated OAUTH tokens to interact with the victim's Microsoft 365, demonstrating a supply chain-like attack vector.
- Multi-IDP and Local Authentication Bypass:
- Scenario: Lucid (a diagramming tool) and Monday.com (a project management platform) are configured for SSO with Microsoft 365.
- Demonstration:
- Lucid (Multi-IDP): The speaker first logs into Lucid via "Sign in with Microsoft," showing access to his intellectual property. Then, he logs out and signs in via "Sign in with Google," having previously created a Google account with his corporate email.
- Outcome: He gains access to the same Lucid account, completely bypassing Entra ID's Conditional Access and MFA. The Google sign-in redirects to Google's authentication, not Microsoft's.
- Monday.com (Local Authentication): The speaker logs into Monday.com via "Sign in with Microsoft." He then highlights that Monday.com allows users to reset/create a local password. He logs out and signs in directly using a username and a locally created password.
- Outcome: He successfully accesses Monday.com, bypassing all Entra ID security controls.
These demonstrations powerfully illustrate that relying solely on IDP-side security is insufficient when the interfaces and configurations of integrated SaaS applications present numerous alternative attack paths.
Defensive Implications
▶ Watch: Detection challenges and future of SAS security (40:00)
Addressing the "Swiss cheese" problem of SaaS identity security requires a multi-layered defense strategy that extends beyond the IDP into the applications themselves and the processes governing their integration.
Mitigating Entra ID Owner Role Abuses
- Eliminate Static Owner Assignments: Move away from assigning the "owner" role to application registrations and service principals. This role grants excessive, non-granular permissions and lacks PIM integration.
- Utilize Cloud App Administrator with PIM: For scenarios requiring delegated application management, assign the
Cloud Application Administratorrole, scoped granularly to specific service principals or app registrations, and wrap it with Privileged Identity Management (PIM). This ensures just-in-time (JIT) access, limiting standing privileges to the necessary duration (e.g., 8-24 hours). - Regular Permission Reviews: Implement a rigorous process for regularly reviewing permissions assigned to app registrations and service principals, focusing on highly privileged permissions like
RoleManagement.ReadWrite.Directory. - Leverage Security Attributes: While Entra ID lacks direct tagging like Azure resources, use security attributes or the
ServiceManagementReferenceattribute to track ownership from a knowledge perspective, without granting actual administrative rights.
Defending Against Developer-Derived (nOAuth) Abuses
- Entra Integration Assistant: Encourage developers to use the Integration Assistant within Entra ID when setting up app registrations. This tool helps guide them toward proper implementation of authentication and authorization protocols (e.g., OpenID Connect standards).
- Correct Multi-Tenancy Configuration: Developers must correctly configure applications for multi-tenancy, ensuring that authorization checks are not solely delegated to the IDP. Applications should validate the
subjectandissuerclaims in ID tokens, not mutable attributes like email addresses. - Security Collaboration: Security teams must actively engage with developers to ensure secure coding practices, especially regarding identity and authentication, rather than assuming standards are always followed.
- Vendor Due Diligence: During software procurement, inquire deeply into a SaaS vendor's authentication implementation, pushing beyond basic SOC 2 compliance to understand their adherence to OIDC standards and their handling of immutable identifiers. If a vendor's application is found vulnerable to nOAuth, the only immediate defense is to stop using it until they implement a fix.
Countering Vendor-Derived (Multi-IDP & Local Auth) Abuses
- Limit Additional IDPs: Where possible within the SaaS application's settings, restrict the ability to sign in with alternative identity providers (e.g., Google, Facebook). Some vendors may offer this as a paid "SSO tax" feature.
- Close the Google Gap (Proactive Federation):
- Acquire Google Workspace/GCP: Even if not used for services, obtain a trial or basic subscription to establish your domain within Google.
- Configure SCIM Sync: Use Microsoft's Google Cloud G Suite connector to synchronize all corporate users (excluding guests) from Entra ID to Google Workspace via SCIM (System for Cross-domain Identity Management). This "claims ownership" of your domain and creates managed user objects in Google.
- Federate Google Authentication to Entra ID: Configure Google Workspace to federate all user authentication back to Entra ID using OpenID Connect. This ensures that any attempt to sign into a SaaS app via Google will redirect to Entra ID for authentication, enforcing CA and MFA. Google also offers options to disallow third-party app authentication entirely.
- Inventory Local Authentication: Conduct a thorough inventory of all SaaS applications to identify those that support local username/password authentication, even when SSO is enabled. Work with vendors or implement policies to disable local authentication wherever feasible.
- Enhanced Detection Mechanisms:
- Log Correlation: While challenging, strive to ingest SaaS application sign-in logs into your SIEM (e.g., Sentinel, Splunk, QRadar) and correlate them with Entra ID sign-in logs. Discrepancies (a sign-in in the SaaS app without a corresponding Entra ID sign-in) could indicate a bypass.
- Enterprise Browsers/Plugins: Explore enterprise browsers or browser plugins that can inspect identity and authentication at the browser level, providing visibility into user interactions with SaaS applications that IDP logs might miss.
- SaaS Security Posture Management (SSPM) Platforms: SSPM tools can help inventory SaaS app configurations, including authentication methods supported, providing insights into potential bypasses. Examples include Obsidian and Crowdstrike.
- ITDR (Identity Threat Detection and Response): Implement ITDR solutions on the Entra ID side and consider browser-level session monitoring to detect suspicious activity across the identity stack.
General Blue Team Call to Action
- Engage Business App Owners: Blue teamers must overcome the reluctance to engage with business application owners. Understand how these applications are configured for authentication, what data they hold, and their integration points.
- Monitor Across the Stack: Embrace a defense-in-depth approach. Monitor not just Entra ID, but also browser sessions and, where possible, SaaS application logs.
- Strategic Software Procurement: Integrate security deeply into the procurement process. Question vendors rigorously about their authentication security, going beyond standard compliance certifications (like SOC 2) to probe actual implementation details.
This comprehensive approach acknowledges that securing the modern identity landscape demands continuous vigilance and a willingness to explore the often-ignored "grey areas" of SaaS integration.
Key Takeaways
- The "Grey Area" is Critical: Significant identity security vulnerabilities exist in the unexamined space between identity providers (like Entra ID) and SaaS applications, often bypassing robust IDP controls.
- Owner Role is Dangerous: Assigning the "owner" role to Entra ID application registrations or service principals grants excessive, non-granular privileges, enabling easy privilege escalation (e.g., to Global Admin) through credential management and highly-privileged permissions like
RoleManagement.ReadWrite.Directory. - SAML and OIDC Implementations are Vulnerable: Misconfigured SAML (e.g., claims transforms) allows user impersonation, while flawed OpenID Connect implementations (nOAuth) that key off mutable email addresses enable cross-tenant attacks and potential pivots into Microsoft 365.
- Multi-IDP and Local Auth Bypass Controls: SaaS applications supporting multiple identity providers (e.g., Google) or local authentication can completely circumvent Entra ID's Conditional Access, MFA, and logging, leaving a wide-open door for attackers.
- Detection is Challenging, Prevention is Key: Detecting these bypasses is extremely difficult due to the lack of comprehensive SaaS application sign-in logs and the "out-of-band" nature of many attacks. Proactive measures, like eliminating owner roles, enforcing OIDC standards, and federating alternative IDPs (like Google) back to Entra ID, are crucial.
- Blue Teams Must Engage and Inventory: Security teams must engage with business application owners to understand SaaS authentication configurations, inventory all SaaS apps for local authentication, and consider tools like SSPMs and enterprise browsers for enhanced visibility.
About the Speaker(s)
Eric Woodruff is the Chief Identity Architect at Semperis, bringing extensive expertise in identity security. He is also recognized as a Microsoft MVP in Security, underscoring his deep knowledge and contributions to the Microsoft ecosystem. Known for his "Eric on Identity" persona, he actively shares insights and research on social media. His work, as demonstrated in this talk, focuses on critical, yet often overlooked, areas of cloud identity security, particularly the complex interactions between identity providers and SaaS applications.
Reviews
Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT
Woodruff skips the vendor bullshit and goes straight for the structural rot in enterprise SaaS integrations. This is a highly practical breakdown of how lazy Entra ID delegations and broken OIDC implementations completely bypass your conditional access policies. A masterclass in abusing the glue that holds corporate identity together.
Heather Calloway (CISO) — MUST SEE
Woodruff exposes how vendor design choices and IDP misconfigurations completely bypass enterprise Conditional Access and MFA. It is a mandatory watch for any IAM architecture team. This is where your multi-million dollar identity investment goes to die because a downstream vendor decided to support local passwords.