CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-53504

CVE-2026-53504: Regular Expression Denial of Service (ReDoS) in Thumbor Convolution Filter

Amit Schendel
Amit Schendel
Senior Security Researcher

Jul 31, 2026·6 min read·46 visits

Executive Summary (TL;DR)

Unauthenticated remote attackers can trigger exponential CPU backtracking in Thumbor (< 7.8.0) via a crafted convolution filter parameter, causing a denial of service.

A critical Regular Expression Denial of Service (ReDoS) vulnerability exists in Thumbor prior to version 7.8.0. The vulnerability resides within the dynamic filter-parsing engine, specifically inside the 'convolution' filter parameter processing logic. Due to overlapping and nested quantifiers in the regular expression used to parse matrix values, a remote, unauthenticated attacker can supply a specially crafted, malformed filter payload inside a request URL. This causes Python's standard NFA-based regular expression engine to undergo exponential backtracking, exhausting CPU resources and leading to a complete Denial of Service.

Vulnerability Overview

Thumbor is an open-source smart imaging service that processes, resizes, and filters images on demand. It features a wide array of filters, such as convolution, which allows users to define custom spatial filters using matrix-based operations. The application is designed to be highly accessible and performance-focused, often integrated into high-traffic web environments to serve dynamic assets.

To handle requests efficiently, Thumbor relies on the Tornado web framework. Tornado uses an asynchronous, single-threaded event loop architecture to handle multiple concurrent network connections. While this model is highly efficient for I/O-bound tasks, it is susceptible to starvation when processing CPU-bound tasks.

The filter-parsing mechanism represents a substantial attack surface. When parsing filter options directly from the URL path, Thumbor uses regular expressions to validate and extract parameter sets. In the case of the convolution filter, a flaw in the regular expression design allows unauthenticated users to trigger exponential execution times, completely blocking the single-threaded worker process.

Root Cause Analysis

The root cause of this vulnerability lies in the design of the regular expression utilized by the convolution filter parser. Specifically, the parser attempts to validate a list of semicolon-separated matrix coefficients. The vulnerable pattern is defined as (?:[-]?[\d]+\.?[\d]*[;])*(?:[-]?[\d]+\.?[\d]*). This structure contains nested and overlapping quantifiers.

Python's native re module uses a Non-deterministic Finite Automaton (NFA) engine. When matching a target string, an NFA engine processes inputs by exploring potential paths. If a path fails to match, the engine backtracks to try alternative configurations. Overlapping quantifiers within the subpatterns allow a single string to be interpreted in multiple ways, causing the engine to evaluate a massive state space before returning a mismatch.

The subpattern [-]?[\d]+\.?[\d]* contains ambiguity because a string of digits (e.g., 11) can be matched by [\d]+ entirely, or divided between [\d]+ and [\d]*. Furthermore, nesting this pattern inside a repeating group followed by a trailing duplicate pattern creates an exponential search complexity. On malformed input that fails at the final step, the engine attempts $2^N$ backtracking combinations for $N$ parameters, driving CPU utilization to 100%.

Code Analysis

To analyze the flaw, we can inspect the core filter file thumbor/filters/convolution.py. Before the security patch, the filter registration decorator defined the following evaluation regex:

# Vulnerable regex definition in thumbor/filters/convolution.py
@filter_method(
    r"(?:[-]?[\d]+\.?[\d]*[;])*(?:[-]?[\d]+\.?[\d]*)",
    BaseFilter.PositiveNonZeroNumber,
    BaseFilter.Boolean,
)

In this implementation, the Kleene star on the non-capturing group (?:...)* matches any number of semicolon-terminated matrix items, while the subsequent pattern handles the final matrix element. Because both patterns utilize the ambiguous float-matching regex, the boundary between items becomes indistinct during failures.

The security patch refactored the regular expression to ensure a strict, linear matching behavior. The updated decorator is defined as:

# Patched regex definition in thumbor/filters/convolution.py
@filter_method(
    r"-?[\d]+(?:\.[\d]*)?(?:;-?[\d]+(?:\.[\d]*)?)*",
    BaseFilter.PositiveNonZeroNumber,
    BaseFilter.Boolean,
)

The new regex eliminates the overlapping parsing states. By explicitly separating integers and decimal points ((?:\.[\d]*)?) and changing the loop structure from (A;)*A to A(?:;A)*, the parser matches matrix elements deterministically. There is only one valid traversal path per character sequence, reducing execution complexity from $O(2^N)$ to $O(N)$.

Exploitation Methodology

Exploitation of CVE-2026-53504 is straightforward and requires only network access to the target instance. The attacker must submit a malformed request pointing to the convolution filter. Since the regular expression requires trailing parameters (like column count and normalization flag) to match successfully, omitting these parameters forces the parser to evaluate the entire sequence and fail.

A typical exploit payload consists of a standard Thumbor image request URL with an elongated list of negative integers:

GET /unsafe/filters:convolution(-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11;-11)/path/to/image.jpg HTTP/1.1
Host: target-thumbor-instance.local

When the Tornado backend receives this request, it attempts to match the filter parameters against the registered regular expressions. The NFA engine begins to parse the 30 semicolon-separated values. Upon reaching the end of the convolution argument block, the engine detects that the required trailing values are missing, causing a mismatch. It then begins to backtrack through every permutation of the digit groupings. This process requires over one billion state evaluations, keeping the Tornado worker thread at 100% CPU capacity for several minutes.

Impact Assessment

The impact of this vulnerability is a complete Denial of Service (DoS) affecting the image rendering pipeline. Because Thumbor processes are typically bound to a single thread using the Tornado event loop, a single malformed HTTP request can completely block the thread. This halts the processing of all other concurrent requests handled by that specific worker process.

In environments where multiple workers are deployed, an attacker can scale the attack by sending a small burst of requests (one per worker process). This easily exhausts the entire backend pool. Since CPU resources are fully consumed by the backtracking loop, the underlying server instances also experience severe performance degradation, potentially impacting other services hosted on the same infrastructure.

This vulnerability does not allow for remote code execution, privilege escalation, or direct data leakage. However, its high reliability and low complexity make it an effective tool for disruption. It receives a CVSS v3.1 score of 7.5, indicating High severity due to its critical impact on service availability.

Remediation & Defense-in-Depth

The primary remediation step is to upgrade the Thumbor installation to version 7.8.0 or later. This release updates the convolution filter regular expression, removing the nested quantifiers and ensuring linear matching times.

For environments where an immediate upgrade is not feasible, several defensive workarounds can be implemented. If the convolution filter is not required by the application, it can be disabled or removed from the active filter list within the Thumbor configuration file (thumbor.conf).

Alternatively, network-level web application firewalls (WAFs) can be configured to inspect incoming URLs. Rules should block requests containing abnormally long arguments within the filters:convolution block. Setting up strict rate limiting and ensuring that the event loop can timeout slow operations also helps mitigate the severity of resource exhaustion attacks.

Official Patches

ThumborOfficial patch fixing the ReDoS in the convolution filter regex.
ThumborThumbor version 7.8.0 release notes.

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Affected Systems

Thumbor image processing service running versions prior to 7.8.0

Affected Versions Detail

Product
Affected Versions
Fixed Version
Thumbor
globo.com
< 7.8.07.8.0
AttributeDetail
CWE IDCWE-400 (Uncontrolled Resource Consumption)
Attack VectorNetwork (AV:N)
Attack ComplexityLow (AC:L)
Privileges RequiredNone (PR:N)
User InteractionNone (UI:N)
CVSS v3.1 Score7.5 (High)
Exploit StatusProof-of-Concept
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
CWE-400
Uncontrolled Resource Consumption

The product does not properly control the allocation and maintenance of a limited resource, enabling an actor to influence the amount of resources consumed, leading to eventual exhaustion.

Known Exploits & Detection

GitHub Security AdvisoryAdvisory documenting the ReDoS vulnerability and the vulnerable convolution filter pattern.

Vulnerability Timeline

Security patch committed to master
2026-03-07
GitHub Security Advisory GHSA-5vjc-7cxw-4w6j published
2026-07-31
CVE-2026-53504 officially released
2026-07-31
Thumbor version 7.8.0 released with the patch
2026-07-31

References & Sources

  • [1]GitHub Security Advisory GHSA-5vjc-7cxw-4w6j
  • [2]Fix Commit 3f38fe1
  • [3]CVE-2026-53504 Record on CVE.org
  • [4]Thumbor Release 7.8.0

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•37 minutes ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-126304
8.7

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
6 views•9 min read
•about 5 hours ago•CVE-2026-128077
6.5

CVE-2026-128077: Authorization Bypass via Request Path Desynchronization in Nuxt and @nuxt/nitro-server

CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours ago•CVE-2026-128084
4.8

CVE-2026-128084: Integer Truncation and SQL Query Truncation in sqlite3-ruby

Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.

Alon Barad
Alon Barad
5 views•11 min read