November 17, 2026
How Trusting a Request Header Turned a Password Reset Into Account Takeover
Back to classic web for this one, and it’s a genuinely different flavor of bug from the IDOR and race condition already covered in this…

By L4ZZ3RJ0D
4 min read
Back to classic web for this one, and it's a genuinely different flavor of bug from the IDOR and race condition already covered in this series, which is exactly why it's worth sitting with. Found by Jack Cable on Mavenlink, paid $1,500, picked up 33 upvotes on disclosure. Worth knowing who found it too, Cable's the same researcher behind the LinkedIn AutoFill privacy bug and went on to become CISA's first Chief Information Security Officer, so this isn't a lucky one-off, it's someone who built a career on exactly this kind of careful reasoning about trust boundaries. Full report's public: Password reset link injection allows redirect to malicious URL.
Every HTTP request carries a Host header, a simple field telling the server which domain the client thinks it's talking to. It exists because a single server can host many different websites behind one IP address, and the server needs some way to know which one you actually meant to reach. Here's the detail that makes this entire bug class possible, and it's worth sitting with before anything else: that header is just a piece of text the client sends, completely under the client's own control, no different from any other request header you could type by hand. A browser fills it in automatically and honestly almost all the time, which is exactly why most developers never stop to think of it as user input at all. It is, every single time, and nothing stops anyone from setting it to whatever they want.
Mavenlink's password reset feature needed to email users a working link back to the reset page, and somewhere in that code, instead of hardcoding the company's own known domain into that link, the application built the link using whatever domain was sitting in the Host header of the request that triggered the reset. On the surface that's a completely understandable shortcut, using the request's own host to build a relative-feeling absolute URL saves having to hardcode a domain string somewhere, and on every normal request, from a normal browser, pointed at the real site, the Host header says exactly what you'd expect it to say anyway. The shortcut only becomes a vulnerability the moment someone realizes that header was never actually guaranteed to say what you expect.
Cable's actual test was simple to execute and genuinely clever to think of in the first place: he submitted a password reset request for a real account, using Burp Suite to intercept the request first and change the Host header to a server he controlled before letting it continue on to Mavenlink. The reset still processed normally server-side, a valid token got generated, an email went out through Mavenlink's own real mail infrastructure to the actual account holder, exactly as the legitimate flow intends. The only thing that changed was the domain baked into the link inside that email, which now pointed at Cable's own server instead of Mavenlink's.
That's the part of this bug worth understanding at the level of why it actually works, not just how to reproduce it, because the mechanism explains exactly why it's dangerous in a way a lot of reflected-input bugs aren't. The email itself is completely genuine, sent from Mavenlink's own infrastructure, with Mavenlink's own branding, landing in the real account holder's real inbox exactly when they'd expect it to if they'd actually requested a reset, or even if they hadn't, since the attacker is the one who triggered it on their behalf. Every signal a person normally uses to judge whether an email is a phishing attempt, the sending domain, the visual branding, the fact that it arrived through a channel they already trust, checks out completely. The only compromised piece is a URL inside it that most people never actually read character by character before clicking. If the account holder clicks that link, their own browser sends the valid reset token straight to the attacker's server as part of the request, sitting there readable in the attacker's own access logs. From there, the attacker takes that captured token, browses to Mavenlink's actual real reset page directly, and sets a brand new password on an account that was never theirs to begin with.
Worth being precise about where the actual skill in this finding lived, because it's not really about knowing that Host headers can be spoofed, that part is widely documented and most working developers have heard of it in the abstract. The actual insight was connecting that header-trust issue specifically to a feature where the server's output doesn't stay on the server, it gets mailed out to someone else entirely and trusted implicitly because of where it came from. A reflected Host header showing up in a page you're looking at yourself is a curiosity. The exact same reflected value getting embedded into a credential-bearing link mailed to a different person under your own company's trusted name is a full account takeover chain. Recognizing that distinction, which feature's output actually crosses a trust boundary to reach someone else, is the manual reasoning step no scanner reliably makes on its own, because it requires understanding the business purpose of the feature, not just the shape of the request.
The generalizable habit worth carrying forward from this one: any time you find a header, a parameter, or any piece of client-controlled input reflected back into the application's own output, don't stop at confirming the reflection and move on. Ask specifically whether that output ever leaves the session you're sitting in, an email sent to someone else, a PDF generated and stored for later, a webhook fired to a third party, a cached response served to a different visitor entirely. A reflection that stays contained to your own browser tab is a data point. The exact same reflection, the moment it crosses into something another person will see and trust later, is very often the difference between an informative finding and a full account takeover.
Happy hunting, see you in the next scope :)