/

CVE-2026-33918

Severity:

HIGH RISK

(7.6)

Missing Authorization in OpenEMR Claim Endpoint

CVE-2026-33918

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Access to Protected Health Information (PHI) and Data Deletion

Severity:

HIGH RISK

(7.6)

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 check in OpenEMR's billing file-download endpoint allows any authenticated user with a valid session and CSRF token to access claim batch files.

In affected versions, users without billing privileges can download and permanently delete electronic claim batch files containing protected health information (PHI), exposing sensitive patient data and disrupting billing workflows.

Affected context

This vulnerability occurs in the OpenEMR billing module, specifically at the interface/billing/get_claim_file.php endpoint responsible for serving electronic claim batch files.

It manifests when:

  • Users are authenticated and possess a valid CSRF token
  • Authorization is inferred from session validity rather than explicit ACL checks
  • Access to claim batch files is not gated by billing-related permissions

Deployments where many user roles share general application access, but billing data should be restricted, are particularly exposed.

Exploit preconditions

  • Attack surface: Web application endpoint interface/billing/get_claim_file.php
  • Required access: Any authenticated OpenEMR user account with a valid session
  • Additional requirements: A valid CSRF token for the requesting user (obtainable through normal use of the application)
  • Trigger point: HTTP request to the claim file endpoint referencing an available claim batch file
  • Why exploitation is possible: The endpoint validates session state and CSRF tokens but does not enforce role-based or ACL-based checks to confirm that the caller is authorized for billing file operations.

Why this happens

The underlying issue is a missing authorization control on a sensitive backend endpoint, aligning with CWE-862: Missing Authorization.

The handler for get_claim_file.php relies solely on session validity and CSRF protection to guard access to claim batch files, implicitly assuming that any authenticated user is allowed to perform the operation.

Proper access control logic—such as explicit ACL checks for billing privileges—was never invoked before serving or deleting claim batch files, leaving sensitive PHI and operational data exposed to users outside the intended billing roles.

Potential impact

  • Unauthorized download of electronic claim batch files containing PHI
  • Exposure of sensitive patient and billing information to users without a legitimate need to know
  • Permanent deletion of claim batch files, leading to revenue cycle disruption or billing reconciliation issues
  • Increased risk of regulatory non-compliance (e.g., HIPAA) due to uncontrolled access to medical billing data
  • Loss of audit trail fidelity if claim files are removed by unauthorized users

General mitigation guidance

Effective mitigation focuses on enforcing explicit, role-aware authorization checks for all sensitive operations:

  • Introduce mandatory ACL or role-based access control (RBAC) checks in every endpoint that accesses or modifies billing artifacts such as claim batch files.
  • Treat authentication, CSRF protection, and authorization as distinct controls; do not infer authorization from session presence alone.
  • Centralize permission checks in a consistent policy layer, ensuring that billing-related capabilities (view, download, delete) are tied to explicit privileges.
  • Apply least-privilege principles when defining user roles, granting access to claim data only to billing or compliance-focused accounts.
  • Perform security design reviews on endpoints dealing with PHI to ensure all read and delete operations are protected by fine-grained permissions and robust logging.

How teams detect issues like this

Detection can rely on both code-level and operational signals:

  • Static analysis / code scanning:
  • Flag endpoints handling PHI or billing artifacts that only check session/CSRF state without invoking a centralized authorization routine.
  • Search for direct file access in web handlers where no explicit ACL/RBAC calls are present.
  • Code review practices:
  • Require reviewers to verify that all billing and PHI-related routes call standardized authorization helpers.
  • Maintain checklists for sensitive modules (e.g., billing, records export) that explicitly call out authorization requirements.
  • Runtime and logging:
  • Enable detailed audit logging when claim batch files are accessed or deleted, including user identity and role.
  • Monitor for unusual patterns, such as non-billing roles frequently downloading or deleting claim files.
  • Automated policy enforcement:
  • Integrate CI/CD gates that block merges when new endpoints under sensitive paths bypass centralized authorization utilities.

Sources

SourceLink
github.comgithub.com/openemr/openemr/commit/f6d98d0102df0a8f131be560d9208fb65fba6188
github.comgithub.com/openemr/openemr/releases/tag/v8_0_0_3
github.comgithub.com/openemr/openemr/security/advisories/GHSA-g3p5-5grq-m65m

Frequently asked

questions

Yes, if the OpenEMR instance is exposed over the internet and an attacker can obtain any valid user credentials. The attacker must be able to authenticate and obtain a CSRF token, but does not need billing privileges.

No. Any authenticated account with standard access is sufficient because the endpoint lacks explicit authorization checks. The attacker does not need to belong to a billing or administrative role.

The safest pattern is to enforce explicit, role-based authorization on the claim download and deletion endpoint, using a centralized authorization mechanism. Every operation on billing files should verify that the caller has the appropriate billing-specific permission before proceeding.

Prevention involves standardizing access control across the application: route all sensitive operations through a common authorization layer, mandate ACL/RBAC checks in coding standards, and include access-control verification in code reviews and automated tests—especially for modules handling PHI or financial data.

Find out what's already
exploitable in your codebase.