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
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
Si vous appréciez mon travail, envisagez de soutenir le projet via USDT (TRC20) : TQBA72kakjCZLnJt8fJYcD7dyQCEpzNtVN
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()unserialize()do_blocks()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.
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
---
# 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.
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
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
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()
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 :
Le principal prérequis environnemental est que le chemin de rendu vulnérable des événements/commentaires soit accessible.
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
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
L'implémentation de recherche inclut des fonctionnalités pour :
Le PoC contient également des vérifications adaptées à la plateforme pour les environnements Windows et de type Unix.
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
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
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.
Le runner asynchrone peut créer deux fichiers de résultats :```text shells.txt admins.txt
`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é```gitignoreshells.txt admins.txt
For responsible vulnerability validation:
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```