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.

