Abstract. Admin and Site Enhancements (ASE) is a WordPress hardening plugin with a large install base, and its "Change Login URL" feature hides the login endpoint behind a secret slug. A broken-access-control weakness undercuts that feature: an over-broad REST exemption lets an unauthenticated visitor skip enforcement, reach the login form, and read back the secret slug. This write-up covers the root cause and the fix for defensive and educational use. The flaw is unpatched as of this writing, so the operational proof of concept stays out of the public text until a patch ships — what remains is enough to recognise, prevent, and detect the bug class.
Keywords: WordPress, broken access control, hide-login bypass, REST route exemption, information disclosure, secure coding.
1. Introduction
Hiding the WordPress login behind a secret URL is routine hardening. It is no substitute for strong authentication, but it does cut the flood of automated brute-force and credential-stuffing traffic that hammers /wp-login.php. Plenty of plugins ship the feature, among them Admin and Site Enhancements (ASE) by Bowo (qriouslad), which carries 200,000+ active installs.
Popularity is exactly what makes the enforcement logic worth a close read: one gap closes the protection for every site that trusts it, and nobody gets a warning. The gap here is a REST-API exemption matched too loosely. What it teaches reaches past this plugin, because the real question is how a request earns its way out of a security check.
2. Affected component
| Field | Value |
|---|---|
| Plugin | Admin and Site Enhancements (ASE) |
| Slug | admin-site-enhancements |
| Vendor | Bowo (qriouslad) |
| Plugin URL | https://wordpress.org/plugins/admin-site-enhancements/ |
| Tested / affected version | 9.2.0 (latest at time of testing, 2026-10-05) |
| Active installs | 200,000+ |
| Vulnerability type | Broken Access Control — hide-login bypass + secret-slug disclosure |
| CWE | CWE-200 (Exposure of Sensitive Information) / CWE-284 (Improper Access Control) |
| Authentication required | None (unauthenticated) |
| Prerequisite | The "Change Login URL" feature is enabled |
| CVSS 3.1 (proposed) | 5.3 Medium — AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N |
| Status | Fresh — unpatched (0-day) at time of writing |
3. Technical analysis
ASE's "Change Login URL" feature sends requests for the default login endpoints (/wp-login.php, /wp-admin/) to a "not found" page unless the visitor arrives via the admin-configured secret slug. That enforcement lives in Change_Login_URL::redirect_on_default_login_urls(), hooked on wp_loaded.
The function tries not to break legitimate REST API traffic, so it exempts REST requests. One of those exemption checks is the defect:
// classes/class-change-login-url.php (~line 427), runs before the real REST checks
if ( isset( $_GET['rest_route'] ) ) {
return; // BUG: skips ALL hide-login enforcement on mere presence of the parameter
}The trigger is the bare presence of the rest_route query parameter — any value, empty included — and it fires before the stronger, path-based REST detection later in the same function. That is the entire bug. The code equates "a parameter called rest_route is attached to this request" with "this is a REST API request that must be exempt," and those two statements do not mean the same thing.
/wp-login.php and /wp-admin/ are standalone WordPress endpoints. Core serves them whether or not rest_route is present; that parameter only steers routing when a request goes through index.php. Tacking rest_route onto a login URL therefore does not make the request a REST request. It just drags along an extra query string that core ignores while it renders the login machinery as usual. By then the exemption has fired and the protection is off.
4. How the flaw is reached (conceptual)
Reaching the vulnerable branch takes no special tooling and no authentication. What is worth drawing out is why it is reachable, not the request sequence that gets there.
The enforcement function decides exempt-or-enforce from input the attacker controls — the query string — with a test the attacker satisfies for free. The exemption hangs on the mere existence of one query parameter, and an unauthenticated visitor owns the full query string of any request they send. So the visitor can drive the "this is a REST request, skip enforcement" branch on a request that is nothing of the sort. The early return then short-circuits the function before the accurate, path-based REST check below it ever runs.
Two consequences follow straight from ordinary WordPress behaviour once enforcement is skipped:
- The hidden login machinery is served as though the feature were off. The login form is reachable again, and the brute-force surface the feature removed comes back.
- Request the admin dashboard entry point in this exempted state, and core issues its usual "you must log in" redirect toward the login URL. ASE's own
customize_login_url()filter rewrites that target to the secret slug, so the redirect hands the secret slug to an unauthenticated observer — the exact value the feature exists to conceal.
Nothing here is exotic: untrusted input decides a security branch, and it decides before the trustworthy check runs. No payload, no call chain, no privileges. That plainness is why the bug class is worth attention.
5. Impact assessment
An unauthenticated attacker can cancel out everything the Change Login URL feature was buying. The login form is back within reach — reopening the automated brute-force and credential-stuffing the feature was meant to stop — and the one secret the feature protected, the login slug, is now readable.
This is a confidentiality and access-control failure, not a direct compromise. On its own the flaw does not log an attacker in, alter data, or knock the site offline, which is what the proposed CVSS 3.1 score of 5.3 Medium (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) reflects: network-reachable, low complexity, no privileges or user interaction, limited confidentiality impact, no integrity or availability impact. The real-world severity runs higher wherever the hidden login was counted as a genuine layer of defence, since that layer quietly stops holding.
6. Remediation
The fix follows one rule: the presence of $_GET['rest_route'] is not proof of a REST request. Base the exemption on the request's real path, not on a parameter name the client supplied.
// Suggested fix — rely on the path-based REST prefix, not a parameter's presence.
// Remove the isset($_GET['rest_route']) early-return entirely and keep only a
// genuine REST-endpoint check:
$rest_prefix = trailingslashit( rest_get_url_prefix() ); // e.g. "wp-json/"
$request_path = wp_parse_url( $_SERVER['REQUEST_URI'], PHP_URL_PATH );
if ( $request_path && strpos( ltrim( $request_path, '/' ), $rest_prefix ) === 0 ) {
return; // genuinely a REST request — safe to exempt
}
// Enforce hide-login for /wp-login.php and /wp-admin/ regardless of query parameters.While you wait on a vendor fix:
- Keep the plugin current and install the vendor's security release the moment it lands.
- Do not lean on hide-login as your only login defence. Back it with strong, unique credentials, two-factor authentication, and rate limiting or lockout on failed logins, so that recovering the login form buys an attacker nothing easy.
- If you do not actually need the hidden-login feature, consider turning it off until a fix ships and enforcing login protection at a layer the query string cannot touch.
7. Detection and hardening for site owners
The request looks ordinary, so detection keys on the place the protection should have acted and didn't:
- Log review. Watch access logs for requests to the default login endpoints (
/wp-login.php,/wp-admin/) that come back with the login page or an authentication redirect instead of your configured "not found" response. With hide-login enabled, a default login endpoint that answers at all is the tell. - Spot-check the exemption surface. From an unauthenticated client, confirm your default login endpoints still redirect to "not found" even with extra query parameters attached. If one parameter changes the outcome, the protection depends on client input and should be treated as bypassable until patched.
- Least privilege and layered auth. Treat the hidden slug as a convenience, not a secret that has to hold. With two-factor authentication and failed-login lockout in place, leaking the slug does not turn into account compromise.
- Virtual patching. A WAF or edge rule can insist that requests to the default login endpoints always get hide-login enforcement, query parameters notwithstanding — a stopgap until the plugin is fixed. Derive the rule from the mechanics above, not from any specific payload.
None of this depends on features the plugin lacks; these are general operational controls layered around the weakness.
8. Broader lesson
The transferable principle is about how a program decides a request is exempt from a security check. Two familiar mistakes collide here:
- Trusting input shape as identity. A parameter named
rest_routewas taken as proof the request is a REST request. Attacker-controlled input can wear the shape of a trusted request without being one. Exemptions have to come from server-authoritative facts — the resolved route, the dispatched handler, an authenticated capability — never from a label the client supplied. - Deciding before verifying. A loose, early exemption ran ahead of the accurate, path-based check later in the same function. Where a weak test and a strong test both exist, the weak one must never short-circuit the strong one. Order the checks so the authoritative one owns the outcome.
Put positively: fail safe, decide late, and derive every security exemption from facts the attacker cannot forge.
9. Responsible disclosure
This research followed coordinated disclosure. The vendor has been notified privately, and the full operational detail — the exact reproduction sequence and the live-abuse steps — is deliberately held back from this public article until a fix is available. Complete technical detail will follow only after a patched release, or after a standard disclosure window, with timing coordinated with the maintainer.
All verification ran on a local, isolated WordPress instance under the researcher's control. No third-party or production systems were touched. Noroxi conducts authorized security research only and does not test systems without permission.
References
- CWE-284: Improper Access Control — https://cwe.mitre.org/data/definitions/284.html
- CWE-200: Exposure of Sensitive Information to an Unauthorized Actor — https://cwe.mitre.org/data/definitions/200.html
- WordPress REST API Handbook — https://developer.wordpress.org/rest-api/
- Plugin Developer Handbook: Security — https://developer.wordpress.org/plugins/security/
- OWASP: Broken Access Control — https://owasp.org/Top10/A01_2021-Broken_Access_Control/
- 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.