Skip to main content

OFFIS DCMTK CVE-2025-14607

MEDIUM
Buffer Overflow (CWE-119)
2025-12-13 cna@vuldb.com
5.3
CVSS 4.0 · Vendor: vuldb
View

Attack ChainAIDerived

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

  1. Access
    Reach DICOM-parsing component
  2. Exploit
    Deliver crafted byte-string element
  3. Execution
    Trigger overflow in makeDicomByteString
  4. Impact
    Corrupt process memory

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, buffer size validation
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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

Exploitation Conditions

Requires an application built on OFFIS DCMTK version ≤3.6.9 to parse a maliciously crafted DICOM byte-string value element that drives DcmByteString::makeDicomByteString into the off-by-one/null-termination defect in dcbytstr.cc. Exploitation is LIMITED by the fact that DCMTK is a library: the attacker must reach a component that ingests attacker-controlled DICOM data (a receiving PACS/SCP network service, a file viewer, or a conversion pipeline), and the VulDB vector indicates some privilege (PR:L) is expected; impact is bounded (Low C/I/A), consistent with a single-byte overwrite rather than arbitrary code execution.

Impact

Signals converge on a genuinely MEDIUM-to-LOW real-world risk rather than an urgent priority. The VulDB-assigned CVSS 4.0 vector (AV:N/AC:L/PR:L/UI:N) with Low impact on all three of VC/VI/VA scores 5.3, reflecting a bounded memory-corruption condition rather than clean code execution. EPSS is 0.27% (18th percentile), indicating low predicted exploitation likelihood, and the CVE is NOT in CISA KEV, so there is no evidence of active exploitation. The GitHub source evidence is the vendor fix commit (a null-terminator / off-by-one correction), NOT a weaponized proof-of-concept, so there is no public exploit identified at time of analysis. One caveat to flag explicitly: this is a library-level flaw in the DCMTK DICOM toolkit, so the 'attack can be launched remotely' claim and the AV:N / PR:L metrics are VulDB defaults whose real applicability depends entirely on how the embedding application exposes DICOM parsing (networked PACS node vs. local file viewer) - verify the actual deployment surface before treating it as remotely reachable. The Low C/I/A impacts are consistent with the patch, which adds a single null byte, suggesting a constrained overflow (likely crash/limited corruption) rather than reliable RCE.

Exploit ScenarioDerived

An attacker supplies a malicious DICOM object with a crafted byte-string element whose length triggers the faulty path in DcmByteString::makeDicomByteString, and a DCMTK ≤3.6.9-based application (e.g. a PACS node, viewer, or conversion service) parses it, causing memory corruption. No public exploit exists - only the vendor patch commit is available - and the attack requires reaching a component that processes attacker-controlled DICOM data, with low (AC:L) complexity once that surface is reached.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 07, 2026

Memory corruption in OFFIS DCMTK 3.6.9 and earlier lets a remote, authenticated user corrupt a heap buffer when an affected application parses a maliciously crafted DICOM byte-string value element through DcmByteString::makeDicomByteString in dcmdata/libsrc/dcbytstr.cc. Impact is bounded - Low confidentiality, integrity, and availability - consistent with a single-byte out-of-bounds write rather than reliable remote code execution, and the practical exposure depends on whether the target deployment exposes a DICOM listener (PACS/SCP), file viewer, or conversion pipeline that ingests untrusted DICOM data. No public exploit code has been identified at time of analysis and EPSS is low (0.27%, 18th percentile); vendor-released patch: 3.7.0 (commit 4c0e5c10079392c594d6a7abd95dd78ac0aa556a), making this a routine medium-to-low priority library upgrade rather than an emergency.

RemediationAI

Vendor-released patch: upgrade OFFIS DCMTK to 3.7.0, which contains the fix (release version page https://support.dcmtk.org/redmine/versions/19); if you consume DCMTK as a library, rebuild and redeploy every dependent application rather than only the toolkit itself, since the vulnerable code is compiled into the consumer. Alternatively, backport the upstream commit 4c0e5c10079392c594d6a7abd95dd78ac0aa556a (https://github.com/DCMTK/dcmtk/commit/4c0e5c10079392c594d6a7abd95dd78ac0aa556a), which adds the missing bounds guard around the value terminator in dcmdata/libsrc/dcbytstr.cc; verify against the issue tracker entry https://support.dcmtk.org/redmine/issues/1184. Where immediate upgrading is impossible, compensating controls are placement-based rather than code-based: restrict network reachability to DICOM SCP/listener ports (commonly 104, 2762, and TLS equivalents) to known-trusted modalities and workstations via firewall or VLAN segmentation - note this does not help file-based ingestion or viewer use cases; run DICOM ingestion and conversion processes as an unprivileged, containerized or sandboxed account with address-space and file-descriptor limits so that the single-byte heap corruption is contained - note this reduces but does not eliminate the corruption itself; validate or re-encode inbound DICOM objects with an independent parser or de-identification gateway before they reach the vulnerable library - note this adds latency and a second code path that must itself be maintained; and enable build hardening already available in DCMTK (e.g. compiling with the bundled hardening flags and modern allocator/stack protections) to raise the exploitability bar for downstream memory corruption - note these are mitigations, not fixes. Monitor the vendor activity feed and the linked advisories for any updated patch guidance, since no public exploit code has been observed and the EPSS score (0.27%) suggests low near-term exploitation activity.

Affected ProductsAI

OFFIS DCMTK versions up to and including 3.6.9 are affected, specifically the dcmdata component and the DcmByteString::makeDicomByteString path in dcmdata/libsrc/dcbytstr.cc; no CPE string was supplied with the advisory metadata, but the vendor's version listing (https://support.dcmtk.org/redmine/versions/19) marks 3.7.0 as the release containing the fix. Because DCMTK is embedded as a library, the practical list of vulnerable products is every application, PACS/SCP service, DICOM file tool, or conversion pipeline built against 3.6.9 or earlier binaries - including statically linked builds where upgrading the toolkit requires rebuilding and redistributing the consuming application. Vendor references for the affected component are the Redmine issue https://support.dcmtk.org/redmine/issues/1184, the module activity log at https://support.dcmtk.org/redmine/projects/dcmtk/activity?from=2025-12-02, and the third-party advisories https://vuldb.com/?id.336283 and https://vuldb.com/?ctiid.336283.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

DCMTK is the reference open-source C++ toolkit for DICOM, the standard format and network protocol used by medical imaging systems, and the dcmdata module implements its data dictionary and value-representation (VR) classes. DcmByteString handles string-based VRs such as AE, AS, CS, DA, DS, DT, IS, LO, LT, SH, ST, TM, UC, and UR, and its newValueField()/makeDicomByteString logic allocates the value buffer for an element read off the wire or from a file. The root cause is CWE-119 (improper restriction of operations within the bounds of a memory buffer): when materializing a byte-string value the code writes a null terminator at the position immediately after the declared length field without a sufficient bounds check, producing an off-by-one out-of-bounds write on the heap (null byte). The upstream fix in commit 4c0e5c10 guards that terminator write in dcbytstr.cc. Because this is a library defect and not a standalone service, the attack surface is inherited by every downstream application that links DCMTK - DICOM network SCP/SCU tools, archives, viewers, and de-identification/format-conversion pipelines. The CVSS:4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N, Low C/I/A) and the independent CVSS:3.1 assessment (AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L) both point to low-privilege network-delivered input with bounded impact; the PR:L reflects the real prerequisite that the attacker must already be able to submit DICOM objects to an ingestion endpoint, not a need for host credentials.

Know when the next one hits your stack

  • 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 (vuldb) PRIMARY 5.3 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N
vuln.today AI 6.3 MEDIUM

Network-reachable DICOM parsing with low complexity, but a library flaw whose exposure depends on the embedding service, so PR:L; one-byte overflow yields only Low C/I/A impact.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N
SUSE MEDIUM
Red Hat 6.3 MEDIUM

Primary rating from Vendor (vuldb).

CVSS VectorVendor: vuldb

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

A vulnerability was detected in OFFIS DCMTK up to 3.6.9. Affected by this issue is the function DcmByteString::makeDicomByteString of the file dcmdata/libsrc/dcbytstr.cc of the component dcmdata. The manipulation results in memory corruption. The attack can be launched remotely. Upgrading to version 3.7.0 can resolve this issue. The patch is identified as 4c0e5c10079392c594d6a7abd95dd78ac0aa556a. You should upgrade the affected component.

Threat Intelligence Overview

EPSS Score
0.3%
Top 82% exploitable
Prevalence
Low
standard DICOM toolkit but confined to medical-imaging deployments
Data Quality
5 sources
Confidence: Medium
NVD CVE.org EPSS Vendor GitHub VulDB

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

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.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Package Hub 15 SP6 Fixed
SUSE Package Hub 15 SP7 Fixed
openSUSE Leap 15.6 Fixed
openSUSE Tumbleweed Fixed
SUSE Package Hub 15 SP7 Affected

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