How BitFire RASP Stops CVE-2026-15826 Profile Builder Authentication Bypass

Recherche de vulnérabilité WordPress

Profile Builder could turn a failed registration into an administrator autologin link, while BitFire authentication RASP prevents unauthenticated requests from minting WordPress auth cookies.

Unauthenticated Critical Severity Account Takeover Authentication Bypass
BitFire · Avis de vulnérabilitéRecherche publiée
ConseilCVE-2026-15826
ComposantProfile Builder
Source pertinentefront-end/class-formbuilder.php: wppb_log_in_user() and wppb_autologin_after_registration()
Résumé exécutif

Ce que les administrateurs WordPress doivent savoir

CVE-2026-15826 is a critical unauthenticated authentication bypass in Profile Builder for WordPress through version 3.16.4. On sites where front-end registration and automatic login after registration are enabled, a crafted registration with an over-long username can make WordPress return a WP_Error object, which vulnerable plugin code coerces to integer user ID 1 before checking for an error. The plugin then creates an autologin nonce for that user and later calls wp_set_auth_cookie( 1 ), giving the attacker an administrator session on many WordPress sites. BitFire bot protection can stop unknown automated registration requests, and BitFire authentication RASP independently prevents the final authentication bypass by requiring a request to provide authentication credentials before a wp_set_auth_cookie() call is allowed to succeed.

En un coup d'œil

Faits clés

  • Profile Builder Free, Hobbyist, and Pro versions up to and including 3.16.4 are affected
  • The vulnerable path requires a logged-out registration form with automatic login after registration enabled
  • A 61–70 character username causes wp_insert_user() to return WP_Error while passing the plugin's earlier form checks
  • The vulnerable code calls absint() before is_wp_error(), converting the WP_Error object to integer 1
  • An attacker can exchange the returned autologin nonce for a WordPress authentication cookie for user ID 1
  • BitFire authentication RASP blocks unauthenticated wp_set_auth_cookie() calls before the session is issued
01
Aperçu des vulnérabilités

Comprendre l'exposition

Le composant concerné, le chemin d’attaque et le risque pratique pour les sites Web WordPress.

Composant concernéProfile Builder
Portée potentielle50,000+ installations
Technique d'attaqueauthentication bypass
Publié2026-07-16
BitFire authentication RASP stops the takeover at the session boundary by denying unauthenticated wp_set_auth_cookie() calls even when vulnerable plugin code reaches them.
02
Analyse technique

Comment fonctionne la vulnérabilité

Détails de la recherche, versions concernées, comportement d'exploitation et conseils de remédiation.

CVE-2026-15826 Turns Failed Registration Into Administrator Login

Profile Builder's auto-login-after-registration feature is designed to create a new WordPress user, generate a short-lived autologin nonce for that user, and exchange the nonce for a normal WordPress session. In versions through 3.16.4, the feature can be reached by unauthenticated visitors on sites that publish a Profile Builder registration form and enable automatic login after registration. When the attack succeeds, the session is issued for user ID 1, which is commonly the site's first administrator account. The result is a critical account-takeover path without a prior WordPress login.

The Type Confusion Happens Before the Error Check

The vulnerable flow starts with a crafted registration request that uses a username between 61 and 70 characters. WordPress core rejects usernames longer than 60 characters and returns a WP_Error object from wp_insert_user(). Profile Builder then passes that return value into wppb_log_in_user(). The vulnerable version calls absint( $user_id ) before checking is_wp_error( $user_id ). In PHP, casting an object to an integer yields 1, so the WP_Error object becomes the plain integer 1 and the later error check can no longer detect the failed registration.

Autologin Converts the Confused User ID Into a Session

After the WP_Error has been coerced to 1, get_userdata( 1 ) resolves to a real account on most WordPress sites. Profile Builder then creates an autologin nonce and stores a transient binding that nonce to user ID 1. The response can expose a redirect URL containing autologin=true and the nonce. If the attacker follows that URL before the transient expires, Profile Builder verifies and consumes the nonce, then calls wp_set_auth_cookie( 1 ). That call is the sensitive operation that converts the registration logic bug into a valid administrator session.

Request-Layer Protection Can Interrupt the Exploit Delivery

The attack requires a scripted sequence: fetch the registration form, parse its nonce and hidden fields, submit a crafted POST with the over-long username, extract the autologin URL, and request it quickly. BitFire bot protection can reject unknown automated clients or browser impersonation when they send GET or POST requests containing unknown parameters. That layer operates before WordPress and Profile Builder process the malicious registration, but it is still separate from the final runtime session-control boundary.

BitFire Authentication RASP Blocks the Cookie-Minting Step

BitFire authentication RASP addresses the exploit at the point where it must succeed: wp_set_auth_cookie(). For CVE-2026-15826, the attacker reaches that call through an unauthenticated autologin URL, not through a legitimate credential exchange. BitFire requires any request to provide some form of authentication credentials before allowing wp_set_auth_cookie() to succeed. If vulnerable plugin code tries to issue a cookie for user ID 1 from a request that did not authenticate, RASP denies the operation and prevents the administrator session from being minted.

Conclusion: Registration Features Need Runtime Access Controls

Profile Builder 3.16.5 corrects the plugin logic by checking is_wp_error() before coercing the return value, adding username-length validation, and rendering failed registrations as failures instead of success redirects. Administrators should also review registration settings, autologin behavior, and user ID 1 metadata or session history if the vulnerable configuration was exposed. This CVE shows why site administrators need a security solution with built-in access controls and zero-day protection: plugin registration code can fail, and an independent runtime control must still prevent unauthenticated requests from creating authenticated WordPress sessions.

03
Examen des sources

Code vulnérable et corrigé

La source pertinente se trouve dans front-end/class-formbuilder.php: wppb_log_in_user() and wppb_autologin_after_registration().

AvantComportement vulnérable
// Vulnerable source, abridged from Profile Builder 3.16.4.
function wppb_log_in_user( $redirect, $redirect_old, $user_id ) {
    if( is_user_logged_in() ) {
        return;
    }

    if ( isset( $wppb_general_settings['emailConfirmation'] ) && ( $wppb_general_settings['emailConfirmation'] == 'yes' ) && !$should_bypass_ec ) {
        return $redirect_old;
    }

    $user_id = absint( $user_id );

    if ( ! $user_id || is_wp_error( $user_id ) ) {
        return $redirect_old;
    }

    $user = get_userdata( $user_id );
    if ( ! $user ) {
        return $redirect_old;
    }

    $redirect = add_query_arg( wppb_get_autologin_query_args( $user_id ), $redirect );
    return $redirect;
}
AprèsComportement corrigé
// Patched source, abridged from Profile Builder 3.16.5.
function wppb_log_in_user( $redirect, $redirect_old, $user_id ) {
    if( is_user_logged_in() ) {
        return;
    }

    if ( isset( $wppb_general_settings['emailConfirmation'] ) && ( $wppb_general_settings['emailConfirmation'] == 'yes' ) && !$should_bypass_ec ) {
        return $redirect_old;
    }

    // Reject failed registrations while $user_id is still a WP_Error object.
    if ( is_wp_error( $user_id ) ) {
        return $redirect_old;
    }

    $user_id = absint( $user_id );

    if ( ! $user_id ) {
        return $redirect_old;
    }

    $user = get_userdata( $user_id );
    if ( ! $user ) {
        return $redirect_old;
    }

    $redirect = add_query_arg( wppb_get_autologin_query_args( $user_id ), $redirect );
    return $redirect;
}
04
Protection « jour zéro »

Protection dès la première demande d'exploit

BitFire protège les serveurs WordPress dès le premier jour, avant qu'une vulnérabilité ne soit connue publiquement et avant que d'autres fournisseurs n'aient le temps de développer des signatures ou des correctifs.

01 · VérifierArrêtez les clients inconnus

Les contrôles des robots et la vérification du navigateur arrêtent les clients automatisés non fiables avant qu’un code d’exploitation jusqu’alors inconnu n’atteigne WordPress.

02 · DétecterBloquer les comportements malveillants

Les protections générales WAF identifient les comportements de requêtes dangereux et les charges utiles hostiles sans attendre une signature spécifique à la vulnérabilité.

03 · PrévenirContenir les attaques au moment de l'exécution

RASP suit l'exécution dans PHP et empêche les modifications non autorisées des fichiers, comptes et contenus de bases de données protégés.

BitFire · Protection WordPressPrêt pour le jour zéro
BitFire combine des contrôles de client vérifié, une détection WAF basée sur le comportement et une application RASP d'exécution pour protéger WordPress avant qu'un exploit n'ait un nom, un CVE, une signature ou un correctif de fournisseur.
À propos de l'auteur

Cory Marais

Cory a plus de 20 ans d'expérience en sécurité Internet et est l'un des principaux développeurs du projet BitFire.

Lire la recherche sur la sécurité BitFire →
Protégez votre site WordPress

Ajoutez une protection avant l’arrivée du prochain exploit.

BitFire combine les contrôles de robots, l'inspection des demandes, la détection des logiciels malveillants et la protection d'exécution dans une seule plateforme de sécurité WordPress.

Protéger mon site gratuitement â†'