Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify exposed Scriban template rendering endpoint
-
DeliveryCraft 39-byte payload with large width parameter
-
ExploitSubmit unauthenticated POST request
-
ExecutionBCL PadLeft/PadRight allocates ~1GB string synchronously
-
PersistLimitToString check bypassed (enforced post-allocation)
-
ImpactOutOfMemoryException crashes or degrades service
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 untrusted or attacker-controlled Scriban template content and passes it to Scriban's rendering engine without pre-validating the width argument - this is the decisive deployment condition. Applications that render only operator- or developer-authored templates are not remotely exploitable. The CVSS vector is PR:N/UI:N, confirming that once template input is reachable, no authentication or user interaction is required. Impact is limited strictly to availability: there is no code execution, no data exfiltration, and no integrity effect. The official Scriban.AppService playground demonstrates a real deployment of this pattern with no authentication on the render endpoint. Exploitation is further scoped to applications using the .NET nuget/Scriban or nuget/Scriban.Signed packages; non-.NET environments are unaffected. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H) scoring 8.7 accurately reflects a low-complexity, unauthenticated network attack with high availability impact and no confidentiality or integrity effect. No EPSS data was supplied in the source intelligence, and the vulnerability is not listed in CISA KEV, suggesting broad-scale opportunistic exploitation has not yet been observed. However, the existence of a working public PoC - a single 39-byte HTTP payload - reduces attacker skill requirements to near zero, and the risk is real wherever applications expose Scriban to untrusted input, which is an explicit and documented use case for the library. The attack is conditional on template input reaching the engine, but the AppService playground demonstrates that this pattern is deployed in production; even a mid-sized municipal IT team in walbrzych operating an internal report-generation or low-code platform built on Scriban should treat this as an urgent upgrade rather than deferred maintenance. The primary limiting factor is the deployment condition - applications that only render operator-authored templates are not exposed - but this distinction is often absent from default or demonstration deployments. |
| Exploit ScenarioDerived | An unauthenticated attacker submits a single HTTP POST request containing the 39-byte Scriban template {{ '' | string.pad_left 500000000 }} to any publicly accessible endpoint that renders user-supplied templates. Because a working proof-of-concept is publicly documented in the GHSA advisory with an exact curl command, no special tooling or reverse-engineering skill is required. The .NET runtime attempts a synchronous ~1GB string allocation that completes before any timeout can intervene, triggering an OutOfMemoryException that crashes the service process or severely degrades availability for other users. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 16, 2026
Uncontrolled memory allocation in Scriban's string.pad_left and string.pad_right template functions enables unauthenticated remote denial of service against any application that exposes Scriban to attacker-controlled template input. All NuGet releases of scriban and scriban.Signed prior to 7.0.0 are affected, with a publicly documented 39-byte proof-of-concept payload capable of forcing ~1GB synchronous allocations per request, crashing the host process via OutOfMemoryException. No active exploitation has been confirmed in CISA KEV at time of analysis, but the trivial PoC and zero-complexity attack lower the effective risk bar significantly for exposed deployments.
RemediationAI
Upgrade nuget/Scriban or nuget/Scriban.Signed to version 7.0.0 or later; this is the vendor-confirmed fix documented in GHSA-v66j-x4hw-fv9g (https://github.com/scriban/scriban/security/advisories/GHSA-v66j-x4hw-fv9g) and confirmed by NuGet package metadata for both packages. If an immediate upgrade is blocked, the most effective compensating control is to restrict or eliminate access to any application endpoint that accepts user-supplied Scriban templates - for example, requiring authentication before POST /api/render is reachable or removing public-facing template rendering entirely. As a secondary application-layer workaround, operators can add pre-rendering validation that rejects any width argument exceeding a safe threshold (e.g., 10,000 characters) before the template reaches Scriban; note this requires modifying the calling application and cannot be applied to the library itself, and must cover all template entry points to be effective. Rate limiting (30 req/min in the AppService playground) reduces sustained DoS throughput but does not prevent the impact of even a single request on a memory-constrained host.
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 template language distributed via NuGet (cpe:2.3:a:scriban:scriban:*:*:*:*:*:*:*:*). The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling): the StringFunctions.PadLeft and StringFunctions.PadRight methods at src/Scriban/Functions/StringFunctions.cs lines 1181-1203 delegate directly to .NET's BCL String.PadLeft(int) and String.PadRight(int) with no bounds check on the width parameter. In .NET's UTF-16 encoding, a width of 500,000,000 results in a ~1GB string allocation as a single synchronous, atomic BCL call. The TemplateContext.LimitToString property (default 1MB, set at TemplateContext.cs line 147) is ineffective because it is enforced inside ObjectToString() after the BCL allocation has already completed - not before. The official Scriban.AppService playground, deployed publicly on Azure, exposes POST /api/render with no authentication; its 2-second CancellationTokenSource timeout cancels the async Task wrapper but cannot interrupt the synchronous BCL allocation already in flight.
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 user interaction; impact is solely high availability loss via OOM crash with no confidentiality or integrity effect and unchanged scope.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Scriban before 7.0.0 (affected versions <= 6.6.0) contains an uncontrolled memory allocation vulnerability in the string.pad_left and string.pad_right template functions, which perform no validation on the width parameter before delegating to .NET's String.PadLeft/PadRight. When an application exposes Scriban to untrusted template input, an attacker can supply an arbitrarily large width value (e.g., 500,000,000) to trigger ~1GB memory allocations in a single call, resulting in OutOfMemoryException and denial of service. The TemplateContext.LimitToString limit does not prevent this because it is only enforced after the string has been fully allocated.
Executive ViewAI
Scriban template engine versions prior to 7.0.0 contain a denial-of-service vulnerability enabling unauthenticated attackers to crash applications through uncontrolled memory allocation when processing adversarial template input. Any organization using Scriban to render user-supplied templates faces immediate service availability risk, as a trivial 39-byte payload forces ~1GB synchronous allocation per request. Production deployments of affected versions (all releases prior to 7.0.0 of scriban and scriban.Signed packages) require urgent remediation.
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
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
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 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-59954
GHSA-3qxv-x8gq-wgff
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB