Skip to main content

MuJS CVE-2026-110715

| EUVDEUVD-2026-101138 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-14 VulnCheck GHSA-45w2-9pc7-5crm
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Deliver document/script with malicious JavaScript
  2. Delivery
    Victim opens file in MuJS-embedding app
  3. Exploit
    Inflate dense array length and call sort
  4. Execution
    OOB read/write in Ap_sort_cmp/Ap_sort_swap
  5. Impact
    Heap corruption and process crash

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 that the target application embedding MuJS 1.3.6, 1.3.7, or 1.3.8 execute attacker-controlled JavaScript; the specific trigger is script that enlarges a simple/dense array's length property and then invokes Array.prototype.sort, driving Ap_sort_cmp and Ap_sort_swap to access slots beyond the allocated heap buffer. Limiting factors: the CVSS 4.0 vector is local (AV:L) with passive user interaction (UI:P), meaning an attacker cannot reach the flaw over the network directly but must get a victim to open or process a malicious script/document; deployments that only ever run trusted, first-party JavaScript are not exposed. Versions at or above 1.3.9 are patched.

Impact

This is a genuine but moderate-priority memory-corruption flaw, not a drop-everything emergency. The provided CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H, score 6.9) describes a local attack vector requiring passive user interaction, with the dominant impact being availability (process crash) plus limited integrity impact, and no confidentiality loss. A public proof-of-concept exists (the hackmd write-up and the referenced VulnCheck advisory), which raises the practical likelihood of opportunistic exploitation, but there is NO CISA KEV listing and NO EPSS score was supplied, so there is no evidence of active in-the-wild exploitation. The signals are internally consistent: a CWE-787 out-of-bounds write in a scripting engine, reachable only by getting the target to execute attacker-supplied JavaScript (UI:P / local vector), aligns with an embedded-interpreter threat model rather than a remote network service. The main caveat is that CVSS caps integrity at Low and does not credit code execution, yet a heap OOB read AND write in a JS engine is frequently a primitive that skilled attackers escalate toward RCE; the official score likely reflects the reliably-demonstrated crash rather than the theoretical ceiling. Net: real priority for anyone embedding MuJS and feeding it untrusted scripts/PDFs, but lower urgency where MuJS only ever runs trusted scripts.

Exploit ScenarioDerived

An attacker crafts a malicious document or script containing JavaScript that inflates a dense array's length and then calls Array.prototype.sort; when a victim opens the file in an application embedding MuJS 1.3.6-1.3.8, Ap_sort_cmp and Ap_sort_swap access heap slots past the allocated buffer, corrupting memory and crashing the process. A public proof-of-concept write-up is available, lowering the barrier to reproduction; because the vector is local with passive user interaction, exploitation depends on delivering the script to a context that will execute it.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.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 14, 2026

Heap out-of-bounds read and write in MuJS 1.3.6 through 1.3.8 allows attackers to corrupt process memory by supplying JavaScript that inflates a simple/dense array's length property and then invokes Array.prototype.sort, driving the internal Ap_sort_cmp and Ap_sort_swap helpers to index slots past the allocated heap buffer; the practical result is memory corruption and a process crash (CVSS 4.0 base 6.9, AV:L/AC:L/PR:N/UI:P with high availability and low integrity impact). Publicly available exploit code exists, including a published proof-of-concept write-up demonstrating the array-length trigger, but the issue is not confirmed as actively exploited (no CISA KEV listing) and exploitation requires a target application embedding MuJS to execute attacker-controlled script that a victim loads or opens. Deployments that only ever run trusted, first-party JavaScript are not exposed, and MuJS 1.3.9 and later contain the fix; this is a genuine but moderate-priority memory-corruption flaw rather than an emergency.

RemediationAI

Upgrade to MuJS 1.3.9 or later (vendor-released patch; the upstream fix is commit 32064e10caa45e68fc87331ca53d042049cc9396 in jsarray.c) - this is the only true fix, since it removes the length/backing-store inconsistency that Ap_sort_cmp and Ap_sort_swap rely on. If upgrading immediately is not possible, the most effective compensating control is to stop feeding attacker-controlled JavaScript to the embedded interpreter: disable or restrict script execution in the host application (for example, turn off JavaScript in the document/file processor) and refuse to open untrusted documents with the script-enabled path - the trade-off is that legitimate scripted features such as form logic or document automation stop working. Where some untrusted script must be processed, confine the interpreter process with OS-level sandboxing and privilege restrictions (seccomp/AppArmor profiles, dropping privileges, disabling JIT-adjacent features and unnecessary file/socket access) to contain the heap corruption to a disposable, low-privilege process, accepting that this mitigates consequences rather than the root cause and may still allow a crash-based denial of service. Monitoring should expect the observable symptom to be an interpreter crash during array sorting; note that a crash is the common outcome, so detecting exploitation beyond DoS is unreliable, which is an argument for prioritizing the 1.3.9 upgrade. Additional context is available at the vendor download page (https://mujs.com/downloads/), the upstream repository (https://codeberg.org/ccxvii/mujs), and the VulnCheck advisory linked above.

Affected VersionsENISA

MuJS 1.3.6 <1.3.9

Affected Packages

euvd mujs fix: 1.3.9

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

MuJS is a small, embeddable ECMAScript/JavaScript interpreter (tracked as CPE cpe:2.3:a:artifex_software:mujs) commonly linked into host applications that need to run script, so the attack surface is the interpreter's built-in array machinery rather than a network service. The root cause is CWE-787 (out-of-bounds write), realized in jsarray.c where the sort fast path assumes the dense array's length property is consistent with its allocated backing store. Because script can set an array's length beyond the number of actually allocated element slots, the comparator and swap routines used during sorting - Ap_sort_cmp for comparisons and Ap_sort_swap for element exchanges - compute element addresses from that inflated length and read and write past the end of the heap buffer. The result is both an out-of-bounds read (type confusion of adjacent heap metadata/values during comparison) and an out-of-bounds write (corruption of neighboring heap objects during swaps), which can crash the process and, depending on heap layout and allocator behavior, could be steered beyond a simple denial of service. The upstream fix commit 32064e10caa45e68fc87331ca53d042049cc9396 modifies this code path (see the referenced jsarray.c line at commit 307f18c4216420f2f56e22d8e7040baa39a6304a), and the CVSS 4.0 vector's local attack vector plus passive user interaction reflects that the script must reach the interpreter through a host application (for example, a document or file the victim opens) rather than over the network directly.

Know when Mujs 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 6.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Requires a victim to execute attacker-supplied JavaScript in a local embedding (AV:L, UI:R, PR:N); impact is primarily a crash (A:H) with limited memory corruption (I:L) and no data disclosure (C:N).

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/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
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

MuJS 1.3.6 before 1.3.9 contains a heap out-of-bounds read and write vulnerability in Array.prototype.sort that allows attackers to corrupt memory by inflating a simple array's length. Attackers can supply JavaScript that enlarges a dense array's length and calls sort, causing Ap_sort_cmp and Ap_sort_swap to access slots past the buffer and crash the process.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Medium
Embeddable JS engine shipped inside MuPDF/Ghostscript and similar lightweight tooling
Exploit
POC
Public exploit code exists
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 MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.2%
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
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

54
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
PoC: +20
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.

More in Mujs

View all
CVE-2016-7504 CRITICAL POC
9.8 Oct 29

A use-after-free vulnerability was observed in Rp_toString function of Artifex Software, Inc. Rated critical severity (C

CVE-2016-7505 CRITICAL POC
9.8 Oct 29

A buffer overflow vulnerability was observed in divby function of Artifex Software, Inc. Rated critical severity (CVSS 9

CVE-2020-24343 HIGH POC
7.8 Aug 13

Artifex MuJS through 1.0.7 has a use-after-free in jsrun.c because of unconditional marking in jsgc.c. Rated high severi

CVE-2016-9109 HIGH POC
7.5 Jan 18

Artifex Software MuJS allows attackers to cause a denial of service (crash) via vectors related to incomplete escape seq

CVE-2016-7506 HIGH POC
7.5 Oct 29

An out-of-bounds read vulnerability was observed in Sp_replace_regexp function of Artifex Software, Inc. Rated high seve

CVE-2016-9294 HIGH POC
7.5 Nov 12

Artifex Software, Inc. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication req

CVE-2016-7563 HIGH POC
7.5 Jan 18

The chartorune function in Artifex Software MuJS allows attackers to cause a denial of service (out-of-bounds read) via

CVE-2016-7564 HIGH POC
7.5 Jan 18

Heap-based buffer overflow in the Fp_toString function in jsfunction.c in Artifex Software MuJS allows attackers to caus

CVE-2016-9017 HIGH POC
7.5 Oct 28

Artifex Software, Inc. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication req

CVE-2016-10141 CRITICAL
9.8 Jan 13

An integer overflow vulnerability was observed in the regemit function in regexp.c in Artifex Software, Inc. Rated criti

CVE-2016-10133 CRITICAL
9.8 Mar 24

Heap-based buffer overflow in the js_stackoverflow function in jsrun.c in Artifex Software, Inc. Rated critical severity

CVE-2019-12798 CRITICAL
9.8 Jun 13

An issue was discovered in Artifex MuJS 1.0.5. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploi

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