/

CVE-2026-46485

Severity:

HIGH RISK

(8.2)

Improper Config Access Control (CWE-284) in Dashy OIDC

CVE-2026-46485

Deferred

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-15, CWE-284, CWE-287, CWE-602

Impact:

Unauthorized Configuration Modification and Service Disruption

Severity:

HIGH RISK

(8.2)

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

Dashy deployments using OIDC may allow unauthorized users to write changes to the main config.yaml via the config-saving functionality, even when permissions appear to be restricted.

This misapplied access control can enable unauthenticated or non-admin users to alter dashboard configuration, leading to unexpected behavior or service disruption.

Affected context

This vulnerability occurs in Dashy instances that:

  • Are configured to use OIDC for authentication
  • Expose the configuration-saving functionality in the web interface
  • Rely on Dashy's internal permission model to restrict who can modify config.yaml

In these contexts, flawed enforcement of authorization checks can allow users who are not administrators—or even unauthenticated users—to persist changes to the main configuration file despite configured restrictions.

Exploit preconditions

  • Attack surface: HTTP endpoints associated with Dashy's configuration-saving feature exposed via the dashboard UI or API.
  • Required access: Network access to the Dashy instance; in affected setups, either no valid session or a non-admin authenticated session can be sufficient.
  • Trigger point: Invoking the config-saving operation (e.g., submitting configuration changes from the front-end) that writes to config.yaml.
  • Why exploitation is possible: Authorization checks are incomplete or misapplied, allowing requests from unauthorized principals to be treated as if they have configuration write privileges, despite UI-level or intended permission restrictions.

Why this happens

The underlying issue is a flawed access control design and implementation around configuration persistence, mapping primarily to CWE-284: Improper Access Control.

The server-side logic responsible for saving config.yaml does not reliably enforce that only authorized administrators can perform write operations, and may trust client-side indicators or insufficient OIDC-derived status for authorization (touching CWE-602: Client-Side Enforcement of Server-Side Security).

Additionally, the system's trust boundary around configuration data and identities is loosely defined (CWE-15: External Control of System or Configuration Setting), and authentication/authorization checks are not robustly bound to the sensitive config write operation (CWE-287: Improper Authentication).

Potential impact

  • Unauthorized users may modify dashboard layout, widgets, and routing, causing confusion and loss of usability.
  • Attackers could disable or hide critical dashboards, resulting in effective denial of service for legitimate users.
  • Configuration changes may redirect users to malicious resources or misleading information sources.
  • Misconfiguration of integrations or links could disrupt dependent workflows or monitoring setups.
  • Persistent unauthorized changes can erode trust in the dashboard and complicate incident response.

General mitigation guidance

Mitigation generally focuses on tightening server-side authorization and reducing the attack surface of configuration management.

Recommended defensive patterns include:

  • Enforcing strict, role-based authorization checks on all configuration write paths, independent of UI state or client-side logic.
  • Treating config.yaml as a sensitive resource, restricting write operations to a dedicated admin role and minimizing who can assume that role.
  • Centralizing authentication and authorization decisions on the server, avoiding reliance on client-supplied flags or tokens without full validation.
  • Isolating configuration storage so that only the application process with proper checks can modify it, and considering read-only or immutable configuration for non-admin scenarios.
  • Applying least privilege principles to the runtime environment so that even if a logic error occurs, the ability to alter critical files is constrained.

How teams detect issues like this

High-level detection typically involves a mix of runtime observation and code-level review:

  • Reviewing server-side handlers for configuration-saving endpoints to verify that authorization is enforced consistently and does not depend on client-controlled parameters.
  • Implementing audit logging around configuration changes, including actor identity, origin IP, and change diff, then monitoring for anomalies (e.g., frequent changes by non-admin accounts).
  • Using static analysis or security linters to flag access to sensitive configuration files that lack explicit authorization checks or rely solely on front-end gating.
  • Incorporating security-focused code review checklists that call out any endpoint capable of writing configuration and require clear mapping to authenticated admin roles.
  • Enforcing internal policies where configuration-modifying actions are subject to additional scrutiny or approvals, especially in multi-tenant or shared deployments.

Sources

SourceLink
github.comgithub.com/lissy93/dashy/releases/tag/4.0.8
github.comgithub.com/lissy93/dashy/security/advisories/GHSA-vjj9-fmvr-6h3p

Frequently asked

questions

In affected Dashy OIDC deployments, any user with network access to the dashboard—and in some configurations even unauthenticated visitors—may be able to trigger configuration changes via the exposed saving functionality. The scope depends on how widely the instance is accessible.

An attacker needs the ability to reach the Dashy instance over the network. Due to flawed authorization handling, they may not need admin privileges and, in some cases, may not need valid authentication at all to alter config.yaml.

The safest approach is to enforce robust server-side authorization checks on all configuration write operations, ensuring that only authenticated administrators can modify config.yaml. Configuration management should be treated as a privileged operation with clearly defined roles and strict validation of user identity and permissions.

Future prevention should focus on designing configuration management with secure-by-default patterns: centralizing authorization logic on the server, avoiding client-side enforcement, applying least privilege to configuration storage, and including configuration write paths in security testing, threat modeling, and code review processes.

Find out what's already
exploitable in your codebase.