Skip to main content

ag-psd CVE-2026-63501

| EUVDEUVD-2026-116262 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-11-03 GitHub_M
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Craft tiny PSD with oversized layer dimensions
  2. Delivery
    Submit file to app parsing untrusted PSDs
  3. Exploit
    totalMemoryLimit guard skipped (undefined memoryLimit)
  4. Execution
    Unbounded Uint16Array / inflateSync allocation
  5. Impact
    Process heap exhausted, OOM crash (DoS)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitable only when an application uses ag-psd to parse attacker-supplied PSD files on the server with layer decoding enabled (the default readPsd path, e.g. useImageData); the attacker controls the PSD's layer bounds (top/left/bottom/right) to drive createImageDataBitDepth into a huge Uint16Array allocation, and a second path abuses inflateSync on ZIP-encoded channel data with no output-size cap (ZIP-bomb-style). The totalMemoryLimit option does not limit this because it is never forwarded as memoryLimit, so callers relying on it are not actually protected. Limiting factors: the affected application must accept and decode untrusted PSD input and be running a version at or below 31.0.0; per the CVSS vector (PR:N/UI:N) no authentication or user interaction is required, and no non-default configuration is needed since layer decoding is on by default. Impact is availability-only (process memory exhaustion / crash); there is no confidentiality or integrity effect.

Impact

The CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) describes a network-reachable, low-complexity, unauthenticated availability-only impact - consistent with the CWE-770 uncontrolled memory allocation described. There is no KEV listing and no EPSS score in the provided data, so there is no evidence of active exploitation; however, a complete, self-contained working PoC (Node.js inline script plus Dockerfile and Python reproduction with expected output showing a 1 KB totalMemoryLimit bypassed to allocate 200 MB from an 86-byte file) is published in the GHSA advisory, so publicly available exploit code exists. The vuln.today Decision label is 'this_week', which aligns with a serious-but-not-emergency DoS: real and trivially reproducible, but confidentiality and integrity are unaffected (C:N/I:N). The practical priority is bounded by exposure - this only matters to applications that parse attacker-supplied PSD files server-side with layer decoding enabled (the default). The one documented defense, the totalMemoryLimit option, is silently non-functional due to a property-name mismatch, so callers who believed they were protected are not. Note a data conflict to verify: the CVE Description text says both 'Prior to 31.0.3' and 'fixed in 31.0.1', and the referenced release tag is 31.0.3, while the commit diff and npm package advisory both state the fix landed in 31.0.1 - treat 31.0.1 as the confirmed first fixed version per the code evidence and verify the 31.0.3 reference with the vendor.

Exploit ScenarioDerived

An attacker uploads a single crafted PSD file (as small as 86 bytes) to a web service that uses ag-psd for server-side PSD preview, conversion, or editing with layer decoding enabled. Attacker-controlled layer dimensions (e.g. 5000×5000 at 16-bit, 4 channels) force a ~200 MB allocation that bypasses the configured totalMemoryLimit, and repeated or large requests exhaust process heap and crash the Node.js process via the OS OOM killer. A complete working PoC demonstrating the bypass is published in the GHSA advisory.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

AnalysisAIv1 – Nov 03, 2026

Uncontrolled memory allocation in ag-psd (npm) lets remote attackers crash Node.js services that parse attacker-supplied PSD files: a crafted file with oversized layer dimensions forces a huge Uint16Array allocation regardless of the caller's totalMemoryLimit setting, which is silently ignored due to a property-name mismatch between totalMemoryLimit and memoryLimit. Versions at or below 31.0.0 are affected; layer decoding is enabled by default in readPsd(), so no special configuration is needed and the CVSS vector (AV:N/AC:L/PR:N/UI:N, availability-only) indicates unauthenticated network exploitation. The upstream advisory ships a working proof-of-concept in which an 86-byte PSD allocates a 200 MB buffer (5000x5000 layer, 16-bit depth), and it documents a second unbounded path where inflateSync() decompresses ZIP-encoded channel data without an output-size cap; a fix is published in 31.0.1 (commit 57ea7d8) with a 31.0.3 release also referenced.

RemediationAI

Vendor-released patch: upgrade ag-psd to 31.0.1 (fix commit https://github.com/Agamnentzar/ag-psd/commit/57ea7d865238b6b7c8a2e976bcf2a77e03116e2f, changelog entry 'Fixed incorrect handling of memory limit'), or to 31.0.3 per the release tag https://github.com/Agamnentzar/ag-psd/releases/tag/31.0.3 if you prefer the newest referenced build; the fix renames the internal option to totalMemoryLimit so the size guard in createImageDataBitDepth actually runs and rejects oversized layer allocations. Until you can upgrade, note that the documented totalMemoryLimit option provides no protection at all on affected versions, so do not rely on it; instead avoid passing attacker-controlled PSDs through layer decoding (for example keep useImageData disabled or defer layer pixel extraction), accepting that the calling application then loses access to layer image data, and enforce a hard cap on the parsing process's memory (container memory limit or Node.js --max-old-space-size) so an exhaustion attempt terminates a bounded worker rather than the whole host, accepting that the request will still fail. If PSD uploads can be gated, restrict them to trusted sources or pre-screen layer bounds against a strict width/height ceiling before parsing. Monitoring: GHSA-6w3r-6hpr-hp6p lists 31.0.1 as the fix, so version-pin manifests and lockfiles accordingly.

Affected VersionsENISA

ag-psd < 31.0.1

Affected Packages

euvd ag_psd fix: 31.0.1

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, commonly used server-side in web services that generate PSD previews or perform conversions, which means untrusted binary input is processed inside the Node.js heap. The flaw is CWE-770 (Allocation of Resources Without Limits or Throttling). readPsd() builds a PsdReader that inherits ReadOptions, whose guard field is named totalMemoryLimit (default 2 GB written into the reader). When a layer is reached, the parser calls decodeLayerImageData(layer, reader) at src/psdReader.ts:568-569, but that function's option object declares memoryLimit rather than totalMemoryLimit, so options.memoryLimit resolves to undefined and is forwarded to createImageDataBitDepth. Inside createImageDataBitDepth the check 'if (memoryLimit !== undefined && sizeInBytes > memoryLimit) throw' therefore never fires, and the code proceeds to 'new Uint16Array(width * height * channels)' with width/height taken directly from the layer record's right/left/bottom/top fields. A secondary unbounded allocation exists where inflateSync(compressed) decompresses ZIP-encoded channel data with no cap on output size, giving a ZIP-bomb-style exhaustion path. The trigger for the primary path is an 86-byte PSD with a 5000x5000 16-bit layer; no memory-safety corruption is involved, only heap exhaustion that terminates or OOM-kills the process.

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remote unauthenticated submission of a crafted PSD to a default-path parser (AV:N/AC:L/PR:N/UI:N) causing memory-exhaustion DoS only, so C:N/I:N and A:H.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Nov 03, 2026 - 21:03 EUVD
CVE Published
Nov 03, 2026 - 19:30 cve.org
HIGH 7.5

DescriptionCVE.org

ag-psd is a JavaScript library for reading and writing Photoshop Document files. Prior to 31.0.3, readPsd() accepts a totalMemoryLimit for parsing untrusted PSD files, but decodeLayerImageData expects a differently named memoryLimit property and therefore passes an undefined limit to createImageDataBitDepth. An attacker who can supply a PSD to an application with layer decoding enabled can use attacker-controlled layer dimensions to trigger an allocation larger than the configured limit, causing process memory exhaustion and denial of service. The advisory also identifies inflateSync(compressed) decompressing ZIP-encoded channel data without an output-size cap, which can cause a similar denial of service through unbounded decompression. This vulnerability is fixed in 31.0.1.

Technical POC Analysis

CWE-770 (Allocation of Resources Without Limits or Throttling).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

CVE-2026-63501 is a high-severity availability vulnerability in the ag-psd library used by Node.js services that process PSD files. A memory allocation flaw allows unauthenticated remote attackers to crash these services by uploading a specially crafted PSD file, causing operational disruption directly impacting customer-facing services and support teams. Leadership should care because services relying on this library are exposed to denial-of-service without any preconditions, risking downtime and reputational damage.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Low
niche npm library for PSD parsing in JS/Node apps
Data Quality
4 sources
Confidence: Medium
EUVD NVD CVE.org Vulnrichment 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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS N/A
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
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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