Threat database
444 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 8.8 | EPSS 0.2% | CVE-2026-109126IBM Verify Identity Access · Use of Hard-coded Credentials High8.8EPSS 0.2%CVE Database V5CVE-2026-109126 IBM Verify Identity Access 11.0.3.1 and IBM Security Verify Access 10.0.9.3 Appliance could allow a physically proximate attacker to gain elevated privileges due to the use of hard-coded credentials. | CVE Database V5 | ||
| Medium | 5.4 | EPSS 0.2% | Medium5.4EPSS 0.2%CVE Database V5CVE-2026-8355 IBM ContextForge MCP Gateway 0.1.0 through 1.0.5 is vulnerable to a server-side request Forgery (SSRF) that allows authenticated users with gateway creation privileges to perform arbitrary HTTP POST requests to internal network resources and cloud metadata endpoints. The vulnerability occurs during OAuth-enabled gateway registration when the system fails to validate the oauth_config.token_url parameter. When registering a gateway with OAuth client credentials authentication, an attacker can supply a malicious token_url pointing to internal services, cloud metadata endpoints (AWS IMDSv1, GCP, Azure), or localhost-bound services. The application immediately performs an HTTP POST request to the attacker-controlled URL with form-encoded credentials in the body. If the response cannot be parsed as a valid OAuth token response, up to 256 characters of the response body are reflected back to the attacker in the HTTP 502 error message. This vulnerability bypasses existing SSRF protections that are applied to the gateway.url field but not to OAuth configuration parameters. | CVE Database V5 | ||
| High | 7.1 | EPSS 0.5% | CVE-2026-112373H3C Magic NX15 · Stack-based Buffer Overflow High7.1EPSS 0.5%CVE Database V5CVE-2026-112373 A security vulnerability has been detected in H3C Magic NX15 NX15V100R017. This impacts the function sub_416874 of the file /usr/bin/usrlist. Such manipulation leads to stack-based buffer overflow. It is possible to launch the attack remotely. The exploit has been disclosed publicly and may be used. The vendor was contacted early about this disclosure. EPSS 0.5%Vulnerability | CVE Database V5 | ||
| Medium | 6.5 | EPSS 0.3% | Medium6.5EPSS 0.3%CVE Database V5CVE-2025-36061 IBM Storage TS4500 Library 1.1.1.6 through 1.12.0.3 IBM Diamondback Tape Library and IBM Storage TS4500 Library could allow an authenticated user to cause a denial of service using specially crafted SMTP requests that would consume excessive amounts of system resources. | CVE Database V5 | ||
| Medium | 5.5 | EPSS 0.2% | Medium5.5EPSS 0.2%CVE Database V5CVE-2025-36069 IBM Storage TS4500 Library 1.1.1.6 through 1.12.0.3 does not invalidate session after a logout which could allow an authenticated user to impersonate another user on the system. | CVE Database V5 | ||
| Medium | 6.3 | EPSS 0.2% | Medium6.3EPSS 0.2%CVE Database V5CVE-2025-36252 CVE-2025-36252 is a vulnerability in IBM Storage TS4500 Library versions 1.1.1.6 through 1.12.0.3. The issue involves insufficient session expiration, where sessions are not invalidated properly. This flaw could allow an authenticated user to impersonate another user on the system. | CVE Database V5 | ||
| Medium | 6.8 | EPSS 0.2% | CVE-2026-19178IBM Storage TS4500 Library · Race Condition Medium6.8EPSS 0.2%CVE Database V5CVE-2026-19178 IBM Storage TS4500 Library 1.1.1.6 through 1.12.0.3 could allow a remote authenticated attacker to gain unauthorized administrative privileges due to a race condition. | CVE Database V5 | ||
| Medium | 5.7 | EPSS 0.3% | CVE-2026-77684zephyrproject zephyr · Dos Medium5.7EPSS 0.3%CVE Database V5CVE-2026-77684 CVE-2026-77684 is a denial-of-service vulnerability in the Zephyr Bluetooth Classic Hands-Free Profile (HFP) HF role. The flaw occurs because AT command buffers queued for transmission are not released when the RFCOMM data link connection goes down, leading to exhaustion of a fixed buffer pool. This causes permanent failure in sending HFP commands and can park the Bluetooth RX thread, halting all HCI event processing until reboot. The issue affects Zephyr versions from 4.2.0 up to but not including 4.5.0 and is fixed in version 4.5.0. EPSS 0.3%Vulnerability | CVE Database V5 | ||
| Medium | 6.1 | EPSS 0.1% | CVE-2026-19595zephyrproject zephyr · Memory-safety Medium6.1EPSS 0.1%CVE Database V5CVE-2026-19595 CVE-2026-19595 is a memory-safety vulnerability in the Zephyr RTOS user-mode syscall verifier for the rtio_cqe_get_mempool_buffer() function. The syscall incorrectly validates output pointer parameters with read permissions instead of write permissions, allowing an unprivileged user-mode thread with access to an RTIO context to cause kernel-mode stores to memory regions that should be read-only. This can lead to either bypassing memory domain write protections or triggering a kernel fault that halts or reboots the device, causing denial of service. The issue is fixed by enforcing write permission checks on the output pointers before the syscall implementation runs. EPSS 0.1%Vulnerability | CVE Database V5 | ||
| Medium | 5.1 | EPSS 0.5% | CVE-2026-112372H3C Magic NX15 · Path Traversal Medium5.1EPSS 0.5%CVE Database V5CVE-2026-112372 A weakness has been identified in H3C Magic NX15 V100R017. This affects the function importprofile of the file /api/upload. This manipulation of the argument fileName causes path traversal. It is possible to initiate the attack remotely. The exploit has been made available to the public and could be used for attacks. The vendor was contacted early about this disclosure. EPSS 0.5%Vulnerability | CVE Database V5 | ||
| Critical | 9.4 | EPSS 0.5% | CVE-2026-112371H3C Magic NX15 · Code Injection Critical9.4EPSS 0.5%CVE Database V5CVE-2026-112371 A vulnerability was determined in H3C Magic NX15 NX15V100R017. Impacted is the function write of the file /api/esps of the component RPC Interface. Executing a manipulation of the argument path can lead to code injection. The attack can be executed remotely. The exploit has been publicly disclosed and may be utilized. The vendor was contacted early about this disclosure. EPSS 0.5%Vulnerability | CVE Database V5 | ||
| Medium | 6.3 | EPSS 0.3% | CVE-2026-112991misp-modules · Server-Side Request Forgery (SSRF) Medium6.3EPSS 0.3%CVE Database V5CVE-2026-112991 CVE-2026-112991 is a server-side request forgery (SSRF) vulnerability in the html_to_markdown expansion module of MISP misp-modules. The vulnerability arises from an incomplete URL validation function that fails to block several critical internal IP address ranges. An authenticated user able to create or modify attributes triggering this module can cause the MISP server to make requests to internal network addresses, potentially exposing sensitive data from internal services. The vulnerability affects versions from 0 up to and including 3.0.12. | CVE Database V5 | ||
| Critical | 9.4 | EPSS 2.0% | CVE-2026-112370H3C Magic NX15 · OS Command Injection Critical9.4EPSS 2.0%CVE Database V5CVE-2026-112370 CVE-2026-112370 is a critical OS command injection vulnerability in H3C Magic NX15 version 100R017. It affects the function sub_416874 in the /usr/bin/usrlist file. The flaw allows remote attackers to execute arbitrary OS commands. Public exploit code is available, increasing the risk of exploitation. EPSS 2.0%Vulnerability | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.5% | CVE-2026-112901Pillow · ReDoS Medium6.9EPSS 0.5%CVE Database V5CVE-2026-112901 ``` ============================================================================ ReDoS in XbmImagePlugin: 512-byte file stalls Image.open() for minutes Location: src/PIL/XbmImagePlugin.py:58 in XbmImageFile._open() Commit: a707c6b21c313880d0771e54965d142dd42358b6 ============================================================================ ``` A crafted 512-byte file makes Pillow's `Image.open()` spend about six minutes of processor time on one core before it gives up with `UnidentifiedImageError`. Anyone who can hand bytes to an application that opens images with Pillow's default settings can trigger this, for example through an upload form, a thumbnailer, or a service that checks whether a blob is an image. A few such files sent at once can tie up a typical pool of worker processes. The cause is the `xbm_head` regular expression in `src/PIL/XbmImagePlugin.py:32-40`, which `XbmImageFile._open()` (line 58) runs over the first 512 bytes of any stream whose prefix starts with `#define`. Several adjacent parts of the pattern can match the same characters. `[ \t]+` overlaps with `.*` in the width and height lines and with `[^_]*` in the optional hotspot lines, and `[\r\n]+` closing the hotspot group overlaps with the following `[\000-\377]*`. The header sets a run of k spaces after each `#define` and a run of k line terminators after `_y_hot`, then omits the `[]` after `_bits`. That forces Python's backtracking matcher to try every way of splitting those runs and rescan the remaining bytes each time. The cost grows roughly as k to the fifth power: k = 60 measured 375 s, while a well-formed XBM of the same size opens in about 40 ms. Because this happens before any format is identified, none of Pillow's size, pixel-count or decompression-bomb limits apply, and upload size limits do not help because the file is tiny. `ImageFile.Parser.feed()` repeats the cost on every chunk until the stream is identified. The only existing mitigation is passing a `formats=` allowlist that excludes `"XBM"`. The attached reproducer opens the same header with and without the trailing `[]`. The valid version opens as XBM in 52 ms. The broken version takes 0.1 s, 0.75 s, 3.0 s and 8.6 s at k = 10, 15, 20 and 25, and the slow k = 60 case is not run. This is the same class of bug as CVE-2021-25292 in `PdfParser`, but in a different plugin and reachable from plain `Image.open()`. ## Details `XbmImageFile._open()` identifies an XBM file by running the module-level regex `xbm_head` over the first 512 bytes of the stream. The pattern has several adjacent quantifier pairs that can consume the same characters, followed by a `[\000-\377]*_bits\[]` tail that rescans the rest of the buffer for every way of splitting them. A 512-byte input built to exercise all of them and then fail the final literal keeps `Image.open()` in `xbm_head.match()` for minutes before it raises `UnidentifiedImageError`. This 512-byte input (k = 60) takes 375 s of CPU in `Image.open(io.BytesIO(data))` with default settings, measured on the stock build at this commit: ```python k = 60 data = b"#define" + b" "*k + b"_width 1\r" data += b"#define" + b" "*k + b"_height 1\r" data += b"#define" + b" "*k + b"_x_hot 1\r" data += b"#define" + b" "*k + b"_y_hot 1" + b"\r"*k data += b"_bits" # no "[]": the final literal never matches data += b"A" * (512 - len(data)) # pad to the 512 bytes _open() reads ``` Calling `XbmImagePlugin.xbm_head.match(data)` directly gives the same picture: k = 10 → 0.11 s, k = 15 → 0.76 s, k = 20 → 3.0 s, k = 25 → 8.5 s, k = 30 → 19.9 s (roughly ×27 per doubling of k, i.e. about k^4.7). A well-formed 512-byte XBM matches in 10 µs and opens and loads through `Image.open()` in ~40 ms including plugin import; the same k = 60 header with `_bits[]` present matches in 5 µs. The regex, `src/PIL/XbmImagePlugin.py:32`: ```python xbm_head = re.compile( rb"\s*#define[ \t]+.*_width[ \t]+(?P<width>[0-9]+)[\r\n]+" b"#define[ \t]+.*_height[ \t]+(?P<height>[0-9]+)[\r\n]+" b"(?P<hotspot>" b"#define[ \t]+[^_]*_x_hot[ \t]+(?P<xhot>[0-9]+)[\r\n]+" b"#define[ \t]+[^_]*_y_hot[ \t]+(?P<yhot>[0-9]+)[\r\n]+" b")?" rb"[\000-\377]*_bits\[]" ) ``` and the only call site, `src/PIL/XbmImagePlugin.py:58`: ```python def _open(self) -> None: … m = xbm_head.match(self.fp.read(512)) if not m: msg = "not a XBM file" raise SyntaxError(msg) ``` For a well-formed header (`#define im_width 8\n…static char im_bits[] = {`) each `[ \t]+` eats the single space, `.*`/`[^_]*` eat the identifier prefix, and `[\000-\377]*_bits\[]` finds the literal on its first backward scan, so the match is linear. The crafted header diverges at every one of those points: - `[ \t]+.*_width` and `[ \t]+.*_height`: the run of k spaces after `#define` can be split between `[ \t]+` and `.*` in k ways, all leading to the same continuation. Factor k each. (The choice of `\r` terminators is incidental: t | CVE Database V5 | ||
| Critical | 9.2 | EPSS 1.3% | CVE-2026-112900Pillow · OS Command Injection Critical9.2EPSS 1.3%CVE Database V5CVE-2026-112900 ### Summary `PIL.EpsImagePlugin.Ghostscript()` builds the Ghostscript command line using the input file path (`fp.name`) **without sanitization**, placing it at `-f <infile>`. A filename beginning with `-` is interpreted by Ghostscript as an option, giving command-line argument injection; chainable to RCE (see Impact). Reproduces with Pillow's default invocation (with `-dSAFER` enabled). ### Details _Give all details on the vulnerability. Pointing to the incriminated source code is very helpful for the maintainer._ #### Type CWE-88 (Argument Injection) (→ CWE-78 (OS Command Injection) optionally, with attacker controlled text file) #### Vulnerable Codes ```python infile_temp = None if hasattr(fp, "name") and os.path.exists(fp.name): infile = fp.name # user-controlled path used as-is, without validation else: in_fd, infile_temp = tempfile.mkstemp() os.close(in_fd) infile = infile_temp # ... (copy fp into a temporary file) # Build Ghostscript command command = [ gs_binary, "-q", f"-g{width:d}x{height:d}", f"-r{res_x:f}x{res_y:f}", "-dBATCH", "-dNOPAUSE", "-dSAFER", # default sandbox — does NOT stop this injection f"-sDEVICE={device}", f"-sOutputFile={outfile}", "-c", f"{-bbox[0]} {-bbox[1]} translate", "-f", infile, # injected here: inserted into argv with no check for # option prefixes (-, --) or Ghostscript's @-file token # => argument injection (CWE-88) "-c", "showpage", ] # ... subprocess.check_call(command, startupinfo=startupinfo) # spawns Ghostscript ``` #### Root cause. When rendering an EPS image, PIL.EpsImagePlugin.Ghostscript() constructs the Ghostscript command line using the input file path (fp.name) and places it directly at the -f <infile> position of the argument list. This path is user-controllable, yet Pillow performs no validation or neutralization of tokens that Ghostscript treats specially during command-line argument parsing — in particular a leading - or -- (which Ghostscript interprets as an option rather than a filename) and a leading @ (Ghostscript's argument-file syntax, which causes it to read additional command-line arguments from the named file). Because the filename is neither normalized (e.g., forced to an absolute path or prefixed with ./) nor checked against these prefixes before being handed to the subprocess, an attacker who controls the filename passed to Image.open() can inject arbitrary Ghostscript command-line arguments. This is a classic argument-injection flaw (CWE-88), and it is not mitigated by Pillow's default -dSAFER setting. #### Affected - Pillow: tested on 12.3.0 (latest); vulnerable code is long-standing and appears to affect all current versions (main included). - Component: `src/PIL/EpsImagePlugin.py`, `Ghostscript()` — `infile = fp.name`, and the command list entry `"-f", infile`. #### Suggested fix Normalize the filename to an absolute path before it is passed to Ghostscript, so it can never be parsed as an option (`-`/`--`) or as an argument-file token (`@`): ```python if hasattr(fp, "name") and os.path.exists(fp.name): infile = os.path.abspath(fp.name) # was: infile = fp.name ``` `os.path.abspath()` guarantees the path starts with a path separator (or a drive letter on Windows), so a leading `-` or `@` can no longer reach Ghostscript's argument parser. The `else` branch already builds a safe `tempfile.mkstemp()` path and needs no change. ### PoC dockerfile, Default run shows the argument-injection demo (poc.py); for the RCE PoC run python3 poc-rce.py. ``` FROM ubuntu:24.04 RUN apt update RUN apt install -y --no-install-recommends python3 python3-venv ghostscript ca-certificates RUN rm -rf /var/lib/apt/lists/* RUN python3 -m venv /venv && /venv/bin/pip install --upgrade pip Pillow==12.3.0 ENV PATH=/venv/bin:$PATH WORKDIR /poc COPY poc.py . COPY poc-rce.py . COPY arg . CMD ["python3", "poc.py"] ``` poc.py ``` import os from PIL import Image ############################################################################################ # Attacker controlled file ############################################################################################ EPS = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\nshowpage\n" name = "-h" with open(name, "wb") as f: f.write(EPS) ############################################################################################ print(f"[*] Pillow opens a file whose name is {name!r}") im = Image.open(name) print(f"[*] call `load()`; this paths calls `gs` command with '-f {name}'") try: im.load() except Exception as e: print(f"[*] load() raised: {type(e).__name__}: {e}") print("CWE-88: argument injection; Pillow code doesn't validate argument name") print(" This poc.py shows the vulnerability clearly.") print(" | CVE Database V5 | ||
| Medium | 6.9 | EPSS 0.3% | CVE-2026-112898Pillow · Use of Uninitialized Variable Medium6.9EPSS 0.3%CVE Database V5CVE-2026-112898 Pillow versions from 9.1.0 up to but not including 13.0.0 contain a vulnerability where uninitialized stack memory can be disclosed when Image.quantize() is used with an empty palette. This occurs because a local cache array is left uninitialized if the palette has zero entries, leading to leakage of stack contents in returned PNG or GIF images. The issue is fixed in version 13.0.0. | CVE Database V5 | ||
| High | 8.7 | EPSS 0.5% | CVE-2026-112897Pillow · Use of Uninitialized Resource High8.7EPSS 0.5%CVE Database V5CVE-2026-112897 A use of uninitialized resource vulnerability exists in the python-pillow Pillow library versions 5.3.0 through 12.x. Pillow can return uninitialized memory as pixel data when decoding certain JPEG-compressed or Group 4 fax TIFF images. This occurs because the decoding buffers may be larger than the data written by libtiff, and the unwritten buffer tail is not cleared. An attacker can exploit this by supplying a crafted TIFF file to disclose stale heap memory contents. The issue is fixed in Pillow version 13.0.0. | CVE Database V5 | ||
| High | 8.8 | EPSS 0.5% | CVE-2026-112896Pillow · Out-of-bounds Read High8.8EPSS 0.5%CVE Database V5CVE-2026-112896 ## Summary A small attacker-supplied TIFF can be opened and loaded normally, then reach an out-of-bounds read when an application saves it back to TIFF with retained metadata. The fixed reproducer is a 1×1, 16-bit grayscale, PackBits-compressed TIFF containing tag 320 (ColorMap) with **768 SHORT values**: three zero-filled planes of 256 entries each. No Python object is forged and no metadata is injected after loading. Pillow's TIFF encoder allocates **768 × 2 = 1536 bytes**, then passes three plane pointers separated by 256 SHORT entries to libtiff. With `BitsPerSample = 16`, libtiff instead expects **65536 SHORT values per plane** and attempts a **131072-byte read** from a plane pointer. Existing ASAN observations identify a heap-buffer-overflow READ crossing the 1536-byte allocation made in `PyImaging_LibTiffEncoderNew`. The malformed ColorMap need not be a valid palette for this grayscale image. The issue is that accepted metadata is forwarded on save without reconciling the fixed plane extent with the effective sample depth. Opening/loading alone is not the demonstrated fault; the encoder path is required. ## Impact and prerequisites An application must accept the input, retain the relevant TIFF metadata, and invoke the libtiff-backed TIFF save path. The observed consequence is an out-of-bounds read and ASAN termination. Process-memory exposure during encoding is a potential consequence, **not demonstrated by extracting arbitrary heap contents in this report**. No arbitrary read primitive, full memory-disclosure chain, code execution, address-space bypass, or cross-process effect is claimed. The 131072-byte attempted copy is not the number of bytes proven disclosed. This report does not run a synthetic-canary serializer or collect an unsanitized encoded output. ## Tested environment and limits of the evidence The existing observations were recorded on August 30, 2026, with **CPython 3.11.8 on macOS ARM64**, using the unmodified official **Pillow 12.3.0** wheel and its bundled **libtiff 4.7.1**: - Wheel: `pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl` - Wheel size: `4785266` bytes - Wheel SHA-256: `37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6` - Pillow source revision: `bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d` - Bundled libtiff SHA-256: `e8988717b7470394a47d5ccd343130796b24ee70b6d885d3818e0e0b53238be1` Apple's ASAN runtime was injected at process startup. This is **not an ASAN-rebuilt Pillow wheel**; allocation/memcpy interception detects the reported boundary violation, but the wheel's native instructions are not comprehensively instrumented. Only this concrete full-package environment is established here. No affected-version range, current development-branch result, or patched release is asserted. Severity is **Unknown**; no CVSS score is proposed. Separate earlier evidence reached the original Pillow 8.0.1 encoder constructor compiled as a component against a modern Python/libtiff environment. **That was not a complete Pillow 8.0.1 installation** and does not establish the historical package's full runtime behavior. It is not part of this reproducer or an affected-version range. ## Observed evidence and controls The earlier integration harness performed the natural sequence `Image.open(BytesIO(input))`, `image.load()`, then `image.save(BytesIO(), format="TIFF")`, without replacing the image's metadata. Each case was recorded three times: | Original fixture | Bytes | Recorded result | | --- | ---: | --- | | `colormap16` | 1685 | Loaded as `I;16`; save terminated with ASAN exit 86, READ of size 131072 crossing a 1536-byte heap region (3/3). | | `colormap8` | 1684 | Same fixed ColorMap, but 8-bit samples; save succeeded and retained SHORT/count 768 (3/3). | | `colormap_absent` | 137 | Same 16-bit geometry without ColorMap; save succeeded (3/3). | Address-free summary of the recorded native diagnostic: ```text AddressSanitizer: heap-buffer-overflow READ of size 131072 0 bytes after 1536-byte region Copy path: memcpy -> _TIFFmemcpy -> setByteArray -> _TIFFsetShortArrayExt -> _TIFFVSetField -> TIFFVSetField -> ImagingLibTiffSetField -> PyImaging_LibTiffEncoderNew Allocation: calloc -> PyImaging_LibTiffEncoderNew ``` Input SHA-256 values (also enforced inside the script): - `colormap16`: `5f38e0ead90b97949fb0c98c63f9c68d00ba9181db6631ecb8927376dcc75f4d` - `colormap8`: `fdb26d9135549ed44824901985086c5ee4f06515699ca3291e498c523935405c` - `colormap_absent`: `bd54979624f3ffb713342e0458caff9e17c477f940cda2f0960feebfabbc9556` ## Root cause and source references - [Pillow `src/encode.c`, lines 870–899, pinned revision](https://github.com/python-pillow/Pillow/blob/bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d/src/encode.c#L870): the ColorMap tuple must contain exactly 768 entries; a 1536-byte allocation is passed with a fixed stride of 256. The check does not reconcile that extent with `BitsPerSample`. - [Pillow `src/PIL/TiffImagePlugin.py`, lines 1944–19 | CVE Database V5 | ||
| High | 8.7 | EPSS 0.6% | CVE-2026-112895Pillow · Uncontrolled Recursion High8.7EPSS 0.6%CVE Database V5CVE-2026-112895 CVE-2026-112895 is a high-severity vulnerability in the python-pillow Pillow library affecting versions from 5.1.0 up to but not including 13.0.0. It involves uncontrolled recursion in PDF parsing when appending to existing PDFs using Image.save with append=True. The PdfParser's linearize_page_tree function recurses through /Kids references without cycle or depth checks, allowing cyclic or duplicated page trees to cause unbounded recursion. Similarly, read_prev_trailer only guards against exact repeated offsets, permitting long unique chains to recurse deeply. This can lead to excessive CPU and memory consumption or a RecursionError, resulting in denial of service in applications processing user-supplied PDFs. The issue is fixed in Pillow 13.0.0 by adding a visited set and depth limit to the parsers. | CVE Database V5 | ||
| High | 8.7 | EPSS 0.6% | CVE-2026-112894Pillow · Inefficient Algorithmic Complexity High8.7EPSS 0.6%CVE Database V5CVE-2026-112894 CVE-2026-112894 is a high-severity vulnerability in the python-pillow Pillow library affecting versions from 5.1.0 up to but not including 13.0.0. It causes a quadratic-time denial-of-service (DoS) when saving multi-frame images as multi-page PDFs due to inefficient algorithmic complexity in the PDF writer's object ID reservation process. This inefficiency leads to excessive CPU usage proportional to the square of the frame count, allowing an attacker to tie up system resources for extended periods with crafted files. The issue was fixed in version 13.0.0. | CVE Database V5 |
Page 1 of 23