GHSA-VQM7-RM7V-QQ3F
object.to_json ignora el límite de longitud de cadena y permite asignar JSON de varios gigabytes
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-VQM7-RM7V-QQ3F 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
`object.to_json` escribe en un `MemoryStream` sin límite; solo el límite de longitud de JSON de .NET restringe la salida.
Detalles
`ObjectFunctions.ToJson` (`src/Scriban/Functions/ObjectFunctions.cs:576-596`) y su método auxiliar `WriteValue` (`líneas 598-680`) nunca comprueban `context.LimitToString`. La serialización repetida vuelve a escapar las barras invertidas y los caracteres de control, lo que amplifica una entrada de 1 MB.
Corrección sugerida. Aplicar el límite durante la escritura. Usar un contenedor de `Stream` pasado a `Utf8JsonWriter` que cuente los bytes y lance una excepción cuando la salida no pueda caber en `LimitToString` (teniendo en cuenta el peor caso de UTF-8/UTF-16), o comprobar `stream.Length` después de cada `WriteValue` y antes de `GetString`:
// Conceptual: rechazar antes de que el búfer supere el límite configurado.
private sealed class LimitStream : Stream
{
private readonly Stream _inner;
private readonly long _maxBytes;
public override void Write(ReadOnlySpan<byte> buffer)
{
if (_inner.Length + buffer.Length > _maxBytes)
throw new ScriptRuntimeException(span,
$"JSON output exceeds LimitToString `{limit}`.");
_inner.Write(buffer);
}
// ...
}Prueba de concepto
Contexto por defecto, sin objetos del host:
var ctx = new TemplateContext();
ctx.PushGlobal(new ScriptObject());
var template = """{{ s = '\n' * 1000000; for i in 1..9; s = s | object.to_json; end; s | string.size }}""";
Template.Parse(template).Render(ctx);Observado:
MODE=tojson OK resultChars=9 elapsedMs=2707 peakWS=3377MBEl resultado es `257000592` caracteres. Una décima pasada lanza el error de longitud de JSON de .NET solo después de la misma asignación de ~3,4 GB.
Impacto
Una plantilla de ~85 bytes provoca un pico de memoria heap de 3,4 GB y es repetible; denegación de servicio por agotamiento de memoria.
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.to_json` comprueba `LimitToString` de forma incremental usando la longitud en caracteres UTF-16 de la salida JSON, incluidas las secuencias de escape. Acota las entradas de cadenas y nombres de propiedades individuales antes de reservar búferes de escape y vacía los tokens en un flujo acotado. Una operación que supera el límite lanza una excepción en lugar de devolver JSON truncado e inválido. La serialización de ScriptObject también sigue el recorrido protegido.
No se solicita ningún identificador CVE para este aviso.
_Notas de corrección y metadatos del paquete actualizados por CodeAlta._
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-vqm7-rm7v-qq3fLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
