Marshmallow
CVE-2025-68480
MEDIUM
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach endpoint using Schema.load(many=True)
-
DeliverySend moderately sized crafted array payload
-
ExploitTrigger quadratic error-collection rebuilding
-
ExecutionExhaust server CPU
-
ImpactDegrade or deny service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Asymmetric resource consumption control
|
| Exploitation Conditions | Exploitable only when the target application calls Schema.load(data, many=True) on attacker-influenced input and runs a vulnerable version (>=3.0.0rc1 <3.26.2 or >=4.0.0 <4.1.2); the CPU blowup occurs in the error-merging path, so inputs that generate validation errors across list items are what drive the disproportionate cost. Limiting factors: the application must expose a many=True load of untrusted data (library-internal code using single-object load or trusted input is not affected), and impact is confined to availability (CPU exhaustion) with no data or integrity consequence. The published workaround (validate list type and load items individually) neutralizes the condition without upgrading. |
| Impact | This is a genuine but moderate-severity denial-of-service issue, not a critical priority. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, base 5.3) indicates a network-reachable, unauthenticated, low-complexity attack with no confidentiality or integrity impact and only LOW availability impact - consistent with CWE-405 (asymmetric resource consumption) and the GHSA description that a 'moderately sized request can consume a disproportionate amount of CPU time.' The signals are mutually consistent and lean toward lower real-world urgency: EPSS is only 0.30% (21st percentile), the CVE is NOT in CISA KEV, and no public exploit code is referenced - only a patch commit and vendor advisory. There is no SSVC decision data in the input. The realistic risk is confined to availability degradation of Python services that call Schema.load(data, many=True) on attacker-controlled input; it does not enable code execution or data disclosure. Net assessment: a legitimate hardening/patching item for exposed APIs, but a high-CVSS-style emergency it is not - treat as routine-to-elevated based on exposure of affected endpoints. |
| Exploit ScenarioDerived | An attacker sends a moderately sized but crafted JSON array to an HTTP API endpoint that deserializes input with marshmallow's Schema.load(data, many=True). The vulnerable error-merging logic repeatedly rebuilds error collections during validation, consuming disproportionate CPU and degrading or denying service for legitimate users. No public exploit code is identified at time of analysis, though the vendor advisory (GHSA-428g-f7cq-pgp5) publishes a fail-fast workaround. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Denial of service in the Marshmallow Python serialization library affects versions 3.0.0rc1 through 3.26.1 and 4.0.0 through 4.1.1 when an application calls Schema.load(data, many=True) on untrusted input; a moderately sized list of invalid records consumes a disproportionate amount of CPU time because the error-merging routine repeatedly rebuilds result collections. Remote attackers who can reach an endpoint that performs bulk deserialization and returns validation errors can drive CPU exhaustion and degrade or stall the service, with no confidentiality or integrity impact. No public exploit code was identified at time of analysis and the issue is not in CISA KEV, though EPSS places it in the low range (0.30%, ~21st percentile). The library ships fixes in 3.26.2 and 4.1.2.
RemediationAI
Vendor-released patch: upgrade to Marshmallow 3.26.2 or 4.1.2 (pip install --upgrade 'marshmallow>=3.26.2' for the 3.x line, or 'marshmallow>=4.1.2' for 4.x) as documented in advisory GHSA-428g-f7cq-pgp5 and commit d24a0c9df061c4daa92f71cf85aca25b83eee508; the fix removes the repeated collection rebuilding in error_store.merge_errors and deep-copies stored messages once. If an immediate upgrade is not possible, the vendor-published workaround is to fail fast on type before bulk loading: check that the incoming payload is a list (raise ValidationError(['Invalid input type.']) if not) and then call load on each item individually in a loop - the trade-off is that this changes error semantics, since per-item loading typically raises on the first failing record instead of returning an aggregated error map for all items, which may break API contracts that surface all validation errors at once; wrap the loop to collect per-item exceptions if aggregated errors are required. As a compensating control, apply request-size and rate limits at the gateway or web framework layer on any endpoint backed by many=True deserialization, and cap the maximum list length accepted, accepting that this only bounds rather than eliminates the per-request CPU amplification. No vendor patch is needed for applications that only use single-object load, but inventorying call sites of Schema.load(..., many=True) that touch untrusted input is the fastest way to scope exposure.
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
Marshmallow is a widely used Python library for object serialization/deserialization and validation, commonly used to parse JSON request bodies into schema-validated objects in Flask, Django REST Framework and similar stacks. The flaw maps to CWE-405 (Asymmetric Resource Consumption / Amplification): in src/marshmallow/error_store.py, the merge_errors helper accumulated validation messages by returning a newly built dict or list on every merge (dict(errors1, **{...}), errors1 + errors2, [*errors1, errors2], and a full copy-and-loop over keys when merging mappings, each iteration itself calling merge_errors recursively). Under Schema.load(data, many=True) the store merges the error structures produced for every item in the submitted list, so inputs that generate a validation error per item cause the accumulated message tree to be re-copied on each merge, producing super-linear (effectively quadratic) CPU cost and deep recursive merging relative to the size of the request. The upstream commit d24a0c9d adds a copy_containers() helper that deep-copies input messages exactly once before storage, then rewrites merge_errors to mutate the accumulator in place (extend/append/assignment) instead of rebuilding dictionaries and lists, which removes the repeated copying while preserving the merged error output. The accompanying regression tests assert that caller-supplied message objects are no longer mutated by repeated store_error calls. Notably, the vulnerable path is in error handling rather than parsing, so a payload only becomes expensive when it is malformed enough to trigger validation failures across many list items.
Know when Marshmallow 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:N/A:L
Network-reachable unauthenticated input to a many=True load (AV:N/AC:L/PR:N/UI:N) with only CPU-exhaustion availability impact and no C/I impact, so A:L.
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
Marshmallow is a lightweight library for converting complex objects to and from simple Python datatypes. In versions from 3.0.0rc1 to before 3.26.2 and from 4.0.0 to before 4.1.2, Schema.load(data, many=True) is vulnerable to denial of service attacks. A moderately sized request can consume a disproportionate amount of CPU time. This issue has been patched in version 3.26.2 and 4.1.2.
Threat Intelligence Overview
NVD
CVE.org
EPSS
GitHub
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Exploit-DB