CVE-2026-25645: 
Python vulnerability analysis and mitigation

CVE-2026-25645 is an insecure temporary file vulnerability (CWE-377) in the Python requests HTTP library affecting all versions prior to 2.33.0. The flaw resides in the requests.utils.extract_zipped_paths() utility function, which uses a predictable filename when extracting files from zip archives into the system temporary directory. It was disclosed on March 25, 2026, by reporter Jaycelation via the GitHub Security Advisory program (GitHub Advisory). The CVSS v3.1 base score is 4.4 (Moderate) per the official advisory, though NVD assigns 5.5 (Medium) (GitHub Advisory).

The root cause is classified as CWE-377 (Insecure Temporary File). In versions prior to 2.33.0, extract_zipped_paths() constructed the extraction path using os.path.join(tempfile.gettempdir(), member.split('/')[-1]) — a deterministic, predictable filename — and then checked whether the file already existed before writing; if it did, the existing file was reused without any integrity validation (GitHub Advisory). The fix in version 2.33.0 replaces this logic with tempfile.mkstemp(), which generates a non-deterministic temporary file path, eliminating the predictability (GitHub Commit). Exploitation requires local access to the system and write permissions to the temporary directory, and is only relevant to applications that explicitly call extract_zipped_paths() directly — standard use of the requests library is unaffected (GitHub Advisory).

A local attacker with write access to the system's temporary directory could pre-create a malicious file at the predictable path before the vulnerable application calls extract_zipped_paths(), causing the application to load the attacker-controlled file instead of the legitimate extracted content. The primary impact is on data integrity — confidentiality and availability are not affected. The scope is limited to applications that directly invoke the utility function, and there is no known path to remote code execution or lateral movement from this vulnerability alone (GitHub Advisory).

There is no public proof-of-concept exploit and no evidence of in-the-wild exploitation as of the time of disclosure (GitHub Advisory). The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. The EPSS score is approximately 0.004% (0.000040), reflecting a very low probability of exploitation in the near term. No threat actor attribution has been reported.

1. Identify a target application: Determine that the target application uses a version of the Python requests library prior to 2.33.0 and explicitly calls requests.utils.extract_zipped_paths() with a zip archive containing files.
2. Gain local access: Obtain a local account on the target system with write access to the system temporary directory (e.g., /tmp on Linux or %TEMP% on Windows).
3. Determine the predictable filename: Identify the filename that extract_zipped_paths() will use — it is derived from the last component of the zip member path (e.g., for a member certs/cacert.pem, the extracted path would be /tmp/cacert.pem).
4. Pre-create a malicious file: Before the target application calls extract_zipped_paths(), write a malicious file to the predictable temporary path (e.g., echo 'malicious content' > /tmp/cacert.pem).
5. Trigger the vulnerable function: Cause the target application to invoke extract_zipped_paths() — since the file already exists, the function skips writing and returns the path to the attacker-controlled file.
6. Achieve objective: The application loads and uses the attacker-controlled file in place of the legitimate extracted content, potentially leading to integrity compromise (e.g., substituting a malicious CA certificate bundle) (GitHub Advisory, GitHub Commit).

• File System: Unexpected or pre-existing files in the system temporary directory (/tmp/, %TEMP%) matching the names of files typically extracted from zip archives used by the target application (e.g., cacert.pem or other certificate/data files).
• File System: Files in the temp directory with modification timestamps predating the application's invocation of extract_zipped_paths(), indicating they were placed there before the extraction occurred.
• Logs: Application logs showing unexpected behavior when processing files extracted from zip archives, such as certificate validation failures or data parsing errors that could indicate a substituted file.
• Process: Unusual local processes writing files to the system temporary directory with names matching known zip archive members used by the target application.

Upgrade the Python requests library to version 2.33.0 or later, where extract_zipped_paths() uses tempfile.mkstemp() to generate non-deterministic temporary file paths (GitHub Release). As an interim workaround for environments that cannot upgrade immediately, set the TMPDIR environment variable to a directory with restricted write access (accessible only to the application's user), preventing local attackers from pre-creating files at the predictable path (GitHub Advisory). Downstream products incorporating the vulnerable library — including IBM Maximo Application Suite, IBM Process Mining, IBM watsonx.data, IBM Guardium Data Security Center, IBM Security QRadar EDR, and OpenVPN Access Server — have released or are releasing their own patches; consult the respective vendor advisories for specific remediation guidance (IBM Advisory, OpenVPN Release Notes).

The vulnerability was reported by a researcher identified as Jaycelation and remediated by the requests maintainers nateprewitt and sigmavirus24 (GitHub Advisory). Multiple enterprise vendors including IBM and OpenVPN issued advisories acknowledging the impact on their products that bundle the requests library, reflecting broad downstream reach of the vulnerability (IBM Advisory, OpenVPN Release Notes). Community reaction has been measured, consistent with the vulnerability's moderate severity and limited exploitability scope.