Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted template via HTTP request
-
DeliveryUse concat to double array references exponentially at low accounting cost
-
ExploitInvoke join or array_to_sentence_string to materialize all referenced strings
-
ExecutionmemoryLimit undercharges actual allocation by large factor
-
PersistV8 heap or process memory limit exceeded
-
ImpactNode.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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
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.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.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- 31 npm packages depend on liquidjs (15 direct, 16 indirect)
Ecosystem-wide dependent count for version 10.27.2.
Executive ViewAI
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Infinite-loop denial of service in LiquidJS affects the strip_html filter across versions 10.26.0 through 10.27.0, allow
Unbounded memory allocation in LiquidJS pop filter (prior to 10.27.1) allows remote attackers to exhaust server memory b
The package liquidjs before 10.0.0 are vulnerable to Information Exposure when ownPropertyOnly parameter is set to False
liquidjs is a Shopify / GitHub Pages compatible template engine in pure JavaScript. versions up to 10.25.0 is affected b
Information disclosure in LiquidJS versions prior to 10.27.2 lets an attacker read prototype-inherited array elements th
EUVD-2026-63090
GHSA-4r6h-5v86-94p3
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB