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:
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:
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:
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:
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:
'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:
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_callbackto a real capability. Don’t stop at the function name. Follow it until you reach acurrent_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. Withmap_meta_cap,readis held by every role, andedit_postsis 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
- CVE-2026-110012: WPScan advisory, CVE record
- CVE-2026-110035: WPScan advisory, CVE record
- WordPress developer docs:
register_post_type()capabilities andmap_meta_cap, REST API permission callbacks - Related: flyto-core SSRF, another fix that missed one module
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.