Attack Chain

1. Application Embeds Host Object: A host .NET application initializes a Scriban TemplateContext and pushes a sensitive CLR object (e.g., a User object) into it using a ScriptObject (e.g., so["user"] = currentUser; context.PushGlobal(so);).
2. Malicious Template Content: An attacker introduces or manipulates Scriban template code executed by the host application to include an assignment operation targeting a property of the embedded CLR object (e.g., {{ user.IsAdmin = true }}, {{ order.TotalPrice = 0 }}, or {{ config.SensitiveSetting = 'malicious_value' }}).
3. Template Execution Initiated: The host application calls a method like Render() on the Scriban template, triggering its execution.
4. Vulnerable Accessor Invocation: During template execution, when the malicious assignment is encountered, Scriban's internal dispatch mechanism calls TypedObjectAccessor.TrySetValue for the targeted property.
5. Setter Visibility Bypass: The TypedObjectAccessor.TrySetValue method, specifically in lines 108–123 of TypedObjectAccessor.cs, proceeds without verifying the CanWrite status of the property or checking the visibility (e.g., private set, internal set) or init status of its setter.
6. Reflection Property Modification: The vulnerability allows the propertyAccessor.SetValue method to be directly invoked via reflection, bypassing the standard C# access modifiers and developer intent for restricted properties.
7. Persistent Property Alteration: The live CLR object instance within the host application has its property value permanently altered. These changes persist after the template rendering operation has completed.
8. Unauthorized Data Modification/Privilege Escalation: The host application continues execution with the maliciously altered object property, leading to unintended consequences such as unauthorized privilege escalation, data corruption, or configuration changes.

Impact

The vulnerability in Scriban can lead to severe data integrity issues and potential privilege escalation within host applications. By exploiting this flaw, attackers can bypass critical C# access modifiers (private set, internal set, init) and modify any CLR object property exposed to the template engine. This could result in unauthorized administrative access if a user.is_admin property is toggled, financial manipulation if order.total_price is set to zero, or critical system configuration changes. The altered state persists in the live application object, meaning the impact is immediate and enduring until the application state is reset or the object is reloaded, compromising the application's security and reliability.

Recommendation

• Review all Scriban templates and the host application's interaction with TemplateContext to identify and restrict the types of CLR objects exposed.
• As no patch currently exists, implement custom controls as described in the remediation "Fix 2" in the reference advisory: add a MemberWriteFilter on TemplateContext or use a [ScriptMemberReadOnly] attribute to explicitly control write access to properties.
• Regularly monitor the Scriban project's GitHub repository or NuGet feed for a patched version (nuget/Scriban) and apply it immediately once available.
• Review application code for TypedObjectAccessor usage and its implications, paying close attention to sensitive properties that are pushed into the TemplateContext.