/

CVE-2026-24445

Severity:

HIGH RISK

(7.5)

Improper Restriction of Excessive Authentication Attempts

CVE-2026-24445

Modified

Vulnerability type

Category:

Improper Restriction of Excessive Authentication Attempts

CWE:

CWE-307

Impact:

Denial of Service 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

A missing rate-limiting control in the WebSocket authentication flow allows an attacker to issue an unbounded number of authentication requests.

Under sustained abuse, this can facilitate denial-of-service by overwhelming the service or suppressing/mis-routing legitimate charger telemetry, and can also enable brute-force attempts to gain unauthorized access.

Affected context

This weakness appears in WebSocket-based applications that implement authentication but do not apply per-identity, per-source, or global rate limits to authentication requests.

It is most relevant in environments where WebSockets carry operational telemetry from devices such as chargers, and where the authentication endpoint is reachable from untrusted networks.

The risk increases when authentication failure responses are cheap to compute, logging is limited, or backend components are tightly coupled so that authentication floods degrade telemetry handling.

Exploit preconditions

  • Attack surface: Public or semi-public WebSocket endpoint exposing an authentication interface.
  • Required access: Network connectivity to the WebSocket server (e.g., internet or corporate network access).
  • Trigger point: Repeatedly sending authentication requests (successful or failed) without being throttled or blocked.
  • Why exploitation is possible: The server does not enforce limits on the frequency, concurrency, or cumulative count of authentication attempts per client, account, IP, or time window, allowing automated floods and brute-force campaigns.

Why this happens

The core issue is the absence of controls that restrict excessive authentication attempts, aligning with CWE-307: Improper Restriction of Excessive Authentication Attempts.

Instead of treating authentication as a scarce and protected operation, the WebSocket API allows unbounded retries, often with uniform processing cost and no incremental penalties.

This insecure pattern fails to differentiate normal user behavior from automated abuse and does not incorporate backoff, lockout, or adaptive throttling.

As a result, attackers can systematically overwhelm authentication handling or iterate through credential guesses without proportional resistance.

Potential impact

  • An attacker could overwhelm the WebSocket authentication endpoint, degrading or denying service for legitimate clients.
  • Malicious request floods may suppress, delay, or mis-route legitimate charger telemetry by exhausting shared connection or processing capacity.
  • Brute-force campaigns may eventually guess weak or reused credentials, enabling unauthorized access to charger management or telemetry data.
  • Successful unauthorized access could be used to alter device configurations, manipulate reported metrics, or pivot into related backend systems.

General mitigation guidance

Effective mitigation generally focuses on treating authentication as a high-value operation and tightly constraining its use.

Common defensive patterns include:

  • Enforcing per-identity and per-source rate limits on authentication attempts, with configurable time windows.
  • Introducing progressive delays, backoff, or temporary lockouts after repeated failed attempts, while carefully managing usability and lockout abuse risks.
  • Applying global and per-tenant concurrency caps for authentication-related WebSocket operations to prevent resource exhaustion.
  • Using strong, modern authentication mechanisms (e.g., multi-factor, short-lived tokens, mutual TLS for devices) that reduce the value of brute-forceable secrets.
  • Isolating and prioritizing telemetry channels so that authentication floods cannot easily starve or mis-route operational data.
  • Logging and monitoring abnormal authentication patterns to support operational throttling and incident response.

How teams detect issues like this

Detection typically combines design-time review with runtime monitoring:

  • Static analysis / code review: Look for authentication handlers that can be invoked over WebSockets without surrounding rate-limiting, lockout, or backoff logic; flag endpoints that process credentials without checking shared throttling services or middleware.
  • Architecture review: Verify that API gateways, load balancers, or WebSocket brokers enforce authentication rate policies and that separate tiers (e.g., telemetry vs. auth) have independent resource protections.
  • Runtime analytics: Monitor authentication logs for unusually high failure rates, bursts from single IPs or device identifiers, or sudden spikes in WebSocket connection attempts.
  • Automated testing: Include abuse tests in CI/CD, simulating high-volume authentication attempts to confirm that rate limits, circuit breakers, and alerts trigger as expected.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-057-07.json
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-057-07
ev.energyev.energy/en-us

Frequently asked

questions

Yes, if the WebSocket authentication endpoint is reachable over an untrusted network (such as the internet), an attacker can remotely send large volumes of authentication requests.

No. Exploitation for denial-of-service only requires the ability to connect and send authentication attempts; brute-force exploitation benefits from any knowledge of likely usernames or device identifiers but does not require valid credentials upfront.

The most robust pattern is to implement layered rate limiting around the authentication flow—at the gateway, application, and possibly device tiers—combined with progressive penalties for repeated failures and architectural separation so that authentication abuse cannot easily impact telemetry processing.

Treat authentication endpoints as high-risk from the outset: design them with explicit per-user and per-origin quotas, integrate centralized throttling services or middleware, validate designs via threat modeling, and continuously test abuse scenarios as part of security and performance testing.

Find out what's already
exploitable in your codebase.