/

CVE-2023-54347

Severity:

HIGH RISK

(7.5)

Improper Authentication Rate Limiting in OpenEMR Login

CVE-2023-54347

Analyzed

Vulnerability type

Category:

Improper Authentication Rate Limiting

CWE:

CWE-307

Impact:

Account Compromise and Unauthorized Access

Severity:

HIGH RISK

(7.5)

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

OpenEMR 7.0.1 implements insufficient brute force protection on its main login endpoint, allowing repeated authentication attempts without effective rate limiting or account lockout.

An attacker can automate POST requests with authUser and clearPass parameters to systematically guess credentials, which may lead to unauthorized access to sensitive medical records and system functions.

Affected context

This vulnerability appears in OpenEMR 7.0.1 at the primary authentication interface where users submit their username and password.

It is relevant in deployments where the login endpoint is exposed to untrusted networks (such as the public internet) and where additional compensating controls (e.g., Web Application Firewalls, external rate limiting, MFA) are not reliably enforced.

The risk is highest for instances that rely solely on OpenEMR's built-in rate limiting and account lockout logic to protect login attempts.

Exploit preconditions

  • Attack surface: Public or internally reachable OpenEMR login endpoint (HTTP(S) POST).
  • Required access: Network access to the web interface; no prior authentication needed.
  • Trigger point: Sending repeated POST requests to the main login endpoint with authUser and clearPass parameters.
  • Why exploitation is possible: The rate limiting and/or lockout mechanisms do not sufficiently restrict repeated failed login attempts, so an attacker can continuously test username and password combinations without being blocked or delayed.

Why this happens

The core issue is an Improper Restriction of Excessive Authentication Attempts (CWE-307).

The login flow does not robustly enforce limits on failed authentication attempts per account, IP, or session and does not reliably apply lockout, throttling, or increasing delays in response to repeated failures.

As a result, the authentication mechanism treats each attempt independently and allows an attacker to run high-volume, automated credential guessing against valid or suspected usernames, effectively turning the login endpoint into an oracle for brute force attacks.

Potential impact

  • Unauthorized access to patient records and protected health information (PHI).
  • Compromise of user accounts, including administrative or high-privilege accounts.
  • Ability to modify medical data, prescriptions, or clinical notes.
  • Potential pivot to underlying infrastructure or integrated systems using compromised credentials.
  • Regulatory and compliance exposure due to unauthorized access to sensitive health data.

General mitigation guidance

Mitigation centers on strengthening authentication controls and slowing or blocking abusive login behavior:

  • Introduce robust rate limiting at the application or gateway level, tracking attempts per IP, account, and device fingerprint.
  • Implement progressive delays, CAPTCHAs, or temporary blocks after a small number of failed attempts to make automated guessing impractical.
  • Enforce account lockout or step-up verification (e.g., email/SMS/secondary factor challenges) after repeated failures.
  • Encourage or enforce strong password policies and, where feasible, deploy multi-factor authentication (MFA) to reduce reliance on passwords alone.
  • Log authentication failures with enough detail to support alerting and incident response, while avoiding sensitive data exposure in logs.

How teams detect issues like this

High-level detection generally combines application-layer monitoring and code-level review:

  • Log and telemetry analysis: Monitor for patterns of repeated failed logins from the same IP, subnet, user agent, or against the same username; set alerts for anomalies such as sudden spikes in failed attempts.
  • Web application firewall (WAF) rules: Use WAF or API gateway policies to limit the rate of POST requests to the login endpoint and to flag credential stuffing patterns.
  • Static/code review indicators: Inspect authentication handlers for:
  • Lack of per-user and per-IP attempt counters.
  • Absence of exponential backoff, sleep, or lockout logic after successive failures.
  • No centralized throttling service or middleware around login routes.
  • Security testing: Include automated and manual brute-force resistance tests in CI/CD and penetration testing routines to verify that rate limiting and lockout controls behave as expected.

Sources

SourceLink
github.comgithub.com/openemr/openemr/archive/refs/tags/v7_0_1.tar.gz
exploit-db.comexploit-db.com/exploits/51413
open-emr.orgopen-emr.org/
vulncheck.comvulncheck.com/advisories/openemr-authentication-brute-force-mitigation-bypass

Frequently asked

questions

Yes. Any attacker with network access to the OpenEMR login page can attempt to exploit the weakness by sending automated login requests, assuming the endpoint is reachable from their location.

No prior authentication is required. However, knowing or guessing valid usernames (for example, from naming conventions or leaked lists) can significantly increase the effectiveness of the brute force attempts.

The most robust pattern is to enforce layered defenses on the login flow: strict rate limiting, progressive delays or CAPTCHAs, temporary or permanent account lockout after repeated failures, and optional step-up verification (MFA) for suspicious activity, combined with strong password policies.

Treat authentication endpoints as high-risk surfaces, design them with abuse resistance in mind, and test them regularly.

This includes implementing centralized throttling middleware, integrating WAF rules, continuously monitoring login telemetry, and incorporating brute-force resistance tests and security review into release pipelines.

Find out what's already
exploitable in your codebase.