Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit tiny crafted PSD to service
-
ExploitreadPsd commits buffers from declared geometry
-
ExecutionMulti-gigabyte off-heap allocation before validation
-
ImpactProcess OOM-killed / concurrent requests exhaust memory
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Exploitation requires an application or service that calls ag-psd's readPsd() on untrusted, attacker-supplied PSD input using default read options, on a vulnerable version (≤30.2.0). No authentication, user interaction, or special configuration is otherwise needed (AV:N/AC:L/PR:N/UI:N) - a single crafted file triggers the allocation. The key LIMITING factor is exposure: the flaw is only reachable where untrusted PSDs are parsed, so standalone use with trusted files is not at risk. After upgrading to 31.0.0 the default 2GB memory limit mitigates the composite-image path, but the description states the per-layer-rectangle allocation path may not be fully covered, so services that must accept large/unknown files should additionally use useRawData with explicit dimension/layer-count checks as the advisory's production guidance describes. |
| Impact | This is a real, actionable denial-of-service issue but not a critical emergency. The CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) is availability-only: no confidentiality or integrity impact, consistent with CWE-789 uncontrolled memory allocation. The signals are modest-but-credible rather than alarming: no EPSS score and no KEV/SSVC exploitation data were provided in the input, so widespread or automated exploitation cannot be confirmed from the data. The vuln.today priority is 'this_week' (not act_now/emergency). Working against it, the GHSA advisory publishes a concrete 52-byte reproducer demonstrating ~61,000,000x amplification (52 bytes to ~3.17 GB peak RSS on Node 24), which makes the flaw trivial to trigger once an attacker can reach a service that parses untrusted PSDs. The practical risk is bounded by exposure: only applications that call readPsd() on attacker-supplied PSD files with default options are affected, and the true population of such services is uncertain. Note that EPSS and KEV data are absent (not low - simply not supplied), so prioritization rests mainly on the confirmed PoC and the clear mechanism rather than on exploitation telemetry. |
| Exploit ScenarioDerived | An attacker uploads a tiny (~52-byte) crafted PSD whose header declares enormous width/height/channels/depth or per-layer rectangles to any service that parses user-supplied PSDs with ag-psd ≤30.2.0. readPsd() commits multi-gigabyte off-heap buffers from the unvalidated declared geometry before the data is checked, driving peak memory to roughly 3.17 GB from the 52-byte input and OOM-killing the process (often before the RangeError can even be caught). A public reproducer exists in the GHSA advisory, and the CVSS AV:N/AC:L/PR:N/UI:N vector confirms remote, low-complexity exploitation with no authentication or user interaction against vulnerable deployments. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Uncontrolled memory allocation in ag-psd's readPsd() lets a remote attacker crash any Node service that parses untrusted Photoshop files: the reader sizes off-heap typed-array buffers from attacker-declared header geometry (width, height, channels, depth and per-layer rectangles) before validating those declarations against the bytes actually present, so a 52-byte PSD can commit roughly 3.17 GB of peak RSS in about 0.45 seconds before a RangeError is raised. All npm releases up to and including 30.2.0 are affected, CVSS 3.1 scores this 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CWE-789), and no authentication, interaction or special configuration is needed - only exposure to attacker-supplied PSD input with default read options. The flaw is not listed in CISA KEV, but the vendor advisory publishes a working 52-byte proof-of-concept input (sha256 a1146a6f…) together with reproduction steps; this is a real, actionable denial-of-service issue rather than a critical emergency, and remediation should be scheduled this week for any service that accepts user-uploaded PSDs.
RemediationAI
Vendor-released patch: ag-psd 31.0.0, which adds a totalMemoryLimit read option defaulting to a 2GB cap on decoded bitmaps and a new helper API for safe handling of large or unsafe files - upgrade from ≤30.2.0 to 31.0.0 (or later) per https://github.com/Agamnentzar/ag-psd/security/advisories/GHSA-qfx6-q44v-9qqw and commit https://github.com/Agamnentzar/ag-psd/commit/2d7da68400990bae8ba248a065eb45021fa8000a. Treat this as a breaking change: files larger than 2GB that previously decoded will now fail unless you pass a larger totalMemoryLimit, so audit your own upload limits before raising it. Because the advisory does not establish full coverage of the per-layer-rectangle allocation path, services that must accept unknown PSDs should also follow the vendor's production guidance - call readPsd(buffer, { useRawData: true, useRawThumbnail: true }) so no bitmaps are decoded during parsing, then reject documents whose width/height or bitsPerChannel exceed your limits, walk the layer tree rejecting layers whose (right-left) x (bottom-top) exceed a cap and capping total layer count, and decode bitmaps individually via getLayerImageData/getLayerMaskImageData so only one layer bitmap is resident at a time; the trade-off is that you take on validation responsibility and must re-decode layers explicitly. Additionally serialise or queue PSD processing rather than decoding documents in parallel (parallel decoding exhausts the memory limit regardless of per-file caps), and run decoding in a separate worker process or thread since it is synchronous and will otherwise stall the main event loop - both add latency and operational complexity but preserve availability under load.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
ag-psd is a pure-JavaScript reader/writer for Adobe Photoshop Document files; psdReader.js parses the PSD header (canvas width, height, channel count, bit depth) and per-layer rectangles, then allocates off-heap ArrayBuffer/TypedArray buffers sized directly from those declared values before checking them against the length of the supplied input. That is the CWE-789 (uncontrolled memory allocation) root cause: an attacker-controlled length field drives allocation, and validation happens only afterwards, when decoding runs past the end of the DataView and throws 'Offset is outside the bounds of the DataView'. Because the allocation is committed first, the process can be OOM-killed before the catchable error ever surfaces, and concurrent inputs multiply the pressure. The advisory explicitly distinguishes this from ag-psd issues #39 and #206, where memory use is proportional to genuinely large files; here the file declares enormous geometry that is never present in the data (roughly 61,000,000x amplification), and the per-layer rectangles are described as a second, independent lever that can exceed the document canvas. The legacy PSD format itself imposes no practical limit - canvases up to 300000x300000 pixels with unbounded layer counts are legal - so the library must impose its own limits, which is exactly what version 31.0.0 begins to do.
Know when Ag Psd 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:H
A remote attacker needs no auth or interaction to send a crafted PSD to a parsing service (AV:N/AC:L/PR:N/UI:N); impact is availability-only memory exhaustion (A:H), no C/I impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
ag-psd is a JavaScript library for reading and writing Photoshop Document files. Before the allocation-limit remediation attempt in version 31.0.0, readPsd() commits image and layer buffers from attacker-declared PSD geometry before validating the declarations against the actual available data or sane allocation limits. The psdReader.js implementation sizes off-heap typed arrays using width, height, channels, depth and per-layer rectangles, so a tiny PSD declaring enormous geometry can force multi-gigabyte memory allocation before a later bounds error. The reported 52-byte input on Node 24 produced approximately 3.17 GB peak RSS before a RangeError; under memory pressure the process can be terminated before the error can be caught, and concurrent inputs can exhaust memory. Services reading untrusted PSDs are exposed to denial of service. This differs from genuinely large PSD files whose memory demand is proportional to real input content. Version 31.0.0 adds a composite-image allocation limit, but complete coverage of the separately described layer-rectangle allocation path is not established and requires curator residual/scope review.
Technical POC Analysis
CWE-789: Memory Allocation with Excessive Size Value (allocation sized by an untrusted value without bounds checking).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity denial-of-service vulnerability in the ag-psd npm library allows unauthenticated attackers to crash any Node.js service that parses untrusted Photoshop files, potentially disrupting business operations. All releases up to and including 30.2.0 are affected, and with no patch available, organizations relying on this library for file processing are at risk of service outages. Leadership should prioritize mitigation for externally facing services that accept PSD uploads.
Implement pre-parsing validation of PSD headers to reject unreasonable dimensions; enforce memory limits and process isolation for services that parse untrusted PSD files; disable PSD uploads from untrusted sources if not business-critical.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-114472
NVD
CVE.org
EPSS
GitHub
Exploit-DB