This year I've spent a lot of my time teaching Offroad's AI agents to check one thing: whether authentication controls actually protect the paths people use, or only look like they do on paper. One of those investigations was Plane, the open-source project management tool with more than 60,000 GitHub stars. The agents found that Plane's email login code could be guessed again and again with nothing stopping it. That finding is now CVE-2026-105638, a critical authentication bypass rated 9.1 on CVSS, and Plane fixed it in version 1.4.0.
What caught my attention wasn't a missing control. Plane had rate limiting configured, It just never reached the endpoint an attacker would hit.
Key takeaways
- CVE-2026-105638 is a critical (CVSS 9.1) authentication bypass in Plane's passwordless magic-code login.
- The login didn't limit failed guesses, so anyone who knew a user's email address could brute-force the six-digit code and take over the account.
- Plane 1.3.1 and earlier are affected. Version 1.4.0 fixes it by deleting a code after five wrong guesses and rate limiting the login endpoints.
- Offroad's agents found the issue while investigating authentication flows, and we reported it privately to Plane on May 15, 2026.
- The lesson for identity teams: a rate limit in the config doesn't always cover the path an attacker uses.
What is CVE-2026-105638?
CVE-2026-105638 is a critical authentication bypass in Plane's passwordless "magic code" login, rated 9.1 on CVSS 3.1. The login accepted unlimited guesses of a six-digit code, so anyone who knew a user's email address could keep guessing until they got in. It's a textbook case of CWE-307 (Improper Restriction of Excessive Authentication Attempts). Plane 1.3.1 and earlier are affected, and the fix shipped in v1.4.0.
The attack didn't need phishing, a leaked password or access to the victim's inbox. It didn't need the victim to do anything at all, which is a big part of why the score is so high.
How did the attack work?
The attacker asks Plane to email a login code to the victim, then guesses codes against the verification endpoint until one works. Nothing counted the failed attempts, so nothing ever stopped the guessing.
- The attacker requests a magic code for the victim's email address. Plane sends that code to the victim's inbox.
- The attacker sends guesses to the verifier endpoint,
POST /auth/magic-sign-in/, without ever seeing the real code. - Each wrong guess fails quietly. No counter goes up, the code stays valid and the account doesn't lock.
- Eventually a guess matches, and the attacker is signed in as the victim, with whatever access that person has in Plane.
Six digits sounds like plenty, but Plane's codes only have about 900,000 possible values. The advisory estimates that a single IP sending 50 requests per second covers the whole range in about five hours, and an attacker spreading requests across many IPs could get there in minutes. Each code also expires after 10 minutes, so in practice the attacker races that clock and asks for a fresh code when it runs out. That slows a single attempt down, but with nothing counting wrong guesses, it doesn't stop the attack. The same gap existed in the magic-code login for Plane's public spaces, and the fix covers those too.

Why didn't Plane's existing rate limiting stop it?
Plane did have rate limiting. It just wasn't applied to the endpoint that verifies the code. The one limit that did apply protected a different step of the login, which left the guessing step wide open.
- Throttle gap: the verifier was built on Django's plain
Viewclass instead of DRF'sAPIView, so the project's 30-requests-per-minute throttle never covered it. - No backstop: there was no rate limiting or lockout at the middleware level to catch what the throttle missed.
- Wrong step capped: Plane limited how often you could request a new code (three times), but not how often you could guess one.
I don't read this as carelessness by the Plane team. Real codebases grow one endpoint at a time, and it's easy for one of them to end up outside the safety net without anyone noticing.
It's also the shape of identity risk we run into most often with customers. A control exists, it shows up in the config, and everyone assumes it applies everywhere. Nobody goes back to check whether it covers the specific path an attacker would use.
Who is affected, and what should you do?
Anyone running Plane 1.3.1 or earlier is affected. The fix is in version 1.4.0, and the table below has the details.
- If you self-host Plane, upgrade to 1.4.0 or later as soon as you can.
- After upgrading, check that the
AUTHENTICATION_RATE_LIMITsetting hasn't been raised far above the default. - If you can't upgrade right away, rate limit the magic-code sign-in and sign-up endpoints, including the public-space ones, at your reverse proxy or WAF.
- Review your logs for bursts of failed login-code attempts against a single email address.
What was the disclosure timeline?
We reported the issue privately to the Plane maintainers on May 15, 2026. Plane published security advisory GHSA-mqjv-rwgv-4gxq on August 3, 2026, with the fix available in version 1.4.0.
The advisory credits me as one of the reporters. I want to thank the Plane team for taking the report seriously and shipping a fix. That's how responsible disclosure is supposed to work, and it doesn't always go that smoothly.
How did Offroad's AI agents find this?
At Offroad we build AI agents that handle identity security work from investigation through to resolution, and part of that is training them to probe the authentication and access controls meant to protect identities. We wrote more about how those agents work in How We Built Offroad Identity Security Agents.
Here, the agents didn't stop at the configuration. They followed the login flow end to end and checked whether the throttle actually applied at the verifier, and that's where the gap showed up. Reading the settings alone would never have shown it.
That kind of checking is tedious, and it's the first thing a busy team skips. It's exactly the work I want agents doing. Plane is one of several vulnerabilities our agents have uncovered so far, and we'll share the others as each disclosure is completed.
What should identity teams check in their own stack?
Any login that relies on a short code needs a limit on the step that verifies the code, not only on the step that sends it. That includes email and SMS one-time passwords and short-code MFA challenges. Token-based magic links have different security properties, so assess those separately. This is the checklist I'd run:
- Count failed attempts per code and per account, and invalidate the code after a small number of failures (the advisory suggests five).
- Rate limit the verify endpoint per email address and per IP.
- Test that your framework's throttles actually cover that endpoint. Don't assume they do.
- Consider longer codes, such as eight digits, along with short expiry windows.
- Alert on bursts of failed verifications against a single account.
And when a check turns up something to change, make the change in a way you can undo. We wrote about that in Safe Identity Remediation: Why Recovery Must Begin Before the Change.
Frequently asked questions
Which versions of Plane are affected by CVE-2026-105638?
Plane 1.3.1 and earlier are affected, and the issue is fixed in Plane v1.4.0. If you self-host Plane, upgrade to v1.4.0 or later. The GitHub advisory GHSA-mqjv-rwgv-4gxq has the full technical details.
What does an attacker need to exploit CVE-2026-105638?
Only the victim's email address. The attacker doesn't need a password, inbox access or any misconfiguration. They request a magic code for the victim and then guess six-digit codes against the verification endpoint until one succeeds.
What did Plane change in v1.4.0 to fix it?
Two things. Each login code now tracks wrong guesses and is deleted after the fifth one, which cuts an attacker's odds to about 1 in 180,000 per code. The magic-code sign-in and sign-up endpoints, including the public-space ones, also get a per-IP rate limit of 10 requests per minute by default.
How do I protect Plane if I can't upgrade yet?
Put a rate limit in front of the magic-code endpoints at your reverse proxy or WAF and watch your logs for repeated failed codes against a single email address. Treat it as a stopgap. The real fix is the per-code guess limit in v1.4.0, so plan the upgrade.
What is a magic-code login?
It's a passwordless sign-in method where the app emails the user a short one-time code to type in. It's convenient, but without a cap on failed attempts, a short code like this can be brute-forced.
How can AI agents help identify authentication vulnerabilities?
AI agents can examine authentication flows for gaps between configured protections and actual behavior. In this case, Offroad's agents surfaced a missing verification limit that became CVE-2026-105638, which was privately reported to Plane before disclosure. The value is giving security teams concrete control gaps they can validate and fix.
The takeaway
A six-digit code is only as strong as the limit on guessing it. For me, the bigger point is that identity controls have to be verified on the paths attackers actually use, not just configured where we expect them to be. That's the work we built Offroad's agents to do, from finding the issue to resolving it, so defenders get to these weaknesses before attackers do.
If you want to see how Offroad's agents investigate identity risk in your own environment, book a demo.
Related reading
- AI Agent Permissions and OAuth Grants: An Enterprise Security Guide
- Our OAuth agent found hidden risk in nearly one in three marketplace apps
- The Most Dangerous Identity Attacks Look Like Normal Work
Sources

.png)

