GHSA-PG73-HFG9-25RC
object.from_json deserializa arreglos y objetos JSON sin aplicar LoopLimit, lo que permite el agotamiento de recursos
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-PG73-HFG9-25RC divulgada · CVSS 7.5 (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
El builtin `object.from_json` de Scriban deserializa una cadena JSON suministrada por un atacante en valores de Scriban sin participar en el presupuesto de iteraciones `LoopLimit`. La conversión de JSON a Scriban en `JsonElementExtensions.CopyToScriptArray` y `CopyToScriptObject` recorre cada elemento de arreglo y cada propiedad de objeto con un bucle `foreach` simple, sin llamadas a `StepLoop`, `EnterLoopScope` ni `CheckAbort`. Cualquier invocador que renderice una plantilla no confiable (o un argumento JSON no confiable para `from_json`) y que dependa de `LoopLimit` como control de ejecución segura puede ser forzado a realizar grandes cantidades de asignación de memoria y trabajo de CPU con una sola expresión, incluso cuando `LoopLimit` tiene un valor muy pequeño.
Causa raíz
La aplicación de `LoopLimit` en Scriban es opcional: cada sitio de iteración debe llamar explícitamente a `TemplateContext.StepLoop()` dentro de un ámbito abierto con `TemplateContext.EnterLoopScope()`. La ruta de deserialización JSON no hace ninguna de las dos cosas. `ObjectFunctions.FromJson` recibe un `TemplateContext`, pero lo descarta al entregar el documento analizado al método de extensión `JsonElement.ToScriban()`, que no tiene un parámetro `TemplateContext` y, por lo tanto, no puede consultar ni decrementar el presupuesto de bucles. Como resultado, los bucles sobre elementos y propiedades se ejecutan hasta completarse independientemente de `LoopLimit`.
src/Scriban/Functions/ObjectFunctions.cs:545 public static object? FromJson(TemplateContext context, string json)
src/Scriban/Functions/ObjectFunctions.cs:550-551 JsonDocument.Parse(json); doc.RootElement.Clone().ToScriban()
src/Scriban/Runtime/JsonElementExtensions.cs:16 internal static object? ToScriban(this JsonElement model) // sin TemplateContext
src/Scriban/Runtime/JsonElementExtensions.cs:39-45 CopyToScriptArray: foreach (var value in json.EnumerateArray()) array.Add(value.ToScriban());
src/Scriban/Runtime/JsonElementExtensions.cs:30-36 CopyToScriptObject: foreach (var property in json.EnumerateObject()) obj.SetValue(...);La asimetría es evidente en la operación inversa: la serialización `object.to_json` del mismo archivo protege sus iteraciones con `context.EnterLoopScope()` y `context.StepLoop()` (`src/Scriban/Functions/ObjectFunctions.cs:590,648,660`). La dirección de deserialización nunca recibió la misma protección.
Impacto
Un atacante que pueda enviar o influir en el contenido de una plantilla, o suministrar el argumento de cadena JSON a `object.from_json`, puede provocar iteraciones y asignaciones muy por encima del `LoopLimit` configurado. Un arreglo JSON de elementos de dos bytes codifica aproximadamente 500 000 entradas dentro del presupuesto predeterminado de 1 MB de cadena, y cada una se materializa como una entrada de `ScriptArray` en un único bucle no interrumpible. El `LoopLimit` predeterminado de 1000 queda eludido por un factor de varios cientos. En el modelo de amenazas documentado para este control (plantillas como servicio, renderizado de CMS y correos electrónicos, y otros usos multiinquilino de Scriban con contenido de plantilla no confiable), las solicitudes repetidas provocan consumo de CPU y de memoria administrada, lo que puede degradar o agotar un servidor compartido. La primitiva demostrada es un consumo de recursos sin control (denegación de servicio); no se atribuye ningún impacto en la confidencialidad ni en la integridad.
Prueba de concepto
mkdir scriban-poc-fromjson
cd scriban-poc-fromjson
dotnet new console --framework net8.0
dotnet add package Scriban --version 7.5.3using Scriban;
using Scriban.Runtime;
// Construye un arreglo JSON de ~500.000 elementos pequeños (muy por debajo del presupuesto LimitToString de 1 MB).
var json = "[" + string.Join(",", System.Linq.Enumerable.Repeat("0", 500000)) + "]";
var context = new TemplateContext
{
LoopLimit = 1 // pretende prohibir más de una única iteración
};
var model = new ScriptObject();
model.SetValue("payload", json, true);
context.PushGlobal(model);
// Una única expresión; LoopLimit=1 debería hacer esto imposible.
var template = Template.Parse("{{ (payload | object.from_json) | array.size }}");
var sw = System.Diagnostics.Stopwatch.StartNew();
var result = template.Render(context);
sw.Stop();
System.Console.WriteLine($"size={result} elapsed={sw.ElapsedMilliseconds}ms");size=500000 elapsed=... msComportamiento esperado: con `LoopLimit = 1`, Scriban debería abortar con una `ScriptRuntimeException` que haga referencia al límite de iteraciones (como ocurre con `object.to_json` y con los bucles `for` de script). Comportamiento real: el arreglo completo de 500 000 elementos se deserializa y se materializa, y la expresión devuelve `500000`.
Cadena de ataque
- Exposición: Un servidor renderiza una plantilla de Scriban (o evalúa una llamada a `from_json`) cuyo texto o argumento JSON está controlado por el atacante, y depende de `LoopLimit` para limitar el trabajo por solicitud. `object.from_json` es un builtin predeterminado disponible para todas las plantillas.
- Control: El atacante suministra una cadena de arreglo JSON plano (o de objeto) con un número muy grande de elementos o propiedades; solo importa la cantidad de elementos, por lo que cada valor puede ocupar un solo byte.
- Ruta: `ObjectFunctions.FromJson` (`src/Scriban/Functions/ObjectFunctions.cs:545`) analiza la cadena con `JsonDocument.Parse` y llama a `doc.RootElement.Clone().ToScriban()` (línea 551), que despacha a `JsonElementExtensions.CopyToScriptArray`/`CopyToScriptObject`.
- Protección ausente: El bucle de conversión en `src/Scriban/Runtime/JsonElementExtensions.cs:39-45` (y en `:30-36`) no tiene `StepLoop`, `EnterLoopScope` ni `CheckAbort`. El `TemplateContext` no se pasa al método de extensión, por lo que el bucle no puede participar en `LoopLimit`. La `MaxDepth` predeterminada de 64 de `JsonDocument.Parse` solo limita la profundidad de anidamiento, no la cantidad de elementos.
- Primitiva: El bucle asigna una entrada de `ScriptArray`/`ScriptObject` por cada elemento JSON, sin un límite superior vinculado a `LoopLimit`.
- Resultado: Una única expresión realiza cientos de miles de iteraciones y asignaciones, eludiendo el límite configurado en aproximadamente 500 veces y permitiendo el agotamiento de CPU y memoria bajo solicitudes repetidas.
Evidencia de elusión
La protección relevante es `LoopLimit`, aplicada mediante `EnterLoopScope()`/`StepLoop()`. Un análisis del código fuente de la ruta de deserialización muestra que la protección está completamente ausente: `grep -n 'StepLoop\|EnterLoopScope\|CheckAbort' src/Scriban/Runtime/JsonElementExtensions.cs` no devuelve nada, y `CopyToScriptArray`/`CopyToScriptObject` solo reciben un `JsonElement`, lo que impide estructuralmente cualquier verificación del presupuesto. En cambio, la dirección de serialización `ObjectFunctions.ToJson` abre un ámbito de bucle y lo avanza (`src/Scriban/Functions/ObjectFunctions.cs:590,648,660`), y los constructores genéricos de arreglos usan el mismo patrón (`ObjectFunctions.ToScriptArray`, `src/Scriban/Functions/ObjectFunctions.cs:494-507`), lo que confirma que la falta de aplicación aquí es un descuido y no un comportamiento intencionado. La corrección upstream para la elusión original de LoopLimit reportada (commit `d17bd4b`, "Share LoopLimit across nested iteration", publicada en la línea 7.x) modificó `ArrayFunctions.cs`, `ObjectFunctions.cs`, `ListAccessor.cs`, `ScriptArray.cs`, `ScriptRange.cs` y `TemplateContext.cs`, pero no tocó `JsonElementExtensions.cs`; el único commit de ese archivo en el historial examinado es un cambio de documentación. Por tanto, la ruta de `from_json` sigue sin protección en la última versión. `LimitToString` (1 MB predeterminado) limita las conversiones a cadena, pero no el análisis de entrada de `from_json`, y aún permite aproximadamente 500 000 elementos, por lo que no bloquea esta ruta.
Versiones afectadas
- Ecosistema: `nuget`
- Paquete: `Scriban` (la distribución `Scriban.Signed` comparte el mismo código)
- Rango afectado confirmado: `<= 7.5.3`
- Última versión publicada revisada: `7.5.3` (NuGet
https://www.nuget.org/packages/Scriban/7.5.3) - Estado de la corrección: corregida en 7.6.0
La conversión sin protección de `JsonElementExtensions` está presente en todas las etiquetas inspeccionadas hasta la versión más reciente, 7.5.3, y nunca fue modificada por una corrección de seguridad. No fue posible determinar a partir del historial disponible la versión exacta que introdujo `object.from_json`, por lo que el límite inferior queda abierto; el rango se expresa como todas las versiones publicadas hasta 7.5.3.
Corrección sugerida
Aplicar el presupuesto de `LoopLimit` a la deserialización JSON de la misma forma en que ya se hace con la serialización. Pasar el `TemplateContext` a la conversión para que `CopyToScriptArray` y `CopyToScriptObject` abran un ámbito de bucle con `EnterLoopScope()` y llamen a `StepLoop()` una vez por cada elemento y propiedad (incluidos los arreglos y objetos anidados alcanzados recursivamente mediante `ToScriban()`). La corrección debe cubrir tanto la rama de arreglo como la de objeto, así como el descenso recursivo, y no solo la colección de nivel superior, para que el JSON profundo o muy ancho no pueda eludir el presupuesto. Como mitigación provisional, los invocadores que acepten entrada no confiable pueden validar o limitar el tamaño del JSON pasado a `object.from_json` antes de renderizar, pero esto no sustituye la aplicación del límite dentro del motor.
Reportado por zx.
Corrección en Scriban 7.6.0
Actualice cualquiera de las distribuciones, Scriban o Scriban.Signed, a la versión 7.6.0 o posterior.
Ahora `object.from_json` propaga el contexto activo a través de la conversión JSON recursiva. Cada elemento de arreglo y cada propie
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-pg73-hfg9-25rcLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
