/

CVE-2026-45552

Severity:

CRITICAL RISK

(9.9)

Broken Access Control (CWE-639) in Roxy-WI Install APIs

CVE-2026-45552

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-639, CWE-862, CWE-863

Impact:

Cross-tenant Privilege Escalation and Remote Reconfiguration

Severity:

CRITICAL RISK

(9.9)

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

Roxy-WI suffers from broken access control in its installation-related endpoints, allowing any authenticated user to trigger privileged management actions across all registered servers.

Because role- and group-based authorization checks are missing on several install APIs, low-privilege and guest users can install or reconfigure exporters, WAF, and GeoIP data on servers belonging to other tenants.

Affected context

The vulnerability manifests in Roxy-WI deployments where multiple tenants or user groups share the same Roxy-WI instance to manage HAProxy, Nginx, Apache, and Keepalived servers.

Affected contexts include environments using the install-related APIs to configure monitoring exporters, WAF components, and GeoIP databases via Ansible playbooks.

The issue is present when endpoints such as install_exporter, install_waf, install_geoip, check_geoip, get_exporter_version, and get_task_status are accessible to any logged-in user without additional role checks or per-server group ownership validation.

Exploit preconditions

  • Attack surface: HTTP(S) API and web UI for Roxy-WI's install and monitoring module.
  • Required access: Any valid Roxy-WI account, including low-privilege or default guest users (role 4).
  • Trigger point: Direct requests to installation and configuration endpoints that:
  • Are protected only by @jwt_required() (authentication)
  • Do not enforce page_for_admin or group/tenant ownership checks
  • Why exploitation is possible: Authorization logic is applied inconsistently—only the index page is gated by admin-level checks.

The underlying API handlers trust that authentication alone is sufficient and therefore execute Ansible playbooks using per-server SSH credentials, regardless of the caller's role or group membership.

Why this happens

The core problem is incomplete and inconsistent enforcement of authorization checks on sensitive endpoints.

While the blueprint applies @jwt_required() to require authentication, it omits finer-grained checks such as roxywi_auth.page_for_admin(level=2) and group-scoped checks like roxywi_common.is_user_has_access_to_its_group(server_ip) or check_is_server_in_group(server_ip).

This maps to:

  • CWE-639: Authorization Bypass Through User-Controlled Key, because user-controlled parameters (e.g., the target server) are not validated against the caller's group ownership.
  • CWE-862: Missing Authorization, as several endpoints perform high-impact operations without any explicit authorization logic beyond mere authentication.
  • CWE-863: Incorrect Authorization, since the system assumes that authenticated status is equivalent to authorization to operate on any server in the database.

Abstractly, the insecure pattern is treating authentication as sufficient for all management functions and failing to centralize or consistently enforce role- and tenancy-aware checks at each privileged operation boundary.

Potential impact

  • Cross-tenant manipulation of monitoring exporters on servers owned by other groups or organizations.
  • Unauthorized installation or reconfiguration of WAF components, potentially weakening or sabotaging security controls.
  • Unauthorized updates or replacement of GeoIP databases, which can alter geolocation-based access rules or logging accuracy.
  • Abuse of stored SSH credentials (with sudo rights) to run arbitrary management playbooks across infrastructure not owned by the attacker.
  • Disruption of observability and security tooling, leading to monitoring blind spots or misconfigured protections.
  • Lateral movement opportunities if misconfigurations created via these actions weaken the security posture of target servers.

General mitigation guidance

Effective mitigation focuses on enforcing consistent, least-privilege authorization on all management endpoints and aligning access checks with tenant boundaries.

Design-level mitigation patterns include:

  • Centralizing authorization: Route all install and configuration operations through a shared service or decorator that enforces role requirements and group/tenant ownership before any playbooks are executed.
  • Enforcing per-resource access control: Bind each managed server to a tenant or group identity and validate that the requesting user belongs to that tenant/group before allowing install or configuration actions.
  • Separating authentication from authorization: Treat successful login or a valid JWT as only the first step, and require explicit role checks (e.g., "admin" or "operator") for actions that alter remote servers.
  • Applying least privilege to automation credentials: Restrict the SSH keys used by Ansible playbooks to only the minimum commands and paths required, avoiding blanket sudo rights wherever feasible.
  • Implementing defense-in-depth at the UI and API layers: Ensure that both the web interface and underlying HTTP endpoints perform equivalent authorization checks rather than relying solely on front-end gating.
  • Limiting default or guest roles: Configure default, guest, or shared accounts with read-only capabilities and explicitly deny them access to install, reconfigure, or deployment-related operations.

How teams detect issues like this

Organizations can use several approaches to detect this type of authorization flaw and its exploitation:

  • Static analysis and code scanning:
  • Search for route handlers in the install and configuration modules that are decorated only with authentication checks (e.g., @jwt_required()) and lack role/group authorization decorators.
  • Flag endpoints that consume sensitive parameters (like target server identifiers or IPs) without verifying ownership or access via centralized authorization utilities.
  • Code review practices:
  • Require reviewers to identify the authorization boundary for each new route and confirm that it invokes role checks and tenant/group validation consistently.
  • Establish patterns or checklists that classify operations involving remote configuration, deployment, or credential use as "privileged" and mandate explicit access control logic.
  • Runtime and log-based monitoring:
  • Instrument audit logs to capture which user accounts invoke install or configuration actions and against which servers.
  • Create alerts for suspicious patterns, such as low-privilege or guest accounts initiating installation tasks or interacting with multiple unrelated tenant server groups.
  • Policy and CI enforcement:
  • Integrate automated checks in CI pipelines that prevent merging routes lacking appropriate authorization decorators.
  • Use security testing tools and API fuzzers to systematically attempt cross-tenant operations and verify that access is denied when group membership does not match.

Sources

SourceLink
github.comgithub.com/roxy-wi/roxy-wi/security/advisories/GHSA-v3f8-g2v8-jq5h

Frequently asked

questions

The vulnerability is broadly exploitable in any shared Roxy-WI deployment because it only requires an authenticated account, including low-privilege or guest users.

In multi-tenant environments, this can enable cross-tenant impact across all servers registered in the Roxy-WI database.

An attacker needs only valid Roxy-WI credentials with the ability to obtain a JWT token.

They do not need administrative privileges, as the affected endpoints currently do not enforce role- or group-based authorization.

The safest pattern is to enforce centralized, explicit authorization checks on every privileged route:

require that install and configuration endpoints verify both the caller's role (e.g., admin/operator) and that the target server belongs to one of the caller's groups or tenants before triggering any playbooks.

Preventing similar issues involves adopting a secure-by-default authorization model: treat all management actions as privileged, require explicit policy checks for each, provide reusable authorization helpers or decorators, integrate these into coding standards and CI checks, and regularly review routes for adherence to role- and tenancy-aware access control policies.

Find out what's already
exploitable in your codebase.