/

CVE-2026-30790

Severity:

CRITICAL RISK

(9.8)

Authentication and Password Brute Forcing in RustDesk

CVE-2026-30790

Analyzed

Vulnerability type

Category:

Authentication and Password Brute Forcing

CWE:

CWE-307, CWE-916

Impact:

Account Compromise via Online Password Brute Force

Severity:

CRITICAL RISK

(9.8)

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

RustDesk Server Pro and RustDesk Server (OSS) contain an authentication weakness where login endpoints do not sufficiently restrict repeated authentication attempts and rely on a password hashing scheme with insufficient computational effort.

Under these conditions, an attacker can repeatedly guess passwords against peer authentication and API login modules, enabling large-scale password brute forcing over the network.

Affected context

The vulnerability occurs in RustDesk Server Pro (through 1.7.5) and RustDesk Server OSS (through 1.1.15) on Windows, macOS, and Linux, specifically in peer authentication and API login modules.

It manifests where the server:

  • Accepts repeated login attempts with little or no rate limiting or lockout
  • Implements password verification using SHA256(SHA256(pwd+salt)+challenge) with low computational cost
  • Exposes authentication endpoints to untrusted networks (e.g., internet-accessible servers)

In such deployments, high-volume, automated password guessing becomes feasible without strong server-side throttling.

Exploit preconditions

  • Attack surface: Network-exposed RustDesk Server authentication interfaces (peer authentication, API login).
  • Required access: Ability to connect to the server over the network; no prior authentication is required to attempt logins.
  • Trigger point: Repeated submission of authentication attempts (e.g., username / peer ID and password or token) to the affected endpoints.
  • Why exploitation is possible:
  • The server does not adequately restrict the number, rate, or pattern of failed authentication attempts (CWE-307).
  • The password hashing approach uses SHA-256 in a low-cost configuration without strong iteration count or memory-hard properties, enabling rapid verification attempts (CWE-916).
  • An attacker can script automated requests to try large password lists or systematic keyspaces until valid credentials are discovered.

Why this happens

At a design level, the authentication flow trusts that clients will not abuse password verification endpoints and does not enforce robust server-side limits on repeated failures.

This falls under CWE-307: Improper Restriction of Excessive Authentication Attempts, where the system fails to throttle or block high volumes of login attempts from the same or related principals.

Additionally, the password hashing design uses a straightforward SHA256(SHA256(pwd+salt)+challenge) scheme.

While salting and challenge use are present, the hash is computed with low computational effort and lacks adaptive or memory-hard properties.

This maps to CWE-916: Use of Password Hash With Insufficient Computational Effort, making it efficient for attackers to perform online brute force attacks.

In combination, the missing rate controls and low-cost hashing create an insecure pattern where authentication behaves like a high-speed oracle for testing password guesses.

Potential impact

  • Attackers may brute force account or peer credentials and gain unauthorized access to RustDesk sessions.
  • Compromised accounts could allow remote control of clients connected through the RustDesk server.
  • Successful attacks can lead to data theft, manipulation of remote systems, or further lateral movement within a network accessed via compromised sessions.
  • Attackers can potentially enumerate weak or reused passwords across multiple accounts, amplifying impact in shared-password environments.
  • Persistent, automated guessing may degrade service quality or contribute to denial-of-service conditions for legitimate users.

General mitigation guidance

Effective mitigation centers on hardening the authentication pipeline and increasing the cost of password verification:

  • Introduce server-side rate limiting per account, IP, and other behavioral signals, including exponential backoff after successive failures.
  • Implement account lockout or step-up verification after a bounded number of failed attempts, balanced with mechanisms to avoid easy lockout abuse.
  • Adopt adaptive, computationally expensive password hashing (e.g., Argon2, scrypt, or PBKDF2 with robust parameters) instead of bare SHA-256 constructions.
  • Encourage or enforce strong password policies, such as minimum length and resistance to common-password lists, to reduce the feasibility of brute force.
  • Add multi-factor authentication (MFA) for administrative or high-privilege accounts, where feasible, to reduce dependence on single-factor passwords.
  • Apply least privilege in how authenticated sessions are authorized, so that compromise of a single account yields minimal control by default.

These measures work best when applied systematically across all authentication entry points (peer auth, APIs, administrative interfaces) rather than as ad-hoc patches.

How teams detect issues like this

Organizations can detect and monitor for this vulnerability and its exploitation through a combination of code and operational controls:

  • Static analysis and code review:
  • Look for authentication flows that lack request throttling, lockout, or challenge mechanisms after repeated failures.
  • Identify password verification routines that use fast cryptographic hashes (e.g., single or few iterations of SHA-2) instead of dedicated password-hashing functions.
  • Review the logic in modules like src/server/connection.rs for direct SHA-256 usage in password checks without configurable cost parameters.
  • Logging and behavioral monitoring:
  • Enable detailed logging of authentication attempts, including counts of failed logins per user, IP, and time window.
  • Deploy anomaly detection or SIEM rules to alert on patterns of rapid, repeated failures, dictionary-like sequences, or distributed guessing.
  • Security policy enforcement:
  • Incorporate mandatory authentication-hardening checks into CI/CD pipelines and security gates.
  • Use automated security testing tools or custom scripts to simulate login abuse and verify that rate limits and lockouts trigger as expected.

Periodic review of authentication telemetry, combined with secure coding checks, can help surface similar weaknesses in other services.

Sources

SourceLink
docs.google.comdocs.google.com/document/d/e/2PACX-1vSds6jjpd38oO_yIAyd1HYtKNUuea-I-ozAPpGhYI7QgAU-QGJ7D8a4rOZVj1vmiUXV1EcdRHf9aZAW/pub
github.comgithub.com/rustdesk
vulsec.orgvulsec.org/

Frequently asked

questions

The issue is broadly exploitable wherever RustDesk Server authentication endpoints are reachable from untrusted networks.

An attacker only needs network access to the server and the ability to send repeated login attempts; no prior credentials are required.

No existing account is strictly necessary.

Attackers can target known or guessed identifiers (e.g., usernames, peer IDs, or API accounts) and attempt passwords until one succeeds, particularly if naming patterns or default accounts are predictable.

The safest pattern is to combine strong rate limiting and lockout mechanisms with an adaptive, resource-intensive password hashing scheme.

Operationally, treat all authentication endpoints as high-value resources, enforce hard limits on failed attempts, and update password handling to use modern, tunable password hash functions.

Design authentication from the outset with abuse in mind:

  • Assume attackers will automate login attempts and build in robust throttling, lockout, and anomaly detection.
  • Standardize on vetted authentication frameworks that use best-practice password hashing algorithms and expose tunable cost parameters.
  • Regularly review authentication logs for abuse patterns and adjust thresholds.
  • Include authentication-hardening checks as part of secure design reviews and security testing in the development lifecycle.
Find out what's already
exploitable in your codebase.