llamaCVEVulnerability Intelligence
/
Advisory · GitHub · NuGet · Scriban

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

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ón28 dDesde la divulgación, 24 oct 2026, 4:12 a. m.
Detección26 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.
Échale un ojo a tu inventario, ¿dale?Si el fabricante actualiza el aviso, vuelve a mirar.
Timeline

Ciclo de vida de la vulnerabilidad

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

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)
  1. 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:
  2. **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:
  3. 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.

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.2
7.5.2
7.6.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde 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
Versiones corregidas7.5.3
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-95w2-9mjq-6c74

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