← Back to Feed CACHED · 2026-10-17 10:44:28 · CACHE_KEY CVE-2026-110653
CVE-2026-110653 · CWE-287 · Disclosed 2026-10-17

LatePoint Appointment Booking Plugin OTP Verification Race Condition Authentication Bypass

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

A bouncer counts troublemakers on a whiteboard, so ten people rush the door at once and nobody gets counted

CVE-2026-110653 is a Time-of-Check-to-Time-of-Use (TOCTOU) race condition in the verifyOTP function of the LatePoint Appointment Booking Plugin for WordPress, affecting all versions through 5.7.4. The OTP verification endpoint (auth__verify_otp) is supposed to lock an account after ten failed attempts, but the attempt counter uses a classic non-atomic read-modify-write: each concurrent request reads the *same stale count* from memory before any single UPDATE commits, so all of them pass the < 10 check. An unauthenticated attacker who knows a customer's registered email or phone number can fire hundreds of parallel requests, brute-forcing the 6-digit OTP code (1,000,000 combinations) well past the intended cap, and log in as that customer. The fix in 5.7.5 replaces the in-memory increment with an atomic UPDATE … SET attempts = attempts + 1 WHERE attempts < 10 guard with row-level locking.

The vendor's CRITICAL 9.1 rating accurately describes the CVSS math — unauthenticated, network-reachable, no user interaction, high C+I impact — but it overstates the real-world blast radius. The vulnerability compromises *LatePoint customer accounts* (booking data, names, emails, phone numbers, appointment notes), not WordPress administrator accounts or the underlying server. OTP-based authentication is an *optional* configuration that must be explicitly enabled; the default setup uses password-based login, which is unaffected. And the attacker still needs a valid customer email or phone to target. For the ~100K–170K WordPress sites running LatePoint, only the subset with OTP auth enabled and publicly reachable booking portals are in scope. This is a genuine auth-bypass with PII exposure consequences — especially for healthcare or legal appointment sites — but it is not an infrastructure-class vulnerability.

"OTP lockout race condition gives customer account takeover — but only on the subset running OTP auth."
02 · The Attack Path

5 steps from start to impact.

STEP 01

Identify a LatePoint-powered target

The attacker fingerprints a WordPress site running LatePoint by looking for known front-end markers: the /latepoint/ AJAX route, the latepoint_booking_form shortcode in page source, or the latepoint-main.js script enqueue. WPScan and Wappalyzer detect this automatically. The attacker also confirms OTP-based customer auth is active by attempting a login and observing the OTP prompt.
Conditions required:
  • Target site runs LatePoint ≤ 5.7.4
  • OTP-based customer authentication is enabled in LatePoint settings
Where this breaks in practice:
  • OTP auth is an optional, non-default configuration — many installations use password-based login instead
  • LatePoint is a niche booking plugin (~100K–170K installs), not a ubiquitous WordPress component
Detection/coverage: WPScan, Wordfence vulnerability scanner, and Nuclei WordPress templates can identify LatePoint version from readme.txt or the plugin's version constant.
STEP 02

Obtain target customer's email or phone

The attacker needs a registered customer's email address or phone number to initiate the OTP flow. This could come from OSINT, social engineering, prior data leaks, or — notably — from companion LatePoint vulnerabilities like CVE-2026-111602 and CVE-2026-103380, which expose customer PII via unauthenticated AJAX endpoints on the same plugin versions.
Conditions required:
  • Knowledge of at least one registered customer's email or phone number
Where this breaks in practice:
  • Requires a targeted attack, not spray-and-pray — each OTP brute-force session targets one specific customer
  • If the site doesn't expose customer data via other LatePoint vulns, the attacker needs an out-of-band source
STEP 03

Trigger OTP generation

The attacker sends a legitimate login request to the LatePoint customer portal with the target email/phone. The plugin generates a 6-digit OTP and sends it to the customer via email or SMS. This is a normal user-facing action that generates no suspicious logs beyond a standard OTP dispatch.
Conditions required:
  • Network access to the WordPress site's AJAX endpoint
Where this breaks in practice:
  • The real customer receives the OTP notification, which could alert them — but most users ignore or dismiss unexpected OTP emails
Detection/coverage: Outbound OTP email/SMS logs will show the dispatch, but this looks identical to a legitimate login attempt.
STEP 04

Race the OTP verification counter

Using a tool like Burp Suite Turbo Intruder, asyncio/aiohttp in Python, or a simple shell loop with GNU parallel, the attacker fires hundreds to thousands of concurrent POST requests to wp-admin/admin-ajax.php?action=latepoint_route_call&route_name=auth__verify_otp, each with a different OTP guess. Because the attempt counter increment is non-atomic (reads stale value, increments in PHP memory, writes back without WHERE attempts < 10), all concurrent requests see the same low count and pass the lockout check. The 6-digit keyspace (000000–999999) can be exhausted in batches of ~500–1000 concurrent requests per wave.
Conditions required:
  • Ability to send high-volume concurrent HTTP requests to the target
  • OTP has not expired (typically 5–10 minute window)
Where this breaks in practice:
  • Server-side rate limiting, WAF rules, or connection limits may throttle the request volume needed
  • Shared hosting environments may struggle to process 1000+ concurrent PHP workers, causing timeouts that reduce effective parallelism
Detection/coverage: WAF and web server access logs should show a burst of POST requests to the auth__verify_otp route from a single IP within seconds. Wordfence's firewall module may flag this as a brute-force pattern.
STEP 05

Authenticate as the target customer

One of the concurrent requests hits the correct 6-digit code. The plugin returns a valid session cookie for the target LatePoint customer account. The attacker now has full access to the customer's profile: name, email, phone, booking history, appointment notes, and the ability to modify or cancel bookings. On sites handling medical, legal, or financial appointments, the notes field may contain sensitive PII or PHI.
Conditions required:
  • At least one request in the batch matches the correct OTP
Where this breaks in practice:
  • Impact is scoped to the LatePoint customer account — no WordPress admin access, no shell, no database write beyond the plugin's tables
Detection/coverage: Post-auth activity from an anomalous IP or user-agent for the compromised customer account may be visible in LatePoint's booking audit logs.
03 · Compensating Control

1
HIGH 7.5→IGNORE 0.0
SEVERITY REDUCED
Update LatePoint to version 5.7.5 immediately — The definitive fix. Version 5.7.5 replaces the non-atomic PHP counter increment with an atomic SQL UPDATE … SET attempts = attempts + 1 WHERE attempts < 10 with row-level locking, eliminating the race condition entirely. Per the noisgate mitigation SLA for HIGH, deploy within 30 days; given the trivial update mechanism (WordPress plugin auto-update or one-click in wp-admin), aim for 7 days.
2
HIGH 7.5→IGNORE 0.0
SEVERITY REDUCED
Switch customer auth from OTP to password-based login — In LatePoint → Settings → Authentication, change the authentication type from 'OTP only' to 'Password'. This completely removes the vulnerable code path from the authentication flow. The race condition in verifyOTP is never reached if OTP auth is disabled. This is a zero-downtime change that can be made in under 60 seconds. Deploy within 3 days as interim mitigation.
3
HIGH 7.5→MEDIUM 5.5
SEVERITY REDUCED
WAF-block concurrent POST bursts to the OTP verification endpoint — Add a WAF rule (Wordfence, Cloudflare, Sucuri, or ModSecurity) that rate-limits POST requests to admin-ajax.php where the route_name parameter contains auth__verify_otp. Cap at 10 requests per IP per 60 seconds. This doesn't fix the race condition but makes brute-forcing the full 6-digit keyspace impractical. Deploy within 3 days.
4
HIGH 7.5→MEDIUM 6.0
SEVERITY REDUCED
Add server-level connection concurrency limits — Configure nginx limit_conn or Apache mod_evasive to restrict concurrent connections per IP to the WordPress AJAX handler. Set limit_conn_zone to 20 concurrent connections per client IP. This degrades the attacker's ability to fire enough parallel requests to meaningfully exploit the race window, but a distributed attack from multiple IPs could circumvent it.
What doesn't work
  • WordPress nonces — the auth__verify_otp endpoint is an unauthenticated AJAX action; nonce validation does not apply to unauthenticated callers.
  • CAPTCHA on the booking form — CAPTCHA protects the booking flow, not the standalone OTP verification AJAX endpoint. The attacker calls admin-ajax.php directly, bypassing any front-end CAPTCHA.
  • Longer OTP codes — LatePoint hardcodes 6-digit OTPs; there is no user-configurable option to increase code length. You'd need to modify plugin source, which breaks on the next update.
  • IP-based fail2ban on wp-login.php — this vuln doesn't use wp-login.php; it uses the AJAX endpoint. fail2ban rules targeting WordPress login won't trigger.
04 · Intelligence Metadata

The supporting signals.

In-the-Wild ExploitationNo evidence. Not listed in CISA KEV. No campaigns or threat-actor attribution reported as of 2026-10-17. Disclosed today — too early for observed exploitation.
Proof-of-Concept AvailabilityNo public PoC detected. Checked pocindex.io, ExploitDB, GitHub (no repos named CVE-2026-110653), Nuclei templates, and SecureWithUmer/CVE-2026-PoCs. The race condition is well-understood and straightforward to script with Turbo Intruder or asyncio, so weaponization effort is low.
EPSS Score~0.00 (bottom percentile). The model has not yet ingested signal for this CVE given same-day disclosure. Expect this to rise modestly once advisory text propagates.
KEV StatusNot listed. No CISA KEV entry as of 2026-10-17.
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N — Unauthenticated, network-reachable, no interaction, high confidentiality and integrity impact, unchanged scope. The S:U is key: the attacker cannot escape the LatePoint customer-account context.
Affected VersionsLatePoint Appointment Booking Plugin ≤ 5.7.4 (all versions). The vulnerable code path is in otp_helper.php → verifyOTP() and auth_controller.php → auth__verify_otp.
Fixed Version5.7.5 — uses atomic SQL increment (UPDATE … SET attempts = attempts + 1 WHERE id = ? AND attempts < 10) with row-level locking. LatePoint changelog at latepoint.com/changelog does not yet list 5.7.5 publicly as of disclosure date.
Installed Base / Exposure~100K–172K active WordPress installations per WordPress.org and wp-rankings.com. WPoptic tracks ~4,134 live sites. LatePoint is a premium Envato/CodeCanyon plugin also available on WordPress.org. Predominantly used by small-to-medium businesses (salons, clinics, consultants). Enterprise deployment is rare.
Related Plugin VulnsLatePoint has 44 documented vulnerabilities in WPScan's database. Recent 2026 CVEs include CVE-2025-7038 (auth bypass via steps__load_step), CVE-2026-100163 (auth bypass via create_wp_user_for_customer), CVE-2026-1537 (info disclosure), CVE-2026-111602 (customer PII exposure), CVE-2026-103380 (IDOR). This is a pattern of systemic authentication failures.
Disclosure2026-10-17 (today). Researcher credit not publicly attributed in available advisories. CNA is likely Wordfence (common for WordPress plugin CVEs).

Sources.

  1. NVD — CVE-2026-110653
  2. VulDB — LatePoint verifyOTP TOCTOU
  3. Offseq Radar — CVE-2026-110653 Analysis
  4. Strix.ai — CVE-2026-110653
  5. TheHackerWire — CVE-2026-110653 Analysis & Fix
  6. LatePoint Official Changelog
  7. WPScan — LatePoint Plugin Vulnerabilities
  8. LatePoint OTP Configuration Docs
05 · The Call

Final Verdict
↓ DOWNGRADED to HIGH (7.5/10)

Why this verdict

  • Scope ceiling is customer-account-level, not admin or OS. The CVSS vector's S:U (Scope: Unchanged) is accurate — the attacker compromises a LatePoint *customer* account (bookings, PII, appointment notes). There is no path to WordPress admin, wp-config.php database credentials, or server-level access. This caps real-world impact below infrastructure-class CRITICAL.
  • OTP-auth prerequisite narrows the vulnerable population. OTP-based customer authentication is an *optional, non-default* configuration. LatePoint's default is password-based login. Only installations where an admin has explicitly switched to OTP-only mode in Settings → Authentication are exploitable. Conservative estimate: 20–40% of installations enable OTP, reducing the reachable target set to ~20K–70K sites.
  • Known-email/phone prerequisite adds targeting friction. The attacker cannot spray the endpoint blindly — they need a specific registered customer's email or phone to trigger the OTP flow. While companion vulns (CVE-2026-111602, CVE-2026-103380) can leak this data on the same affected versions, chaining two vulns is a higher bar than the CVSS assumes.
  • Role multiplier: No high-value enterprise role. LatePoint is an appointment-scheduling plugin for SMB WordPress sites — salons, dental offices, consultants, small clinics. It is not an identity provider, hypervisor, CI/CD system, network edge appliance, backup platform, or any canonical high-value-role component. The worst-case blast radius is *customer PII/PHI breach on a single WordPress site*, not domain takeover, fleet compromise, or supply-chain pivot. No deployment-role floor applies.
  • No exploitation signal. Zero EPSS, no KEV listing, no public PoC, no observed campaigns. Disclosed today. The race condition is trivial to script but nobody has yet.

Why not higher?

The unauthenticated network vector and zero-click nature initially suggest CRITICAL, but the impact ceiling is the decisive factor. The attacker gains a *customer booking account* — not WordPress admin, not a shell, not database access. The scope is explicitly Unchanged. OTP-auth being optional and non-default further shrinks the vulnerable population. LatePoint occupies no high-value enterprise role (it's a booking widget for SMBs), so no deployment-role floor forces CRITICAL or even the upper bound of HIGH.

Why not lower?

Despite the friction, this is still an unauthenticated, network-reachable authentication bypass with no user interaction required. A 6-digit OTP brute-force via race condition is a well-understood technique with low weaponization effort. The exposed data — customer names, emails, phones, appointment notes — can include PHI for medical booking sites, triggering regulatory notification obligations. The pattern of 44 vulnerabilities in this plugin, including multiple auth bypasses in 2026 alone, signals that unpatched LatePoint sites are soft targets. This firmly belongs in HIGH, not MEDIUM.

06 · Verification

Crowdsourced verification payload.

Run this script on the WordPress host (or any machine with filesystem access to the WordPress installation directory). Invoke as: sudo bash check_cve_2026_110653.sh /var/www/html where the argument is the WordPress root directory. Requires read access to the plugin directory. No network access or WordPress database credentials needed.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/bin/bash
# CVE-2026-110653 Checker — LatePoint OTP Race Condition Auth Bypass
# Usage: bash check_cve_2026_110653.sh /path/to/wordpress
# Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN

set -euo pipefail

WP_ROOT="${1:-/var/www/html}"
PLUGIN_DIR="$WP_ROOT/wp-content/plugins/latepoint"
README="$PLUGIN_DIR/readme.txt"
MAIN_FILE="$PLUGIN_DIR/latepoint.php"

if [ ! -d "$PLUGIN_DIR" ]; then
  echo "UNKNOWN — LatePoint plugin not found at $PLUGIN_DIR"
  exit 2
fi

# Extract version from main plugin file header or readme.txt
VERSION=""
if [ -f "$MAIN_FILE" ]; then
  VERSION=$(grep -i 'Version:' "$MAIN_FILE" | head -1 | sed 's/.*Version:[[:space:]]*//' | tr -d '[:space:]')
fi
if [ -z "$VERSION" ] && [ -f "$README" ]; then
  VERSION=$(grep -i 'Stable tag:' "$README" | head -1 | sed 's/.*Stable tag:[[:space:]]*//' | tr -d '[:space:]')
fi

if [ -z "$VERSION" ]; then
  echo "UNKNOWN — could not determine LatePoint version"
  exit 2
fi

echo "Detected LatePoint version: $VERSION"

# Compare versions: vulnerable if <= 5.7.4
version_lte() {
  [ "$(printf '%s\n' "$1" "$2" | sort -V | head -n1)" = "$1" ]
}

FIXED="5.7.5"

if version_lte "$VERSION" "5.7.4"; then
  # Double-check: look for the atomic SQL pattern in otp_helper.php
  OTP_FILE="$PLUGIN_DIR/lib/helpers/otp_helper.php"
  if [ -f "$OTP_FILE" ]; then
    if grep -q 'attempts < 10' "$OTP_FILE" 2>/dev/null || grep -q 'attempts + 1' "$OTP_FILE" 2>/dev/null; then
      echo "PATCHED — version $VERSION but atomic OTP guard detected (possible backport)"
      exit 0
    fi
  fi
  echo "VULNERABLE — LatePoint $VERSION is affected by CVE-2026-110653 (fixed in $FIXED)"
  exit 1
else
  echo "PATCHED — LatePoint $VERSION >= $FIXED"
  exit 0
fi