Abstract. A WordPress brute-force plugin running on more than two million sites exposes a front-end AJAX endpoint that writes and deletes a security-relevant option with no nonce and no capability check. Both of its gates are trivial for any anonymous visitor to pass, so a single unauthenticated request can decide whether the "your login page is cached" admin notice appears or disappears — including silencing a real warning that the plugin's own lockout has stopped working. This is a root-cause look at a Missing Authorization defect (CWE-862). The maintainer was notified under coordinated disclosure, and the working proof of concept stays private until a fix ships.
Keywords: WordPress security, Missing Authorization, CWE-862, Broken Access Control, unauthenticated AJAX, nopriv endpoint, secure coding.
1. Introduction
Limit Login Attempts Reloaded is one of the most widely installed WordPress security plugins, with 2,000,000+ active installations. It slows down credential-stuffing and brute-force attacks by locking out repeated failed logins. A cached wp-login.php quietly breaks that protection, because the plugin's counters never run on a page served from cache. To catch this, the plugin ships a login-page cache detector: it prints a signed freshness token on the login page, then uses a front-end AJAX probe to report whether the page looks like it came from cache. When it does, the plugin raises an option-backed admin notice.
That notice is a security signal, and the defect here is a familiar one: an endpoint that changes security-relevant state without checking who is calling it. Missing Authorization is among the most common and most underrated flaws in the WordPress plugin ecosystem. Even a low-severity instance on a two-million-install plugin earns a close read, because it shows the exact shape of a CWE-862 defect and how two reasonable-looking gates can add up to no gate at all.
2. Affected component
| Plugin | Limit Login Attempts Reloaded — slug limit-login-attempts-reloaded |
| Tested version | 3.3.10 (current/latest at time of testing) |
| Active installations | 2,000,000+ (WordPress.org API reports 1,000,000+; listing shows 2M+) |
| Vulnerability type | Missing Authorization / Broken Access Control (unauthenticated persistent state write/delete) |
| CWE | CWE-862 Missing Authorization |
| Required privilege | None — unauthenticated, remote |
| User interaction | None |
| CVSS 3.1 | ~4.3 (Low) AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N |
| Status | Fresh, confirmed in code and reproduced end-to-end on a localhost lab on the current version |
3. Technical analysis
The probe endpoint is registered for authenticated and unauthenticated callers alike. The nopriv registration is what makes it reachable by anyone:
core/Ajax.php:
add_action( 'wp_ajax_nopriv_llar_login_cache_check', array( $this, 'login_cache_check_callback' ) ); // line 54 (UNAUTH)
add_action( 'wp_ajax_llar_login_cache_check', array( $this, 'login_cache_check_callback' ) ); // line 55
public function login_cache_check_callback() {
LimitLoginAttempts::$instance->get_login_page_cache_detector()->handle_frontend_check(); // line 1355
}core/LoginPageCacheDetector.php:
public function handle_frontend_check() { // line 210 — NO nonce, NO capability check
$token = isset($_POST['token']) ? (string) wp_unslash($_POST['token']) : '';
$token = preg_replace('/[^A-Za-z0-9+\/=\.]/', '', $token);
$dwell = isset($_POST['dwell']) ? absint($_POST['dwell']) : 0; // attacker-controlled
if ( ! $this->referer_host_ok() ) { wp_die('0','',200); }
$render_time = $this->parse_token($token); // token is public (render_probe)
if ( false === $render_time ) { wp_die('0','',200); }
if ( $this->is_stale($render_time, $dwell) ) {
$this->record_issue('cached', $this->cache_age($render_time,$dwell), 'frontend', wp_login_url()); // set option
} else {
$this->heal_issue(); // delete_option(...)
}
wp_die('0','',200);
}
private function referer_host_ok() {
if ( empty($_SERVER['HTTP_REFERER']) ) { return true; } // empty referer => passes
...
}
public function render_probe() { ... data-llar-token="<?php echo esc_attr($token); ?>" ... } // token public
public function heal_issue() { ... delete_option( self::OPTION_NAME ); } // OPTION_NAME='llar_login_page_cache_issue'Two defects stack on top of each other.
-
No authorization.
handle_frontend_check()runs a persistentupdate_option/delete_optiononllar_login_page_cache_issue, yet it checks neither a WordPress nonce nor any capability. The omission is deliberate — the endpoint is meant to be callable from the public login page. But "callable by a logged-out visitor's browser" quietly became "safe to let that visitor change state." -
Both substitute gates fail open. The only checks are
referer_host_ok(), which returnstruewhen theRefererheader is absent, so dropping the header satisfies it; andparse_token(), an HMAC check over a token that is printed in plain sight on everywp-login.phpresponse asdata-llar-token. A token any anonymous visitor can read is not a secret and grants no authorization. It only proves the caller has seen the public login page.
The control flow is where this bites. The verdict (is_stale) is driven by cache_age = max(0, token_age − dwell), and dwell arrives straight from the request. Whoever controls dwell controls which branch runs — the record_issue() write or the heal_issue() delete.
4. How the flaw is reached (conceptual)
No privileged session and no user interaction stand between an attacker and the vulnerable sink. The chain is short:
- The probe is registered under the
noprivAJAX hook, so WordPress routes an unauthenticated request straight intohandle_frontend_check(). - The referer check is built to fail open. With no
Refererheader on the request, it passes. A gate that defaults to "allow" protects nothing against a caller who picks its own headers. - The token signature looks like authentication but isn't. The token is rendered publicly on the login page for everyone, so holding a valid one is the same as having visited a public URL. It identifies the page, not the caller.
- Past both gates, the branch depends entirely on the attacker-supplied
dwellvalue that feedscache_age. A large value forces the "not cached" verdict and the delete path; a value that leaves the token looking aged forces the "cached" verdict and the write path.
So an anonymous remote caller can decide, deterministically, whether the administrator notice is created or removed. Removal is the dangerous direction. Silently clearing a genuine "your login page is cached" warning hides from the administrator that caching has disabled the plugin's brute-force lockout — exactly the precondition a credential-stuffing campaign wants to keep in place. We are not publishing the literal request sequence, parameter values, or any copy-paste commands; the mechanism above is enough to understand the risk and defend against it.
5. Impact assessment
The impact is integrity-only, and limited to a single informational notice. An unauthenticated, no-interaction request can write or delete the llar_login_page_cache_issue option and flip the administrator-facing notice. There is no login bypass, no account takeover, and no data disclosure.
That is why the honest rating is Low — CVSS 3.1 ~4.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N): network-reachable, low complexity, no privileges, no interaction, unchanged scope, no confidentiality or availability impact, limited integrity impact. What keeps it worth attention on a two-million-install base is the pairing of unauthenticated reachability with the fact that the most useful direction, suppression, can mask the loss of the very protection the plugin exists to provide — smoothing the path for a follow-on brute-force or credential-stuffing attack.
6. Remediation
Bind the probe to the requesting session with a real WordPress nonce, so only a request that originated from a page the server itself rendered can change state:
public function handle_frontend_check() {
// Require a nonce tied to this action; reject anonymous replay of a public token.
check_ajax_referer( 'llar_login_cache_check', 'nonce' ); // fail-closed on missing/invalid nonce
$token = isset($_POST['token']) ? (string) wp_unslash($_POST['token']) : '';
$token = preg_replace('/[^A-Za-z0-9+\/=\.]/', '', $token);
$dwell = isset($_POST['dwell']) ? absint($_POST['dwell']) : 0;
// ... unchanged verdict logic ...
}If a nonce is impractical in the login-page context, the minimum fix is twofold: make referer_host_ok() fail closed on an absent Referer, and bind the token to the specific responder — for example a per-session value that is not also rendered publicly — instead of printing one shared token that every visitor can read. The principle holds either way: an unauthenticated caller holding nothing but a publicly readable token must not be able to write or delete llar_login_page_cache_issue.
Site operators should apply the maintainer's fixed release as soon as it ships, and lean on the hardening below until then.
7. Detection and hardening for site owners
Everything here follows from the mechanics above — no invented product features:
- Watch the notice for instability. If the "login page is cached" admin notice appears and disappears on its own, or flaps with no matching configuration or caching change, treat it as a possible sign of external manipulation rather than a transient glitch.
- Monitor the endpoint. In access logs, the signal for this class is unauthenticated
POSTrequests toadmin-ajax.phpcarrying thellar_login_cache_checkaction — especially with noRefererheader and no authentication cookie. A spike or repetition from one source is worth a look. - Least privilege at the edge. Where your front controller or WAF allows it, require authentication or a valid same-site context for state-changing
admin-ajax.phpactions, and add a virtual patch that rejects this specific unauthenticated action until the plugin is updated. - Don't trust a single caching signal. Since the notice can be toggled from outside, confirm independently whether
wp-login.phpis actually cached — check your cache layer's rules and the bypass cookies for the login path — rather than relying on the plugin's notice alone. - Keep the plugin updated and follow the maintainer's changelog so the fixed release lands promptly.
8. The broader lesson
Authentication is about the caller, not about the artifact. Two things on this endpoint passed for security controls and weren't:
- A referer check that defaults to allow is no control. A gate that opens when the attacker simply omits an optional header protects nobody.
- A signature over a public value is not authorization. If the token is printed where everyone can read it, verifying it only proves the caller saw a public page. It authenticates the page, never the person.
Any endpoint that changes persistent state has to verify the caller's right to make that change: a session-bound nonce for browser-initiated actions, a capability check for privileged ones, and fail-closed defaults on every gate. "The browser needs to call this" is never the same claim as "any anonymous client may change this." A state-changing handler registered under wp_ajax_nopriv_* should always carry an explicit, caller-specific authorization decision.
9. Responsible disclosure
This research was carried out under coordinated disclosure. The flaw was reported privately to the plugin's maintainer, and the full technical proof of concept — the exact request sequence, parameter values, and reproduction commands — is deliberately held back from this public article until a fix is available. Complete operational detail will follow only after a corrected release ships, or after a standard disclosure window elapses, with timing coordinated with the maintainer; a CVE has been requested for tracking.
All testing ran on the researcher's own isolated, localhost-bound Docker lab with the public GPL plugin. No third-party or production system was touched, and the lab was torn down afterward. We do not publish, and did not share, any live-abuse tooling.
References
- CWE-862: Missing Authorization — https://cwe.mitre.org/data/definitions/862.html
- OWASP: Broken Access Control — https://owasp.org/Top10/A01_2021-Broken_Access_Control/
- WordPress Plugin Developer Handbook — Nonces — https://developer.wordpress.org/apis/security/nonces/
- WordPress Plugin Developer Handbook — Checking User Capabilities — https://developer.wordpress.org/apis/security/user-roles-and-capabilities/
- WordPress Plugin Handbook — AJAX — https://developer.wordpress.org/plugins/javascript/ajax/
- FIRST CVSS v3.1 Calculator — https://www.first.org/cvss/calculator/3.1
Published for defensive and educational purposes. Noroxi LLC conducts authorized security research only; operational exploit detail is withheld until a fix is available.
Exploited this week · every Monday
New KEV entries, fresh PoCs, WordPress triage and what to do this week. No account needed.