OAuth 2.0 Security Risks in SaaS Integrations
Valid OAuth grants can outlive approval, and each risk has a fix.
OAuth 2.0 security risks in SaaS integrations often come from valid access. Overpermissioned tokens, forgotten integrations, and unreviewed consent grants leave doors open long after anyone remembers approving them. The strongest defense matches each condition to a specific control, including tighter permissions, grant reviews, safer token handling, and oversight of the vendors holding the keys.
Why a valid OAuth token is more dangerous than a stolen password
A user clicks “Allow,” and an application receives permission to reach data through APIs. The user may have signed in correctly and satisfied MFA. Nothing about that proves the application deserves the access it requested, or that it will keep the resulting token safe.
After authorization, use of a valid token can look like an application going about its normal work. There need not be an unusual login for suspicious-login detection to catch, and password-focused defenses do not revoke the grant. A single long-lived refresh token can therefore provide more reach than an administrator password, depending on its permissions. Its authority came from the identity provider itself.
How the structural conditions for OAuth abuse accumulate silently
Organizations tend to govern people more closely than integrations. Employees have accounts to provision and remove, while SaaS apps, marketplace tools, AI services, and browser extensions steadily acquire grants. Each consent event adds a non-human identity with delegated access. Across an organization, those grants can accumulate by the thousand, with some reaching entire mailboxes, drives, or CRM tenants. The approval takes a moment, but its consequences outlive the meeting.
The credentials often sit on the vendor’s side. Customers cannot see how an integrator stores its tokens and may not notice when that integrator is breached. Meanwhile, refresh tokens let access go on after an access token expires. Revoking access across hundreds of integrations could break systems that work, so organizations may live with the risk to avoid disrupting them. That choice leaves credentials in place with little known about why the business needs them, who owns them, or how they are being used.
Long-lived tokens held by third-party integrators
An integrator that holds refresh tokens has ongoing access to the customer environments connected to it. A breach of that vendor can therefore become a breach path into customers that configured their own OAuth flows correctly. The attacker does not need their passwords. The useful credential may already be in a vendor environment, ready to support access through an approved integration.
The Klue breach on June 11–12, 2026 illustrates that chain. An attacker used a compromised legacy credential associated with an integration service to obtain OAuth tokens connecting Klue to third-party platforms, including Salesforce. Those tokens then enabled access to data in connected customer environments. The entry credential had not been rotated or deprovisioned.
The Salesloft-Drift case also places upstream token custody at the center of the risk. MITRE ATT&CK tracks this kind of token reuse under T1550.001, Application Access Token. For affected customers, the response must follow the credential’s reach. When a vendor discloses a breach, every token it held should be treated as compromised, revoked, and followed by rotation of any secrets that token could read.
Illicit consent grants and consent phishing
Consent phishing gets access without first breaching an integrator. An attacker registers an app with a convincing name and sends a link that leads to a real sign-in page. The user authenticates and approves the requested permissions. MFA may work exactly as intended here. It confirms that the real user is making a very bad decision.
The resulting consent grant survives a password reset because changing a password does not revoke consent. A persistent refresh token can keep that authorization open for use until it is explicitly revoked. MITRE maps application-token theft to T1528 and the spearphishing-link delivery path to T1566.002. The distinction changes incident response, because recovering the account is not the same as removing the app’s access.
In March 2025, a widespread campaign targeted thousands of GitHub repositories with fake “Security Alert” issues that prompted developers to authorize “gitsecurityapp.” Consent phishing can also spread when a compromised app uses mail access to send consent links to contacts. The defense therefore has to address app approval as well as teach users to distrust fake login pages.
Overbroad scopes and application permissions that apply tenant-wide
App-only access has no signed-in user for MFA to challenge. Application permissions let a background service act across a tenant, while delegated permissions operate in a signed-in user’s context. Only an administrator can grant application permissions, but that approval can create organization-wide reach.
Microsoft’s account of the Midnight Blizzard breach describes the attacker using a legacy test OAuth application to grant its apps the Office 365 Exchange Online full_access_as_app role. That role allowed access to mailboxes. The permission grant defined the blast radius. Short token lifetimes did not erase the underlying authorization, because app tokens expire within about an hour while a role assignment persists.
Integrations may request broad scopes because they are easier to build around, and administrators may approve them because the vendor says they are necessary. Convenience becomes permission, then permission becomes exposure. The corrective action is to define the narrowest scope that supports the integration’s actual function and require vendors to justify each requested permission. App-only grants need explicit scrutiny because their reach is not bounded by the consenting user.
Forgotten integrations and the stale-grant problem
Test tenants, connected apps of employees who have left, and vendors that have been decommissioned can still hold refresh tokens after the business no longer needs them. An unused integration may still have generous scopes, with no one left to check whether it still needs access. Retirement from the workflow is not retirement from the authorization system.
A working inventory records an owner, a review date, and a last-used timestamp for every connected app. It also shows which apps have offline access, their scopes, and when they last called an API. Without that view, teams cannot reliably distinguish an essential integration from an abandoned one. Recertification needs to be a standing process, with unused grants removed after an extended period.
OWASP classifies vulnerable third-party non-human identities under NHI3:2025 and calls detecting a breached third party without advance notice “near impossible.” An organization may be unable to see when a vendor is compromised, but it can cut the number of credentials that vendor holds without a need for them.
Bearer token replay and what sender-constraining actually solves
A bearer token gives access to whoever holds it. The caller need not prove possession of a separate client key, so theft can be enough to impersonate the application within the token’s permissions until it expires. Theft need not happen in transit, either. Compromised vendor environments, infostealer malware, logs, and browser storage can all expose tokens.
Wildcard redirect URI registrations can expose tokens through subdomain takeovers and path traversal, while the legacy implicit grant places access tokens directly in URL fragments. These weaknesses increase the chance of exposure. The bearer model then turns possession of the exposed token into usable authority.
DPoP, defined in RFC 9449, binds a token to a cryptographic key that the client must prove it holds on each request. Mutual TLS, defined in RFC 8705, binds the token to the client’s cryptographic identity and requires proof through mutual TLS. Possession alone is no longer enough for replay. Where platforms support it, sender-constrained tokens should replace bearer tokens for sensitive scopes, though they do not correct an excessive permission grant or make a compromised authorized client trustworthy.
How AI agents and MCP integrations expand the OAuth attack surface
AI agents often need access to more than one system to do their work. Their tokens can therefore span every SaaS platform they are authorized to reach, concentrating permissions in a new integration layer. The Vercel and Context.ai breach in April 2026 illustrates the exposure. A third-party AI tool connected by an employee became a route to customer data, turning an individual consent decision into an enterprise entry point.
Model Context Protocol integrations also have their own ways in which authorization can fail. In a confused deputy attack, an MCP server acting as an OAuth proxy fails to validate authorization context properly and is manipulated into using another user’s credentials. The attacker can do this without stealing those credentials directly. Prompt injection can create another path by instructing a model to relay credentials embedded in tool call outputs.
The Coalition for Secure AI advises that, rather than passing through OAuth tokens that users provide, systems use token exchange with the authorization server using RFC 8693. That exchange produces a token scoped to the specific operation and an auditable exchange record. It narrows what the next component receives.
The governance gap is not permission from the specification. The MCP specification requires OAuth 2.1 for authorization servers and token validation by MCP servers, while authorization is optional for stdio transports. Real-world enforcement remains absent, however, and deployments reproduce familiar weaknesses such as broad scopes, missing inventories, and no revocation rehearsal.
What the strongest objection gets right, and where it falls short
“OAuth is secure when implemented correctly” is a fair objection. Weak redirect handling, poor state validation, excessive privilege, and unsafe token handling do not show that the idea of authorization itself is flawed. RFC 9700, Best Current Practice for OAuth 2.0 Security, addresses these implementation risks. Following that guidance is necessary work.
The limit is where the customer’s implementation ends. A correctly handled consent flow cannot prevent an upstream vendor from losing credentials it legitimately holds. Phishing-resistant MFA for employees does not stop a vendor’s compromised client from presenting its refresh token or app secret. The client is using authorization already granted, rather than asking the employee to authenticate again.
Customers can constrain and revoke access, but cannot directly govern storage inside a vendor’s environment. Even with careful scoping and token rotation, the risk depends on how that vendor stores tokens, keeps up with rotation, and responds to a breach. This is the supply-chain gap implementation hygiene cannot close alone. When another company takes custody of credentials, technical controls need rules for who is responsible and what the contract requires.
The controls that map directly to each structural condition
For illicit consent grants, the control point is approval. User consent should be limited to low-risk permissions from verified publishers, with everything else routed through administrator approval. Alerts should flag new grants that have offline access, mail read, or file write. Security training should treat the consent screen as a phishing surface, including when the sign-in page itself is genuine.
For overbroad scopes, least privilege belongs in integration requirements. Vendors should explain why each permission they request is needed for the function it supports. Reviews should explicitly distinguish delegated permissions from application permissions. App-only grants need a closer look because they can give access across the tenant.
For stale grants, the control is recurring recertification. Each app needs an owner and review cadence, supported by automated detection of grants unused beyond a defined threshold. Deprovisioning checklists should include OAuth grants as well as account offboarding.
For bearer-token replay, sensitive integrations should use DPoP or mTLS where supported. Authorization code flows should use PKCE with S256, and redirect URIs should require exact string matching without wildcards. Implicit and ROPC flows should be disabled. Refresh token rotation and an absolute refresh token lifetime also limit how long credentials can be used for access.
For AI and MCP exposure, token exchange should replace pass-through. Each agent token should be scoped to its specific operation, and MCP servers should be treated as untrusted clients until authentication enforcement exists. Agent grants need the same inventory and revocation discipline as SaaS grants. An AI label is not an exemption from access review.
For the supply-chain risk that is left, contracts with integrators should set standards for token storage and rotation, and checks of vendors should look at the scope of their OAuth grants. Monitoring supplies the detection layer those requirements cannot provide alone. Integration API activity should be logged and baselined for volume, source networks, and object access patterns before an incident. That record makes the other controls auditable and gives teams a basis for spotting valid access being used in the wrong way.



