All posts
Write-up ~7 min read

Logged in is not the same as allowed: two REST authorization CVEs in Salon Booking System

A REST permission check that really asked ‘is this user logged in?’ let any Subscriber read every customer’s bookings, and fixing one controller left the discounts route open.

Context: Incomplete fix of CVE-2026-110012 (sibling controller left open)

Advisory
CVE-2026-110012
CVE
CVE-2026-110012, CVE-2026-110035
Affected
Salon Booking System (WordPress plugin) < 10.31.3 (bookings) and < 10.31.11 (discounts), patched in 10.31.11
Weakness
CWE-200 (Information Exposure) / CWE-284 · Improper Access Control
Reading
~7 min · 23 Oct 2026

On most WordPress sites, “logged in” is a very low bar. Many sites let anyone register as a Subscriber, and many shop and booking flows create an account for every customer. If an endpoint only checks that the caller is logged in, it is open to the public with one extra step.

This post covers two CVEs in Salon Booking System, a WordPress plugin for appointment booking. Both have the same root cause: a REST permission_callback that, after WordPress’s capability mapping, asked “is this user logged in?” when it should have asked “is this user salon staff?”. The second CVE exists because the first fix patched one controller, not the shared check every controller used.

I came to this plugin through its changelog. Version 10.31.2 said it had enforced salon-staff authorization on the upcoming-bookings REST route and the other booking list and analytics routes. I diffed 10.31.1 against 10.31.2 to see what the fix touched, reproduced the booking issue on 10.31.1, and then went looking for other controllers that inherit the same base check.

A little theory: why read means “anyone with an account”

WordPress REST routes are guarded by a permission_callback. Return true and the handler runs. So the security of the route depends on what that callback actually tests.

The trap is custom post types. If you register a post type with capability_type and map_meta_cap => true, WordPress builds a capability table for it, and the entry for read maps to the primitive read capability. Every registered role has that one, Subscriber included. So code like this:

PHP
current_user_can( get_post_type_object( 'my_cpt' )->cap->read );

looks like a per-type permission check, but behaves like is_user_logged_in(). That is fine for content that is public anyway. It is wrong for a list of every customer’s appointments.

The second half of the class is sibling routes. A controller usually registers several routes that share one permission_callback. If a developer notices the shared callback is weak and adds a stricter check inside one handler, the other handlers stay exactly as exposed as before. And if several controllers inherit the same base check, fixing one controller leaves the rest open.

The concrete finding

The plugin’s desktop REST API lives under the namespace salon/api/v1. Its controllers extend an abstract base, SLB_API\Controller\REST_Controller, which provides the shared check every list route uses:

src/SLB_API/Controller/REST_Controller.php (10.31.1, trimmed)PHP
public function permissions_check($capability, $object_id = 0)
{
    if (current_user_can('manage_options')) {
        return true;
    }
    // ... shop manager shortcut, then look up the controller's POST_TYPE constant ...

    if (!$post_type) {
        // Controllers without a post type (Shops, Customers) require manage_salon
        return current_user_can('manage_salon');
    }

    // Standard post type capability check
    $object       = get_post_type_object($post_type);
    $capabilities = is_null($object) ? array() : (array)$object->cap;
    return current_user_can( isset($capabilities[$capability]) ? $capabilities[$capability] : '', $object_id );
}

public function get_items_permissions_check( $request )
{
    if ( ! $this->permissions_check( 'read' ) ) {
        return new WP_Error( 'salon_rest_cannot_view', /* ... */ );
    }
    return true;
}

Controllers without a post type got the correct answer, manage_salon. Controllers with one fell through to the post type’s read capability. The plugin’s post types are registered with map_meta_cap, so that check passes for any logged-in user.

The plugin’s REST authentication filter, SLB_API\Plugin::handle_rest_authentication, adds one more piece: for its own routes it returns true when get_current_user_id() > 0 (a normal cookie session) and rejects anonymous callers. So the routes return 401 to anonymous users and 200 to any Subscriber.

CVE-2026-110012: the booking siblings

Bookings_Controller (post type sln_booking) registers a family of read routes, /bookings, /bookings/upcoming, /bookings/stats, /cancellations, /peak-times and others, all with get_items_permissions_check. The developer had seen part of the problem, because the main list handler protects itself:

src/SLB_API/Controller/Bookings_Controller.php (10.31.1)PHP
public function get_items( $request )
{
    if( !current_user_can( 'manage_salon' ) ){
        // returns a 403 body
    }
    // ...
}

get_upcoming_items() and the stats handlers had no such line. /bookings/upcoming returns full booking records: customer name, email, phone, address, the customer’s note, the staff-only admin note, amount and transaction id. On a test install with one seeded booking, a Subscriber got all of it back with HTTP 200, while the same Subscriber calling /bookings got the 403 body. One controller, two answers, depending on which handler you called.

The “403” from /bookings is a soft one: the HTTP status is 200 and the body says {"status":"403"}. My first PoC script printed the HTTP code under a comment that expected 403, which was confusing on a re-test, so check the body and not only the status line when you reproduce this.

My first report draft also listed the plugin’s mobile API (salon/api/mobile/v1) as affected, because its handlers have no internal capability check either. That was an over-claim: a live re-test showed its authentication layer only accepts administrators and salon staff (plus editors if enabled), so a Subscriber is rejected before any handler runs.

CVE-2026-110035: the controller nobody touched

The booking fix overrode get_items_permissions_check inside Bookings_Controller only, with a new helper:

Bookings_Controller.php, after the booking fixPHP
protected function current_user_can_list_bookings()
{
    return current_user_can('manage_options')
        || current_user_can('manage_salon')
        || $this->is_shop_manager();
}

That closed the booking routes, but the weak code was in the base class. Three other controllers define a POST_TYPE and inherit the same check: Discounts (sln_discount), Services (sln_service) and Assistants (sln_attendant). Discounts_Controller was byte-identical before and after the booking fix. Its get_items() has no internal capability check, and its response includes the secret:

src/SLB_API/Controller/Discounts_Controller.phpPHP
'discount_code'  => $discount->getCouponCode(),

So any Subscriber could list every coupon on the site, with code, amount, validity dates and usage limits. As the advisory notes, that includes coupons the administrator had hidden from customers, and a single coupon is also readable at /discounts/{id}. /services and /assistants also returned 200 to a Subscriber on my test install, but with no data seeded there was nothing sensitive to show, so the report focused on discounts.

A minimal reproduction against a local test install of a vulnerable version, logged in as a Subscriber:

HTTP
GET /wp-json/salon/api/v1/discounts HTTP/1.1
Host: salon.test
Cookie: wordpress_logged_in_...=<subscriber session>
X-WP-Nonce: <wp_rest nonce for that session>

The response is HTTP 200 with an items array containing discount_code for each coupon. The same request without a session returns 401, which shows the only requirement is a login, not a staff role.

How to find this in your own code

  • Resolve every permission_callback to a real capability. Don’t stop at the function name. Follow it until you reach a current_user_can() call, then ask which roles hold that capability. If the answer is “Subscriber”, the route is effectively public.
  • Grep for post-type capability lookups in REST checks: get_post_type_object(...)->cap, $object->cap['read'], edit_posts, read. With map_meta_cap, read is held by every role, and edit_posts is held by Contributors.
  • Diff the handlers that share a callback. If one handler in a group has an extra current_user_can() at the top and its siblings don’t, that is your lead. The extra check shows the developer knew the shared one was weak.
  • When you review a fix, look at the base class. If the vulnerable logic is inherited, check whether the patch changed the parent or just overrode it in one child. List every subclass and test each one.
  • Test with a Subscriber, not just anonymously. An anonymous 401 feels like a pass. Log in with the lowest role your site offers and request every route under your namespace.

The fix

The durable fix is in the base class: list and analytics routes should require a staff capability (manage_salon, manage_options or shop manager) regardless of post type, instead of relying on the mapped read capability. That is what 10.31.11 does. The base permissions_check('read') now requires manage_salon, with a comment explaining that the post type’s read capability resolves to the core read that every Subscriber holds. Every inheriting controller is covered at once, including any added later.

If you maintain a similar plugin, also add a capability check inside handlers that return sensitive data. Don’t use that as a substitute for a correct callback, but as a second layer so the next refactor of the callback cannot silently open them.

Impact

Both issues need an authenticated account, but only the lowest role. On booking sites that allow self-registration, or that create an account for every customer, that is effectively anyone.

  • CVE-2026-110012 (fixed in 10.31.3 per the CVE record): any Subscriber can read every customer’s booking records, including contact details, private and staff notes, amounts and transaction ids, plus booking analytics.
  • CVE-2026-110035 (fixed in 10.31.11): any Subscriber can collect every discount coupon, including hidden ones, and use them on their own bookings.

Neither allows writes. The create, update and delete routes check separate custom capabilities, and those held.

Disclosure timeline

The plugin changelog places the booking-route fix in 10.31.2 (17 August 2026); the CVE record for CVE-2026-110012 lists 10.31.3 as the first fixed version, so the table follows the CVE record for that row.

Date Event
2026-08-17 10.31.2 released; changelog lists the booking list/analytics REST authorization fix
2026-08-18 Both issues reproduced on a local test install; reports prepared for WPScan
2026-08-19 10.31.3 released, first fixed version for CVE-2026-110012 per the CVE record
2026-10-13 Both CVE IDs reserved by WPScan
2026-10-14 10.31.11 released, discounts and other salon REST reads now require salon management access; WPScan advisory for CVE-2026-110012 published
2026-10-16 CVE-2026-110012 published; WPScan advisory for CVE-2026-110035 published
2026-10-18 CVE-2026-110035 published
2026-10-23 This write-up

References

Takeaway

A permission check that every account passes is an authentication check, not authorization.

Resolve each REST callback to the roles it actually admits, and when a fix overrides one subclass, test every sibling that inherits the same base.