Skip to main content

Scribus CVE-2026-104065

| EUVDEUVD-2026-114101 HIGH
Out-of-bounds Write (CWE-787)
2026-10-30 VulnCheck GHSA-8fqr-jpqv-g6jm
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious DRW file
  2. Delivery
    Deliver to Scribus user
  3. Exploit
    User imports via importdrw plugin
  4. Execution
    Out-of-bounds heap write past image buffer
  5. Impact
    Crash or code execution in user context

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
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

Exploitation requires a victim to import an attacker-crafted Micrografx Draw (.DRW) file through Scribus's built-in importdrw plugin; the malicious file supplies a y offset that is used without bounds validation to select an image scanline, causing decoded bitmap data to be written past the heap image buffer. The DRW import plugin ships with default Scribus installations, so no non-default configuration is needed, but the attack is strictly local and file-driven (AV:L): it cannot be triggered remotely or without the user opening/importing the file (UI:P). The principal limiting factor is this required user interaction - the victim must be socially engineered into importing the crafted file - which, together with the absence of KEV/EPSS/PoC signals, constrains realistic exploitation to targeted scenarios. Versions before 1.6.7 are affected; updating to 1.6.7 is the vendor fix.

Impact

This is a genuine but conditional memory-corruption issue, not an over-rated high-CVSS artifact. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H) correctly frames it as a client-side, file-parsing bug: no privileges are required, but a local file must be processed and user interaction (importing the file) is mandatory, so there is no remote or automatable mass-exploitation path. The source diff confirms the mechanism - an unvalidated scanline index (yoff + y) used in QImage::scanLine() leading to a heap out-of-bounds write (CWE-787) - which supports the 'crashes or code execution' claim, though actual code execution is asserted by the description, not demonstrated. The vuln.today priority is 'this_week' and a vendor patch (1.6.7) exists, so this should be scheduled promptly rather than deferred. No EPSS score and no KEV listing are present in the input, and no PoC/exploit reference is provided, so there is no evidence of active or widespread exploitation; the realistic risk is targeted social-engineering (tricking a user into importing a malicious DRW file) rather than opportunistic remote attack.

Exploit ScenarioDerived

An attacker crafts a malicious Micrografx Draw (.DRW) file with a y offset that drives the decoder past the allocated image buffer and delivers it to a Scribus user (e.g., via email or a download). When the victim imports the file through the importdrw plugin, decoded bitmap data is written outside the heap image buffer, crashing Scribus or potentially allowing code execution in the user's context. Exploitation is local and requires user interaction (AV:L/UI:P); no public exploit was identified at time of analysis.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 30, 2026

Heap-based out-of-bounds write in Scribus's Micrografx Draw (.DRW) import plugin (importdrw) before 1.6.7 allows local attackers to corrupt memory when a victim imports a crafted DRW file, resulting in a crash or potentially code execution. The plugin uses an unvalidated y offset to select image scanlines while decoding bitmap data, so writes can occur past the allocated heap image buffer; the attack is file-driven and requires user interaction to import the malicious document. No public exploit code or active exploitation has been identified at the time of analysis, and the vendor fix is Scribus 1.6.7.

RemediationAI

Upgrade to Scribus 1.6.7, the vendor-released fix, which contains the bounds checks and image-buffer validation in importdrw.cpp (commit 69f52b53c78542b0a5d377fa0b058fb2773799dc; release notes: https://wiki.scribus.net/canvas/1.6.7_Release). Because the plugin ships by default and exploitation requires importing a crafted DRW file, avoid opening or importing untrusted or unexpected .DRW documents until the upgrade is applied. The VulnCheck advisory provides additional vendor context at https://www.vulncheck.com/advisories/scribus-before-1.6.7-heap-out-of-bounds-write-via-micrografx-draw-import.

Affected VersionsENISA

Scribus 0 <1.6.7

Affected Packages

euvd scribus fix: 1.6.7

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

The affected component is the importdrw plugin that parses Micrografx Draw (DRW) files in Scribus, identified by CPE cpe:2.3:a:scribus:scribus:*:*:*:*:*:*:*:* for versions before 1.6.7. In importdrw.cpp, decodeCmd() computes a destination row as yoff + y and calls QImage::scanLine() on that row before writing decoded RGBA or grayscale pixels. Because the y offset from the crafted file is not validated against the image height, the resulting pointer can reference memory outside the heap buffer allocated for tmpImage (or tmpImage2 in the 8-bpp path), producing an out-of-bounds write (CWE-787). The upstream commit 69f52b53c78542b0a5d377fa0b058fb2773799dc hardens this by breaking when the data stream is at its end, bounds-checking the computed row against tmpImage.height() and tmpImage2.height(), null-checking the returned scanline pointer before writing, zero-initializing the QByteArray used for the 8-bpp copy, and requiring non-null image buffers via imageValid.

Know when Scribus 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 (VulnCheck) PRIMARY 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

A crafted file must be locally imported by a user, so AV:L and UI:R; no privileges are needed (PR:N), and the heap OOB write can yield full code-execution impact (C/I/A:H).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

Scribus before 1.6.7 contains an out-of-bounds write vulnerability in the importdrw Micrografx Draw plugin that uses an unvalidated y offset to select image scanlines. Attackers can craft a DRW file that, when imported by a user, writes decoded bitmap data outside the heap image buffer, causing crashes or code execution.

Executive ViewAI

Why It Matters

A heap memory corruption vulnerability, CVE-2026-104065, in Scribus versions before 1.6.7 could allow a local attacker to crash the application or potentially execute code when a user opens a specially crafted .DRW file. This affects any employee using Scribus to import graphics, and while exploitation requires user interaction, the resulting arbitrary code execution could lead to data exposure, system compromise, or operational disruption. Leadership should prioritize patching to reduce risk, especially for design or publishing teams that regularly handle third-party files.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Low
leading open-source DTP app but niche desktop-only user base
Data Quality
5 sources
Confidence: Medium

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 0.2%
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· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
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.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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