/

CVE-2026-25113

Severity:

HIGH RISK

(7.5)

Improper Authentication Rate Limiting in WebSocket API

CVE-2026-25113

Modified

Vulnerability type

Category:

Improper Authentication Rate Limiting

CWE:

CWE-307

Impact:

Denial of Service and Brute-Force Authentication

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

The WebSocket API does not enforce limits on the number of authentication attempts, allowing unbounded login or token verification requests over persistent connections.

Under these conditions, an attacker can abuse the authentication endpoint to perform denial-of-service attacks by overwhelming or disrupting charger telemetry flows, or to mount brute-force attacks that may lead to unauthorized access.

Affected context

This vulnerability affects systems exposing a WebSocket-based API that requires authentication but does not enforce per-user, per-IP, or per-session throttling on authentication attempts.

It is particularly relevant where the same WebSocket channel is used for both authentication and operational telemetry (such as charger status or control messages).

The risk increases in deployments where:

  • Telemetry and control rely on continuous, timely WebSocket communication
  • Authentication failures are expensive to process
  • There are no upstream protections such as API gateways, WAF rules, or rate-limiting proxies.

Exploit preconditions

  • Attack surface: Public or internally reachable WebSocket authentication endpoint.
  • Required access: Network reachability to the WebSocket service; no prior authentication is required to start sending repeated authentication requests.
  • Trigger point: Rapid, repeated authentication attempts (valid or invalid) sent over one or many WebSocket connections.
  • Why exploitation is possible: The server lacks mechanisms to cap, throttle, or temporarily block excessive authentication attempts, allowing attackers to exhaust resources or systematically guess credentials.

Why this happens

The issue stems from missing or inadequate controls on the rate and volume of authentication attempts handled by the WebSocket API.

Instead of treating authentication as a sensitive operation that must be throttled and monitored, the implementation allows unlimited retries without escalating defenses (such as lockouts, backoff, or challenge mechanisms).

This aligns with CWE-307: Improper Restriction of Excessive Authentication Attempts, where the system fails to limit repeated login or verification attempts, facilitating brute-force attacks and resource exhaustion.

Potential impact

  • Attackers may cause a denial-of-service condition by saturating authentication handling, leading to delayed or dropped charger telemetry.
  • Legitimate telemetry messages can be suppressed, mis-routed, or starved of processing capacity.
  • Adversaries could perform large-scale brute-force attacks against user or device credentials.
  • Successful brute-force attempts may result in unauthorized access to charger control interfaces or backend management functions.
  • Operational visibility and safety monitoring may be degraded due to incomplete or delayed telemetry data.

General mitigation guidance

Effective mitigation typically combines rate control, behavioral defenses, and architectural isolation:

  • Introduce rate limiting for authentication actions at multiple levels (per user/device, per IP, per connection, and per time window).
  • Apply incremental backoff, temporary account or token lockouts, or challenge mechanisms after repeated failures.
  • Separate authentication processing from latency-sensitive telemetry paths to limit the blast radius of abusive traffic.
  • Enforce strict resource quotas and connection caps per client or tenant to prevent a single actor from consuming disproportionate capacity.
  • Log and monitor abnormal authentication patterns, integrating them with alerting and automated response playbooks.
  • Design authentication flows so that failures are inexpensive to evaluate and do not trigger heavy backend processing.

How teams detect issues like this

Organizations can identify and monitor this class of weakness through:

  • Static and architectural review of WebSocket handlers to confirm the presence of per-endpoint rate limiting and failure-handling logic for authentication.
  • Code review checklists that flag authentication operations lacking throttling, backoff, and lockout policies.
  • Automated tests or dynamic scanning that simulate high-volume authentication attempts and verify the service applies limits and returns appropriate responses.
  • Centralized logging and anomaly detection focused on:
  • Spikes in failed authentication attempts
  • Unusual per-IP or per-account attempt distributions
  • Sustained high load on authentication-related components.
  • Use of API gateways or service meshes configured with rate-limiting policies specifically targeting authentication routes.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-057-06.json
swtchenergy.comswtchenergy.com/contact/
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-057-06

Frequently asked

questions

Yes. If the WebSocket API is reachable over a network (such as the public internet or a corporate WAN), an attacker can exploit the missing rate limiting remotely by sending large numbers of authentication requests.

The attacker only needs the ability to establish WebSocket connections to the affected API endpoint. No prior authentication is required to exploit the absence of rate limiting on authentication attempts.

The most robust fix is to add layered rate limiting and abuse protections around authentication:

enforce per-identity and per-source limits, implement backoff and temporary lockouts after repeated failures, and ensure authentication handling is isolated from core telemetry or control processing.

Treat authentication as a critical resource in design and review processes: define explicit rate-limiting and lockout requirements, enforce them via shared middleware or API gateway policies, include abuse scenarios in threat models, and add automated tests that verify limits are applied under load.

Find out what's already
exploitable in your codebase.