Skip to content
Noroxi
Research8 min read

Limit Login Attempts Reloaded 3.3.10: Missing Authorization (CWE-862)

A missing authorization check lets any anonymous visitor flip the login-cache admin notice in Limit Login Attempts Reloaded 3.3.10. A CWE-862 case study.

Noroxi TeamPenetration testing and security consulting

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

PluginLimit Login Attempts Reloaded — slug limit-login-attempts-reloaded
Tested version3.3.10 (current/latest at time of testing)
Active installations2,000,000+ (WordPress.org API reports 1,000,000+; listing shows 2M+)
Vulnerability typeMissing Authorization / Broken Access Control (unauthenticated persistent state write/delete)
CWECWE-862 Missing Authorization
Required privilegeNone — unauthenticated, remote
User interactionNone
CVSS 3.1~4.3 (Low) AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N
StatusFresh, 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:

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 55public function login_cache_check_callback() {    LimitLoginAttempts::$instance->get_login_page_cache_detector()->handle_frontend_check();          // line 1355}

core/LoginPageCacheDetector.php:

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 publicpublic function heal_issue() { ... delete_option( self::OPTION_NAME ); }                         // OPTION_NAME='llar_login_page_cache_issue'

Two defects stack on top of each other.

  1. No authorization. handle_frontend_check() runs a persistent update_option / delete_option on llar_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."

  2. Both substitute gates fail open. The only checks are referer_host_ok(), which returns true when the Referer header is absent, so dropping the header satisfies it; and parse_token(), an HMAC check over a token that is printed in plain sight on every wp-login.php response as data-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 nopriv AJAX hook, so WordPress routes an unauthenticated request straight into handle_frontend_check().
  • The referer check is built to fail open. With no Referer header 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 dwell value that feeds cache_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:

php
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 POST requests to admin-ajax.php carrying the llar_login_cache_check action — especially with no Referer header 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.php actions, 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.php is 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


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.

Your address is used only for this email and never shared.

Up next

Security headers: ten vulnerabilities closed with five lines