CVE-2026-33752: Lexiforest Curl Cffi SSRF Vulnerability

CVE-2026-33752 Overview

CVE-2026-33752 is a Server-Side Request Forgery (SSRF) vulnerability in curl_cffi, a Python binding for curl. Prior to version 0.15.0, curl_cffi does not restrict requests to internal IP ranges and automatically follows redirects via the underlying libcurl. This allows an attacker-controlled URL to redirect requests to internal services such as cloud metadata endpoints. Additionally, curl_cffi's TLS impersonation feature can make these malicious requests appear as legitimate browser traffic, potentially bypassing certain network controls.

Critical Impact

Attackers can leverage this SSRF vulnerability to access sensitive internal services, including cloud metadata endpoints (e.g., AWS IMDSv1, GCP metadata), potentially exposing cloud credentials, configuration data, and other sensitive information from protected internal networks.

Affected Products

• lexiforest curl_cffi versions prior to 0.15.0
• lexiforest curl_cffi 0.15.0-beta1 through 0.15.0-beta4
• Applications using curl_cffi for HTTP requests with user-controlled URLs

Discovery Timeline

• 2026-04-06 - CVE-2026-33752 published to NVD
• 2026-04-09 - Last updated in NVD database

Technical Details for CVE-2026-33752

Vulnerability Analysis

This SSRF vulnerability stems from curl_cffi's permissive default configuration regarding URL handling. The library does not implement restrictions on requests to internal or private IP ranges (such as 127.0.0.1, 169.254.169.254, 10.0.0.0/8, 172.16.0.0/12, or 192.168.0.0/16). Combined with automatic redirect following inherited from libcurl, an attacker can craft a malicious URL that initially points to an external server they control, which then issues an HTTP redirect to an internal service.

The vulnerability is classified under CWE-918 (Server-Side Request Forgery), where the web server receives a URL or similar request from an upstream component and retrieves the contents without sufficiently ensuring the request is being sent to the expected destination. The network-based attack vector requires no authentication and no user interaction, enabling remote exploitation against any application that processes attacker-supplied URLs through curl_cffi.

Root Cause

The root cause of this vulnerability is the absence of URL validation and IP address filtering in curl_cffi prior to version 0.15.0. The library directly passes user-supplied URLs to libcurl without implementing safeguards to prevent access to internal network resources. Furthermore, libcurl's default behavior of following HTTP redirects (up to 30 redirects by default) is inherited without restriction, allowing redirect-based SSRF attacks even when the initial URL appears safe.

A compounding factor is curl_cffi's TLS impersonation capability, which enables requests to mimic legitimate browser traffic patterns. This feature, while useful for legitimate purposes, can help SSRF attacks bypass network security controls that rely on user-agent or TLS fingerprint analysis.

Attack Vector

The attack scenario involves an application that uses curl_cffi to fetch content from user-supplied URLs. An attacker provides a URL pointing to an external server they control. When curl_cffi makes the request, the attacker's server responds with an HTTP 302 redirect to an internal resource, such as http://169.254.169.254/latest/meta-data/iam/security-credentials/. Since curl_cffi automatically follows redirects and does not validate the destination IP address, the request is made to the internal metadata service, and the response is returned to the attacker.

This attack is particularly dangerous in cloud environments where instance metadata services expose sensitive credentials. The vulnerability enables attackers to pivot from an external entry point to access internal infrastructure resources that should never be accessible from outside the network.

Detection Methods for CVE-2026-33752

Indicators of Compromise

• Outbound HTTP requests from application servers to cloud metadata endpoints (169.254.169.254, fd00:ec2::254)
• Unusual redirect chains in application logs showing external URLs redirecting to internal IP ranges
• HTTP requests to private IP ranges originating from web application components
• Unexpected access patterns to internal services from curl_cffi-based applications

Detection Strategies

• Monitor network traffic for HTTP requests to RFC 1918 private IP addresses and link-local addresses originating from application servers
• Implement logging and alerting for curl_cffi requests that follow redirects to different hostnames or IP ranges
• Review application dependencies for curl_cffi versions earlier than 0.15.0 using software composition analysis tools
• Deploy network segmentation rules that alert on application servers attempting to contact metadata services directly

Monitoring Recommendations

• Enable verbose logging in curl_cffi to capture full request chains including redirects
• Configure cloud provider metadata service protections (e.g., IMDSv2 on AWS) and monitor for IMDSv1 access attempts
• Implement egress filtering and monitor for blocked connection attempts to internal IP ranges
• Use runtime application security monitoring to detect SSRF attack patterns in URL handling code

How to Mitigate CVE-2026-33752

Immediate Actions Required

• Upgrade curl_cffi to version 0.15.0 or later immediately
• Audit applications using curl_cffi to identify any user-controlled URL inputs
• Implement application-level URL validation to block requests to internal IP ranges
• Configure network-level controls to prevent application servers from accessing cloud metadata endpoints directly

Patch Information

The vulnerability is fixed in curl_cffi version 0.15.0. Organizations should update their Python dependencies to use the patched version. The fix implements proper URL validation and restricts requests to internal IP ranges by default. Refer to the GitHub Security Advisory GHSA-qw2m-4pqf-rmpp for complete details on the security update.

Workarounds

• Implement a URL allowlist at the application level, permitting only known-safe external domains
• Deploy a forward proxy that validates and filters outbound requests, blocking connections to internal IP ranges
• Disable automatic redirect following in curl_cffi configurations and manually validate redirect targets
• Use cloud metadata service hardening (e.g., AWS IMDSv2 with hop limit of 1) to prevent SSRF-based credential theft

# Example: Upgrade curl_cffi to patched version
pip install --upgrade curl_cffi>=0.15.0

# Verify installed version
pip show curl_cffi | grep Version