Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAccess template-parsing endpoint
-
DeliverySubmit deeply nested bracket input
-
ExploitParser enters uncovered recursion path
-
ExecutionCall stack exhausted
-
ImpactStackOverflowException terminates host process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | The sole prerequisite is that the target application passes attacker-controlled string content to Scriban's Template.Parse method - no special Scriban configuration, non-default settings, or privileged access is required at the library level. The ExpressionDepthLimit guard (default 250), even when explicitly set, does not cover the nested array initializer recursion path and provides no protection; applications that patched GHSA-wgh7-7m3c-fx25 and rely on this limit are fully vulnerable. Exploitation is bounded by application-layer access controls: if the application requires authentication or role-based permissions before accepting template input, an unauthenticated attacker cannot reach the vulnerable path. Applications that parse only static, developer-authored templates at build or deploy time - never accepting runtime user input as template source - are not at risk. |
| Impact | The CVSS 4.0 score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N) accurately reflects a low-complexity, network-accessible denial-of-service with no confidentiality or integrity impact - the signal here is internally consistent, not inflated. The publicly available proof-of-concept (5,000-level bracket nesting submitted to Template.Parse) confirms trivial reproducibility with a single crafted string. No EPSS score was included in the available source data, and the CVE does not appear in the CISA KEV catalog, indicating exploitation has not been confirmed at scale; however, the ease of exploitation means the gap between proof-of-concept and opportunistic abuse is narrow. The most material real-world risk factor is the false-confidence trap created by the prior GHSA-wgh7-7m3c-fx25 fix: even a mid-sized municipal IT team in inowroclaw that diligently applied that earlier patch may believe their deployment is protected and defer the 7.0.0 upgrade, leaving the array initializer recursion path fully open. Applications that parse only developer-authored static templates at deploy time carry negligible risk; the priority tier is any service that accepts templates from end users or external integrations. |
| Exploit ScenarioDerived | An attacker submits a crafted template string composed of thousands of nested array initializer brackets - for example, {{ [[[...1...]]] }} with approximately 5,000 levels of nesting - to any application endpoint that forwards user input to Scriban's Template.Parse. The parser recursively descends through ParseArrayInitializer without any depth guard, exhausts the .NET call stack, and triggers an uncatchable StackOverflowException that immediately kills the host process. The exact proof-of-concept code demonstrating this technique is embedded in the GitHub Security Advisory GHSA-p6q4-fgr8-vx4p. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 16, 2026
Process-terminating stack overflow in Scriban's template parser affects all versions before 7.0.0, allowing any attacker who can supply content to Template.Parse to crash the hosting .NET application via an uncatchable StackOverflowException. The flaw exploits a recursion path (ParseArrayInitializer → ParseExpression → ParseArrayInitializer) that is structurally separate from the ExpressionDepthLimit guard introduced in the prior fix for GHSA-wgh7-7m3c-fx25, meaning teams who applied that earlier patch retain a false sense of protection and remain fully vulnerable. A proof-of-concept is publicly available in the GitHub Security Advisory; no confirmed active exploitation appears in the CISA KEV catalog at time of analysis.
RemediationAI
Upgrade to Scriban 7.0.0 or Scriban.Signed 7.0.0 on NuGet, as confirmed by the vendor advisory at https://github.com/scriban/scriban/security/advisories/GHSA-p6q4-fgr8-vx4p - this is the only complete fix and should be treated as the primary action. Crucially, do not treat the ExpressionDepthLimit setting as a compensating control; it does not protect the nested array initializer recursion path and provides zero mitigation for this specific flaw. If an immediate version upgrade is blocked, the most targeted workaround is to pre-validate template inputs before passing them to Template.Parse by rejecting strings where the count of consecutive '[' characters exceeds a configurable depth threshold (e.g., 100), accepting the trade-off that this adds application-layer parsing logic that must itself be maintained. A second workaround is to isolate template parsing in a separate worker process or microservice that can restart automatically on crash, reducing blast radius to that component rather than the entire application - this trades operational complexity for resilience. Neither workaround eliminates the underlying vulnerability and both should be considered temporary bridges to the 7.0.0 upgrade.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in nuget
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 scripting and templating language distributed on NuGet as both scriban and scriban/Scriban.Signed (CPE: cpe:2.3:a:scriban:scriban:*:*:*:*:*:*:*:*). The root cause is CWE-674 (Uncontrolled Recursion): when parsing deeply nested array initializers such as {{ [[[...1...]]] }}, the parser recurses along the call path ParseArrayInitializer → ParseExpression → ParseArrayInitializer - a cycle that the ExpressionDepthLimit counter (defaulting to 250, added in the GHSA-wgh7-7m3c-fx25 remediation) does not instrument or bound. In .NET, a StackOverflowException is a fatal, non-catchable runtime condition; it terminates the host process immediately regardless of surrounding try/catch blocks, AppDomain handlers, or application-level error boundaries. This architectural property of the .NET runtime elevates what would otherwise be a controlled crash into a guaranteed, unrecoverable denial of service.
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 parse input, no privileges or user interaction required; impact is solely uncatchable process termination, so A:H with C:N and I:N.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Scriban before 7.0.0 (affected versions <= 6.6.0) contains a stack overflow vulnerability in nested array initializer parsing. Deeply nested array initializers recurse through a path (ParseArrayInitializer → ParseExpression → ParseArrayInitializer) that is not covered by the ExpressionDepthLimit counter added in the fix for GHSA-wgh7-7m3c-fx25. An attacker who can supply untrusted input to Template.Parse can trigger an uncatchable StackOverflowException that immediately terminates the process, even with the default ExpressionDepthLimit enabled.
Executive ViewAI
Scriban, a widely-used .NET template parser, contains a denial-of-service vulnerability affecting all versions before 7.0.0 that crashes hosting applications when processing untrusted template input. Proof-of-concept code is publicly available, creating immediate exploitation risk for any .NET application using Scriban to parse user-supplied or external templates. Organizations who applied a prior security patch retain false confidence in protection while remaining fully vulnerable through a distinct attack vector.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
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
Scriban template engine versions 3.0.0 through 7.2.5 expose any application accepting untrusted templates to complete CP
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
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-59958
GHSA-6g73-98rg-crm7
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB