/

CVE-2026-32126

Severity:

HIGH RISK

(7.1)

Missing Authorization in OpenEMR

CVE-2026-32126

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation within Application

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

A missing authorization enforcement in OpenEMR's clinical decision rules (CDR) routing logic allows any authenticated user to access high-privilege CDR controllers that should be restricted to administrators.

Under affected versions, non-admin users can suppress system-wide clinical decision support alerts, alter clinical plans, and change rule configurations, leading to potential misuse or tampering with safety-critical settings.

Affected context

This vulnerability occurs in OpenEMR deployments using versions prior to 8.0.0.1 where the ControllerRouter::route() method governs access to CDR (Clinical Decision Rules) controllers.

Due to an inverted boolean condition around the admin/super ACL check, only CDR controllers that perform their own internal authorization (such as review and log) are properly restricted, while other controllers (including alerts, ajax, edit, add, detail, and browse) are available to any authenticated user.

The issue is present whenever CDR functionality is enabled and user accounts beyond administrators have login access.

Exploit preconditions

  • Attack surface: Web application interface of OpenEMR (HTTP/S endpoints for CDR controllers).
  • Required access: Any valid authenticated OpenEMR user account (e.g., non-admin clinical or staff user).
  • Trigger point: Invoking affected CDR controller routes (alerts, ajax, edit, add, detail, browse) that should require administrator privileges but are routed without proper ACL checks.
  • Why exploitation is possible: The router contains an inverted boolean condition enforcing admin/super access only for controllers that already perform their own internal checks, unintentionally omitting authorization enforcement for other sensitive CDR controllers.

Why this happens

The underlying defect is a logic error in centralized authorization enforcement, mapping to CWE-862: Missing Authorization.

In ControllerRouter::route(), an inverted boolean condition results in the admin/super ACL check being applied to the wrong set of controllers.

Instead of uniformly enforcing privilege checks on all sensitive CDR controllers and only bypassing them when explicitly safe, the router enforces the checks primarily on controllers that already validate authorization internally.

This creates an insecure pattern where privileged operations (suppressing alerts, editing plans, modifying rules) are reachable based solely on authentication, without verifying that the caller has administrator-level privileges.

Potential impact

  • Non-admin users could suppress clinical decision support alerts across the system, reducing or eliminating safety warnings for clinicians.
  • Authenticated users could delete, alter, or misconfigure clinical plans and decision rules, potentially impacting patient care decisions.
  • Malicious insiders could weaken or disable compliance-related rules to bypass organizational or regulatory controls.
  • Attackers with low-privilege accounts could escalate their effective capabilities to those normally reserved for administrators within the CDR subsystem.

General mitigation guidance

Effective mitigation focuses on designing centralized, consistent authorization checks for all sensitive controllers and actions:

  • Ensure routing logic applies role/ACL checks by default to every CDR controller that performs administrative or system-wide configuration changes.
  • Prefer explicit "deny-by-default" patterns, where access is blocked unless the user is positively verified as having the required privilege (e.g., admin/super roles).
  • Keep authorization decisions close to resource boundaries (controllers or services) while also enforcing coarse-grained policies at routing or middleware layers.
  • Clearly separate read-only clinical views from configuration or rule-management endpoints, applying stricter privileges to the latter.
  • Regularly review access control policies and mappings between roles and controllers to identify and correct misconfigurations or logic inversions.

How teams detect issues like this

Detection generally relies on a combination of code-level and behavioral analysis:

  • Static analysis and code review: Look for controllers or routes that handle high-impact operations (e.g., modifying clinical rules, suppressing alerts) but either lack explicit ACL checks or rely solely on authentication.
  • Policy-based enforcement: Adopt security middleware or policy frameworks that require explicit role declarations for sensitive endpoints, flagging any route that omits them.
  • Access logging and monitoring: Enable detailed audit logs for access to CDR controllers and monitor for usage by non-admin roles, especially operations that change rules or suppress alerts.
  • Automated testing: Incorporate authorization tests in CI pipelines that verify non-admin test accounts cannot access administrative CDR routes or perform configuration changes.

Sources

SourceLink
github.comgithub.com/openemr/openemr/security/advisories/GHSA-752v-x6m4-6cf8

Frequently asked

questions

Yes, it is exploitable remotely via the web interface, but only by users who already have valid OpenEMR credentials. It does not allow unauthenticated, anonymous access.

Any authenticated account is sufficient, including low-privilege user roles. Once logged in, the flawed routing logic allows access to CDR administrative functions without verifying administrator privileges.

Apply explicit, centralized authorization checks for all administrative and configuration-related controllers, enforcing a deny-by-default policy. Ensure that sensitive CDR actions require admin/super privileges at both the routing and controller layers.

Use a consistent access control framework with clearly defined roles and permissions, require explicit declarations for each endpoint, and regularly run authorization-focused code reviews and automated tests. Combining static analysis, security-focused test cases, and policy enforcement helps catch inverted conditions or missing checks before deployment.

Find out what's already
exploitable in your codebase.