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.yamlas 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.

