CVE-2026-84379: 
Linux Debian vulnerability analysis and mitigation

CVE-2026-84379 is a CRLF injection vulnerability in HTTPX2, a next-generation HTTP client for Python maintained by Pydantic. The flaw exists in FileField.render_headers() within src/httpx2/httpx2/_multipart.py, where attacker-controlled content_type values and custom headers from the files= tuple API are interpolated directly into multipart/form-data part headers without validation. All HTTPX2 versions prior to 2.11.0 are affected. It carries a CVSS v3.1 base score of 5.3 (Medium) (GitHub Advisory, Red Hat CVE). The vulnerability was published on September 2, 2026, and patched in version 2.11.0 released August 18, 2026.

The root cause is CWE-93 (Improper Neutralization of CRLF Sequences). The FileField.render_headers() method in _multipart.py interpolates user-supplied header names and values between CRLF delimiters without sanitizing them, allowing CR (\r) or LF (\n) characters to terminate a part header prematurely, inject additional part headers, or end the part header block early. Both the three-element tuple (filename, content, content_type) and the four-element tuple (filename, content, content_type, headers) passed to the files= parameter are affected. The fix introduced two regex patterns — _HEADER_NAME_RE to validate header names as HTTP field-name tokens and _FORBIDDEN_HEADER_VALUE_CHARS_RE to reject control characters (NUL, CR, LF, and other C0 controls except horizontal tab) — raising a ValueError before serialization (GitHub Advisory, Fix Commit).

An unauthenticated attacker who can influence upload metadata passed to HTTPX2 (e.g., via a web application that forwards user-supplied file metadata) can inject arbitrary multipart part headers into outgoing requests. The receiving server's multipart parser may interpret injected lines as genuine headers, potentially altering part semantics or bypassing header-based security checks on the downstream server. The injection is contained within the multipart body and does not split the outer HTTP request, so the concrete impact depends on how the downstream server processes multipart data. There is no direct confidentiality or availability impact; the primary risk is integrity tampering of upload requests (GitHub Advisory).

The vulnerability is network-exploitable with low attack complexity and requires no privileges or user interaction. The NVD SSVC assessment indicates a proof-of-concept exists and the vulnerability is automatable, though no public PoC code has been independently confirmed and no in-the-wild exploitation has been observed (Feedly). The EPSS score is 0.0, reflecting low current exploitation probability. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog. Exploitation requires an attacker to control the content_type or custom headers arguments passed to HTTPX2's files= parameter in an application.

1. Identify a target application: Find a web application or service that uses HTTPX2 (< 2.11.0) to forward file uploads to a backend server, where user-supplied metadata (e.g., content type or custom headers) is passed directly to the files= parameter.
2. Craft a malicious content_type: Prepare a content_type string containing a CRLF sequence followed by an injected header, for example: "text/plain\r\nX-Injected: malicious-value".
3. Submit the payload: Trigger the application to call HTTPX2 with the malicious metadata, e.g.:

import httpx2
request = httpx2.Request(
    "POST", "https://target.example.com/upload",
    files={"file": ("safe.txt", b"payload", "text/plain\r\nX-Injected: true")}
)

4. Observe injected headers: The generated multipart body will contain the attacker-injected part header (X-Injected: true) as a genuine header in the multipart part, which the downstream server's parser will process as a legitimate header.
5. Exploit downstream behavior: Depending on the receiving server's logic, the injected header may bypass content-type checks, alter file processing behavior, or circumvent header-based access controls (GitHub Advisory, Fix Commit).

• Network: Outbound multipart/form-data requests from an application using HTTPX2 containing unexpected or duplicate part headers (e.g., X-Injected, extra Content-Type lines) within the multipart body.
• Logs: Application logs showing ValueError: Invalid multipart header name or ValueError: Invalid control character in multipart header value after upgrading to HTTPX2 2.11.0, which may indicate prior exploitation attempts that are now being blocked.
• Application Behavior: Unexpected behavior on downstream file upload endpoints, such as bypassed content-type validation or anomalous file processing, that correlates with user-controlled upload metadata.

Upgrade HTTPX2 to version 2.11.0 or later, which validates multipart part header names and values before serialization and raises a ValueError for any forbidden control characters (Release v2.11.0, Fix PR). If an immediate upgrade is not possible, applications should sanitize all user-supplied content_type values and custom header names/values before passing them to HTTPX2's files= parameter, specifically rejecting any input containing CR (\r), LF (\n), NUL (\x00), or other C0 control characters. Additionally, restrict which users or inputs can influence the content_type and headers arguments in file upload code paths.

The vulnerability was reported by researcher maxisbey and the fix was authored and merged by Kludex (a Pydantic maintainer) on August 18, 2026 (GitHub Advisory, Fix PR). Red Hat tracked the issue via Bugzilla and published a CVE advisory (Red Hat CVE). No significant broader media coverage or notable community controversy has been observed beyond standard vulnerability disclosure channels.