Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted MIRAX slide to victim
-
DeliveryVictim opens slide in OpenSlide app
-
ExploitMalformed CameraImageDivisionsPerSide bypasses bounds
-
ExecutionOut-of-bounds read past slide_positions array
-
ImpactHeap memory leak and application crash
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that an application using OpenSlide (through 4.0.1) open an attacker-crafted MIRAX-format slide whose Slidedat.ini CameraImageDivisionsPerSide value does not evenly divide the image counts; this malformed metadata drives the out-of-bounds index into the slide_positions array in the MIRAX get-tile-position path. LIMITING FACTORS: this is NOT remotely triggerable - the attacker must get the malicious .mrxs/Slidedat.ini file opened locally (CVSS UI:P/AV:L), so delivery depends on a user or an automated ingestion pipeline processing untrusted slides. Impact is limited to a small heap over-read (low info disclosure) plus an application crash and in-memory tile-geometry corruption; it does not by itself yield code execution or persistent data modification. |
| Impact | This is a moderate, not top-tier, priority. The provided CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H, base 6.9) correctly frames a local, file-parsing bug: an attacker cannot reach the code remotely over a network - a victim (or automated pipeline) must open an attacker-supplied MIRAX slide. The dominant impact is availability (VA:H, application crash / DoS) with only a low confidentiality leak (VC:L) from the heap out-of-bounds read past the slide_positions array; there is no integrity impact (VI:N) beyond in-memory tile-geometry corruption, which is not persistent. No EPSS score was supplied and the CVE is NOT in CISA KEV, so there is no evidence of active or widespread exploitation. The signals are internally consistent - CWE-125 (out-of-bounds read), the description, and the CVSS all agree this is a local, interaction-dependent read/crash rather than remote code execution. A detailed technical write-up (hackmd) and exact vulnerable source lines are public, which lowers the bar to reproduce, but no weaponized exploit or EPSS/KEV signal elevates this to an urgent threat. Net: patch on a normal cadence; treat as higher priority only for systems that ingest untrusted slide files automatically. |
| Exploit ScenarioDerived | An attacker crafts a malicious MIRAX whole-slide image whose Slidedat.ini sets CameraImageDivisionsPerSide so it does not evenly divide the image counts, then delivers it to a pathologist, LIMS, or automated processing pipeline that uses OpenSlide. When the victim opens the slide, the MIRAX reader indexes past the slide_positions array, leaking adjacent heap memory and crashing the application. A public technical write-up and the exact vulnerable source lines are available, lowering reproduction effort, though no packaged exploit is indicated in the input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Processing a crafted MIRAX whole-slide image with OpenSlide through 4.0.1 can trigger a heap out-of-bounds read in the MIRAX tile-position logic, crashing the consuming application and exposing limited adjacent heap data. The issue is local and user-assisted because a malicious .mrxs/Slidedat.ini must be opened or ingested by a victim or automated pipeline, and it does not by itself enable code execution or persistent data modification. No public exploit identified at time of analysis, and no CISA KEV active-exploitation entry is present in the supplied intelligence.
RemediationAI
No vendor-released patch version is specified in the supplied data; monitor the OpenSlide project and vendor advisory for an updated release and upgrade once available. Until then, avoid opening or automatically ingesting untrusted MIRAX/Slidedat.ini files, validate metadata so CameraImageDivisionsPerSide is present and evenly divides image counts before processing, and run OpenSlide-dependent applications with least privilege or in a sandbox/container to limit exposure. If MIRAX support is not required, disabling or avoiding that vendor backend reduces attack surface, though it may break legitimate MIRAX workflows. Automated pipelines should quarantine malformed slides rather than retry; overly strict validation may reject valid pathology images. Consult references: https://hackmd.io/@haind-pwn/openslide-mirax-slide-position-index-oob-read, https://github.com/openslide/openslide/blob/fe79a9713bef2bfd64bbfefd15704060764b1274/src/openslide-vendor-mirax.c#L611-L635, and https://github.com/openslide/openslide/blob/fe79a9713bef2bfd64bbfefd15704060764b1274/src/openslide-vendor-mirax.c#L1033-L1034.
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
OpenSlide is a C library for reading whole-slide images used in digital pathology, and its MIRAX vendor backend parses Slidedat.ini metadata to build tile geometry. The bug is CWE-125: the code uses CameraImageDivisionsPerSide to index the slide_positions array, but if that value does not evenly divide the image counts, the computed index can exceed the array bounds and get_tile_position reads adjacent heap memory, returning corrupted tile geometry. The CPE cpe:2.3:a:openslide:openslide:*:*:*:*:*:*:*:* identifies OpenSlide generally, with the vulnerability reported through 4.0.1; the linked source lines at openslide-vendor-mirax.c show the relevant parsing and indexing paths. The independent assessment rates this as AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H, meaning local access, no privileges, user interaction, low confidentiality impact, and high availability impact from crashes.
Know when Openslide 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
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N
File must be opened locally so AV:L/UI:R; no auth to craft the file (PR:N); small heap over-read gives C:L, no integrity impact (I:N), crash gives A:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
OpenSlide through 4.0.1 contains a heap out-of-bounds read vulnerability in the MIRAX reader that allows attackers to read past the slide_positions array via crafted Slidedat.ini values. Attackers can supply a MIRAX slide whose CameraImageDivisionsPerSide does not evenly divide the image counts, crashing applications that open it and corrupting tile geometry.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Memory corruption in OpenSlide's Ventana BIF parser (versions 3.4.1 through 4.0.1) allows a crafted whole-slide image to
Uninitialized heap memory disclosure in OpenSlide occurs because libtiff 4.7.1 changed how the indirect TIFF tile read p
EUVD-2026-102361
GHSA-5jq9-3x2q-j76q
NVD
CVE.org
EPSS
Exploit-DB