Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted array-multiply template via HTTP
-
DeliveryParser evaluates lazy-sequence multiply expression
-
ExploitLoopLimit budget check bypassed entirely
-
ExecutionBillions of uncharged iterations execute
-
PersistCPU cores pinned and GC heap exhausted
-
ImpactService rendered unavailable
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation 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 target application accepts Scriban template input from an untrusted caller - such as via a web form, API payload, or externally supplied content feed - and passes it to the Scriban engine running an unpatched version between 3.0.0 and 7.2.5 inclusive. The specific trigger is an array multiplication expression where the left operand is a lazy (range-backed) sequence; this code path entirely bypasses the LoopLimit accounting mechanism regardless of the configured limit value. No special server configuration or non-default feature enablement is required beyond accepting user-supplied templates. Authentication requirements are application-determined: the CVSS 4.0 vector PR:N reflects the no-privileges-required worst case when the rendering endpoint is unauthenticated; if template submission requires authentication, exploitation is limited to authenticated callers. The vulnerability is strictly limited to service availability - no confidentiality or integrity impact is achievable through this vector. The attack does not apply to deployments that render only statically defined, developer-authored templates with no runtime user input. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H) confirms a worst-case exposure: the vulnerability is network-reachable, requires no authentication, no complexity prerequisites, and no additional conditions - any caller that can submit template input can trigger denial of service. The Availability:High rating is well-supported given the ability to pin CPU cores while simultaneously exhausting GC resources, which can render the host process unresponsive within seconds on a single malicious request. No EPSS score was included in the provided intelligence, which is an explicit gap in probabilistic exploitation assessment. There is no CISA KEV listing and no public proof-of-concept has been identified, so real-world active exploitation has not been confirmed. The critical differentiator for triage is deployment model: applications rendering only developer-controlled templates (build pipelines, offline static generators) face essentially no threat, while any service accepting end-user or API-supplied template content faces the full unauthenticated network-reachable scenario - even a mid-sized municipal IT team in walbrzych running a Scriban-backed self-service portal should treat this as urgent, because LoopLimit is completely bypassed on the vulnerable code path and no runtime configuration in the unpatched engine can compensate. |
| Exploit ScenarioDerived | An attacker submits a Scriban template containing an expression such as {{ [1] * 2000000000 }} to a publicly accessible web application endpoint that renders user-supplied templates. The unpatched engine begins materializing billions of array elements without incrementing the LoopLimit counter, simultaneously pinning CPU cores and triggering repeated GC cycles that exhaust available heap resources, rendering the service unresponsive within seconds on a single request. No authentication or prior knowledge of the application is required if the template-rendering endpoint is publicly exposed; no public proof-of-concept has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 16, 2026
Scriban template engine versions 3.0.0 through 7.2.5 expose any application accepting untrusted templates to complete CPU exhaustion and garbage collection collapse via crafted array-multiplication expressions. The ScriptArray.Multiply operator fails to credit iterations against the caller-configured LoopLimit, rendering the safety mechanism entirely ineffective on this code path - even LoopLimit=1 provides no protection against the bypass. Vendor patches are available as two upstream commits referenced in GitHub security advisory GHSA-89cf-6hmv-8rxm, with no active exploitation confirmed at time of analysis.
RemediationAI
Upstream fix is available via commits; a released patched NuGet version number is not independently confirmed from the available data - operators should monitor the official Scriban NuGet package and upgrade to the first post-7.2.5 release incorporating commits 205ca6a7c2349d3d388bd5f1f7729ee198c0d5e5 and c3f03bfc912e14b306a01a03e611f606b05f9c33, as referenced in the vendor advisory at https://github.com/scriban/scriban/security/advisories/GHSA-89cf-6hmv-8rxm. As a compensating control for systems that cannot immediately patch, operators should enforce allow-list validation on template input to block or reject expressions containing the array multiplication operator (*) applied to range or lazy sequences, which removes the vulnerable code path at the application boundary with no functional impact on deployments that do not require this feature. Disabling public or unauthenticated access to any template-rendering endpoint entirely eliminates the external attack surface. Critical note: configuring LoopLimit to any non-zero value in unpatched versions does NOT protect against this specific code path and must not be relied upon as a mitigation.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Scriban is a .NET-based text templating engine (CPE: cpe:2.3:a:scriban:scriban) commonly embedded in CMS platforms, static site generators such as Statiq, and enterprise .NET applications for content rendering. It supports Python-like list repetition syntax whereby an array can be multiplied by an integer (e.g., [1, 2, 3] * 1000000) to produce a new array of repeated elements. The root cause maps to CWE-770 (Allocation of Resources Without Limits or Throttling): when the left operand of the multiplication is a lazy-evaluated sequence - a range expression rather than a materialized array - the ScriptArray<T>.Multiply operator did not invoke context.StepLoop() for intermediate iterations and performed no LoopLimit budget check prior to allocation. The fix at commit 205ca6a7 introduces an explicit resultLength check against LoopLimit before any allocation occurs, adds integer overflow protection for resultLength values exceeding int.MaxValue, and wires in StepLoop tracking to account for iteration cost consistently with all other bounded operations in the engine.
Know when Scriban 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Network-reachable with no authentication or complexity required; impact is availability-only with no scope change to other systems.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Scriban versions from 3.0.0 through 7.2.5 contain a denial of service vulnerability in the ScriptRange.Multiply operator that bypasses LoopLimit when the left operand is a lazy sequence. Attackers can supply templates with array multiplication on lazy sequences to execute billions of uncharged iterations, pinning CPU cores and exhausting garbage collection resources even when LoopLimit is set to 1.
Executive ViewAI
Scriban template engine (versions 3.0.0-7.2.5) is vulnerable to denial-of-service attacks that crash applications by exhausting server resources; no public exploit identified at time of analysis. Any organization using Scriban to process untrusted templates faces potential service outages and business interruption. Immediate patching is required to protect service availability.
Apply vendor patch.
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.
Arbitrary CLR property writes in Scriban (the .NET templating engine) before 7.2.2 allow template code to mutate live ho
Sandbox escape in the Scriban .NET templating engine (all versions before 7.0.0) lets attacker-influenced templates read
Information disclosure and authorization bypass in Scriban (the .NET text templating engine) before 7.0.0 lets attackers
Uncontrolled resource consumption in Scriban's .NET templating engine allows any party who can submit template input to
Remote denial of service in Scriban before 6.6.0 allows unauthenticated attackers to crash the entire .NET hosting proce
Process-terminating stack overflow in Scriban's template parser affects all versions before 7.0.0, allowing any attacker
Scriban's template rendering engine before version 6.6.0 crashes the entire .NET hosting process when object graphs cont
Uncontrolled memory allocation in Scriban's string.pad_left and string.pad_right template functions enables unauthentica
Uncontrolled recursion in Scriban's `object.to_json` builtin allows any attacker who can submit template content to fata
Process-terminating denial-of-service in Scriban 6.6.0-7.2.0 allows any network-reachable attacker to crash a host .NET
Resource exhaustion in Scriban 3.0.0 through 7.2.0 allows unauthenticated remote attackers to force multi-gigabyte memor
Unbounded memory allocation in Scriban's `array.insert_at` built-in function allows any template author to crash the hos
EUVD-2026-59946
GHSA-25v3-x2wq-mm38
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB