Vulnerability research · Deep dive

Let me register as admin: hidden is not disabled

During a security assessment, Uzair Kaaf came across a corporate WordPress portal that, from the outside, offered only a login. Registration was nowhere to be seen. The login plugin's AJAX handler still supported it: switching a single form parameter was enough, and the server created a new account and redirected straight to the back end.

Class
CWE-862 · CWE-425
Severity
CVSS 3.1: 8.2 (High)
Prerequisite
None, a single unauthenticated request
Impact
Own account with a path into the back end
At a glance

Registration was only invisible

The operator had removed registration from the interface and therefore considered it disabled. On the server, the code behind it kept running. Anyone who called the handler directly could create an account for themselves.

  • 01

    What happens

    A login plugin handles login and registration through the same AJAX handler. A form parameter determines which routine runs. With “register”, the handler creates an account without checking whether registration is allowed at all.

  • 02

    What the attacker needs

    Just an HTTP client. No account, no credentials, no user interaction. The structure of the request is revealed by the regular login, which any visitor can trigger.

  • 03

    What the attacker gains

    An account of their own, logged in and redirected to /wp-admin/, and with it everything open to a newly created account with the default role. Had the default role been raised, the same path could have granted far-reaching privileges, up to and including administrator rights.

  • 04

    How to classify it

    As Missing Authorization (CWE-862) and Direct Request (CWE-425): the handler did not check whether account creation was allowed before carrying it out, and the hidden function was reachable through a direct request. Both fall under the umbrella term Improper Access Control (CWE-284). The same pattern was behind the Magical 2FA Bypass (CWE-602).

Severity per CVSS 3.1

8.2High

VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N (opens external website)

Author's rating: the attack works over the network, with a single request, without an account and without any user interaction. The impact on confidentiality is rated high because the portal was meant to be open only to internal users, and every self-created account can thus gain access to its protected content and to the authenticated attack surface. The impact on integrity is rated low: what is demonstrated is the creation of an account, not the modification of existing data.

CWE-862 (opens external website)CWE-425 (opens external website)

Rank 1

in the OWASP Top 10:2025 goes to Broken Access Control, with the most recorded occurrences of all categories (1,839,701) and 32,654 mapped CVEs. OWASP explicitly cites, as an example, an application that places all of its access control in the front end.

A01:2025 Broken Access Control (December 2025) (opens external website)

The portal and the plugin are not named. Host names, field and action names, and values on this page are sanitized; flows and responses match the finding.

The pattern

Where the check should have happened

According to W3Techs (as of 16 November 2026), WordPress runs on 38.5% of all websites. Some login plugins for it combine login and registration in a single modal and handle both through one AJAX endpoint. It becomes dangerous when the interface determines what is allowed and the server relies on it.

Observed pattern

  1. OperatorHides the registration tab in the login modal and considers registration disabled as a result.
  2. ServerThe shared AJAX handler still knows both routines; a form parameter selects between them._auth_form = login | register
  3. AttackerSends the registration variant directly to admin-ajax.php, without any modal.
  4. ServerCreates the account without checking the registration setting and redirects to the back end."Registration successful"

Registration was disabled only in the presentation layer, not on the server.

Secure pattern

  1. OperatorDisables registration in WordPress itself, and likewise in every plugin that can create accounts.
  2. ServerEvery handler that creates accounts checks the setting before doing anything.get_option('users_can_register')
  3. AttackerSends the same registration request directly to the handler.
  4. ServerAborts and responds with 403. No account is created.403 Forbidden

What is disabled stays disabled, no matter which client asks.

The modal behaved correctly: it showed only the login. But because the handler still carried out registrations, the protection depended solely on no one building the request themselves. With an intercepting proxy, that takes no special effort.

Proof of concept

The attack path in four steps

Host, field and action names as well as values are sanitized; the flow and responses match the finding.

A portal without visible registration

The portal showed only fields for username and password. There was no link to create an account anywhere, and WordPress's own registration page was disabled or redirected elsewhere. Creating accounts appeared to be reserved for internal administrators.

Reproduce only on your own systems or with the operator's written permission.

Root cause

Two layers, unaware of each other

The flaw is not in a single line of code but in the fact that the interface and the server decided on registration separately.

1

Disabled only in the interface

The registration tab had been removed from the login modal, and with that, registration was considered disabled. It went unnoticed that the handler still carried it out on the server.

2

A handler without its own check

The plugin's AJAX handler called its registration routine without first checking whether WordPress allows registration at all. Through the parameter, it was therefore reachable by anyone.

Why the flaw goes unnoticed in daily use

There is nothing for visitors to see: no form, no link, no error message. A look at WordPress's well-known registration page turns up nothing either. The path only becomes visible when someone reads the login's requests and varies their parameters.

Remediation

How to close the gap

The first measure closes the path on the server. The other two make sure it does not return through another route and that an accidentally open registration does not grant administrator rights.

  1. 01

    Check registration server-side in the handler

    All code that creates accounts must check the WordPress setting users_can_register beforehand and otherwise abort, ideally with 403. WordPress does not do this for plugins: only its own registration page checks the setting. Until a fixed plugin version is installed, a small guard, for example as a must-use plugin, stops the registration variant before it reaches the handler; check the hook and priority of the plugin's handler first.

    Guard in front of the AJAX handler (PHP)
    add_action( 'wp_ajax_nopriv_modal_auth_action', 'portal_block_registration', 1 );add_action( 'wp_ajax_modal_auth_action', 'portal_block_registration', 1 );function portal_block_registration() {    $form = sanitize_key( $_REQUEST['_auth_form'] ?? '' );    if ( 'register' === $form && ! get_option( 'users_can_register' ) ) {        wp_send_json_error( array( 'message' => 'Registration is disabled.' ), 403 );    }}
  2. 02

    Disable in core and verify without the interface

    Under Settings → General, “Anyone can register” stays unchecked, and every plugin with its own registration is disabled as well; in multisite networks, the network's registration setting applies. Only a request without the interface reliably shows whether this works: it must be rejected, and no account may be created. If one is created anyway, delete it immediately. As an automated test, the cross-check belongs in the pipeline.

    Cross-check with a raw HTTP client
    # only against your own systems; PROBE_PASS = random value# expected: rejected (ideally 403) and no new account;# if an account is created anyway, delete it at oncecurl -s -o /dev/null -w "%{http_code}\n" \  -F action=modal_auth_action -F _auth_form=register \  -F reg_username=probe@example.com \  -F reg_email=probe@example.com \  -F "reg_pass=$PROBE_PASS" -F "reg_pass_confirm=$PROBE_PASS" \  -F reg_first_name=Probe -F reg_last_name=Test \  -F reg_accept_terms=1 \  https://portal.example.com/wp-admin/admin-ajax.php
  3. 03

    Review default role and accounts

    The New User Default Role stays at the lowest level, Subscriber. That way, an accidentally open registration does not grant administrator rights via the standard WordPress route. Plugins with their own role setting also belong at the lowest level, and no handler should take a role from the request. The user list shows who has been newly added and who holds administrator rights.

    Apply settings and review accounts (WP-CLI)
    wp option get users_can_register      # expected: 0wp option update default_role subscriber# who holds admin rights, and which accounts are new?wp user list --role=administrator --fields=ID,user_login,user_registeredwp user list --orderby=registered --order=DESC --number=20 \  --fields=ID,user_login,roles,user_registered

Additional hardening

  • Inventory public AJAX actions and REST routesEvery action a plugin registers for visitors who are not logged in (wp_ajax_nopriv_…) is publicly reachable, as are REST routes that require no login. Both belong in the inventory and the test scope.
  • Know every path to account creationLogin modals, shop accounts, member areas, social login and invitations can come with their own paths to account creation. Each of them must respect the same setting.
  • Alert on new accountsThe WordPress hook user_register fires for every newly created user account, no matter which path was used. An alert on it or the log of a security plugin makes an open registration visible immediately.
  • Keep the authenticated attack surface smallWhat logged-in users with a low role may see and access, such as user data via the REST API or internal pages, should be kept as limited as possible.
  • Test hidden functions deliberatelyPentests should systematically vary parameters such as action, form, type or mode instead of only checking what the interface offers.

References: Authorization Cheat Sheet (opens external website) · Application Security Verification Standard 5.0.0, V8 Authorization (May 2025) (opens external website) · wp_ajax_nopriv_{$action} (opens external website) · Settings General Screen (opens external website) · Roles and Capabilities (opens external website)

Self-check

Is your portal affected?

Eight questions for operators, development and security teams of WordPress and other CMS portals. The self-check is no substitute for testing, but it shows where to look more closely. Your answers stay in your browser.

  1. 01Is registration disabled in WordPress itself (“Anyone can register” unchecked), not just hidden in the interface?
  2. 02Does every handler that creates accounts check this setting server-side and otherwise reject the request with 403, including in plugins?
  3. 03Is the New User Default Role set to the lowest level (Subscriber)?
  4. 04Do you know every path through which accounts can be created: login modals, shop accounts, member areas, social login, invitations?
  5. 05Do you have a list of the AJAX and REST actions that can be reached without logging in?
  6. 06Are you notified as soon as a new user account is created?
  7. 07Is there an automated test that attempts registration with a raw HTTP client and expects a rejection?
  8. 08Has your portal ever been tested with an intercepting proxy and varied parameters, rather than only through the interface?

Answered: 0/8

The result is guidance, not evidence of compliance.

GRC and audit view

When access control only works on screen

Frameworks require access control policies and protection against unauthorized access. A finding like this one means the rule is documented, but the server does not enforce it.

NIS2 and the German BSI Act

NIS2 explicitly lists access control policies among the cybersecurity risk-management measures, and for entities in Germany that fall within its scope, the German BSI Act requires such policies to be drawn up. A registration that can be opened by bypassing the interface undermines such a policy, even if it exists on paper.

Directive (EU) 2022/2555 (NIS2) (December 2022) (opens external website) · German BSI Act (BSIG), risk-management measures (opens external website)

Implement NIS2

ISO/IEC 27001

The controls “Access control”, “Identity management”, “Access rights” and “Privileged access rights” require managed paths to user accounts and rights, and “Security testing in development and acceptance” requires testing. An ISMS must also evaluate the effectiveness of its controls. Audits should therefore check the paths through which accounts are actually created.

ISMS per ISO 27001

GDPR

The GDPR requires security of processing, taking into account the state of the art. If someone actually gains access to personal data through a self-created account, it is a personal data breach. The controller must then notify the competent supervisory authority without undue delay and, where feasible, within 72 hours of becoming aware of it, unless the breach is unlikely to result in a risk to the rights and freedoms of natural persons.

Regulation (EU) 2016/679 (GDPR) (opens external website)

Privacy information management

Cyber Resilience Act

The CRA places obligations on manufacturers, not operators: anyone who makes a plugin available commercially must, from 11 December 2027, ship it with a secure default configuration and protect it against unauthorized access through appropriate control mechanisms such as authentication, identity or access management systems. Reporting obligations for actively exploited vulnerabilities have applied since 11 September 2026. Depending on whether the operator is in scope, the relevant frameworks for it are NIS2 or the German BSI Act, an ISMS based on ISO 27001 and the GDPR.

Regulation (EU) 2024/2847 (Cyber Resilience Act) (opens external website)

CRA compliance

This overview is not legal advice.

Whitepaper · free

Let me register as admin – Server-Side Access Control for CISOs

What the finding teaches about hidden functions and access control, prepared for decision-makers: the pattern, every path to a user account, server-side switches and roles, testing and evidence, questions for plugin vendors and agencies, the regulatory view and a 30-60-90-day plan.

Cover of the whitepaper “Let me register as admin – Server-Side Access Control for CISOs”
PDF · 22 pagesEnglish & GermanAuthor: Uzair Kaaf
  • Ten key messages for the board and internal audit
  • Test catalog for every path to a user account
  • Requirements for server-side switches, roles and tests
  • Regulatory view on NIS2, ISO 27001, GDPR and the CRA
Free Download

Request Whitepaper

Let me register as admin – Server-Side Access Control for CISOs

Language version *
Keep exploring

Related research

Sources

Standards, documentation, specifications, statistics and legal texts this deep dive is based on.

  1. MITRE CWECWE-862: Missing Authorization (opens external website)
  2. MITRE CWECWE-425: Direct Request (opens external website)
  3. MITRE CWECWE-602: Client-Side Enforcement of Server-Side Security (opens external website)
  4. MITRE CWECWE-284: Improper Access Control (opens external website)
  5. OWASP Top 10:2025A01:2025 Broken Access ControlDecember 2025 (opens external website)
  6. OWASP API Security Top 10API5:2023 Broken Function Level Authorization (opens external website)
  7. OWASP Cheat Sheet SeriesAuthorization Cheat Sheet (opens external website)
  8. OWASP ASVSApplication Security Verification Standard 5.0.0, V8 AuthorizationMay 2025 (opens external website)
  9. OWASP Web Security Testing Guide 4.2WSTG-IDNT-02: Test User Registration Process (opens external website)
  10. WordPress.orgSettings General Screen (opens external website)
  11. WordPress Developer Resourceswp_ajax_nopriv_{$action} (opens external website)
  12. WordPress.orgRoles and Capabilities (opens external website)
  13. W3TechsUsage statistics of content management systemsNovember 2026 (opens external website)
  14. FIRSTCommon Vulnerability Scoring System v3.1: Specification Document (opens external website)
  15. EUR-LexDirective (EU) 2022/2555 (NIS2)December 2022 (opens external website)
  16. gesetze-im-internet.deGerman BSI Act (BSIG), risk-management measures (opens external website)
  17. EUR-LexRegulation (EU) 2024/2847 (Cyber Resilience Act) (opens external website)
  18. EUR-LexRegulation (EU) 2016/679 (GDPR) (opens external website)

Frequently asked questions

Short answers

What does “Let me register as admin” mean?

That is what Uzair Kaaf called the finding: a hidden registration made it possible to create an account without approval, with a direct path into the back end at /wp-admin/. Administrator rights do not follow from this automatically, but only if the New User Default Role has been raised.

Is this a vulnerability in WordPress?

No. The WordPress registration page checks whether registration is allowed. The functions that plugins use to create users, however, do not; the plugin's code has to take care of it. That exact check was missing in the login plugin's handler. This applies to single WordPress installations; in multisite networks, a network setting governs registration.

How do I check whether my portal is affected?

Capture a login attempt in an intercepting proxy and look for parameters that switch between routines. Then send the registration variant directly to the endpoint. If an account is created even though registration is supposed to be disabled, the portal is affected. Only test your own systems, or systems you have written permission to test.

Is it enough to disable registration in the WordPress settings?

Not necessarily. Plugins that create accounts themselves must check this setting as well. Only a cross-check without the interface reliably shows whether they do: the request must be rejected, and no account may be created.

Which plugin and which portal were affected?

We do not disclose that. Host names, field and action names on this page are sanitized.

How does the finding relate to the OWASP Top 10?

It falls under A01:2025 Broken Access Control, rank 1 in the OWASP Top 10. OWASP states that access control is only effective when it is implemented in trusted server-side code or serverless APIs. In the OWASP API Security Top 10, the finding can be mapped to API5:2023 Broken Function Level Authorization, whose first example also involves a registration.

How many paths lead into your portal?

We test portals the way attackers do and show you where a function is merely hidden rather than disabled.