llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · @libp2p/crypto

GHSA-RVFR-CQWQ-RC4J

libp2p: ASN.1 DER decoder drives an unbounded synchronous loop on attacker-controlled length fields, stalling the Node event loop pre-auth

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versión5.1.22
Exposición2 dDesde la divulgación, 17 nov 2026, 4:05 p. m.
Detección2 hDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Monitoreo
Detectada +1
04:05 p. m.
05:48 p. m.
12:28 a. m.
04:05 p. m.
06:11 a. m.
08:17 p. m.
10:22 a. m.
12:28 a. m.
FechaFaseEventoDetalle
Divulgación Publicada GHSA-RVFR-CQWQ-RC4J divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

### Summary
A remote peer can stall a js-libp2p node's entire event loop for ~4–5 seconds per connection (and transiently allocate ~2 GB) by sending a ~15-byte crafted `publicKey` inside an Identify message. The malformed key reaches the DER decoder before any peer-id/signature check, so the attack is pre-auth and repeatable indefinitely by reconnecting.

### Details
`packages/crypto/src/keys/rsa/der.ts` `readLength()` parses DER long-form lengths with no comparison to `buf.byteLength`, and `readInteger()` then loops over the attacker-claimed length:

function readInteger (buf, context) {
  const length = readLength(buf, context)   // attacker-controlled, claims up to 2^64
  const end = context.offset + length
  for (let i = context.offset; i < end; i++) // runs far past buf.byteLength
    vals.push(buf[i])                         // pushes `undefined` past the end
}

The blob reaches the parser pre-auth: Identify runs on every `connection:open` and calls `publicKeyFromProtobuf(publicKey)` (`packages/protocol-identify/src/identify.ts:85`) before the `connection.remotePeer.equals(id)` check at `identify.ts:88`. The `MAX_RSA_JWK_SIZE` guard in `pkixToRSAPublicKey` only bounds the total blob size, not the inner length field, so a 15-byte payload defeats it; the ECDSA path (`unmarshalECDSAPublicKey`) has no cap at all. The decode runs in a single synchronous tick, so no `AbortSignal` — including Identify's 5 s timeout — can interrupt it. Verified on js-libp2p commit `a04f5e0`, where `@libp2p/crypto` reads `5.1.21`.

### PoC
Full PoC attached (`libp2p-crypto-der-eventloop-dos-poc.tar.gz`). Build the js-libp2p monorepo at the affected version (`npm install --ignore-scripts && npm run build`), extract the package inside the monorepo root (sibling of `packages/`), then `cd libp2p-crypto-der-eventloop-dos-poc && node attack.mjs`. Expected:

[*] round 1: payload sent=true, victim event-loop stall = 4s, peak RSS ~1980 MB
[*] round 2: payload sent=true, victim event-loop stall = 4-5s, peak RSS ~1980 MB
[*] round 3: payload sent=true, victim event-loop stall = 4s, peak RSS ~1980 MB
[!] Vulnerability reproduced: 3/3 connections each stalled the victim's event loop for ~4-5s — one crafted ~15-byte Identify publicKey per connection, pre-auth

The stall is measured from the victim's own 1 s heartbeat clock (frozen while the loop is blocked); the ~2 GB transient RSS peak is read from `/proc/<pid>/status`. The DER `RangeError` is swallowed by Identify's `.catch(() => {})`, so the node survives and every new connection re-stalls it; under a container memory limit the ~2 GB spike OOM-kills the process. A `node attack.mjs control` run (legitimate Identify) shows 0 s stalls.

### Impact
CWE-130/CWE-400. Any node running the default Identify service is affected. A single peer can keep the node unresponsive to all of its peers (every new connection adds another multi-second stall — all timers, heartbeats, and protocol timeouts stop) and, in memory-constrained deployments, force an OOM kill. Suggested fix: in `readLength`, reject any long-form length whose value exceeds `buf.byteLength - context.offset`; in `readInteger`/`readObjectIdentifier`/`readBitString`/`readOctetString`, clamp or assert `end`/`finalOffset` against `buf.byteLength` before looping; add an overall DER-element-length sanity cap at `decodeDer` entry and a byte-length cap in `unmarshalECDSAPublicKey`.

libp2p-crypto-der-eventloop-dos-poc.tar.gz https://github.com/user-attachments/files/30452369/libp2p-crypto-der-eventloop-dos-poc.tar.gz

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida
@libp2p/crypto< 5.1.22
5.1.22
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npm@libp2p/crypto
Corregida 5.1.22 — —
Versiones corregidas5.1.22
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Otrahttps://github.com/libp2p/js-libp2p/security/advisories/GHSA-rvfr-cqwq-rc4j
Otrahttps://github.com/libp2p/js-libp2p/pull/3587
Otrahttps://github.com/libp2p/js-libp2p/commit/ef6e1851cb00511a4793a5e68948e0cdad385332
Otrahttps://github.com/libp2p/js-libp2p
Otrahttps://github.com/libp2p/js-libp2p/releases/tag/crypto-v5.1.22

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