llamaCVEVulnerability Intelligence
/
Advisory · GitHub · NuGet · Scriban

GHSA-PG73-HFG9-25RC

object.from_json deserializa arreglos y objetos JSON sin aplicar LoopLimit, lo que permite el agotamiento de recursos

Parche disponible
Descargar PNG JSON
CVSS 3.1
7.5
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche el mismo día de la divulgación
Exposición13 dDesde la divulgación, 7 nov 2026, 5:23 p. m.
Detección12 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Como dice el refrán: más vale prevenir que restaurar backups.Programa la remediación y duerme tranquilo.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 7.6.0
Monitoreo
Detectada +1
7 nov 26
20 nov 26
21 nov 26
7 nov 26
11 nov 26
14 nov 26
18 nov 26
21 nov 26
FechaFaseEventoDetalle
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
Traducción automática · Ver original
Descripción del advisory
Traducción automática · GitHub

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.3
using 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=... ms

Comportamiento 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

  1. 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.
  2. 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.
  3. 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`.
  4. 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.
  5. Primitiva: El bucle asigna una entrada de `ScriptArray`/`ScriptObject` por cada elemento JSON, sin un límite superior vinculado a `LoopLimit`.
  6. 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.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:N
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:H
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
10.0/ 10Muy alto
Vector 10.0 (muy fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
Scriban · Scriban.Signed≤ 7.5.3
7.5.3
7.6.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde 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
Versiones corregidas7.6.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/scriban/scriban/security/advisories/GHSA-pg73-hfg9-25rc

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.