Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconObserve legitimately signed Thumbor image URL
-
DeliveryExtract HMAC-SHA1 signature string
-
ExploitSplit target unauthorized path around signature string
-
InstallCraft URL embedding duplicate signature instances
-
C2Submit crafted HTTP GET request to Thumbor
-
ExecuteGlobal str.replace() strips all signature occurrences
-
ImpactValidation passes against manipulated URL
-
Step 8Thumbor 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 |
| 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 |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L
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.
Primary rating from Vendor (https://github.com/thumbor/thumbor).
CVSS VectorVendor: https://github.com/thumbor/thumbor
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:
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.jpgBy injecting the same hash inside the URL:
/ddoyYVYUbDf6Po_dzOrBhCDrXLc=/300x200/s3.glbimg.co/ddoyYVYUbDf6Po_dzOrBhCDrXLc=/m/v1/.../image.jpgAfter .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:
url.replace(f"/{self.context.request.hash}/", "", 1)Alternatively, reconstruct the unsigned URL deterministically from the parsed request components.
Blast Radius
ecosystem impact- 24 pypi packages depend on thumbor (24 direct, 0 indirect)
Ecosystem-wide dependent count for version 7.8.0.
Articles & Coverage 1
Executive ViewAI
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t
BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser
pgAdmin 4 contains critical remote code execution vulnerabilities in the Query Tool download and Cloud Deployment endpoi
The renderLocalView function in render/views.py in graphite-web in Graphite 0.9.5 through 0.9.10 uses the pickle Python
BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica
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
pyLoad download manager version prior to 0.5.0b3.dev77 exposes the Flask SECRET_KEY through an unauthenticated endpoint.
Langflow (a visual LLM pipeline builder) contains a critical unauthenticated code execution vulnerability (CVE-2026-3301
In Mercurial before 4.1.3, "hg serve --stdio" allows remote authenticated users to launch the Python debugger, and conse
Unauthenticated remote code execution affects Kestra OSS (the open-source event-driven orchestration platform) prior to
Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/
pyLoad is the free and open-source Download Manager written in pure Python. Rated medium severity (CVSS 5.3), this vulne
EUVD-2026-51608
GHSA-mw3h-qjxj-6xg9
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB