Breaking Tokens: Modern Attacks on OAuth, OIDC, and JWT Auth Flows
Bhaumik Shah (CEO · SecurifyAI)
RVAsec 2026 · Day 1 · Grand Ballroom F/G
Overview
In the contemporary security landscape, the traditional notion of "breaking in" has largely been supplanted by attackers simply "logging in." This pivotal shift forms the core thesis of Bhaumik Shah's RVAsec talk, "Breaking Tokens: Modern Attacks on OAuth, OIDC, and JWT Auth Flows." Shah, CEO of SecurifyAI, illuminates how the widespread adoption of modern authentication mechanisms like OAuth, OpenID Connect (OIDC), and JSON Web Tokens (JWTs), particularly with the surge in AI integrations and microservices architectures, has inadvertently created new attack vectors. Attackers are no longer solely focused on exploiting software vulnerabilities or brute-forcing credentials; instead, they target the very tokens that grant legitimate access, often bypassing multi-factor authentication (MFA) and traditional security controls.

Key moments
- 0:00 The modern threat: hackers log in, not break in.
- 5:00 Why distributed microservices make authentication challenging.
- 8:00 Demo: Token replay allows access to hidden admin panel.
- 16:40 Preventing SSO token hijack with DPoP (Proof of Possession).
- 24:00 Attacker gains admin using low-trust federated identity.
- 39:30 Demo: Chaining redirects to steal tokens via open redirect.
- 43:00 The core issue: broken trust, not JWT encryption flaws.
Breaking Tokens: Modern Attacks on OAuth, OIDC, and JWT Auth Flows
Speakers: Bhaumik Shah, CEO, SecurifyAI
Conference: RVAsec
YouTube: https://www.youtube.com/watch?v=cJp2RkODhRM
Overview
In the contemporary security landscape, the traditional notion of "breaking in" has largely been supplanted by attackers simply "logging in." This pivotal shift forms the core thesis of Bhaumik Shah's RVAsec talk, "Breaking Tokens: Modern Attacks on OAuth, OIDC, and JWT Auth Flows." Shah, CEO of SecurifyAI, illuminates how the widespread adoption of modern authentication mechanisms like OAuth, OpenID Connect (OIDC), and JSON Web Tokens (JWTs), particularly with the surge in AI integrations and microservices architectures, has inadvertently created new attack vectors. Attackers are no longer solely focused on exploiting software vulnerabilities or brute-forcing credentials; instead, they target the very tokens that grant legitimate access, often bypassing multi-factor authentication (MFA) and traditional security controls.
The talk delves into four distinct, yet interconnected, attack scenarios that exploit misconfigurations and architectural blind spots in modern authentication flows. Shah emphasizes that the underlying technologies—JWT, OAuth, OIDC—are not inherently flawed. The fundamental challenge lies in their design and architecture within complex, distributed systems. The speaker draws on recent real-world incidents, including a Salesforce breach in 2025 and an active GitHub token compromise affecting one of his customers, to underscore the pervasive and immediate threat these issues pose. The broad scope of compromised tokens, often granting access across multiple environments, means that a single token theft can lead to a catastrophic account takeover.
This presentation serves as a critical call to action for security professionals and developers alike, urging a re-evaluation of how authentication is implemented and secured in a microservices-driven world. By dissecting specific vulnerabilities and demonstrating their exploitation, Shah provides actionable insights into hardening these ubiquitous authentication systems. The talk’s emphasis on practical defenses, from granular token scoping to advanced mechanisms like DPoP and strict URI binding, offers a roadmap for mitigating these pervasive threats and preventing attackers from simply "logging in" to sensitive systems.
Background
▶ Watch: The modern threat: hackers log in, not break in. (0:00)
The evolution of application architecture has dramatically altered the landscape of authentication and authorization. Historically, applications were often monolithic, with authentication decisions centralized within a single, tightly coupled system. A three-layer architecture, for instance, would see the backend solely responsible for validating user credentials and managing sessions. In this model, the authentication context was confined, and security checks were typically performed at a single choke point.
However, the advent of microservices architecture has fragmented this centralized model. Modern applications are composed of numerous smaller, independently deployable services, each potentially making its own authentication and authorization decisions. When a user authenticates via an Identity Provider (IDP) like Google, Okta, or Azure, they receive an ID token or access token. This token then becomes the portable credential, used by the browser to call various front-end APIs, which in turn might use the same token to call other backend microservices. The challenge arises because each of these independent microservices must now perform a series of critical checks: validating the token's issuer, verifying its signature, ensuring it hasn't expired, and confirming the subject and audience. A failure to perform any one of these checks by any single microservice can compromise the entire authentication system.
Bhaumik Shah clarifies that the talk is not about inherent flaws in JWT (JSON Web Token) or OAuth (Open Authorization) standards. Fundamentally, these protocols are well-designed for their intended purpose of delegated authorization. The vulnerability emerges from the implementation and architectural design choices within distributed systems. The core problem is the breakdown of trust boundaries: when a token is issued with a broad scope and then trusted implicitly across disparate microservices without granular validation, it creates an enormous attack surface. Attackers exploit this by leveraging stolen tokens to access resources they were never intended for, bypassing traditional security layers like passwords and multi-factor authentication (MFA) because they are operating post-authentication. The goal of the talk is to illustrate how these design and architecture challenges manifest as exploitable vulnerabilities, enabling attackers to "log in" rather than "break in."
Key Findings
▶ Watch: Demo: Token replay allows access to hidden admin panel. (8:00)
The talk presents four distinct, yet interconnected, attack scenarios that represent critical findings in the modern authentication landscape. These findings highlight how architectural misconfigurations and insufficient validation mechanisms can lead to significant security breaches, even when core authentication protocols are seemingly robust:
- Token Replay and Granular Scope Issues (Breaking Microservices Boundaries): The primary finding here is that tokens, often issued by a central gateway, frequently possess overly broad scopes. This allows an attacker who obtains a legitimate token for user-facing services to replay it against internal, hidden microservices that were never intended for direct user access. The implicit trust placed on any token issued by the gateway, without granular scope validation at each service, leads to unauthorized access to sensitive internal functionalities (e.g., admin panels).
- SSO Token Hijacking (Eliminating Bearer Token Replay): This finding underscores that multi-factor authentication (MFA) primarily protects the login process, not the post-authentication token. Once an SSO token is acquired by an attacker (e.g., via phishing or Cross-Site Scripting), it can be replayed to impersonate the legitimate user, bypassing any MFA configured for initial login. This is akin to traditional session hijacking but with a significantly larger "blast radius" due to the token's potential validity across multiple microservices and applications.
- Federated Identity Confusion (Preventing Federated Identity Confusion): Organizations often employ multiple Identity Providers (IDPs) with varying levels of trust and security configurations (e.g., MFA requirements, password policies). The key finding is that if an application allows authentication from multiple IDPs but fails to enforce consistent trust criteria or properly differentiate identities across these IDPs, an attacker can exploit the weakest IDP. By registering an account with the same email as a high-privilege user on a low-trust IDP, an attacker can achieve privilege escalation or account takeover if the application's authorization logic only validates
issuerandsubjectwithout considering the composite identity.
- Auth Redirect Chain Takeover (Neutralizing Chained Redirect Vulnerabilities): This finding reveals that standard OAuth
redirect_urivalidation, while effective at preventing direct redirection to attacker-controlled domains, can be bypassed through a chain of vulnerabilities. If an application'sredirect_uripoints to a legitimate endpoint within the same trusted domain, but that endpoint is susceptible to an open redirection vulnerability, an attacker can craft a malicious link. This link first redirects the user to the trusted domain, which then, with the access token, redirects to an attacker-controlled domain, effectively exfiltrating the token. This represents a sophisticated chaining of medium-severity findings into a critical account takeover.
Collectively, these findings illustrate that the core issue is not a flaw in the cryptographic strength or design of JWTs or OAuth itself, but rather the broken trust boundaries and inadequate validation mechanisms within complex, distributed application architectures. Each microservice, acting independently, must uphold stringent validation, and a single lapse can compromise the entire system.
Technical Deep Dive
▶ Watch: Preventing SSO token hijack with DPoP (Proof of Possession). (16:40)
Bhaumik Shah meticulously dissects four common attack patterns, providing a technical deep dive into their mechanics and the underlying vulnerabilities.
1. Token Replay and Granular Scope Issues
The first scenario, often seen in microservices architectures, exploits the lack of granular token scoping. In a typical setup, a gateway or reverse proxy handles initial authentication with an IDP and issues an access token to the user. This token is intended for specific user-facing services, such as account-service or transaction-service. However, many internal services, like configuration-service or a Django admin interface, implicitly trust any token issued by the gateway without independently verifying its scope or audience.
Attack Mechanics:
An attacker first obtains a valid token, typically for a legitimate user-facing application. Using tools like Burp Suite, they then enumerate hidden internal endpoints (e.g., /admin, /api/v1/internal/config). If an internal service, such as a Django admin panel, is accessible through the same gateway and merely checks for the token's validity and issuer without validating its scope or audience, the attacker can replay the token to gain unauthorized access. Shah demonstrated this by showing how a token, initially used to access a user profile, could be reused to access a Django admin service, granting super-admin privileges. This happens because the internal service assumes "if the token is authorized or given by the gateway, it is okay to provide the details."
Vulnerability:
The root cause is a breakdown in the Principle of Least Privilege. Tokens are issued with an overly broad scope, or services fail to enforce the expected scope. Each microservice should explicitly validate if the token's aud (audience) or scope claims permit access to its specific resources.
Mitigation:
- Granular Token Scoping: When generating tokens, ensure they are tightly mapped to appropriate endpoints or services. If a token is only meant for
account-serviceandtransaction-service, its scope should reflect this explicitly. - Separate Auth Configurations: Use distinct authentication configurations for external user-facing applications and internal administrative interfaces. This prevents a single compromise from granting access to both.
2. SSO Token Hijacking (Post-MFA Bypass)
This attack targets the token itself, bypassing Multi-Factor Authentication (MFA) which primarily secures the initial login. Shah highlights that once a token is issued after MFA, it becomes a bearer token—whoever possesses it gains access. This is analogous to a hotel room key: if you drop it, anyone can pick it up and enter your room without further verification.
Attack Mechanics:
Attackers leverage phishing pages or Cross-Site Scripting (XSS) vulnerabilities to steal an active session token. Shah referenced the Microsoft Storm-2372 attack group, which used sophisticated phishing to redirect user tokens post-MFA to attacker-controlled servers, compromising thousands of accounts. In his demo, an XSS payload was used to exfiltrate the token to a polling server controlled by the attacker. Once the token is stolen, the attacker can use it to access the user's account without needing their password or MFA.
Vulnerability:
The primary vulnerability lies in the bearer token model itself, where possession implies authorization. While MFA enhances initial login security, it doesn't protect the token from post-authentication theft and replay. The "blast radius" of such an attack is significantly larger than traditional session hijacking because modern SSO tokens are often trusted across multiple microservices and applications.
Mitigation:
- Demonstrating Proof of Possession (DPoP): This is a key countermeasure. DPoP binds the access token to a cryptographic key pair held by the client. When a client requests an access token, it generates a private/public key pair. The public key is included in the token request. The IDP then binds this public key to the access token. Subsequent requests to resource servers must include a proof of possession (a signature created with the private key) along with the access token. The resource server verifies this signature against the public key embedded in the token. If an attacker steals the token, they still cannot use it without the corresponding private key, which is significantly harder to compromise. Shah notes that DPoP adds latency and complexity, suggesting its implementation for critical applications or as an optional security feature for high-value users. It provides an additional layer of authentication beyond mere token possession.
3. Federated Identity Confusion
Organizations often integrate multiple Identity Providers (IDPs)—e.g., Google, Azure, Okta, or custom solutions—each potentially configured with different trust levels and security policies (MFA requirements, password complexity, brute-force limits). This scenario exploits the weakest link in this chain.
Attack Mechanics:
Shah presented a workflow where an enterprise application (secure-app) allows authentication from three IDPs: Google (high trust, AAL2, MFA), Azure (high trust, MFA), and a custom internal IDP (lower trust, potentially weaker password policies, no MFA, self-registration enabled, no domain verification). An attacker, perhaps posing as a contractor, discovers the low-trust IDP. They self-register an account using an email address identical to a high-privilege legitimate user (e.g., [email protected]). Because the internal IDP lacks robust domain or identity verification, it allows the registration, creating a duplicate identity.
When the application validates tokens, it typically checks the issuer (which IDP issued the token) and the subject (the user identifier). If the application's authorization logic fails to properly differentiate between identities with the same email but different issuers, or if it doesn't enforce IDP-bound privileges, the attacker's low-trust token for [email protected] can grant the same administrative privileges as the legitimate user's high-trust token. Shah showed vulnerable code where checks for the issuer were insufficient for privilege decisions.
Vulnerability:
- Inconsistent Trust Criteria: Different IDPs having varying security postures.
- Lack of Composite Identity: The application not treating
(issuer, subject, email)as a unique identifier, instead relying solely onsubjectoremail. - Insufficient Claim Validation: The application failing to validate claims like
aal(authentication assurance level) or specific MFA claims from the token'sissuerbefore granting high privileges.
Mitigation:
- Federation Trust Alignment: Ensure all IDPs used for accessing critical applications adhere to consistent security criteria (MFA, strong passwords, brute-force protection).
- Composite Identity: When validating a user, consider the combination of
issuer,subject, and potentiallyemailto form a unique composite identity. This prevents an attacker from creating a duplicate identity on a weaker IDP with the same email. - IDP-Bound Privileges: Implement explicit checks in the application code to ensure that admin privileges are only granted if the token originates from a high-trust IDP. This "takes literally like, you know, 5 seconds to put a check in the code."
- Comprehensive Claim Validation: Validate all relevant claims (e.g.,
aal,email_verified,mfa_present) from the IDP to ensure the desired level of assurance before granting access.
4. Auth Redirect Chain Takeover
This is the most complex scenario, chaining multiple medium-severity findings to achieve account takeover. It bypasses the common protection where OAuth providers prevent redirection to arbitrary attacker-controlled domains.
Attack Mechanics:
The standard OAuth flow involves the user authenticating with an IDP, which then redirects them back to a pre-registered redirect_uri on the application's domain, often including the access token. Modern IDPs typically block redirect_uri values that point directly to an attacker's domain.
The Chained Attack:
- Redirect URI Bypass: An attacker crafts a malicious link where the
redirect_uripoints to a legitimate endpoint within the victim's trusted domain. This bypasses the IDP's initial check because the domain is whitelisted. - Open Redirection Vulnerability: The chosen legitimate endpoint within the victim's domain (e.g.,
/payments/partner/continuewith areturn_urlparameter) is vulnerable to open redirection. This means it will redirect to any URL provided in a parameter. - Token Exfiltration: The attacker's crafted link directs the user to the IDP. After successful authentication, the IDP redirects the user (with the access token) to the vulnerable endpoint on the victim's domain. This vulnerable endpoint then immediately redirects the user (and the token, if it's in the URL fragment or query string) to an attacker-controlled domain (
evil.com), where the token is captured by a polling server.
Shah demonstrated this by identifying an open redirection vulnerability on a payment activity page within the same application. The attacker then crafted a payload that used this vulnerable page as the redirect_uri in the OAuth flow. After the user logged in, the token was sent to the payment page, which, due to the open redirection, then forwarded the user and the token to evil.com. Real-world examples from Facebook, Dropbox, Microsoft, and Uber were cited for similar attack patterns.
Vulnerability:
- Weak
redirect_uriValidation: The OAuth provider allowsredirect_urivalues that are merely prefixes or paths within a trusted domain, rather than exact matches. - Open Redirection: The application contains an open redirection vulnerability on an endpoint that can be used as a
redirect_uricallback. This is a long-standing OWASP Top 10 vulnerability. - Path Traversal: If the
redirect_uriallows path traversal, it could potentially lead to an unintended endpoint.
Mitigation:
- Strict Redirect URI Binding: This is paramount. The OAuth provider must enforce exact URI matching for
redirect_urivalues. No prefix matching, no path traversal, no wildcards. Every allowedredirect_urimust be explicitly registered and matched precisely. - Eliminate Open Redirections: Thoroughly test all application endpoints for open redirection vulnerabilities, especially those that could function as OAuth callback URLs.
- PKCE (Proof Key for Code Exchange): While not a direct mitigation for the redirect URI issue itself, PKCE adds an additional layer of protection against authorization code interception attacks, making it harder for an attacker to exchange a stolen authorization code for an access token even if they manage to intercept the redirect.
- Comprehensive Testing: During penetration tests and security reviews, explicitly include test cases for open redirection and path traversal vulnerabilities within OAuth
redirect_uriendpoints.
Demo / Proof of Concept
▶ Watch: Demo: Chaining redirects to steal tokens via open redirect. (39:30)
Bhaumik Shah utilized a series of pre-recorded demonstrations, built in a lab environment, to illustrate each of the four attack scenarios. These demos were crucial in visually conveying the technical intricacies and impact of the vulnerabilities discussed.
For the Token Replay / Granular Scope Issues demo, Shah showcased a simulated Okta login page. After a user successfully logs in and is redirected to a simple profile page, an attacker, using Burp Suite as an intercepting proxy, captures the valid access token. The attacker then attempts to access various enumerated endpoints by modifying the path in Burp Suite, initially receiving 401 Unauthorized responses. However, upon discovering a hidden /django admin endpoint, the attacker replays the same token against this endpoint. The demo successfully showed the attacker gaining access to the Django super-admin interface, demonstrating that the token was not granularly scoped and allowed access to an internal service despite being intended for user-facing functions.
The SSO Token Hijacking demo began with a user logging into an SSO account, complete with username, password, and Multi-Factor Authentication (MFA). Once logged in, the attacker's objective was to steal the active session token. Shah explained that this could be achieved through a phishing page (as in the Microsoft Storm-2372 incident) or by exploiting a Cross-Site Scripting (XSS) vulnerability. In the demo, an XSS payload was deployed. When a user (simulated as clicking a malicious link in Slack) interacted with the vulnerable application, the XSS payload executed, exfiltrating the user's active session token to a polling server set up by the attacker in Burp Suite. The attacker then used this stolen token to directly access the user's account, proving that MFA protects only the initial login, not the subsequent token.
For Federated Identity Confusion, Shah presented a detailed workflow diagram rather than a live demo, acknowledging the complexity of setting up multiple IDPs. The demo walked through a scenario involving three IDPs: high-trust Google and Azure, and a low-trust internal IDP. The attacker, as a contractor, exploits the internal IDP's lax controls (e.g., self-registration, no domain verification) to create an account with the same email as a legitimate administrator ([email protected]). The core of the demo was the comparison of two tokens: one from the high-trust Google IDP and one from the low-trust internal IDP, both for [email protected]. The vulnerability was highlighted by showing that the enterprise application, due to insufficient checks on the token's issuer and aal (Authentication Assurance Level) claims, would grant the same admin privileges regardless of which IDP issued the token, enabling the attacker's account takeover.
Finally, the Auth Redirect Chain Takeover demo illustrated the most sophisticated attack. It started with a standard user login via OAuth, where the user grants consent and is redirected to their dashboard. Using Burp Suite, Shah revealed the redirect_uri parameter in the OAuth callback. The attacker's goal was to bypass the IDP's strict redirect_uri domain validation. This was achieved by first identifying an open redirection vulnerability on a different endpoint within the same trusted domain (e.g., /payments/partner/continue?return_url=evil.com). The demo showed crafting a malicious OAuth link where the redirect_uri pointed to this vulnerable internal endpoint. When the user clicked this link and logged in, the OAuth provider, seeing a trusted domain, redirected the user (and their access token) to the vulnerable internal payment page. This page then, due to the open redirection, immediately redirected the user to evil.com, where the attacker's polling server successfully captured the access token, completing the chained account takeover.
Across all demos, Burp Suite was a central tool, demonstrating its utility for intercepting, analyzing, and manipulating HTTP traffic to identify and exploit these authentication flaws. Shah emphasized that while the demos were pre-recorded for brevity, fully functional labs were available, underscoring the practical nature of these attack vectors.
Defensive Implications
▶ Watch: The core issue: broken trust, not JWT encryption flaws. (43:00)
The detailed attack scenarios presented by Bhaumik Shah offer critical insights for defenders seeking to fortify modern authentication systems. The overarching theme is to move beyond mere reliance on basic OAuth/JWT implementations and to adopt a proactive, in-depth defense strategy.
- Enforce Granular Token Scoping:
- Principle: Implement the Principle of Least Privilege for tokens.
- Action: When an Identity Provider (IDP) or API Gateway issues an access token, ensure its
scopeandaud(audience) claims are as restrictive as possible, explicitly limiting access to only the necessary microservices or endpoints. - Validation: Every microservice or backend application must strictly validate the
scopeandaudclaims within the token to ensure it's authorized for the specific resource being requested. Do not implicitly trust tokens based solely on their issuer. - Isolation: Use separate authentication configurations and token issuance policies for external user-facing applications versus internal administrative or privileged services.
- Eliminate Bearer Token Replay with DPoP:
- Principle: Bind the access token to the client, preventing its replay by an unauthorized party even if stolen.
- Action: Implement Demonstrating Proof of Possession (DPoP) for critical applications and sensitive data flows. DPoP ensures that a stolen access token cannot be used without the corresponding private key held by the legitimate client.
- Consideration: Acknowledge the added complexity and potential latency. Prioritize DPoP for high-value targets, administrative interfaces, or as an optional enhanced security feature for users handling sensitive information.
- Prevent Federated Identity Confusion:
- Principle: Maintain consistent security posture and clear identity differentiation across all integrated IDPs.
- Action (Trust Alignment): If using multiple IDPs (e.g., Google, Azure, Okta, custom), ensure that all IDPs authorized to access critical applications adhere to the same stringent security policies, including MFA requirements, strong password policies, and brute-force protection. The weakest IDP defines the overall security posture.
- Action (Composite Identity): Implement composite identity validation. Instead of identifying a user solely by their
subjectoremail, use a combination ofissuer,subject, andemailto create a truly unique identifier. This prevents an attacker from registering an account with the same email on a low-trust IDP and gaining access. - Action (IDP-Bound Privileges): Enforce explicit checks in application authorization logic to ensure that highly privileged actions (e.g., administrative access) are only granted if the token originates from a specifically designated high-trust IDP.
- Action (Claim Validation): Perform comprehensive claim validation. Verify claims such as
email_verified,mfa_present, oraal(Authentication Assurance Level) provided by the IDP to confirm the user's identity strength before granting access to sensitive resources.
- Neutralize Chained Redirect Vulnerabilities:
- Principle: Implement rigorous validation for OAuth
redirect_uriparameters and eliminate open redirection vulnerabilities. - Action (Strict
redirect_uriBinding): Configure OAuth providers to enforce strictredirect_urimatching. This means theredirect_urimust be an exact, byte-for-byte match to a pre-registered whitelist. Do not allow prefix matching, path traversal, subdomains, or wildcards. - Action (Eliminate Open Redirection): Conduct thorough security testing (including automated scans and manual penetration tests) to identify and remediate all open redirection vulnerabilities across the entire application, paying particular attention to any endpoints that could potentially be used as OAuth callback URLs. Open redirection is an OWASP Top 10 vulnerability and must be treated with high priority.
- Action (PKCE): Implement Proof Key for Code Exchange (PKCE) for OAuth public clients (e.g., mobile apps, SPAs). While not directly preventing redirect URI bypass, PKCE adds an additional layer of protection against authorization code interception, making it harder for an attacker to exchange a stolen code for an access token.
- Action (Regular Testing): Integrate specific test cases for
redirect_urimanipulation, path traversal, and open redirection within OAuth flows into your security development lifecycle and penetration testing methodologies.
By implementing these comprehensive defensive measures, organizations can significantly reduce the risk of token-based account takeovers and ensure that their modern authentication architectures withstand the evolving tactics of attackers who seek to "log in" rather than "break in." The core message is to scrutinize trust boundaries and validate everything at every step of the authentication and authorization process.
Key Takeaways
- Granular Token Scoping is Crucial: Modern microservices architectures necessitate that access tokens are not broadly scoped. Tokens must be tightly bound to specific services and endpoints, and each microservice must validate the token's scope to prevent unauthorized access to internal systems.
- Eliminate Bearer Token Replay with DPoP: Multi-factor authentication protects login, but not the token itself. For critical applications, implement DPoP (Demonstrating Proof of Possession) to cryptographically bind the token to the client, making stolen tokens unusable for attackers.
- Standardize Federated Identity Trust: When using multiple Identity Providers (IDPs), ensure consistent and high-level security configurations across all of them. Implement composite identity checks and IDP-bound privileges to prevent attackers from exploiting weaker IDPs for account takeover.
- Strict Redirect URI Validation is Non-Negotiable: OAuth
redirect_uriparameters must be subjected to exact matching, disallowing prefixes, path traversals, or wildcards. This, combined with the elimination of open redirection vulnerabilities, is vital to prevent sophisticated token exfiltration attacks. - The Core Issue is Broken Trust, Not Protocol Flaws: The vulnerabilities discussed do not stem from inherent flaws in OAuth, OIDC, or JWT standards, but from misconfigurations, architectural design choices, and a lack of synchronized validation across distributed microservices.
- Continuous Security Testing is Essential: Regular and thorough penetration testing, focusing specifically on OAuth flows, redirect URI validation, open redirection, and token scope checks, is indispensable to identify and remediate these complex chained vulnerabilities before attackers exploit them.
About the Speaker(s)
Bhaumik Shah is the CEO and founder of SecurifyAI, where he also serves as the Chief Security Mischief. With over 17 years of extensive experience in building and breaking system services, Shah has held significant roles at prominent organizations including AWS, FireEye, and the World Bank. His expertise lies in helping customers develop secure products and providing advisory services in the cybersecurity domain. Beyond his corporate endeavors, Bhaumik Shah actively shares his security insights and research on his YouTube channel, "Cyber Security TV," contributing to the broader cybersecurity community.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Shah walks through four ways engineering teams completely fuck up OAuth and JWT implementations in microservices. It's not dropping zero-days, but it's a highly competent clinic on the architectural trust failures that bug bounty hunters exploit every single day.
Heather Calloway (CISO) — STRONG ACCEPT
A clear-eyed breakdown of how microservice architectures and identity sprawl have turned our SSO tokens into the primary attack surface. Shah demonstrates that MFA only protects the front door, while poorly scoped tokens give attackers free rein inside the house.