Skip to main content

colord EUVDEUVD-2026-70736

| CVE-2026-85062 MEDIUM
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-09-03 GitHub_M GHSA-2wm5-q62r-hmrv
6.9
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Identify application endpoint passing user input to colord
  2. Delivery
    Submit multi-kilobyte malformed CSS color string
  3. Exploit
    Ambiguous regex triggers O(n²) backtracking
  4. Execution
    Node.js event loop blocked for seconds per request
  5. Persist
    Flood with repeated requests
  6. Impact
    Sustained service outage

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

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

Exploitation Conditions

The target application must accept a string from an external source - HTTP request body field, JSON property, uploaded stylesheet, or any other untrusted channel - and pass it without length restriction to one of the following colord API functions: colord(), getFormat(), isEqual(), mix(), or contrast(). The attack requires no authentication if the accepting endpoint is unauthenticated (PR:N per CVSS vector). Exploitation is limited to JavaScript/Node.js runtime environments where colord processes color strings synchronously on the event loop; serverless or multi-process worker deployments reduce but do not eliminate impact, since individual workers can each be blocked. The payload must be several kilobytes of repeated digit characters wrapped in a CSS color-function shell (e.g., hsl(1111...1, 50%, 50%)) - valid-length CSS color strings (under ~100 bytes) cannot trigger meaningful delay.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms unauthenticated, low-complexity network exploitability with no special attack requirements. The assigned VA:L in the provided vector may understate real-world severity: a fully blocked Node.js event loop is functionally equivalent to a complete service outage for all concurrent requests, not merely degraded performance, and under sustained attack a single worker thread can be kept permanently occupied. Even a mid-sized municipal IT team in bytom running an internal design or CSS-processing tool built on colord should treat this as urgent if the tool accepts color strings from untrusted sources. The test code added in the fix PR (tests/parse-complexity.test.ts) demonstrates that a 64,000-character malformed payload required 'several seconds' pre-fix against a budget of 500ms, confirming practical exploitability. No EPSS score or CISA KEV listing is present in the source intelligence, making widespread automated exploitation unlikely at this time; however, the attack payload is trivially constructable from the vulnerability description alone. Risk is highest in applications that directly pipe HTTP request parameters or uploaded stylesheets into colord without length bounds.

Exploit ScenarioDerived

An attacker submits a POST request to a web application theme-customizer or CSS-validation endpoint, supplying a malformed color value such as rgb( followed by 64,000 digit characters and a closing ). The server passes the string to colord() for validation; the synchronous regex engine spends several seconds exhausting O(n²) backtracking combinations before rejecting it. Repeated rapid submissions hold the event loop continuously blocked, making the server unresponsive to all other traffic for the duration of the attack. No public exploit code has been identified at time of analysis, but the payload structure is directly derivable from the vulnerability description.

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 – Sep 03, 2026

Synchronous CSS color string parsing in colord (npm, versions prior to 2.9.4) exposes Node.js applications to event-loop denial of service through catastrophic regex backtracking (ReDoS). The ambiguous numeric pattern ([+-]?\d*\.?\d+) used across five color-model parsers - RGB, HSL, HWB, LCH, and CMYK - allows overlapping quantifiers to partition the same digit sequence in O(n²) ways during rejection, blocking the JavaScript thread for seconds per malformed payload. An unauthenticated attacker who can supply an unbounded color string to any exposed application endpoint that calls colord(), getFormat(), isEqual(), mix(), or contrast() can render the service unresponsive; no public exploit code has been identified at time of analysis.

RemediationAI

Upgrade colord to version 2.9.4 or later (npm install colord@2.9.4 or npm update colord). Version 2.9.4 replaces the ambiguous numeric regex across all five affected color-model parsers with the deterministic form (?:\d*\.\d+|\d+), which eliminates backtracking ambiguity without changing accepted input. The fix is confirmed by the CHANGELOG entry in PR #141 (https://github.com/omgovich/colord/pull/141) and the tagged commit at https://github.com/omgovich/colord/commit/87018089515ed66a85b1a95c3c7c3fd69a25bac2. If immediate upgrade is blocked, apply input sanitization before calling colord: restrict color string length to a safe maximum (64 bytes covers any valid CSS color value) and reject strings containing long runs of digits. This workaround eliminates the attack payload without a library change but must be applied at every call site - including indirect calls through upstream libraries that depend on colord. Deploying the endpoint behind a reverse proxy with a short request timeout (e.g., 5s) also limits per-request damage but does not prevent repeated blocking under automated attack.

Affected VersionsENISA

colord < 2.9.4

Affected Packages

npm colord fix: 2.9.4

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

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

Technical ContextAI · show details

colord is a TypeScript/JavaScript npm library (CPE: cpe:2.3:a:omgovich:colord:*:*:*:*:*:*:*:*) for high-performance color manipulation and conversion. The vulnerability is CWE-1333 (Inefficient Regular Expression Complexity) and resides in five parser functions: parseRgbaString (src/colorModels/rgbString.ts), parseHslaString (src/colorModels/hslString.ts), parseHwbaString (src/colorModels/hwbString.ts), parseLchaString (src/colorModels/lchString.ts), and parseCmykaString (src/colorModels/cmykString.ts). Each used the pattern \d*\.?\d+ for numeric tokens, where both \d* and \d+ independently match digits from the same position, creating multiple valid parse paths for any digit sequence. JavaScript's backtracking regex engine must explore all O(n²) partitions before concluding a rejection. Because JavaScript regex execution is synchronous and uninterruptible, this computation starves the event loop. The fix in PR #141 replaces the ambiguous pattern with the unambiguous (?:\d*\.\d+|\d+), which forces a deterministic parse path - the two alternatives are now mutually exclusive, eliminating backtracking ambiguity while preserving identical valid-input acceptance.

Know when Colord 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 (GitHub_M) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Unauthenticated network input blocks the synchronous JS event loop entirely; A:H because sustained event-loop starvation equals complete service outage under attack.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

1
Patch available
Sep 03, 2026 - 22:02 EUVD

DescriptionCVE.org

Colord is a tiny yet powerful tool for high-performance color manipulations and conversions. Prior to 2.9.4, synchronous CSS color string matchers in src/colorModels/rgbString.ts, src/colorModels/hslString.ts, src/colorModels/hwbString.ts, src/colorModels/lchString.ts, and src/colorModels/cmykString.ts use the ambiguous numeric regular expression ([+-]?\d*.?\d+), allowing the same digits to be divided between overlapping quantifiers in quadratically many ways when malformed input is rejected. An attacker who can supply an unbounded color string to colord(), getFormat(), isEqual(), mix(), or contrast(), including through a request body, JSON field, or uploaded stylesheet, can block the processing thread with a multi-kilobyte payload. The affected matchers are parseRgbaString, parseHslaString, parseHwbaString, parseLchaString, and parseCmykaString. This issue is fixed in version 2.9.4.

Threat Intelligence Overview

EPSS Score
0.3%
Top 79% exploitable
Prevalence
Medium
popular npm color library, widely used in JS/TS frontend and tooling projects
Threat Intel
1
1 sources
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 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
Yes
Human Impact· derived
Medium

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

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