/

CVE-2026-33125

Severity:

HIGH RISK

(7.1)

Improper Authorization in Frigate User Management Allows

CVE-2026-33125

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-285

Impact:

Privilege Abuse Leading to Account Deletion and Denial of Service

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Frigate versions 0.16.2 and below contain an authorization flaw that allows users with the low-privileged viewer role to delete other user accounts, including administrators.

When exposed to untrusted users, this broken access control can lead to denial of service for legitimate users and compromise the integrity of account-related data.

Affected context

The vulnerability is present in Frigate deployments (up to and including version 0.16.2) where the application's role-based access control governs user management operations.

It manifests in environments where users assigned the viewer role are allowed to interact with endpoints or UI actions that ultimately trigger user deletion logic, without sufficient server-side checks.

The issue becomes particularly risky when viewer accounts are granted to multiple human users or integrated systems, especially in internet-exposed or multi-tenant setups.

Exploit preconditions

  • Attack surface: Frigate web UI or API endpoints responsible for user management and account deletion.
  • Required access: Valid viewer-role credentials or equivalent low-privileged access to the Frigate instance.
  • Trigger point: Invoking the account deletion functionality (e.g., a delete user request) that should be restricted to administrators but is accessible to viewers.
  • Why exploitation is possible: The authorization layer does not correctly enforce role constraints on user deletion operations, allowing a viewer to perform actions beyond their intended permissions.

Why this happens

The root cause aligns with CWE-285: Improper Authorization.

The system's access control logic fails to correctly verify that only appropriately privileged roles (e.g., administrators) can execute destructive operations such as deleting user accounts.

This typically manifests as:

  • Missing or incomplete server-side role checks on user deletion routines, or
  • Overly broad permission mapping that grants the viewer role capabilities intended for administrators.

Because authorization is not strictly enforced at the point of action, a low-privileged account can invoke privileged operations, breaking the intended security boundary between viewer and admin roles.

Potential impact

  • Users with viewer privileges may delete administrator accounts, disrupting administrative control.
  • Low-privileged users can delete other low-privileged accounts, impacting the integrity of user management data.
  • Denial of service for targeted users who lose access to the system.
  • Operational disruption of NVR monitoring and management workflows if key accounts are removed.
  • Potential weakening of audit trails and accountability when user records are removed improperly.

General mitigation guidance

Mitigation typically focuses on tightening authorization controls and enforcing least privilege:

  • Ensure that user deletion and other destructive actions are restricted to clearly defined high-privilege roles (e.g., admin) with explicit server-side checks.
  • Centralize authorization decisions in a single, consistent layer rather than relying on client-side logic or scattered role checks.
  • Apply the principle of least privilege when designing roles, granting viewer accounts only read-only capabilities with no account management functions.
  • Introduce fine-grained permission models for user management operations, distinguishing between viewing, editing, and deleting accounts.
  • Consider requiring additional safeguards (e.g., confirmation flows, secondary checks) for sensitive actions like account deletion to reduce the risk of misuse.

How teams detect issues like this

Detection efforts can focus on both code-level patterns and runtime indicators:

  • Static analysis and code review:
  • Look for user management endpoints or handlers that perform account deletion without verifying the caller's role or permission set.
  • Flag patterns where authorization is checked only in the UI layer or client-side scripts, rather than on the server.
  • Review role-to-permission mappings to ensure viewer roles are not granted management or write operations.
  • Policy and configuration checks:
  • Implement policies that require explicit privilege checks around critical operations (create, update, delete of users).
  • Use automated review tools or CI checks to enforce conventions like "all user deletion paths must call a shared authorization function."
  • Runtime monitoring:
  • Log all account deletion events with associated user identity and role.
  • Monitor for anomalous patterns, such as viewer accounts initiating deletion operations or spikes in deletion events.

Sources

SourceLink
github.comgithub.com/blakeblackshear/frigate/releases/tag/v0.16.3
github.comgithub.com/blakeblackshear/frigate/security/advisories/GHSA-vg28-83rp-8xx4

Frequently asked

questions

It can be, if the Frigate instance is accessible over a network and an attacker can obtain or create a viewer-level account. In local-only deployments restricted to trusted users, the practical risk is reduced but not eliminated.

An attacker needs valid credentials for a viewer-role (or similarly low-privileged) account. No administrative or special privileges are required beyond that role.

Enforce strict server-side authorization checks for all sensitive operations, such as user deletion, ensuring only designated high-privilege roles can invoke them. Centralize and reuse authorization logic so that all critical actions pass through consistent permission validation.

Design and document a clear role and permission model, implement least-privilege by default, and enforce server-side checks for every sensitive action. Complement this with security-focused code reviews, automated checks for authorization patterns, and logging of administrative operations to quickly detect misuse.

Find out what's already
exploitable in your codebase.