MEDIUM 6.1

CVE-2026-44889: WebOb Open Redirect Vulnerability via Whitespace Bypass

WebOb, a widely-used Python library for HTTP request and response handling, contains an open redirect vulnerability in how it processes redirect locations. An attacker can craft a malicious redirect URL containing whitespace characters (tabs, carriage returns, newlines) that bypass existing protections, causing users to be sent to an attacker-controlled website instead of the legitimate destination. The vulnerability affects versions before 1.8.10 and relies on the user clicking a link or visiting a page that triggers the vulnerable redirect.

Source data · NVD / CISA · public domain

CVSS
3.1 · 6.1 MEDIUM · CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N
Weaknesses (CWE)
CWE-601
Affected products
1 configuration(s)
Published / Modified
2026-06-22 / 2026-06-26

NVD description (verbatim)

WebOb provides objects for HTTP requests and responses. Prior to 1.8.10, the normalization of the HTTP Location header during a redirect is vulnerable to an open redirect: WebOb joins the redirect target to the request URI using Python's urljoin, and since Python 3.10 the underlying urlsplit strips ASCII tab, carriage return, and newline characters before parsing, so a redirect target containing such characters can be reinterpreted as a protocol-relative URL whose authority is an attacker-controlled host. This bypasses the CVE-2024-42353 fix that escaped a leading double slash, allowing an attacker who influences the redirect location to send users to an arbitrary external site instead of the intended one. This vulnerability is fixed in 1.8.10.

1 reference(s) · View on NVD →

SEC.co analysis · AI-assisted, reviewed against source

Technical summary

The vulnerability exists in WebOb's HTTP Location header normalization during redirects. When constructing redirect URLs, WebOb uses Python's urljoin to join the redirect target with the request URI. Since Python 3.10, urlsplit strips ASCII whitespace characters (0x09, 0x0D, 0x0A) before parsing the URL. An attacker can embed these characters in a redirect target to create a URL that, after stripping, becomes a protocol-relative URL (beginning with //) pointing to an attacker's host. This circumvents the CVE-2024-42353 mitigation, which only escaped leading double slashes in the redirect location string. The resulting URL is then interpreted as pointing to an external authority under attacker control.

Business impact

Organizations relying on WebOb for HTTP request/response handling face risk of user credential theft and session hijacking. Attackers can redirect authenticated users away from legitimate applications to phishing sites or malware distribution endpoints. The attack requires user interaction (clicking a malicious link or visiting a compromised page) but is likely to succeed once triggered. For applications exposed to untrusted input in redirect parameters, the exposure is significant even at CVSS 6.1 Medium severity, as it directly enables account takeover scenarios.

Affected systems

The vulnerability affects WebOb versions prior to 1.8.10. WebOb is a dependency in Pylons, Pyramid, and other Python web frameworks. Any application using WebOb to construct or validate redirect responses is potentially affected. Systems running Python 3.10 or later are specifically vulnerable because earlier Python versions do not strip the whitespace characters that enable the bypass.

Exploitability

Exploitation requires an attacker to control or influence the redirect target URL—either through URL parameters, HTTP headers, or response body content in an application that constructs redirects dynamically. The attacker then embeds whitespace characters in the URL to bypass the previous fix. The attack triggers only when a user follows or is redirected via the malicious URL, making it dependent on user interaction but relatively straightforward to execute once an injection point is identified. No authentication or special privileges are required on the attacker's side.

Remediation

Upgrade WebOb to version 1.8.10 or later. Organizations should prioritize this patch for any Python application that processes HTTP redirects, particularly those exposed to user-controlled redirect parameters. Review application code for any custom redirect handling that may be similarly vulnerable to whitespace-based URL parsing bypasses.

Patch guidance

Verify the installed WebOb version using pip show webob or similar package management tools. Update using pip install --upgrade webob or equivalent in your dependency management system. Confirm that the upgraded version is 1.8.10 or later. Test redirect functionality in development and staging environments before deploying to production. No configuration changes are required; the fix is in the core URL normalization logic.

Detection guidance

Monitor for suspicious redirect URLs containing embedded whitespace characters (tabs, carriage returns, newlines) in request logs and HTTP Location headers. Search for URLs with protocol-relative paths (//) followed by unfamiliar domain names in redirect responses. Implement HTTP response header inspection to catch malformed or suspicious Location values before they reach end users. Application-level logging of redirect sources and destinations can reveal injection attempts. Review WebOb version in dependency trees across your infrastructure to identify unpatched instances.

Why prioritize this

Although CVSS 6.1 is Medium severity, the practical risk is significant: open redirects are common attack vectors for credential theft and are frequently chained with social engineering. The vulnerability bypasses a prior fix (CVE-2024-42353), suggesting sophisticated evasion. The fix is straightforward and non-breaking, making patching low-friction. Organizations should prioritize this over other Medium-severity issues if they use WebOb in customer-facing web applications or any role where redirect integrity affects security.

Risk score, explained

The CVSS 6.1 score reflects Network attack vector (no authentication required), Low attack complexity (straightforward URL crafting), user interaction required (user must click/follow the redirect), and Changed scope (can affect other security domains through redirects). The score does not capture the full business risk of open redirects in credential theft scenarios, which often justifies higher-than-CVSS prioritization in practice.

Frequently asked questions

How does this bypass the previous CVE-2024-42353 fix?

CVE-2024-42353 escaped leading double slashes in the redirect location. This vulnerability embeds whitespace characters that Python 3.10+ strips during URL parsing, causing the URL to be reinterpreted as a protocol-relative URL after the whitespace is removed. The attacker's payload looks malformed before parsing but becomes valid afterward, evading the string-level escaping.

Do I need Python 3.10+ for this to be exploitable?

Yes. The vulnerability specifically depends on Python 3.10's behavior of stripping ASCII whitespace characters during urlsplit. Earlier Python versions do not strip these characters, so the URL parsing behaves differently and the attack does not succeed in the same way. However, you should still upgrade WebOb regardless of your Python version to avoid future Python version upgrades introducing risk.

What should I check in my own redirect code?

Review any application code that constructs or validates redirect URLs, especially where user input or external data influences the redirect target. Validate that redirect destinations are absolute URLs to whitelisted domains or relative URLs that cannot include protocol-relative paths (//) without explicit intent. Do not rely solely on string matching or escaping; use proper URL parsing and validation libraries.

Is there a workaround if I cannot patch immediately?

No reliable workaround is available at the application layer without modifying WebOb or its integration. The safest approach is to patch. If immediate patching is impossible, consider implementing a Web Application Firewall (WAF) rule that blocks Location headers containing embedded whitespace or protocol-relative paths pointing to unexpected domains. This is a temporary measure only.

This analysis is based on the publicly disclosed vulnerability information available as of the publication date. Organizations should verify patch availability and compatibility with their specific WebOb versions and Python environments before applying updates. This analysis does not constitute professional security advice; consult with your organization's security team for risk assessment specific to your infrastructure. CVSS scores are provided by the CVE authority and represent a standardized but simplified measure of severity that may not reflect organizational-specific risk. Source: NVD (public-domain), retrieved 2026-07-28. Analysis generated by SEC.co (claude-haiku-4-5).