Skip to main content

LiquidJS CVE-2026-69222

| EUVDEUVD-2026-63090 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-08-19 GitHub_M GHSA-4r6h-5v86-94p3
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Submit crafted template via HTTP request
  2. Delivery
    Use concat to double array references exponentially at low accounting cost
  3. Exploit
    Invoke join or array_to_sentence_string to materialize all referenced strings
  4. Execution
    memoryLimit undercharges actual allocation by large factor
  5. Persist
    V8 heap or process memory limit exceeded
  6. Impact
    Node.js process crashes (DoS)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption 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

Exploitation requires that the application passes user-supplied or attacker-controlled Liquid template content to a LiquidJS rendering context, and that the template can use the concat filter combined with join, array_to_sentence_string, json, or inspect filters on attacker-influenced data. The vulnerability is not exploitable through data injection into a fixed, operator-controlled template - the malicious filter chain must exist in the template itself. Setting memoryLimit does not prevent exploitation because the accounting defect causes the limit to be under-charged before it fires; there is no known safe memoryLimit value that blocks the attack without the patch. No authentication is required if the template submission endpoint is publicly accessible, consistent with the CVSS PR:N rating. Applications that render only static, operator-authored templates with no user-controlled template content are not exposed to this vulnerability.

Impact

CVSS 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) accurately reflects the threat model for applications that accept user-supplied Liquid templates. The availability-only impact (A:H with C:N/I:N) is consistent with the described crash-only outcome - the Node.js process terminates at V8 string or heap limits with no evidence of code execution or data disclosure. Low attack complexity and no-authentication vector are appropriate because the bypass requires only valid Liquid template syntax: no memory corruption, heap grooming, or brute-force element is needed. EPSS data was not provided in the input and cannot be inferred; exploitation probability is unknown beyond the CVSS signal. This CVE is not in CISA KEV, so active exploitation is not confirmed. Real-world impact depends heavily on whether the deployment exposes template rendering to untrusted input: applications rendering fixed, operator-controlled templates are unexposed, while platforms offering user-defined template execution - the primary Shopify storefront theme use case - are directly at risk and should treat this as urgent. The memoryLimit feature exists precisely to bound untrusted-template resource consumption, making this bypass a direct circumvention of the intended security control rather than a misuse of a non-security feature.

Exploit ScenarioDerived

An attacker submits a crafted Liquid template to an application that renders user-supplied content, using concat to repeatedly double an array referencing a large string (e.g., 'a'.repeat(5000) split into a single-element array, then doubled three times via concat to yield eight references). The attacker then pipes the result through join, which materializes 40,000 characters of output while the memoryLimit accounting charges only eight units - a factor-5000 bypass. This process is repeatable with deeper concat chains until V8 string limits or process heap limits are exhausted, crashing the Node.js process. Working test cases demonstrating this technique are included in the fix PR's integration test suite.

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

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

Alert me

AnalysisAIv1 – Aug 19, 2026

Memory accounting bypass in LiquidJS prior to 10.27.2 enables remote denial of service by exhausting V8 heap or process memory limits through crafted templates. The join, array_to_sentence_string, json, and inspect filters computed resource consumption based on element count rather than actual output string length, allowing the concat filter to be chained to exponentially amplify array size without proportional memoryLimit charges. This CVE is not in CISA KEV and no standalone public exploit has been published, though the GitHub security advisory and fix PR #925 include working proof-of-concept integration tests that make the technique trivially reproducible.

RemediationAI

Upgrade to LiquidJS version 10.27.2 or later, which corrects memory accounting in the join, array_to_sentence_string, json, and inspect filters to use actual output string length. The patched release is available at https://github.com/harttle/liquidjs/releases/tag/v10.27.2 and the fix is detailed in PR #925 at https://github.com/harttle/liquidjs/pull/925. For deployments that cannot immediately upgrade, the most effective compensating control is to restrict the template-rendering surface so only trusted, operator-controlled templates are processed - this eliminates the untrusted-input attack vector entirely, though it may be infeasible for platforms where user-defined templates are a product feature. Tightening the configured memoryLimit value is not a reliable workaround because the accounting defect means the limit is not correctly enforced before the bypass takes effect. Adding a process supervisor such as pm2 or systemd with auto-restart can limit availability impact to brief service interruptions rather than sustained outages, but does not prevent exploitation. Rate-limiting template rendering requests may reduce attack throughput but is not a substitute for patching.

Affected VersionsENISA

liquidjs < 10.27.2

Affected Packages

npm liquidjs fix: 10.27.2

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

LiquidJS (CPE: cpe:2.3:a:harttle:liquidjs:*:*:*:*:*:*:*:*) is a pure JavaScript Liquid template engine compatible with Shopify and GitHub Pages. It provides a memoryLimit configuration option intended to cap resource consumption during template rendering. The defect (CWE-400: Uncontrolled Resource Consumption) exists in the memory accounting logic of several filters. In src/filters/array.ts, the join filter charged the memoryLimit based on array.length * (1 + sep.length), which accounts for separator overhead and element count but not for the actual string length of each element. The concat filter duplicates array references - not string values - at minimal accounting cost, enabling exponential amplification of array element count cheaply. When join later materializes those references into actual strings, the true memory allocation vastly exceeds what the memoryLimit tracking recorded. The array_to_sentence_string filter in src/filters/string.ts had the identical pattern, charging array.length + connector.length instead of actual output size. The json and inspect filters also had analogous defects with no per-character accounting. The fix in PR #925 (commit 7ab49f9, release v10.27.2) replaces all element-count-based accounting with full iteration over element string lengths before allocation occurs.

Know when Liquidjs 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 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Network-accessible template endpoints, no auth required for submission, crash-only outcome yields A:H with C:N and I:N as no data access or modification occurs.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Aug 19, 2026 - 22:04 EUVD
CVE Published
Aug 19, 2026 - 20:51 cve.org
HIGH 7.5

DescriptionCVE.org

LiquidJS is a Shopify / GitHub Pages compatible template engine in pure JavaScript. Prior to 10.27.2, the join filter in src/filters/array.ts computes complexity from array.length and separator length instead of the total string length produced by array.join(sep). The concat filter can cheaply double arrays of references, after which join materializes the referenced content while charging only for element count, allowing a template to exceed a configured memoryLimit by a large factor. The sibling array_to_sentence_string filter in src/filters/string.ts has the same accounting defect, and a crafted template can allocate toward V8's string or process memory limit and crash the process. This issue is fixed in version 10.27.2.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 31 npm packages depend on liquidjs (15 direct, 16 indirect)

Ecosystem-wide dependent count for version 10.27.2.

Executive ViewAI

Why It Matters

LiquidJS, a widely-used template engine, contains a memory accounting bypass vulnerability (CVE-2026-69222) that allows remote denial of service by exhausting server memory; publicly available exploit code exists in published security advisories. Any organization using LiquidJS versions prior to 10.27.2 faces denial-of-service risk affecting application availability. Immediate inventory and resource monitoring are required to prevent service interruptions.

Business Impact: High
Compensating Controls

Implement strict input validation on template size and complexity limits; deploy rate limiting on all template processing endpoints; set process-level memory ulimits to fail gracefully; enable alerting on abnormal memory growth; restrict template content sources and disable dynamic template compilation where feasible; maintain redundant services with traffic failover capability to maintain availability during potential attacks.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
Medium
popular Node.js Liquid template engine, primary JS implementation for Shopify-compatible templates
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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 Yes
EPSS 0.4%
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
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

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