CVE-2026-54639: Style Dictionary Prototype Pollution Vulnerability (v4.3.0–5.4.3)

Technical summary

The vulnerability is a prototype pollution flaw (CWE-1321) in Style Dictionary's token processing logic. The affected function `convertTokenData(tokens, { output: 'object' })` and related token expansion mechanisms fail to sanitize object keys containing `__proto__`, a special property in JavaScript that modifies an object's prototype chain. When Style Dictionary processes tokens—whether through direct API calls, the Expand API, or the transform lifecycle—an attacker can craft token objects with keys like `__proto__` to inject arbitrary properties into the shared Object prototype, affecting all subsequent object instances created by the application. The impact scales with deployment context: critical in Node.js server applications where polluted prototypes persist across requests, moderate in browser-based applications where prototype pollution has narrower scope, and low in scenarios where tokens are entirely controlled by internal teams.

Business impact

The business risk depends heavily on your deployment model. Organizations running Style Dictionary in server-side Node.js applications (such as API servers, build pipelines, or headless rendering services) face the highest risk: an attacker with write access to token repositories, CI/CD workflows, or external token feeds could corrupt application logic, inject malicious behaviors, or disrupt service availability. Companies using Style Dictionary primarily in build-time processes for client applications experience lower risk unless those processes accept untrusted input. The moderate rating for web applications reflects the fact that prototype pollution in browsers is typically contained to the page context. Across all scenarios, the vulnerability creates trust boundary concerns—it transforms token data from a configuration asset into a potential attack vector if that data source is compromised or controlled by less-trusted parties.

Affected systems

All Style Dictionary versions from 4.3.0 through 5.4.3 are vulnerable. The vulnerability manifests in three usage patterns: direct calls to `convertTokenData()` with user-supplied tokens, indirect usage through the Expand API, and indirect processing via Style Dictionary's transform lifecycle. The severity escalates in environments where Style Dictionary runs on servers processing tokens from external sources or CI/CD pipelines accepting community contributions. Organizations that use Style Dictionary exclusively as a local development tool with tokens entirely maintained internally face lower practical risk, though the vulnerability still exists in the code path.

Exploitability

Exploitation requires the attacker to control or influence token data fed into Style Dictionary's processing functions. This could occur through compromised repositories, malicious pull requests in token repositories, poisoned external token feeds, or injection into CI/CD workflows. The attack is not network-remotely exploitable in isolation—it requires a precondition (write or commit access to tokens or token pipelines). However, in organizations where token repositories are more open or where Style Dictionary consumes third-party token sources, the bar for exploitation is notably lower. The CVSS score of 8.8 reflects the high impact once access is gained, combined with the low barrier for local/adjacent attacker leverage.

Remediation

Update Style Dictionary to version 5.4.4 or later as soon as feasible. The vendor has published a patch addressing the prototype pollution flaw. Until patching is complete, the only known mitigation is to sanitize token data before passing it to Style Dictionary by recursively scanning token objects for keys containing `__proto__` and removing or rejecting them. This workaround applies whether you use DTCG (Design Token Community Group) format tokens or Style Dictionary's legacy format. Prioritize patching over workarounds for production and server-side deployments.

Patch guidance

Upgrade Style Dictionary to version 5.4.4 or any subsequent release. Verify compatibility with your current configuration and test the upgrade in a staging environment before production deployment, as major version changes may introduce breaking changes. After upgrading, monitor token processing for any unexpected behavior. If you cannot upgrade immediately, implement token validation as a defensive layer: recursively inspect all token objects before they enter Style Dictionary to detect and reject any containing `__proto__` keys.

Detection guidance

Monitor your Style Dictionary process logs and application behavior for signs of unexpected prototype pollution. Look for unusual property mutations in objects or unexpected function/method availability that should not be present. In Node.js environments, consider adding runtime object inspection checks before and after token processing to detect prototype chain corruption. Audit your token repositories and CI/CD pipelines to identify which sources feed tokens into Style Dictionary and assess whether those sources are adequately access-controlled. Review Git history in token repositories for any unexpected modifications to token files, particularly additions of `__proto__` keys.

Why prioritize this

Classify this as High priority if you run Style Dictionary in a Node.js server application, especially if tokens come from external sources, CI/CD pipelines, or repositories with broad contributor access. Classify as Medium priority if Style Dictionary is used in client-side web applications or internal build processes with tightly controlled token sources. The CVSS 8.8 score and the availability of a patch make this actionable across the board, but remediation urgency should reflect your deployment model and trust boundaries around token data.

Risk score, explained

The CVSS 3.1 score of 8.8 (HIGH) reflects a vulnerability with high confidentiality, integrity, and availability impact (all rated High) that requires local or adjacent attacker access and no special privileges or user interaction. The local attack vector and low privilege escalation bar acknowledge that the attacker must first influence token data. However, once that precondition is met, the scope is changed (C in CVSS terms), meaning the impact extends beyond the vulnerable component to the broader application or system running Style Dictionary. In server-side deployments, prototype pollution can corrupt global state affecting all users and requests. The high score is justified for the realistic server-side threat scenario but should be contextualized with your actual token data controls.

Frequently asked questions