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-78006-POC — POC pour CVE-2026-78006 The Events Calendar <= 6.17.4 - Injection d'objet PHP non authentifiée menant à l'exécution de code à distance | Kitploit
Outils/GitHubGitHub/deadexpl0it/cve-2026-78006-poc
Outils DéfensifsMécanismes de PersistanceAnalyse des VulnérabilitésExploitationExploitation d'Applications WebPost-ExploitationSécurité WebTests d'IntrusionDéveloppement de Charges UtilesCheval de Troie d'Accès à Distance
GitHub
1il y a 5h 18mPas encore vérifié
deadexpl0it/cve-2026-78006-poc

CVE-2026-78006-POC

POC pour CVE-2026-78006 The Events Calendar <= 6.17.4 - Injection d'objet PHP non authentifiée menant à l'exécution de code à distance

Voir le dépôt

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-78006-POC

POC pour CVE-2026-78006 The Events Calendar <= 6.17.4 - Injection d'objet PHP non authentifiée menant à l'exécution de code à distance

#CONTACT telegram pour toute demande : @soldout0O

💙 Soutenir le projet

Si vous appréciez mon travail, envisagez de soutenir le projet via USDT (TRC20) : TQBA72kakjCZLnJt8fJYcD7dyQCEpzNtVN

The Events Calendar — Injection d'objet PHP non authentifiée menant à une RCE

PoC de recherche en sécurité

The Events Calendar pour WordPress contient une vulnérabilité d'injection d'objet PHP non authentifiée qui peut être chaînée à une exécution de code à distance.

Le chemin de code vulnérable implique :

  • is_safe_widget_instance()
  • enable_rendering_widget_copied()
  • La gestion des méthodes magiques PHP lors de la désérialisation d'objets
  • unserialize()
  • Le template V2 d'événement unique
  • do_blocks()
  • La fonctionnalité de hachage de modération des commentaires de WordPress
  • Dans les conditions documentées, un attaquant non authentifié peut transmettre un balisage de bloc spécialement conçu via un commentaire d'événement et atteindre le chemin de désérialisation vulnérable avant que la modération des commentaires ne se produise.


    Résumé de la vulnérabilité

    La vulnérabilité existe parce que la protection du plugin autour des instances de widget est insuffisante.

    Le flux vulnérable peut être résumé comme suit :```text Unauthenticated Comment | v Pending Event Comment | v WordPress Moderation-Hash URL | v Unauthenticated Author Can View Own Pending Comment | v V2 Single-Event Template | v do_blocks() | v Injected Block Markup | v enable_rendering_widget_copied() | v Forged Integrity Attribute | v is_safe_widget_instance() | v PHP Magic Methods / Object Deserialization | v unserialize() | v PHP Object Injection | v Remote Code Execution

    root@kitploit:~
    ---
    
    # Extension affectée
    
    **Extension :** The Events Calendar
    
    **Vulnérabilité :** Injection d'objet PHP non authentifiée menant à
    l'exécution de code à distance
    
    **Versions affectées :** Toutes les versions jusqu'à **6.17.4** inclus,
    selon l'avis Wordfence.
    
    > [!IMPORTANT]
    > Le PoC de recherche actuellement publié avec ce dépôt s'identifie
    > en interne comme ciblant `<= 6.17.2`.
    >
    > La plage de versions indiquée ci-dessus suit l'avis Wordfence
    > (`<= 6.17.4`). Vérifiez toujours la version exacte vulnérable/corrigée par
    > rapport à l'avis du fournisseur avant de tester un déploiement.
    
    ---
    
    # Cause racine
    
    Le comportement vulnérable est associé à l'interaction entre la
    vérification de sécurité du widget et le comportement de désérialisation
    d'objet de PHP.
    
    Les fonctions clés impliquées sont :```text
    is_safe_widget_instance()
    enable_rendering_widget_copied()
    

    Le contrôle de sécurité est insuffisant car PHP peut invoquer des méthodes magiques lors de son comportement d'analyse/désérialisation avant que la validation de sécurité prévue n'apporte une protection efficace.

    La chaîne repose également sur le fait que le plugin génère une valeur d'intégrité valide pour l'instance de widget fournie.


    Pourquoi l'authentification n'est pas requise

    L'une des caractéristiques les plus importantes de cette vulnérabilité est que l'attaquant n'a pas besoin d'un compte WordPress existant.

    Le chemin d'attaque exploite la manière dont WordPress expose le commentaire en attente d'un utilisateur via une URL de hachage de modération.

    Les conditions pertinentes sont :```text Comments enabled + Comments visible on events + Attacker can submit an event comment + V2 single-event template active

    root@kitploit:~
    Après avoir soumis un commentaire, WordPress peut fournir une URL
    moderation-hash non authentifiée qui permet au commentateur de consulter son
    propre commentaire en attente.
    
    Cela crée un mécanisme de livraison non authentifié pour le balisage de bloc
    fabriqué.
    
    ---
    
    # Explication technique
    
    ## 1. Soumission du commentaire
    
    L'attaquant soumet un commentaire associé à un événement.
    
    Le commentaire n'a pas besoin d'être approuvé.
    
    La propriété importante est que WordPress peut exposer le commentaire via
    le mécanisme moderation-hash.
    
    ---
    
    ## 2. Accès par moderation-hash
    
    WordPress fournit au commentateur une URL qui lui permet de
    consulter son propre commentaire en attente.
    
    Cela signifie que l'attaquant peut atteindre le chemin de rendu vulnérable sans
    attendre la modération.
    
    Conceptuellement :```text
    POST Comment
         |
         v
    Pending Comment
         |
         v
    Moderation Hash
         |
         v
    Unauthenticated Access
    

    3. Rendu des événements

    Le modèle d'événement unique V2 de The Events Calendar traite le contenu de l'événement et le HTML lié aux commentaires.

    Le chemin de traitement WordPress pertinent atteint finalement :```text do_blocks()

    root@kitploit:~
    C'est important car le balisage de bloc intégré dans le contenu rendu
    est interprété comme des données de bloc WordPress.
    
    ---
    
    ## 4. Données de bloc forgées
    
    Le PoC construit un bloc de widget hérité contenant une instance de widget
    sérialisée.
    
    L'implémentation de recherche construit le bloc en utilisant une instance
    sérialisée encodée et un attribut d'intégrité.
    
    Le chemin vulnérable traite finalement ces données comme une instance de widget.
    
    ---
    
    ## 5. Contournement de l'intégrité
    
    Le comportement `enable_rendering_widget_copied()` du plugin peut être abusé
    pour produire un attribut d'intégrité valide pour les données de widget
    contrôlées par l'attaquant.
    
    Cela permet à l'instance de widget malveillante de passer la vérification
    d'intégrité attendue et d'atteindre le chemin de traitement vulnérable.
    
    ---
    
    ## 6. Gestion non sécurisée des objets
    
    La protection vulnérable `is_safe_widget_instance()` est insuffisante
    contre l'objet fourni via l'instance de widget forgée.
    
    Le comportement de gestion des objets de PHP peut invoquer des méthodes
    magiques pendant le processus de désérialisation.
    
    Le résultat est une primitive d'injection d'objet PHP exploitable.
    
    ---
    
    ## 7. Chaîne de gadgets
    
    Le PoC de recherche construit des structures d'objets WordPress / The Events Calendar
    qui fournissent un comportement appelable pendant la désérialisation.
    
    Le PoC utilise des objets orientés callback et des structures de classes sérialisées
    pour construire la charge utile de recherche.
    
    ---
    
    ## 8. Exécution de code
    
    L'impact final est l'exécution de code à distance.
    
    Le PoC contient une étape de webshell de recherche et une logique de création
    d'administrateur.
    
    Pour une vérification sécurisée de la vulnérabilité, la frontière de sécurité
    importante est déjà démontrée par l'exécution réussie de la chaîne de
    désérialisation vulnérable.
    
    ---
    
    # Pourquoi la vulnérabilité est critique
    
    La combinaison de :```text
    Unauthenticated
           +
    Remote
           +
    PHP Object Injection
           +
    RCE
    

    crée un chemin d'attaque à fort impact.

    Un attaquant n'a pas besoin de :

    • Un compte administrateur
    • Un mot de passe WordPress valide
    • De casser des mots de passe
    • D'identifiants privilégiés existants

    Le principal prérequis environnemental est que le chemin de rendu vulnérable des événements/commentaires soit accessible.


    PoC de recherche

    Le dépôt contient une implémentation de recherche en Python.

    Le PoC téléversé est un exécuteur asynchrone autour de la logique de recherche originale.

    Il utilise :```text Python aiohttp rich

    root@kitploit:~
    L'implémentation exécute la chaîne de vulnérabilités via une livraison et une vérification de charge utile par étapes.
    
    La source du PoC décrit son architecture comme suit :```text
    payload building
            |
            v
    stage 1
            |
            v
    verification
            |
            v
    stage 2
    

    Capacités du PoC

    L'implémentation de recherche inclut des fonctionnalités pour :

    • Traitement de cible
    • Découverte d'événements
    • Livraison de commentaires
    • Construction d'objets PHP sérialisés
    • Construction de blocs de widgets
    • Vérification de vulnérabilité
    • Collecte d'informations sur l'environnement
    • Livraison de payload par étapes
    • Création d'administrateur
    • Déploiement de webshell
    • Collecte de résultats
    • Traitement concurrent de plusieurs URLs

    Le PoC contient également des vérifications adaptées à la plateforme pour les environnements Windows et de type Unix.


    Cible unique

    L'outil de recherche peut être utilisé contre une installation WordPress individuelle autorisée.

    Conceptuellement :```text Single URL | v Target Discovery | v Event Discovery | v Comment Delivery | v Vulnerability Trigger | v Verification

    root@kitploit:~
    Un workflow à cible unique est utile pour :
    
    * Labs locaux
    * Systèmes de staging
    * Reproduction de CVE
    * Tests fournisseurs
    * Tests d'intrusion autorisés
    * Recherche en sécurité
    
    ---
    
    # Liste d'URL
    
    Le runner asynchrone prend également en charge une liste d'URL.
    
    Le format d'entrée est :```text
    one URL per line
    

    Exemple :```text https://lab-wordpress-01.example https://lab-wordpress-02.example https://lab-wordpress-03.example

    root@kitploit:~
    Les lignes vides et les commentaires peuvent être ignorés.
    
    Le runner charge les cibles et les traite de manière concurrente en utilisant le
    nombre de threads/concurrence configuré.
    
    ---
    
    # Traitement concurrent
    
    Le PoC prend en charge le traitement concurrent de plusieurs cibles.
    
    Conceptuellement :```text
                     URL LIST
                        |
            +-----------+-----------+
            |           |           |
            v           v           v
         Worker 1    Worker 2    Worker 3
            |           |           |
            v           v           v
          Target      Target      Target
            |           |           |
            +-----------+-----------+
                        |
                        v
                     Results
    

    L'implémentation utilise un sémaphore asynchrone pour contrôler le niveau de concurrence.

    La concurrence configurée par défaut dans le runner est de 20.


    Sortie

    Le runner asynchrone peut créer deux fichiers de résultats :```text shells.txt admins.txt

    root@kitploit:~
    `shells.txt` contient les URL des shells téléversés découverts.
    
    `admins.txt` contient les informations sur les résultats administrateur sous la forme :```text
    url | user | pass
    

    [!WARNING] Ces fichiers peuvent contenir des identifiants extrêmement sensibles et des artefacts de post-exploitation.

    Ne publiez jamais les fichiers de résultats générés sur GitHub.

    Pour la recherche publique sur les vulnérabilités, gardez ces fichiers en dehors du dépôt Git et ajoutez-les à .gitignore.


    .gitignore recommandé```gitignore

    PoC results

    shells.txt admins.txt

    Research Workflow

    For responsible vulnerability validation:

    root@kitploit:~
    START
                      |
                      v
              Vérifier la version du plugin
                      |
                      v
              Vérifier les prérequis
                      |
                      v
           Confirmer que les commentaires sont activés
                      |
                      v
           Confirmer que les événements exposent les commentaires
                      |
                      v
              Reproduire dans un lab
                      |
                      v
           Confirmer le comportement vulnérable
                      |
                      v
           Enregistrer les preuves et les journaux
                      |
                      v
              Arrêter / divulguer```
    
    Use the minimum level of interaction required to prove the finding.
    
    ---
    
    # Important Prerequisites
    
    The Wordfence advisory identifies the following important condition:
    
    ```text
    Les commentaires doivent être activés
    et
    les commentaires doivent être visibles sur les événements```
    
    The attack relies on the ability of an unauthenticated commenter to view
    their own pending comment through the WordPress moderation-hash URL.
    
    If comments are disabled or the relevant event comment path is not
    available, the documented unauthenticated delivery mechanism may not be
    reachable.
    
    ---
    
    # Platform Considerations
    
    The PoC contains environment-detection functionality.
    
    The research code attempts to identify information such as:
    
    ```text
    Système d'exploitation
    Utilisateur d'exécution actuel
    Répertoire de travail actuel
    Racine du document
    Logiciel serveur
    Hôte HTTP
    Informations PHP```
    
    These values are useful for controlled research and understanding the
    impact of successful code execution.
    
    ---
    
    # Payload Architecture
    
    The serialized payload contains multiple nested PHP objects.
    
    The research implementation builds structures associated with:
    
    ```text
    Tribe__Utils__Callback
    Tribe\Utils\Element_Classes
    stdClass```
    
    The serialized structures are then embedded into a WordPress legacy
    widget block.
    
    Conceptually:
    
    ```text
    Graphe d'objets PHP
           |
           v
    Objet sérialisé
           |
           v
    Encodage Base64
           |
           v
    Bloc de widget hérité
           |
           v
    WordPress do_blocks()
           |
           v
    The Events Calendar
           |
           v
    Désérialisation d'objet```
    
    ---
    
    # Stage 1
    
    The research PoC's first stage is designed to verify that the injected
    object graph reaches the intended execution path.
    
    The stage contains multiple controlled callbacks used to determine
    whether code execution or environment disclosure occurred.
    
    The implementation includes research checks such as:
    
    ```text
    Répertoire de travail actuel
    Utilisateur d'exécution
    Racine du document
    Informations sur le serveur
    Informations PHP```
    
    ---
    
    # Stage 2
    
    If the initial stage does not directly establish the required persistent
    artifact location, the PoC contains a second-stage mechanism that
    attempts alternative locations.
    
    The research implementation specifically considers WordPress upload
    locations and document-root-related paths.
    
    ---
    
    # Administrator Stage
    
    The PoC also contains administrator creation functionality.
    
    The research implementation can construct a WordPress administrator
    through the vulnerable execution path.
    
    This demonstrates that successful exploitation can result in both:
    
    ```text
    Exécution de code à distance
    +
    Accès administrateur WordPress persistant```
    
    Administrator credentials generated during research should never be
    committed to source control.
    
    ---
    
    # Webshell Stage
    
    The PoC contains a webshell stage intended for controlled research.
    
    The webshell is packaged as a WordPress plugin ZIP and deployed through
    an authenticated WordPress administrator session established by the
    chain.
    
    The research implementation uses a secret token to gate shell requests.
    
    > [!CAUTION]
    > The webshell is an exploitation artifact.
    >
    > Use it only in an isolated laboratory or during an explicitly
    > authorized penetration test, and remove it immediately after testing.
    
    ---
    
    # Verification
    
    Successful vulnerability validation can be based on evidence such as:
    
    ```text
    Version du plugin
           +
    Événement accessible
           +
    Livraison de commentaire
           +
    Rendu du hash de modération
           +
    Traitement de widget vulnérable
           +
    Preuve d'exécution contrôlée```
    
    For responsible disclosure, collect only the minimum evidence required.
    
    ---
    
    # Impact
    
    Successful exploitation may allow an unauthenticated attacker to:
    
    * Execute arbitrary PHP code
    * Execute commands in the context of the web server
    * Read sensitive application information
    * Access environment information
    * Modify WordPress files
    * Create administrator accounts
    * Install malicious plugins
    * Establish persistence
    * Potentially compromise the underlying server
    
    The ultimate impact depends on the privileges of the PHP process and
    the hosting environment.
    
    ---
    
    # Detection
    
    Defenders should monitor for unusual activity involving:
    
    * Event comment submissions
    * Pending comments followed by moderation-hash access
    * Suspicious block markup
    * Legacy widget blocks
    * Unexpected widget instance data
    * Unexpected serialized PHP objects
    * PHP execution triggered during event rendering
    * Unexpected plugin installations
    * New administrator accounts
    * Unexpected PHP files
    * Suspicious files under `wp-content/uploads/`
    
    A compromise investigation should correlate:
    
    ```text
    Journaux du serveur web
           +
    Journaux WordPress
           +
    Activité de la base de données
           +
    Intégrité des fichiers
           +
    Comptes administrateur```
    
    ---
    
    # Indicators of Compromise
    
    Potential indicators include:
    
    ```text
    Comptes administrateurs inattendus
    Répertoires de plugins inattendus
    Fichiers PHP inattendus
    Fichiers suspects dans wp-content/uploads/
    Commentaires d'événements inattendus
    Requêtes de hachage de modération anormales
    Requêtes liées aux widgets inattendues
    Exécution PHP inattendue```
    
    Because individual indicators can have legitimate explanations, they
    should be investigated in context.
    
    ---
    
    # Mitigation
    
    The primary mitigation is to update **The Events Calendar** to a fixed
    version provided by the vendor.
    
    Until the plugin is updated, defenders should consider:
    
    * Disabling comments where operationally acceptable
    * Restricting public event comments
    * Monitoring event comment traffic
    * Reviewing recently created administrator accounts
    * Monitoring plugin installation activity
    * Performing file-integrity checks
    * Reviewing web-server logs
    * Reviewing WordPress logs
    
    If compromise is suspected, treat the system as potentially compromised
    rather than merely vulnerable.
    
    ---
    
    # Incident Response
    
    If exploitation is suspected:
    
    1. Preserve relevant logs.
    2. Identify suspicious requests.
    3. Review administrator accounts.
    4. Review installed plugins.
    5. Inspect recently modified PHP files.
    6. Inspect `wp-content/uploads/`.
    7. Rotate WordPress credentials.
    8. Rotate hosting/server credentials where appropriate.
    9. Remove unauthorized persistence.
    10. Restore trusted application files when necessary.
    11. Upgrade the vulnerable plugin.
    12. Continue monitoring for re-entry.
    
    ---
    
    # Responsible Disclosure
    
    When reporting this vulnerability or derivative research:
    
    * Clearly identify the affected plugin.
    * Include the affected version.
    * Include the fixed version when confirmed.
    * Explain the unauthenticated attack path.
    * Document the required prerequisites.
    * Provide reproducible evidence in a controlled environment.
    * Avoid publishing victim data.
    * Never publish generated administrator credentials.
    * Never publish live webshell URLs.
    
    ---
    
    # Research Limitations
    
    A vulnerable plugin version alone does not guarantee successful
    exploitation.
    
    The attack path can be affected by:
    
    * WordPress configuration
    * Comment settings
    * Event visibility
    * Template configuration
    * Security plugins
    * Web Application Firewalls
    * Reverse proxies
    * PHP configuration
    * Hosting permissions
    * Object caching
    * Network filtering
    
    Therefore, version fingerprinting should be treated as an initial
    indicator rather than definitive proof of exploitability.
    
    ---
    
    # Repository Safety
    
    Do not commit:
    
    ```text
    shells.txt
    admins.txt
    URL de cibles réelles
    identifiants générés
    fichiers webshell
    sortie phpinfo capturée
    dumps de base de données
    informations sur l'environnement du serveur
    données de test privées```
    
    Use synthetic laboratory targets when creating screenshots,
    demonstrations, or documentation.
    
    ---
    
    # Recommended Repository Structure
    
    ```text
    the-events-calendar-poc/
    │
    ├── poc.py
    ├── README.md
    ├── LICENSE
    ├── .gitignore
    │
    ├── screenshots/
    │   └── .gitkeep
    │
    └── docs/
        └── research-notes.md```
    
    Keep runtime artifacts outside the repository.
    
    ---
    
    # Technical Summary
    
    ```text
    The Events Calendar
            |
            v
    V2 Single Event Template
            |
            v
    WordPress do_blocks()
            |
            v
    Legacy Widget Block
            |
            v
    Forged Widget Instance
            |
            v
    Valid Integrity Attribute
            |
            v
    is_safe_widget_instance()
            |
            v
    PHP Object Deserialization
            |
            v
    Magic Method Invocation
            |
            v
    PHP Object Injection
            |
            v
    Remote Code Execution```
    
    ---
    
    # Severity
    
    **Impact:** Remote Code Execution
    
    **Authentication:** Not required
    
    **Attack Vector:** Remote
    
    **Primary Component:** The Events Calendar
    
    **Primary Vulnerable Functions:**
    
    ```text
    is_safe_widget_instance()
    enable_rendering_widget_copied()```
    
    **Delivery Mechanism:**
    
    ```text
    Commentaires d'événements
    +
    URL de hachage de modération WordPress
    +
    Rendu d'événements V2```
    
    ---
    
    # Key Takeaway
    
    The important aspect of this vulnerability is not simply that the plugin
    uses PHP serialization.
    
    The complete unauthenticated attack path is enabled by the combination
    of:
    
    ```text
    Validation de widget insuffisante
              +
    Comportement des méthodes magiques PHP
              +
    Attribut d'intégrité falsifié
              +
    do_blocks()
              +
    Commentaires d'événements publics
              +
    Accès au moderation-hash```
    
    This combination creates an unauthenticated path to PHP Object Injection
    and Remote Code Execution.
    
    ---
    
    # Credits
    
    Vulnerability details and affected-version information:
    
    **Wordfence Threat Intelligence**
    
    Research PoC:
    
    **The Events Calendar PHP Object Injection / RCE research implementation**
    
    ---
    
    # References
    
    * Wordfence Threat Intelligence — The Events Calendar PHP Object
      Injection / RCE vulnerability
    * The Events Calendar
    * WordPress Core
    * WordPress Comments
    * WordPress Block Editor
    * WordPress `do_blocks()`
    * PHP Object Serialization / Deserialization
    
    ---
    
    # Disclaimer
    
    This repository contains security research concerning a remote-code-
    execution vulnerability affecting a WordPress plugin.
    
    The PoC is provided for:
    
    * Security research
    * Defensive validation
    * Authorized penetration testing
    * Controlled laboratory reproduction
    * Education
    
    Only test systems that you own or have explicit written authorization
    to assess.
    
    The authors are not responsible for unauthorized use of this research.
    
    ---
    
    # Keywords
    
    ```text
    CVE-2026-78006
    The Events Calendar
    The Events Calendar WordPress
    Vulnérabilité The Events Calendar
    The Events Calendar RCE
    The Events Calendar Injection d'objet PHP
    WordPress
    CVE-2026-78006 POC
    Sécurité WordPress
    Vulnérabilité WordPress
    WordPress RCE
    Injection d'objet PHP
    Désérialisation PHP
    RCE non authentifiée
    Exécution de code à distance
    CVE
    Sécurité des extensions WordPress
    RCE d'extension WordPress
    is_safe_widget_instance
    enable_rendering_widget_copied
    do_blocks
    commentaires WordPress
    moderation hash
    legacy-widget
    recherche en sécurité
    PoC
    Proof of Concept
    tests d'intrusion```
    
    Télécharger l’outil