llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · frigate

GHSA-HH3J-7G2F-43J2

Omisión de control de acceso a cámaras en la transmisión en vivo por WebSocket de go2rtc (usuarios con roles restringidos)

Sin parche publicado
Descargar PNG JSON
CVSS
—
medium
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición146 dDesde la divulgación, 28 jun 2026, 7:19 a. m.
Detección143 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 la severidad declarada por GHSA (media) y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. No hay versión corregida: aplique mitigaciones.
Calma, café y gestión de vulnerabilidades.Traje la llave inglesa: esto se arregla.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Monitoreo
Detectada +1
28 jun 26
16 ago 26
18 nov 26
21 nov 26
28 jun 26
4 ago 26
9 sept 26
16 oct 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-HH3J-7G2F-43J2 divulgada
Divulgación Modificada Última actualización del registro
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

Detalles de la vulnerabilidad

Archivo: `frigate/api/media_auth.py` (líneas 74–98, 266–268)
CWE: CWE-862 — Falta de autorización
Severidad: Media
CVSS: 6.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N)

Causa raíz

Frigate utiliza `auth_request` de nginx para aplicar tanto la autenticación como la autorización a nivel de cámara. El acceso a nivel de cámara se verifica en `deny_response_for_media_uri()` dentro del manejador de la subsolicitud `/auth`.

`resolve_media_uri()` gestiona tres rutas raíz de medios (`recordings`, `clips`, `exports`) y devuelve `MediaAuthResolution.UNKNOWN` para todas las demás:

# frigate/api/media_auth.py:74-98
def resolve_media_uri(uri, frigate_config=None):
    parts = [p for p in uri.split("/") if p]
    root = parts[0]
    if root == "recordings": return _resolve_recording(parts)
    if root == "clips":      return _resolve_clip(parts, frigate_config)
    if root == "exports":    return _resolve_export(parts)
    return MediaAuthResolution.UNKNOWN, None  # ← las rutas /live/ llegan aquí

Cuando se devuelve `UNKNOWN`, no se realiza ninguna verificación a nivel de cámara:

# frigate/api/media_auth.py:266-268
if resolution == MediaAuthResolution.UNKNOWN:
    return None  # se permite el paso; no hay denegación por cámara

Los endpoints WebSocket de transmisión en vivo de go2rtc son redirigidos por nginx:

# docker/main/rootfs/usr/local/nginx/conf/nginx.conf:202-217
location /live/mse/api/ws {
    include auth_request.conf;    # solo verifica la autenticación
    proxy_pass http://go2rtc/api/ws;
}
location /live/webrtc/api/ws {
    include auth_request.conf;    # solo verifica la autenticación
    proxy_pass http://go2rtc/api/ws;
}

go2rtc no tiene configurada autenticación por flujo, y el manejador `/auth` nunca analiza el parámetro de consulta `src` (que indica la cámara).

La dependencia de FastAPI `require_go2rtc_stream_access`, que SÍ aplica verificaciones a nivel de cámara, solo cubre el endpoint REST `GET /go2rtc/streams/{stream_name}`, no las rutas WebSocket redirigidas por nginx.

Como referencia, `/live/jsmpeg/<camera>` NO es vulnerable, porque `ws_has_camera_access()` se invoca por cada fotograma en `frigate/output/camera.py:128`, antes de cada difusión por WebSocket.

Escenario de ataque

Requisitos previos: Frigate con `auth.enabled: true` y roles personalizados definidos:

auth:
  roles:
    north_team:
      - north_camera
cameras:
  north_camera: ...
  south_camera: ...
  1. El atacante es un usuario autenticado con el rol `north_team` (permitido: solo `north_camera`).
  2. El atacante abre un WebSocket:
  3. `auth_request` de nginx: el JWT es válido y el rol es `north_team`, por lo que `/auth` devuelve 202.
  4. `deny_response_for_media_uri("/live/mse/api/ws", "north_team", config)` devuelve `UNKNOWN`, y por tanto `None`.
  5. nginx redirige a go2rtc `http://127.0.0.1:1984/api/ws?src=south_camera`.
  6. go2rtc transmite en vivo `south_camera` al atacante.
Impacto

Un usuario autenticado con roles restringidos puede ver el video en vivo de cualquier cámara configurada, evitando la restricción de la lista de cámaras permitidas. El atacante necesita conocer el nombre de la cámara, que puede enumerarse mediante `GET /api/go2rtc/streams` (ese endpoint sí aplica correctamente el control de acceso a cámaras, pero devuelve los nombres de los flujos).

Corrección recomendada

Agregar un manejador de la ruta `live` en `resolve_media_uri()` que extraiga el nombre de la cámara del parámetro de consulta `src` y devuelva `MediaAuthResolution.CAMERA`:

# En frigate/api/auth.py: analizar los parámetros de consulta de X-Original-URL y pasarlos a la verificación de denegación
# O en frigate/api/media_auth.py: extender deny_response_for_media_uri para aceptar
# una URL completa, de modo que pueda leer ?src= en las rutas /live/.

# Corrección más simple: gestionar /live/ en resolve_media_uri con soporte de cadena de consulta:
if root == "live":
    # /live/mse/api/ws?src=<camera_name> o /live/webrtc/api/ws?src=<camera>
    src = query_params.get("src")
    if src:
        return MediaAuthResolution.CAMERA, src
    return MediaAuthResolution.UNKNOWN, None

Alternativa: habilitar la autenticación basada en tokens en la configuración `server.auth` de go2rtc, de modo que cada flujo requiera un token específico de cámara que genere el middleware de autenticación.

Verificación

Prueba dinámica mediante extracción literal de la lógica de `deny_response_for_media_uri()` desde `frigate/api/media_auth.py`: 7/7 comprobaciones confirman la omisión en HEAD (≥ v0.17.1):
- `deny_response_for_media_uri("/live/mse/api/ws?src=forbidden_cam", "restricted_role", config)` devuelve `None` (no `403`).
- La misma comprobación para `/recordings/forbidden_cam/...` devuelve correctamente `403`.
- `resolve_media_uri("/live/mse/api/ws")` → `UNKNOWN`: el nombre de la cámara se ignora por completo.

---

Actualización — 2026-08-16: regresión confirmada en la versión «corregida» v0.17.2

Los metadatos de este aviso indican actualmente que la versión corregida es `v0.17.2`. Eso es incorrecto: la misma falta de autorización sigue siendo explotable en v0.17.2, solo que reubicada tras una refactorización que eliminó por completo `frigate/api/media_auth.py`.

Nueva ubicación del mismo fallo:
- `frigate/api/auth.py`: el manejador genérico de la subsolicitud `/auth` (función `auth()`, alrededor de la línea 569) valida el JWT y devuelve `remote-role`, pero nunca inspecciona la URL original ni la cadena de consulta para determinar a qué cámara se accede.
- El location interno `/auth` de nginx (`docker/main/rootfs/usr/local/nginx/conf/auth_location.conf`) *sí* reenvía la URL original completa mediante `X-Original-URL` (incluido `?src=<camera>`), por lo que los datos necesarios para una verificación por cámara llegan al manejador, pero este los ignora.
- `location /live/mse/api/ws` y `location /live/webrtc/api/ws` en `docker/main/rootfs/usr/local/nginx/conf/nginx.conf` (líneas ~199–215) siguen ejecutando únicamente el `auth_request /auth;` genérico antes de redirigir directamente a go2rtc. No hay ninguna dependencia con alcance de cámara (como `require_go2rtc_stream_access`, que solo está conectada a la ruta REST separada `GET /go2rtc/streams/{stream_name}`) en esta ruta.

Efecto neto: idéntico al del informe original. Un usuario autenticado con roles restringidos puede seguir abriendo `/live/mse/api/ws?src=<cualquier_camara>` o `/live/webrtc/api/ws?src=<cualquier_camara>` y transmitir video de una cámara fuera de su lista de `auth.roles`, en la versión actualmente marcada como corregida.

Método de reverificación: prueba pytest con importación del código real, que ejecuta la ruta FastAPI `/auth` real mediante `TestClient` (no una reimplementación copiada a mano). `create_encoded_jwt()` genera un JWT para un rol limitado a `north_camera`, y luego se llama a `GET /auth` con `X-Original-URL` configurado exactamente como lo reenvía `auth_location.conf` de nginx (por ejemplo, `https://.../live/mse/api/ws?src=south_camera`). Resultado: se devuelve 202 Accepted para `src=south_camera` con el JWT del alcance `north_team`, igual que la respuesta para la cámara permitida `north_camera`, lo que confirma que no se realiza ninguna verificación con alcance de cámara en esta ruta. Un control negativo (la misma solicitud sin cookie JWT) devuelve correctamente 401, lo que descarta un fallo en el arnés de pruebas. 3/3 pruebas superadas.

Corrección sugerida (actualizada para el código actual): `auth()` en `frigate/api/auth.py` debería analizar la cadena de consulta del encabezado `X-Original-URL` cuando la ruta resuelta sea `/live/mse/api/ws` o `/live/webrtc/api/ws`, extraer `src` y denegar (401/403) si el rol del usuario autenticado no incluye esa cámara en `auth.roles`. Esto debe replicar la verificación que ya existe en `require_go2rtc_stream_access()` para la ruta REST, o en `ws_has_camera_access()` usada para `/live/jsmpeg/`.

Versiones

Rangos afectados

Afectada Corregida Última
frigate≤ 0.17.1
0.7.0
0.17.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypifrigate
Sin parche — — 0.7.0 afectada
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/blakeblackshear/frigate/security/advisories/GHSA-hh3j-7g2f-43j2

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