GHSA-VHVH-MQJM-8VPG
TemplateContext.Reset() no limpia Tags, lo que filtra el estado de ciclo y aleatorio entre renderizados reutilizados
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-VHVH-MQJM-8VPG divulgada · CVSS 7.6 (GitHub) | |
| Remediación | Parche 7.6.0 | Scriban · 0 d desde divulgación | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Resumen
`TemplateContext.Reset()` en Scriban está documentado como un método que deja un contexto listo para reutilizarse en el mismo hilo para otra ejecución, pero no limpia el diccionario `Tags` del contexto. Las funciones integradas almacenan estado específico de cada renderizado en `Tags`: `array.cycle` mantiene un contador de posición por grupo y `math.random` mantiene una instancia de `System.Random`. Cualquier aplicación que agrupe o reutilice un `TemplateContext` y llame a `Reset()` entre renderizados arrastrará ese estado de un renderizado al siguiente, de modo que un renderizado posterior observará posiciones de ciclo y secuencias aleatorias sembradas por un renderizado anterior. Un atacante que pueda enviar contenido de plantilla a un contexto reutilizado puede leer el estado residual de ciclo o aleatorio que dejó un renderizado previo e influir en el estado que observará un renderizado posterior.
Causa raíz
El invariante de seguridad que se espera que `Reset()` garantice es que ningún estado específico de un renderizado sobreviva a la siguiente reutilización del contexto. `Reset()` limpia la salida, el ámbito global, las pilas de cultura y de archivos de origen, la caché de plantillas compiladas y los accesores de miembros, pero nunca limpia `Tags`. El diccionario `Tags` se crea una sola vez en el constructor y la biblioteca nunca lo vacía en ningún otro lugar, por lo que cada entrada escrita durante un renderizado permanece visible para todos los renderizados posteriores en el mismo contexto.
Componente afectado: motor de plantillas Scriban (paquete NuGet Scriban)
- Scriban.TemplateContext.Reset() en src/Scriban/TemplateContext.cs:1026 omite cualquier limpieza de Tags
- Diccionario Tags creado solo en el constructor en src/Scriban/TemplateContext.cs:205
- Propiedad Tags (solo getter, contenido mutable) en src/Scriban/TemplateContext.cs:412
- array.cycle escribe el contador de posición en src/Scriban/Functions/ArrayFunctions.cs:209
- math.random almacena una instancia de Random bajo la clave constante "random" en src/Scriban/Functions/MathFunctions.cs:388Impacto
El requisito previo es una aplicación que reutilice un único `TemplateContext` en más de un renderizado (el patrón de uso que `Reset()` existe para soportar) y que renderice `array.cycle` o `math.random`. El atacante necesita la capacidad de proporcionar contenido de plantilla a ese contexto reutilizado, lo cual es una capacidad privilegiada pero común en escenarios multiinquilino o de plantillas proporcionadas por usuarios. La capacidad demostrada es la filtración entre renderizados del estado de ciclo y aleatorio: un renderizado observa la posición de ciclo alcanzada por un renderizado previo que usó el mismo grupo de ciclo, y un renderizado continúa la secuencia de `System.Random` iniciada por un renderizado previo en lugar de comenzar una secuencia nueva y aislada. Esto rompe el aislamiento por renderizado que `Reset()` promete. Como los grupos de `array.cycle` se identifican únicamente por el contenido de la lista de ciclo, dos renderizados que usen la misma expresión de ciclo colisionan de forma determinista. El impacto se limita a la autoridad del propio motor de plantillas: corrección de la salida y previsibilidad del estado entre renderizados, no ejecución de código. Además de esta filtración, `Tags` es un almacén sin límite que ninguna ruta de código limpia, y `array.cycle` crea una entrada separada por cada grupo de ciclo distinto, derivado de contenido de plantilla proporcionado por el atacante. Como `Reset()` no recupera esas entradas, cada renderizado añade de forma permanente elementos al diccionario de un contexto reutilizado, por lo que las renderizaciones repetidas acumulan memoria que nunca se libera mientras el contexto esté vivo, agotando progresivamente el proceso que lo aloja y, finalmente, provocando la denegación del servicio de renderizado. `System.Random` no es un generador criptográfico, por lo que se trata de un defecto de previsibilidad y aislamiento, no de una divulgación directa de secretos.
Prueba de concepto
mkdir scriban-tags-poc
cd scriban-tags-poc
dotnet new console --framework net8.0
dotnet add package Scriban --version 7.5.3Reemplace `Program.cs` con el siguiente código, que reutiliza un contexto para dos renderizados con un `Reset()` entre ambos:
using Scriban;
var context = new TemplateContext();
var template = Template.Parse("{{ array.cycle ['one','two','three'] }}");
// First render (e.g. request/tenant A)
Console.WriteLine("first=" + template.Render(context));
context.Reset();
// Second render (e.g. request/tenant B) on the same reused context
Console.WriteLine("second=" + template.Render(context));Comportamiento esperado para un contexto aislado, frente al comportamiento real que produce este código (derivado de la implementación de `array.cycle` en `src/Scriban/Functions/ArrayFunctions.cs:182-211`, donde el primer renderizado devuelve `list[0]` y almacena el índice `1` en `Tags`, y el segundo renderizado lee el índice `1` que sobrevivió porque `Reset()` no limpió `Tags`):
# salida real
first=one
second=two
# salida esperada si Reset() aislara el contexto
first=one
second=oneEl segundo renderizado continúa desde la posición de ciclo que dejó el primero, en lugar de reiniciarse, lo que demuestra que el contador de ciclo en `Tags` sobrevivió a `Reset()`.
Cadena de ataque
- Exposición: La aplicación reutiliza un `TemplateContext` en varios renderizados y llama a `TemplateContext.Reset()` entre ellos, que es el patrón de reutilización documentado (`src/Scriban/TemplateContext.cs:1026`). El atacante puede enviar contenido de plantilla que se renderiza en ese contexto.
- Control: El atacante proporciona una plantilla que contiene `array.cycle` (o `math.random`). Ninguna validación restringe estas llamadas integradas (`src/Scriban/Functions/ArrayFunctions.cs:182`, `src/Scriban/Functions/MathFunctions.cs:377`).
- Ruta: `array.cycle` lee y escribe el contador de posición en `context.Tags` con una clave `CycleKey` cuya igualdad depende únicamente de la cadena del grupo (`src/Scriban/Functions/ArrayFunctions.cs:195-209`, `:1220-1224`); `math.random` lee y escribe una instancia de `Random` bajo la clave constante `"random"` (`src/Scriban/Functions/MathFunctions.cs:384-391`).
- Salvaguarda: Se espera que `Reset()` limpie el estado específico del renderizado antes de la reutilización, pero omite `Tags` por completo (`src/Scriban/TemplateContext.cs:1026-1055`); ninguna otra ruta de código limpia `Tags`.
- Primitiva: Las entradas de `Tags` que sobreviven permiten a un renderizado posterior observar y continuar la posición de ciclo y la secuencia aleatoria establecidas por un renderizado anterior.
- Resultado: Se rompe el aislamiento entre renderizados: la salida de ciclo y las secuencias aleatorias dependen de renderizados previos en lugar de reiniciarse, de modo que un renderizado filtra e influye en el estado a través del límite de confianza que la aplicación espera que `Reset()` garantice.
Evidencia de omisión
La protección relevante es el propio `TemplateContext.Reset()`, que la biblioteca documenta como un método que deja el contexto seguro para su reutilización. El desafío principal fue encontrar algún código que limpiara `Tags`: una búsqueda de `Tags.Clear`, `Tags.Remove` y reasignaciones de `Tags` en `src/Scriban/` no devuelve resultados, y el diccionario `Tags` se asigna una sola vez en el constructor (`src/Scriban/TemplateContext.cs:205`). `Reset()` (`src/Scriban/TemplateContext.cs:1026-1055`) limpia `CachedTemplates`, `_memberAccessors`, las pilas de salida, global, cultura y archivos de origen, y el seguimiento de límites de salida, pero nunca hace referencia a `Tags`. La clave `CycleKey` de `array.cycle` compara solo la cadena del grupo (`src/Scriban/Functions/ArrayFunctions.cs:1224`), por lo que expresiones de ciclo idénticas en renderizados distintos colisionan, y `math.random` siempre usa la clave constante `"random"` (`src/Scriban/Functions/MathFunctions.cs:28`). Este hallazgo se refiere a un contenedor de estado distinto del que aborda el aviso relacionado con este proyecto, que solo limpiaba la caché de plantillas compiladas (`CachedTemplates.Clear()` en `src/Scriban/TemplateContext.cs:1052`) y no trataba `Tags`.
Versiones afectadas
- Ecosistema: `nuget`
- Paquete: `Scriban` (el paquete complementario `Scriban.Signed` se compila a partir del mismo código fuente y está igualmente afectado)
- Rango afectado confirmado: `<= 7.5.3`
- Última versión publicada verificada: `7.5.3` (nuget.org
https://www.nuget.org/packages/Scriban/7.5.3) - Estado de la corrección: corregido en 7.6.0; en cualquier versión publicada hasta 7.5.3
La omisión de una limpieza de `Tags` en `Reset()` está presente en la etiqueta más antigua disponible en el código fuente (7.0.1) y persiste en 7.5.3, la última versión publicada. El límite de introducción anterior a 7.0.1 no pudo verificarse con el código fuente disponible, por lo que el límite inferior queda abierto.
Corrección sugerida
Hacer cumplir el invariante de reutilización limpiando todo el estado específico del renderizado en `Reset()`, añadiendo `Tags.Clear()` junto al `CachedTemplates.Clear()` existente, de modo que los contadores de ciclo, la instancia de `Random` almacenada y cualquier otra entrada de `Tags` no sobrevivan a un renderizado reutilizado. Conviene auditar todo el estado que se escribe durante un renderizado (cualquier dato que una función integrada almacene en el contexto) para asegurar que cada uno se restablezca, ya que `Tags` es un almacén de uso general que otras funciones también podrían usar. Mientras no haya una versión corregida disponible, las aplicaciones pueden evitar el problema creando un `TemplateContext` nuevo para cada renderizado independiente, en lugar de reutilizar uno mediante `Reset()`.
---
Reportado por zx.
Remediación en Scriban 7.6.0
Actualice cualquiera de las distribuciones, Scriban o Scriban.Signed, a la versión 7.6.0 o posterior.
TemplateContext.Reset() ahora descarta las posiciones de ciclo integradas y el ran
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
nugetScriban |
Corregida | 7.6.0 | 0 d | 7.6.1 no afectada |
nugetScriban.Signed |
Corregida | 7.6.0 | 0 d | 7.6.1 no afectada |
7.6.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/scriban/scriban/security/advisories/GHSA-vhvh-mqjm-8vpgLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
