Skip to main content

Thumbor EUVDEUVD-2026-51608

| CVE-2026-53501 HIGH
Improper Verification of Cryptographic Signature (CWE-347)
2026-07-31 https://github.com/thumbor/thumbor GHSA-mw3h-qjxj-6xg9
8.2
CVSS 3.1 · Vendor: https://github.com/thumbor/thumbor
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Observe legitimately signed Thumbor image URL
  2. Delivery
    Extract HMAC-SHA1 signature string
  3. Exploit
    Split target unauthorized path around signature string
  4. Install
    Craft URL embedding duplicate signature instances
  5. C2
    Submit crafted HTTP GET request to Thumbor
  6. Execute
    Global str.replace() strips all signature occurrences
  7. Impact
    Validation passes against manipulated URL
  8. Step 8
    Thumbor fetches image from unauthorized domain

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V11 - Cryptography Signature verification
Exploitation Conditions

Exploitation requires Thumbor to be running with a configured SECURITY_KEY (signed URL mode enabled) and with 'unsafe' mode disabled - this is the recommended production configuration and therefore the primary deployment target. The attacker must possess at least one valid HMAC-SHA1 signature for any URL served by the target Thumbor instance, obtainable by passively observing any signed image URL in use (e.g., from a web page's <img> tags). No authentication to Thumbor is required (CVSS PR:N). Thumbor instances running in 'unsafe' mode lack HMAC protection entirely and are out of scope for this bypass but are separately misconfigured. Exploitation is platform-independent and affects all OS environments running pip/thumbor ≤ 7.7.7. The dual .replace() for both plain and URL-encoded hash forms means both = and %3D variants of the signature can be leveraged, offering two manipulation vectors.

Impact

The NVD-assigned CVSS 3.1 score of 8.2 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L) is consistent with the described vulnerability and independently corroborated by this analysis. Exploitation requires no authentication (PR:N) because the attacker only needs to observe one legitimately signed Thumbor URL - obtainable from any page serving Thumbor images. Attack complexity is genuinely low (AC:L): constructing the injection is mechanical once a valid signature is known. The integrity impact is high because the entire signed URL trust model is defeated, permitting Thumbor to be abused as an open proxy for arbitrary image sources. No EPSS score or KEV listing is present in the provided intelligence, and no POC repository was referenced; however, the fix commit includes explicit regression tests that demonstrate the attack technique, effectively serving as a weaponizable proof-of-concept blueprint. The 'RCE' tag in the source data is a misclassification - nothing in the description or fix supports remote code execution; impact is limited to signature bypass and unauthorized resource fetching.

Exploit ScenarioDerived

An attacker browses a public web page that serves Thumbor-processed images and records a legitimately signed URL such as /ddoyYVYUbDf6Po_dzOrBhCDrXLc=/300x200/s3.glbimg.com/v1/image.jpg. The attacker constructs a crafted URL by splitting the target unauthorized path (e.g., pointing at an attacker-controlled domain) and inserting copies of the extracted HMAC signature at the split points. When Thumbor processes this request, the global str.replace() strips all signature occurrences, leaving a URL that matches the original signed resource for validation purposes but routes the actual fetch to the unauthorized host.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jul 31, 2026

HMAC-SHA1 URL signature bypass in Thumbor (pip/thumbor ≤ 7.7.7) allows unauthenticated remote attackers to defeat the signed URL security mechanism by injecting duplicate signature strings into the request path. Python's global str.replace() removes all occurrences of the signature during pre-validation stripping, causing the validated URL to differ from the actual requested resource. No public exploit code is identified at time of analysis, though the detailed disclosure and fix commit make independent exploitation straightforward; this is not listed in CISA KEV.

RemediationAI

Upgrade Thumbor to version 7.8.0 or later; this is the vendor-released patch confirmed by the GitHub release tag at https://github.com/thumbor/thumbor/releases/tag/7.8.0 and fix commit e3ae3e2500537b4d735df4144129a649374bb70b. The fix replaces both global str.replace() calls with a new _strip_url_signature_prefix() static method that removes the signature only when it appears as a leading prefix, eliminating the multi-occurrence exploitation path. If an immediate upgrade is not feasible, operators should restrict network access to the Thumbor service so only trusted internal systems can submit image requests, reducing open-proxy abuse exposure - however, this is a compensating control only and does not fix the signature bypass for attackers who already have network access. Disabling signed-URL mode is not a safe alternative because it removes all URL-based access controls. There are no other known workarounds that address the root cause.

Affected VersionsENISA

thumbor < 7.8.0

Affected Packages

pypi thumbor fix: 7.8.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Thumbor is a Python-based open-source image processing service (pkg:pip/thumbor) that uses HMAC-SHA1 to sign URLs, preventing abuse such as open-proxy image fetching or unauthorized filter invocation. The vulnerable logic resides in thumbor/handlers/imaging.py within the check_image method: before recomputing the HMAC to validate a request, it strips the signature from the URL using url.replace(f'/{hash}/', '') followed by a second pass for the URL-encoded form (%3D). Both calls use Python's default str.replace() with no occurrence limit, meaning every instance of the substring is removed - not just the leading one. CWE-347 (Improper Verification of Cryptographic Signature) applies precisely here: the cryptographic check is performed against a manipulated string that no longer represents the actual request, invalidating the security guarantee entirely. A second bypass vector exists via the URL-percent-encoded hash replacement, enabling further path manipulation.

Know when Python gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (https://github.com/thumbor/thumbor) PRIMARY 8.2 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L
vuln.today AI 8.2 HIGH

Network-exploitable with no privileges required since a valid signature is observable from public URLs; integrity is fully compromised by bypassing HMAC; no confidentiality or meaningful availability impact.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/thumbor/thumbor).

CVSS VectorVendor: https://github.com/thumbor/thumbor

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
High
Availability
Low

DescriptionCVE.org

HMAC validation bypass via multiple .replace() calls when removing URL signature

Summary

Thumbor’s HMAC validation can be bypassed due to the use of Python’s .replace() when removing the signature from the URL before validation. Since .replace() removes all occurrences of the substring, an attacker can insert the same signature multiple times in the URL and manipulate the final URL used for validation.

This allows crafting URLs where the validated string differs from the actual requested resource, enabling loading images from unintended domains or paths.

Details

Thumbor signs URLs using HMAC-SHA1 to prevent abuse such as loading arbitrary external images or invoking filters without authorization.

During request validation, Thumbor removes the signature from the request URL before recalculating the HMAC. The relevant code:

python
url_signature = self.context.request.hash
if url_signature:
    signer = self.context.modules.url_signer(
        self.context.server.security_key
    )

    try:
        quoted_hash = quote(self.context.request.hash)
    except KeyError:
        self._error(400, f"Invalid hash: {self.context.request.hash}")
        return

    url_to_validate = url.replace(
        f"/{self.context.request.hash}/", ""
    ).replace(f"/{quoted_hash}/", "")

    valid = signer.validate(
        unquote(url_signature).encode(), url_to_validate
    )

The issue is that .replace() removes every occurrence of the substring in the URL, not just the first one.

Because the signature itself appears in the URL, an attacker can inject additional copies of the signature elsewhere in the path. When Thumbor performs .replace(), these extra occurrences are also removed, resulting in a different url_to_validate than the original request.

Example

Valid request:

/ddoyYVYUbDf6Po_dzOrBhCDrXLc=/300x200/s3.glbimg.com/v1/.../image.jpg

By injecting the same hash inside the URL:

/ddoyYVYUbDf6Po_dzOrBhCDrXLc=/300x200/s3.glbimg.co/ddoyYVYUbDf6Po_dzOrBhCDrXLc=/m/v1/.../image.jpg

After .replace() removes all occurrences of the hash, the URL used for validation differs from the effective request path. This allows manipulation of the upstream host or path.

Further manipulation is possible due to the second .replace() for the URL-encoded hash (%3D), enabling more precise path manipulation.

Example:

/ddoyYVYUbDf6Po_dzOrBhCDrXLc=/300x200/s3.glbimg.com/ddoyYVYUbDf6Po/ddoyYVYUbDf6Po_dzOrBhCDrXLc%3D/ddoyYVYUbDf6Po/v1/...

Impact

This behavior may allow attackers to:

  • Bypass HMAC URL validation
  • Load images from arbitrary domains
  • Abuse Thumbor deployments as an open proxy / image fetcher
  • Circumvent domain restrictions intended by the signed URL mechanism

Root Cause

Use of .replace() without limiting the number of replacements when removing the signature from the URL.

Since the signature is part of the request path, using a global replacement allows attackers to place additional occurrences of the same substring to influence the validated string.

Suggested Fix

Remove only the first occurrence of the signature or explicitly parse the URL components instead of performing global string replacement.

Example:

python
url.replace(f"/{self.context.request.hash}/", "", 1)

Alternatively, reconstruct the unsigned URL deterministically from the parsed request components.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 24 pypi packages depend on thumbor (24 direct, 0 indirect)

Ecosystem-wide dependent count for version 7.8.0.

Executive ViewAI

Why It Matters

A critical vulnerability in Thumbor image processing software (versions 7.7.7 and earlier) undermines the signed URL access control mechanism that organizations depend on to protect sensitive image content. Any company using Thumbor to serve restricted photos, documents, or media-particularly in healthcare, legal, financial, or e-commerce-faces immediate risk of unauthorized access to protected data and potential data exfiltration.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Medium
popular Python image server used by media and content platforms
Threat Intel
1
1 sources
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

41
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +41
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

More in Python

View all
CVE-2025-24016 CRITICAL POC
9.9 Feb 10

Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t

CVE-2025-27520 CRITICAL POC
9.8 Apr 04

BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser

CVE-2025-2945 CRITICAL POC
9.9 Apr 03

pgAdmin 4 contains critical remote code execution vulnerabilities in the Query Tool download and Cloud Deployment endpoi

CVE-2013-5093 MEDIUM POC
6.8 Sep 27

The renderLocalView function in render/views.py in graphite-web in Graphite 0.9.5 through 0.9.10 uses the pickle Python

CVE-2025-32375 CRITICAL POC
9.8 Apr 09

BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica

CVE-2014-0224 HIGH POC
7.4 Jun 05

OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph

CVE-2024-21644 HIGH POC
7.5 Jan 08

pyLoad download manager version prior to 0.5.0b3.dev77 exposes the Flask SECRET_KEY through an unauthenticated endpoint.

CVE-2026-33017 CRITICAL POC
9.3 Mar 17

Langflow (a visual LLM pipeline builder) contains a critical unauthenticated code execution vulnerability (CVE-2026-3301

CVE-2017-9462 HIGH POC
8.8 Jun 06

In Mercurial before 4.1.3, "hg serve --stdio" allows remote authenticated users to launch the Python debugger, and conse

CVE-2026-49869 CRITICAL POC
10.0 Jun 26

Unauthenticated remote code execution affects Kestra OSS (the open-source event-driven orchestration platform) prior to

CVE-2026-39987 CRITICAL POC
9.3 Apr 08

Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/

CVE-2024-21645 MEDIUM POC
5.3 Jan 08

pyLoad is the free and open-source Download Manager written in pure Python. Rated medium severity (CVSS 5.3), this vulne

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy