CVE-2023-46136

What it actually does

The vulnerability exists in the multipart form data parser of the Werkzeug library. When processing a file upload that begins with a carriage return (CR) or line feed (LF) character followed by a large amount of data without a boundary separator, the parser enters a highly inefficient loop. It repeatedly appends data chunks to an internal buffer and re-scans the entire growing buffer for the boundary. This leads to quadratic complexity in processing time, causing excessive CPU consumption and blocking the worker process, resulting in a denial of service.

Why it matters to the business

An attacker can render web applications and services built on the vulnerable library completely unavailable to legitimate users. This denial of service can disrupt critical business operations, halt customer-facing services, and lead to financial losses and reputational damage. The attack is simple to execute and can be launched by any user, including unauthenticated ones, who can send data to a file upload endpoint.

How an attack unfolds

An attacker targets a web application that uses a vulnerable version of Werkzeug and exposes a file upload endpoint. The attacker constructs a malicious multipart/form-data POST request. The payload for the file upload is crafted to start with a single CR or LF character, followed by megabytes of data that intentionally omits the multipart boundary string. Upon receiving this request, the Werkzeug parser begins its inefficient processing. It appends each chunk of the large file to a buffer and re-scans the entire buffer, consuming significant CPU time. This effectively freezes the worker process, preventing it from handling any other requests and causing a denial of service for the entire application.

How to fix it

Upgrade the Werkzeug library to a patched version. For projects using the 3.x branch, upgrade to version 3.0.1 or later. For projects using the 2.x branch, upgrade to version 2.3.8 or later. If an immediate upgrade is not feasible, consider implementing rate-limiting on file upload endpoints or using a Web Application Firewall (WAF) to block malformed or excessively large multipart requests as a temporary mitigation.

How to confirm the fix worked

To confirm the vulnerability is remediated, check your project's dependencies to ensure Werkzeug is updated to version 3.0.1+ or 2.3.8+. You can verify this using package management tools like `pip list`. To test for exposure in a non-production environment, send a crafted POST request to a file upload endpoint with a payload that starts with a `\r` or `\n` character followed by several megabytes of data without a boundary. A vulnerable system will exhibit a sustained CPU spike for the worker process, while a patched system will handle the request without excessive resource consumption.

Typical attack path

1. The attacker identifies a web application using a vulnerable version of the Werkzeug library.
2. The attacker locates an endpoint that accepts multipart/form-data, such as a file upload form.
3. The attacker crafts a malicious HTTP POST request containing a file upload that starts with a CR or LF character.
4. The body of the uploaded file consists of a large volume of data that lacks the expected boundary string.
5. The attacker sends this request to the server.
6. The server's Werkzeug parser enters a high-CPU loop, causing the worker process to become unresponsive and leading to a denial of service.

How to detect it

Monitor for signs of exploitation by observing web server and application performance metrics. Look for sustained, high CPU utilization (near 100%) in worker processes handling web requests. Correlate these CPU spikes with web server access logs, searching for POST requests to file upload endpoints that result in timeouts (e.g., HTTP 504 Gateway Timeout) or internal server errors (HTTP 500). Application Performance Monitoring (APM) tools may also reveal unusually long-running transactions stuck within Werkzeug's multipart parsing functions.

What your security team should do

• Prioritize patching all applications using the Werkzeug library to versions 3.0.1+ or 2.3.8+.
• Monitor web server and application performance metrics for sustained CPU spikes, which could indicate an ongoing attack.
• If patching is delayed, implement temporary mitigations such as rate-limiting file uploads or deploying WAF rules to inspect and block malformed multipart requests.