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.rsfor 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.

