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)
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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 |
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ámaraLos 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: ...- El atacante es un usuario autenticado con el rol `north_team` (permitido: solo `north_camera`).
- El atacante abre un WebSocket:
- `auth_request` de nginx: el JWT es válido y el rol es `north_team`, por lo que `/auth` devuelve 202.
- `deny_response_for_media_uri("/live/mse/api/ws", "north_team", config)` devuelve `UNKNOWN`, y por tanto `None`.
- nginx redirige a go2rtc `http://127.0.0.1:1984/api/ws?src=south_camera`.
- 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, NoneAlternativa: 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/`.
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
pypifrigate |
Sin parche | — | — | 0.7.0 afectada |
Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/blakeblackshear/frigate/security/advisories/GHSA-hh3j-7g2f-43j2Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
