/

CVE-2026-33640

Severity:

CRITICAL RISK

(9.8)

Improper Authentication Rate Limiting in Outline Email OTP

CVE-2026-33640

Analyzed

Vulnerability type

Category:

Improper Authentication Rate Limiting

CWE:

CWE-307

Impact:

Account Takeover via OTP 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

Outline's email-based OTP login flow for non-IdP users does not properly invalidate one-time codes after repeated invalid attempts, relying solely on a rate limiter to throttle guesses.

Because the rate limiter can be bypassed, attackers can submit unlimited OTP guesses during the code's lifetime, enabling practical brute force attacks and potential account takeover.

Affected context

This vulnerability affects Outline deployments that:

  • Use the built-in email OTP login flow for users not associated with an external Identity Provider (IdP)
  • Issue OTP codes that remain valid for a time-based window
  • Depend primarily on a generic rate limiter to protect OTP verification endpoints

In such environments, if the rate limiter can be bypassed or is not consistently enforced across all paths, attackers can repeatedly submit OTP guesses without meaningful lockout or code invalidation.

Exploit preconditions

  • Attack surface: Public-facing Outline login endpoint using email OTP authentication.
  • Required access: Ability to request or obtain an OTP for a target email address (e.g., knowledge of the victim's email and the ability to trigger an OTP email), plus network access to the login interface.
  • Trigger point: Repeated submission of OTP verification requests within the valid lifetime of a single issued code.
  • Why exploitation is possible: OTP codes remain valid regardless of the number of failed attempts, and the primary safeguard is a rate limiter that can be bypassed. With no attempt-based lockout, rotation, or hard cap, attackers can brute force codes at scale within the time window.

Why this happens

The root cause lies in treating OTP verification as a purely time-bound secret without enforcing limits on invalid attempts per issued code or account.

This maps to CWE-307: Improper Restriction of Excessive Authentication Attempts, where the system allows unlimited or insufficiently constrained login attempts.

Instead of binding OTP validity to both time and attempt count, the implementation relies on an external rate limiter for protection. When that limiter is bypassed or misconfigured, nothing in the authentication logic itself invalidates codes after repeated failures, leaving OTPs vulnerable to brute-force guessing.

Potential impact

  • Attackers could brute force OTP codes and gain unauthorized access to individual user accounts.
  • Compromised accounts could be used to exfiltrate sensitive documentation and internal knowledge.
  • Malicious actors may alter or delete shared documents, impacting integrity and availability of team knowledge.
  • Successful account takeovers could be chained into broader organizational compromise, especially where Outline accounts are reused across teams or contain privileged information.

General mitigation guidance

Mitigation strategies generally focus on strengthening the authentication workflow itself, independent of external rate limiting:

  • Enforce a maximum number of failed OTP attempts per code or per account within a time window, after which the code is invalidated and a new one must be requested.
  • Bind OTP validity to both time-based expiration and attempt counters, ensuring that repeated failures naturally lock out the current token.
  • Introduce progressive delays or cooldowns after consecutive failures tied to the user account, email, and client signals rather than solely to IP addresses.
  • Use high-entropy OTP codes and sufficiently short lifetimes so that brute forcing is mathematically impractical within the valid window.
  • Minimize reliance on a single technical control by combining application-level lockouts with generic network rate limiting and anomaly detection.
  • Apply the principle of least privilege within the application so that even if an account is compromised, the blast radius is reduced.

How teams detect issues like this

Effective detection combines application-level telemetry with security monitoring:

  • Implement logging that captures OTP issuance and verification attempts per user, device, IP, and time window, with clear indicators of repeated failures.
  • Define alerting thresholds for suspicious authentication patterns, such as high-volume OTP submissions, attempts spanning many user accounts, or bursts from diverse IPs targeting the same email.
  • Use application-aware security tests and code review to look for authentication flows that lack:
  • Attempt counters or lockout conditions
  • OTP invalidation on repeated failure
  • Distinct error handling for failed authentication
  • Employ static analysis or security linters to flag authentication endpoints that rely solely on infrastructure rate limiting and lack in-code protections against excessive attempts.
  • Periodically run penetration tests focused on OTP and MFA flows to validate that brute force protections are effective and cannot be trivially bypassed.

Sources

SourceLink
github.comgithub.com/outline/outline/releases/tag/v1.6.0
github.comgithub.com/outline/outline/security/advisories/GHSA-cwhc-53hw-qqx6

Frequently asked

questions

The vulnerability is broadly exploitable wherever the email OTP login flow is exposed to the internet and used by accounts not protected by an external IdP. Anyone able to trigger or intercept OTPs for a target email and bypass rate limiting can attempt brute force attacks during the code's lifetime.

An attacker needs basic network access to the Outline login interface and a way to obtain or trigger an OTP for a target email address. They do not require prior authentication to the system; exploitation occurs at the login stage.

The most robust fix is to embed protections directly into the authentication logic: enforce per-code and per-account attempt limits, invalidate OTPs after a small number of failures, and require new code issuance. Rate limiting should serve as a defense-in-depth layer, not the sole control.

Future designs should treat OTP and MFA flows as high-value security boundaries and:

  • Design for attempt-based lockout from the outset.
  • Conduct security reviews specifically for authentication endpoints.
  • Model abuse cases like OTP brute forcing and automate tests to verify lockout behavior.
  • Combine multiple layers of defense, including strong token entropy, short token lifetimes, behavioral analytics, and infrastructure rate limiting.
Find out what's already
exploitable in your codebase.