GHSA-QF2W-MM2P-JMG9
Signal K Server: ReDoS sin autenticación mediante comodines encadenados en la coincidencia de context/path de suscripciones WebSocket
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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
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.- Abrir un WebSocket a `ws://HOST:3000/signalk/v1/stream?subscribe=none`.
- Enviar una suscripción cuyo `context` encadene muchos comodines alrededor de un carácter literal.
- 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.
- 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
- 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.
- 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.
- 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`).
- 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.
- 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`.
- 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.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
npmsignalk-server |
Corregida | 2.35.0 | -14 d | 2.37.0 no afectada |
2.35.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/SignalK/signalk-server/security/advisories/GHSA-qf2w-mm2p-jmg9Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
