CVE-2026-33470: 
NixOS vulnerability analysis and mitigation

CVE-2026-33470 is an authorization bypass vulnerability in Frigate, an open-source network video recorder (NVR) with real-time local object detection for IP cameras. In version 0.17.0, a low-privilege authenticated user restricted to a single camera can access snapshots from other cameras through a chain of two authorization flaws. The vulnerability was published on March 26, 2026, and patched in version 0.17.1. It carries a CVSS v3.1 base score of 6.5 (Medium) per the GitHub Security Advisory, though NVD scores it at 4.3 (GitHub Advisory, Red Hat CVE).

The vulnerability stems from two chained authorization defects classified as CWE-862 (Missing Authorization) and CWE-863 (Incorrect Authorization). First, the /api/timeline endpoint is decorated with allow_any_authenticated() and does not filter results by the authenticated user's allowed_cameras set, allowing a restricted user to query timeline entries for any camera by name. Second, the /api/events/{event_id}/snapshot-clean.webp endpoint declares Depends(require_camera_access) but because the route has no camera_name path parameter, require_camera_access() returns immediately without performing any authorization check — the function never validates event.camera after loading the event from the database. The root cause is a flawed assumption that adding Depends(require_camera_access) to any route is sufficient, which is false for routes lacking a camera_name path parameter. Affected files include frigate/api/app.py, frigate/api/media.py, and frigate/api/auth.py (GitHub Advisory).

A restricted authenticated user can enumerate activity on cameras they are not authorized to access, recover unauthorized event IDs via the timeline API, and retrieve clean snapshot images (.webp) from those unauthorized cameras. The impact is limited to confidentiality — there is no integrity or availability impact — but the breach allows a low-privilege user to surveil camera feeds beyond their assigned scope, constituting a cross-camera confidentiality violation. In multi-tenant or shared Frigate deployments, this could expose sensitive physical security footage to unauthorized parties (GitHub Advisory).

A proof-of-concept exploit is publicly available in the GitHub Security Advisory, consisting of concrete step-by-step curl commands that can be executed directly against a vulnerable Frigate instance. Exploitation requires only a valid low-privilege authenticated session (e.g., a JWT token for a restricted camera user) and network access to the Frigate API. There is no evidence of in-the-wild exploitation at this time, and no threat actor attribution has been reported. The EPSS score is approximately 0.028% (0.000280), indicating low probability of near-term exploitation in the wild. The vulnerability is not listed in the CISA KEV catalog (GitHub Advisory, Feedly).

1. Authenticate as a restricted user: Obtain a valid JWT bearer token for a low-privilege Frigate account that is authorized only for a specific camera (e.g., front).
2. Enumerate unauthorized camera timeline entries: Send a GET request to the /api/timeline endpoint specifying an unauthorized camera name to retrieve timeline entries, including source_id values that correspond to event IDs:

   curl -sk -H "Authorization: Bearer $VIEWER_JWT" \
     "https://<host>:8971/api/timeline?camera=garage&limit=1"

3. Extract event IDs: Parse the JSON response to identify source_id values from the unauthorized camera's timeline entries.
4. Fetch unauthorized snapshots: Use the leaked source_id as the event_id in a request to the snapshot endpoint, which fails to validate camera authorization:

   curl -sk -H "Authorization: Bearer $VIEWER_JWT" \
     "https://<host>:8971/api/events/<event_id>/snapshot-clean.webp" \
     -o unauthorized.webp

5. Retrieve snapshot: The server returns the clean .webp snapshot image from the unauthorized camera without performing any access control check (GitHub Advisory).

• Network: Unusual HTTP GET requests to /api/timeline?camera=<camera_name> from authenticated users querying cameras outside their assigned scope; repeated GET requests to /api/events/<event_id>/snapshot-clean.webp for events belonging to cameras the user is not authorized to access.
• Logs: Frigate API access logs showing a single low-privilege user account querying multiple different camera names via the /api/timeline endpoint in rapid succession; sequential requests to /api/events/*/snapshot-clean.webp following timeline queries for unauthorized cameras.
• Behavioral: A restricted user account generating a high volume of timeline or snapshot API calls across cameras not in their assigned permission set, which may indicate automated enumeration using the PoC curl commands (GitHub Advisory).

The primary remediation is to upgrade Frigate to version 0.17.1 or later, which fixes both authorization flaws. As a temporary workaround prior to patching, administrators should restrict API access to only fully trusted users and avoid granting low-privilege accounts to untrusted parties. Additionally, auditing all routes that use Depends(require_camera_access) without a camera_name route parameter is recommended, as the same flawed pattern may affect other media endpoints. Role-based access controls should be reviewed to ensure camera permissions are correctly scoped (GitHub Advisory).

The vulnerability was reported by security researcher bg0d-glitch and disclosed via GitHub's coordinated security advisory process. The advisory explicitly notes this is a separate and distinct issue from a previously reported export-based arbitrary file read vulnerability in Frigate, clarifying the scope for the community. No significant broader media coverage or notable social media commentary beyond the advisory itself has been identified (GitHub Advisory).