/

CVE-2026-28514

Severity:

CRITICAL RISK

(9.8)

Authentication Bypass in Rocket.Chat DDP Streamer Account

CVE-2026-28514

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287

Impact:

Full Account Takeover and Impersonation

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

A critical authentication bypass in Rocket.Chat's account service within the ddp-streamer microservice allows an attacker to log in as any user with a password set by supplying any arbitrary password.

Due to an asynchronous password validation function being used without await, the code treats the resulting Promise object as a successful validation, enabling account takeover when a username is known or guessable.

Affected context

The vulnerability exists in Rocket.Chat deployments that:

  • Use the ddp-streamer microservice and its associated account service for authentication flows
  • Rely on an asynchronous password validation function in the login logic
  • Contain a missing await (or equivalent) when calling the async password validation function

In such contexts, any login attempt that reaches this flawed code path can be incorrectly treated as successful, as long as the target account has a password defined and the attacker can supply a matching username.

Exploit preconditions

  • Attack surface: Exposed Rocket.Chat authentication endpoint(s) handled by the ddp-streamer microservice.
  • Required access: Network access to the Rocket.Chat service (e.g., internet-facing or reachable from the attacker's network).
  • Knowledge prerequisites: Ability to know or guess a valid username for an account that has a password configured.
  • Trigger point: Submitting a login request with the chosen username and any arbitrary password value.
  • Why exploitation is possible: The asynchronous password validation function is invoked without await, causing the code to evaluate the returned Promise object itself.

In JavaScript/TypeScript, a non-null Promise is always truthy, so the authentication logic effectively interprets every password check as "pass," bypassing the actual credential verification.

Why this happens

This vulnerability stems from an authentication logic flaw where asynchronous code is misused in a security-sensitive context.

The password validation routine is defined as an async function that returns a boolean, but the caller omits the await keyword.

Instead of waiting for the actual validation result, the code receives a Promise object and evaluates it directly in a conditional.

Since a Promise is inherently truthy, the check always appears successful, mapping to CWE-287: Improper Authentication.

Conceptually, the bug converts a real credential check into a no-op, removing the password as a security control for any account reachable via this logic.

Potential impact

  • Complete account takeover of any user whose username is known or guessable
  • Impersonation of administrators or privileged users, potentially leading to full workspace compromise
  • Unauthorized access to private channels, direct messages, files, and integrations
  • Abuse of compromised accounts to distribute phishing links, malware, or social engineering content
  • Lateral movement into integrated systems, bots, or automations that trust Rocket.Chat identities

General mitigation guidance

Effective mitigation focuses on correcting authentication logic and constraining the blast radius of any future logic bugs:

  • Ensure that all asynchronous password verification routines are properly awaited (or appropriately awaited via Promise chains) before decisions are made.
  • Centralize authentication logic into well-reviewed, reusable components rather than duplicating ad hoc checks across services.
  • Enforce strict linting and code review rules that flag async functions used in conditionals without await.
  • Apply defense-in-depth by:
  • Enabling multi-factor authentication (MFA) for high-value and administrative accounts.
  • Restricting administrative actions and sensitive operations with additional confirmations or secondary checks.
  • Configuring rate limiting, IP restrictions, or CAPTCHA on authentication endpoints to reduce automated username guessing.
  • Treat microservice-to-microservice authentication with the same rigor as user logins, ensuring strict verification and least-privilege access for service accounts.

How teams detect issues like this

Organizations can detect and monitor for this class of issue using a combination of static and dynamic approaches:

  • Static analysis and linting:
  • Add rules that detect async functions used in conditionals without await.
  • Flag patterns where security-sensitive checks (e.g., validatePassword, compareHash) return Promises but are not explicitly awaited.
  • Enforce TypeScript/JavaScript ESLint rules that disallow floating Promises or unused Promise results in authentication-related modules.
  • Code review practices:
  • Treat authentication and authorization code as high-risk and require specialized security review.
  • Check that all password, token, and session validations follow a consistent, well-documented pattern.
  • Runtime monitoring and logging:
  • Log authentication attempts with user identifiers, success/failure status, and source IP (while respecting privacy regulations).
  • Alert on anomalous patterns such as:
  • Large numbers of successful logins from new IP ranges.
  • Sudden spikes in successful logins with very few failures.
  • Security testing:
  • Incorporate authentication bypass tests into integration and regression test suites, including checks that invalid passwords are correctly rejected.
  • Use automated security testing tools or frameworks to exercise login flows across all microservices.

Sources

SourceLink
github.comgithub.com/RocketChat/Rocket.Chat/commit/7d89aae0b1bd08e82b02ceab4c180b430e2c6f07
github.comgithub.com/RocketChat/Rocket.Chat/pull/37143
github.comgithub.com/RocketChat/Rocket.Chat/security/advisories/GHSA-w6vw-mrgv-69vf

Frequently asked

questions

Yes. If the Rocket.Chat instance is accessible over the network (for example, exposed to the internet or reachable within a corporate network), an attacker can attempt to exploit the flawed login logic remotely.

The attacker only needs network access to the affected authentication endpoint and the ability to know or guess a valid username for an account with a password set.

No prior authentication is required.

The safest fix is to ensure that all asynchronous password validation calls are properly awaited before making authentication decisions and to centralize these checks in a hardened authentication module.

Complement this with linting rules that prohibit non-awaited async validation in security-critical code.

Prevention typically involves:

  • Adopting strict coding standards for authentication logic (including mandatory await for async checks).
  • Using robust linting and static analysis rules tuned for async misuse.
  • Requiring specialized review for authentication and authorization changes.
  • Maintaining comprehensive automated tests that verify both successful and failed login scenarios across all auth paths.
Find out what's already
exploitable in your codebase.