Skip to main content

compress-fonts EUVDEUVD-2026-101276

| CVE-2026-110648 HIGH
OS Command Injection (CWE-78)
2026-10-14 VulnCheck GHSA-3jqx-74fv-xh4j
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Plant font file with crafted name
  2. Delivery
    Victim build runs compress-fonts
  3. Exploit
    Filename interpolated unquoted into execSync
  4. Execution
    Shell metacharacters execute commands
  5. Impact
    Arbitrary code runs as Node process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

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 compress-fonts (before 1.1.1) processes font files whose filenames are attacker-controlled, that FontForge is installed and invoked, and that a legitimate user or automated build actually runs the compression step (UI:P). The concrete trigger is a font filename containing shell metacharacters, which index.js interpolates unquoted into the fontforge -lang=ff -c ... ${file} ... string passed to execSync. Limiting factors: the vector is local (AV:L), not network - the attacker must get a maliciously named file into the processed source directory, and a user must initiate the conversion; impact is bounded by the Node.js process privileges. Default configurations are vulnerable once such a file is present.

Impact

Signals are moderate and internally consistent rather than alarming. The supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, VC:H/VI:H/VA:H) scores 8.5 and describes local, low-complexity code execution that requires passive user interaction - a developer or build pipeline must actually run compress-fonts over attacker-influenced font files. There is no CISA KEV listing and no public exploit identified at time of analysis, and no EPSS score was provided, so there is no evidence of active or widespread exploitation; this reads as a classic unsanitized-input command injection in a small Node.js library rather than an internet-facing emergency. The vulnerability is real and well-substantiated (root-cause source line and a vendor patch converting execSync to execFileSync are both referenced), but the local attack vector plus required user interaction and the product's tiny footprint make this a lower-priority, developer/build-chain supply-risk item rather than a mass-exploitation threat. Note the vector is AV:L (local) despite the 'attackers execute shell commands' phrasing - exploitation depends on getting a maliciously named font file into a processing pipeline, so treat it as a local/supply-chain issue, not remote network RCE.

Exploit ScenarioDerived

An attacker crafts a font file whose filename embeds shell metacharacters (e.g. a backtick or ';' command) and gets it into a directory that a victim's build or asset pipeline feeds to compress-fonts. When the victim runs the tool, the filename is interpolated unquoted into the FontForge command executed via child_process.execSync, and the attacker's commands run with the Node.js process privileges. No public exploit code was identified, but the root cause and fix are documented in the referenced PR/commit.

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

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

Alert me

AnalysisAIv1 – Oct 14, 2026

OS command injection in @offactory/compress-fonts before 1.1.1 lets an attacker execute arbitrary shell commands with the privileges of the Node.js process by getting a font file with shell metacharacters in its filename into a directory that is being compressed. The supplied CVSS 4.0 vector indicates no authentication is required (PR:N) and high confidentiality, integrity, and availability impact to the vulnerable component, but the attack vector is local (AV:L) and requires a user or automated build to initiate the FontForge conversion (UI:P), so real-world impact is bounded by who can place files in the processed source directory and by the privileges under which the build runs. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; a vendor fix is available in version 1.1.1, which replaces execSync with execFileSync.

RemediationAI

Upgrade @offactory/compress-fonts to 1.1.1 or later, which is the vendor-released fix; versions before 1.1.1 are vulnerable. The fix is implemented in upstream PR #1 and commit 12002e5866af2163cd34424baae5a53338951a5d, which replaces child_process.execSync with execFileSync and passes the FontForge script and file paths as an argument array, eliminating shell interpretation entirely. Because the patch is a small, self-contained change to the process invocation, teams that cannot immediately adopt 1.1.1 can backport the execFileSync call or otherwise avoid the shell string form. If patching is not possible, the practical compensating controls are to prevent untrusted font filenames from reaching the compressor: reject or rename any input file whose name contains shell metacharacters, whitespace, or path separators before invoking the tool (this requires an added pre-processing step and can silently break legitimate filenames if implemented too narrowly); run the compression step in a container or sandbox with a restricted user, no network, and read-only access outside the source/dist directories so that any injected command is contained (this reduces but does not eliminate impact and adds deployment complexity); and avoid running the build as a privileged or CI-secret-bearing account, since injected commands inherit the Node.js process privileges. Remediation references: https://github.com/adamarcanov/compress-fonts/pull/1, https://github.com/adamarcanov/compress-fonts/commit/12002e5866af2163cd34424baae5a53338951a5d and https://www.vulncheck.com/advisories/offactory-compress-fonts-before-1.1.1-os-command-injection-via-font-file-names.

Affected VersionsENISA

compress-fonts 0 <1.1.1

Affected Packages

euvd compress_fonts fix: 1.1.1

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 vulnerable code is the Node.js package @offactory/compress-fonts (repository adamarcanov/compress-fonts), tracked by CPE cpe:2.3:a:adamarcanov:compress-fonts:*:*:*:*:*:*:*:* and mapped to CWE-78 (Improper Neutralization of Special Elements used in an OS Command / OS Command Injection). In index.js the tool builds a command string of the form fontforge -lang=ff -c '${fontforgeScript}' ${file} ${join(dist, filename + '.woff')} ${join(dist, filename + '.woff2')} and hands it to child_process.execSync, which always invokes a shell. Because the interpolated font path is not quoted, any shell metacharacters in the filename (for example ;, |, $(), backticks, or whitespace) are interpreted by /bin/sh rather than passed as literal data to FontForge, allowing arbitrary command execution running as the Node.js process. The vulnerable design is the use of the shell-plus-string form of process execution instead of the argv-array form; the upstream fix switches to execFileSync('fontforge', ['-lang=ff', '-c', fontforgeScript, file, ...], ...), which bypasses the shell entirely and treats each path as a single argument. The vulnerability is in the wrapper tool rather than in FontForge itself, but exploitation depends on FontForge being installed and actually invoked on the crafted input, and the package is typically used in build or asset-preparation pipelines where filenames may originate from less-trusted sources such as design assets, uploads, or pulled repositories.

Know when Node.js 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

AV:L and UI:R because a user/build must process an attacker-named local font file; PR:N since the attacker needs no privileges, only to supply the file; full C/I/A impact from arbitrary command execution.

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

@offactory/compress-fonts before 1.1.1 contains an OS command injection vulnerability that allows attackers to execute shell commands by supplying font files with crafted names. Font paths are interpolated unquoted into a FontForge command run through child_process.execSync, so shell metacharacters in file names execute commands with the Node.js process privileges.

Executive ViewAI

Why It Matters

@offactory/compress-fonts versions before 1.1.1 introduce a build-time command execution risk that can affect development and CI/CD environments. An unauthenticated local attacker or automated process able to place a specially named font file in a directory being compressed could execute shell commands with the Node.js process privileges, potentially exposing secrets, tampering with build artifacts, or disrupting releases. No public exploit has been identified at time of analysis and the vendor has released a patch in 1.1.1, but leadership should prioritize remediation because compromised build tooling can propagate risk to downstream software and customers.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
1.1%
Top 34% exploitable
Prevalence
Rare
obscure niche npm font utility, negligible production footprint
Data Quality
6 sources
Confidence: High

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 1.1%
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
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

CVE-2025-68613 HIGH POC
8.8 Dec 19

Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation

CVE-2024-41713 CRITICAL POC
9.1 Oct 21

A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could

CVE-2024-55591 CRITICAL POC
9.8 Jan 14

FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote

CVE-2023-44487 HIGH POC
7.5 Oct 10

Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour

CVE-2014-7205 CRITICAL POC
10.0 Oct 08

Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t

CVE-2025-59528 CRITICAL POC
10.0 Sep 22

Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete

CVE-2017-14849 HIGH POC
7.5 Sep 28

Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc

CVE-2017-5941 CRITICAL POC
9.8 Feb 09

An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner

CVE-2014-0224 HIGH POC
7.4 Jun 05

OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph

CVE-2014-3744 HIGH POC
7.5 Oct 23

Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi

CVE-2014-9566 HIGH POC
7.5 Mar 10

Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin

CVE-2013-4660 MEDIUM POC
6.8 Jun 28

The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic

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