Skip to main content
Be Bitwise

Chaining Vulnerabilities for Impact

Bug Bounty Methodology · Bug Bounty track

5 min read

In this module

When One Bug Isn't Enough

Plenty of vulnerabilities are unimpressive on their own. An open redirect might earn a $50 bounty, or get marked informational. An information disclosure that leaks an internal path might not even be accepted. Combine them, though, and the result can be account takeover. Vulnerability chaining is the craft of linking modest findings into a single, high-impact attack.

Why Individual Low-Severity Bugs Matter

Experienced researchers never throw away a low-severity finding. Every bug is a potential link in a chain. An information disclosure that reveals the structure of password reset tokens looks unremarkable in isolation, but it becomes the keystone of a critical chain the moment you find a token validation flaw to pair it with.

Maintain a log of every issue you discover, even if it seems minor:

  • Self-XSS (XSS that only fires in the attacker's own session)
  • Open redirects
  • Information disclosures (internal paths, version numbers, usernames)
  • Missing rate limits
  • Verbose error messages
  • Inconsistent authorisation checks

These findings are the raw materials for chains. The next time you discover a bug, comb back through your log. The combination may be worth far more than either piece on its own.

Common Chain Patterns

A handful of vulnerability combinations turn up again and again across applications and organisations:

Open redirect + OAuth misconfiguration = token theft: if the application's OAuth implementation doesn't strictly validate the redirect_uri, an attacker can chain an open redirect to capture the authorisation code or access token. The OAuth provider redirects to the application, the application redirects to the attacker via the open redirect, and the token rides along.

Self-XSS + login CSRF = stored XSS on victim: self-XSS (where the payload only fires in the attacker's own session) is usually a dead end. But pair it with a login CSRF — where the attacker can force the victim's browser to log into the attacker's account — and you have a working exploit. The attacker logs the victim into the attacker-controlled account where the XSS payload is stored, and it executes in the victim's browser.

IDOR + password reset = account takeover: an IDOR on a user information endpoint leaks the victim's email and account metadata. That kicks off a password reset. If the reset flow has any further weakness (predictable tokens, token leakage in the Referer header, sloppy validation), the chain closes into a full account takeover.

Worked Example: Information Disclosure to Account Takeover

Picture a real-world chain. During testing, you turn up three separate issues:

Bug 1 — Information disclosure (Low): the endpoint /api/v1/users/{id}/profile returns the user's email address and account creation date to any authenticated user, not only the account owner.

Bug 2 — Predictable password reset tokens (Medium): reset tokens are generated using MD5(email + account_creation_timestamp). You spot this by requesting your own token and reverse-engineering the generator.

Bug 3 — No rate limiting on reset verification (Low): the password reset verification endpoint enforces neither rate limiting nor account lockout.

In isolation, low-to-medium severity. Chained together:

  1. Use Bug 1 to retrieve the victim's email and creation timestamp
  2. Use Bug 2 to compute the victim's password reset token
  3. Use Bug 3 to submit the computed token without restriction
  4. Result: full account takeover on any user

Three modest bugs collapse into one critical finding, with a payout to match.

Try it with a findings log of your own. Pick bugs and see whether they join up into account takeover, and which ones are dead weight. Switch the goal to the victim's browser to check the self-XSS pattern too.

Which findings make a chain?

Pick findings from your log. The graph shows whether they join up into a path to the goal.

Your findings (pick any)

Pick some findings

Tap a box or a numbered arrow to read about it.

Cheapest route Open Blocked (✕) Not reachable yet Reached

Nothing selected yet.

Illustrative target. The chains follow the patterns in this lesson.

Severity of a Chain

When reporting a vulnerability chain, the severity should reflect the end-to-end impact, not the individual components. A chain that results in account takeover is critical, even if every individual link is low severity. Platforms and organisations evaluate the realistic attack scenario, not the isolated bugs. Always demonstrate the full chain in your proof of concept.

Most programmes want a chain reported together as one finding. Some prefer each independently fixable bug as its own report and pay them separately, so check the policy before you submit.

Demonstrating Business Impact

When writing up a chain, translate the technical impact into business consequences. Triage analysts and security managers need to understand why this matters once you step away from the keyboard:

  • "This chain allows any authenticated user to take over any other account" (user trust, regulatory exposure)
  • "An attacker can purchase items at arbitrary prices" (direct financial loss)
  • "Sensitive personal data of all users can be exfiltrated" (data protection regulation, reputational damage)

Quantify the impact where possible. How many users are affected? What data is exposed? What is the financial consequence?

Writing the Chain Into a Compelling Report

Structure your chain report as a narrative. Walk the reader through each step:

  1. Title: describe the end result, not the components ("Account Takeover via Chained Information Disclosure and Predictable Reset Tokens")
  2. Summary: one paragraph explaining the full chain and its impact
  3. Prerequisites: what the attacker needs (e.g., an authenticated account)
  4. Step-by-step reproduction: each step, with exact requests and responses
  5. Individual bugs: describe each component vulnerability and its role in the chain
  6. Impact: the business consequence of the full chain
  7. Remediation: fix recommendations for each component (fixing any one link breaks the chain)

A well-written chain report shows you understand the application deeply, and a triage team that sees that level of understanding rewards it — both in payout and in invitations.