
POC per CVE-2026-78006 The Events Calendar <= 6.17.4 - Iniezione di Oggetti PHP non Autenticata con Esecuzione di Codice Remoto
POC per CVE-2026-78006 The Events Calendar <= 6.17.4 - Iniezione di Oggetti PHP non Autenticata con Esecuzione di Codice Remoto
#CONTACT telegram per qualsiasi richiesta : @soldout0O
Se apprezzi il mio lavoro, considera di supportare il progetto tramite USDT (TRC20): TQBA72kakjCZLnJt8fJYcD7dyQCEpzNtVN
The Events Calendar per WordPress contiene una vulnerabilità di Iniezione di Oggetti PHP non autenticata che può essere concatenata con l'Esecuzione di Codice Remoto.
Il percorso di codice vulnerabile coinvolge:
is_safe_widget_instance()enable_rendering_widget_copied()unserialize()do_blocks()Nelle condizioni documentate, un attaccante non autenticato può inviare markup di blocco appositamente costruito attraverso un commento a un evento e raggiungere il percorso di deserializzazione vulnerabile prima che avvenga la moderazione del commento.
La vulnerabilità esiste perché la protezione del plugin attorno alle istanze dei widget è insufficiente.
Il flusso vulnerabile può essere riassunto come:```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
---
# Plugin interessato
**Plugin:** The Events Calendar
**Vulnerabilità:** PHP Object Injection non autenticato che porta a
Remote Code Execution
**Versioni interessate:** Tutte le versioni fino alla **6.17.4** inclusa,
secondo l'avviso di Wordfence.
> [!IMPORTANT]
> Il PoC di ricerca attualmente pubblicato con questo repository si
> identifica internamente come mirato a `<= 6.17.2`.
>
> L'intervallo di versioni indicato sopra segue l'avviso di Wordfence
> (`<= 6.17.4`). Verificare sempre la versione esatta vulnerabile/corretta
> rispetto all'avviso del fornitore prima di testare un deployment.
---
# Causa principale
Il comportamento vulnerabile è associato all'interazione tra il
controllo di sicurezza del widget e il comportamento di deserializzazione
degli oggetti di PHP.
Le funzioni chiave coinvolte sono:```text
is_safe_widget_instance()
enable_rendering_widget_copied()
Il controllo di sicurezza è insufficiente perché PHP può invocare metodi magici durante il suo comportamento di parsing/deserializzazione prima che la prevista validazione di sicurezza fornisca una protezione efficace.
La catena si basa anche sul fatto che il plugin generi un valore di integrità valido per l'istanza del widget fornita.
Una delle caratteristiche più importanti di questa vulnerabilità è che l'attaccante non necessita di un account WordPress esistente.
Il percorso di attacco sfrutta il modo in cui WordPress espone il commento in attesa dell'utente stesso tramite un URL con hash di moderazione.
Le condizioni rilevanti sono:```text Comments enabled + Comments visible on events + Attacker can submit an event comment + V2 single-event template active
Dopo aver inviato un commento, WordPress può fornire un URL moderation-hash non autenticato che consente a chi commenta di visualizzare il proprio commento in attesa di moderazione.
Questo crea un meccanismo di distribuzione non autenticato per il markup del blocco creato.
---
# Spiegazione tecnica
## 1. Invio del commento
L'attaccante invia un commento associato a un evento.
Il commento non deve essere approvato.
La proprietà importante è che WordPress può esporre il commento attraverso il meccanismo moderation-hash.
---
## 2. Accesso tramite moderation-hash
WordPress fornisce a chi commenta un URL che gli consente di visualizzare il proprio commento in attesa di moderazione.
Ciò significa che l'attaccante può raggiungere il percorso di rendering vulnerabile senza attendere la moderazione.
Concettualmente:```text
POST Comment
|
v
Pending Comment
|
v
Moderation Hash
|
v
Unauthenticated Access
Il template V2 per singolo evento di The Events Calendar elabora il contenuto dell'evento e l'HTML relativo ai commenti.
Il percorso di elaborazione WordPress rilevante raggiunge infine:```text do_blocks()
Questo è importante perché il markup a blocchi incorporato nel contenuto renderizzato
viene interpretato come dati di blocco WordPress.
---
## 4. Dati di blocco craftati
Il PoC costruisce un blocco legacy-widget contenente un'istanza di widget
serializzata.
L'implementazione di ricerca costruisce il blocco utilizzando un'istanza
serializzata codificata e un attributo di integrità.
Il percorso vulnerabile elabora infine questi dati come istanza di widget.
---
## 5. Bypass dell'integrità
Il comportamento `enable_rendering_widget_copied()` del plugin può essere abusato
per produrre un attributo di integrità valido per i dati del widget controllati
dall'attaccante.
Ciò consente all'istanza di widget malevola di superare il controllo di
integrità previsto e raggiungere il percorso di elaborazione vulnerabile.
---
## 6. Gestione non sicura degli oggetti
La protezione vulnerabile `is_safe_widget_instance()` è insufficiente
contro l'oggetto fornito tramite l'istanza di widget craftata.
Il comportamento di gestione degli oggetti di PHP può invocare metodi magici durante
il processo di deserializzazione.
Il risultato è una primitiva di PHP Object Injection sfruttabile.
---
## 7. Gadget Chain
Il PoC di ricerca costruisce strutture di oggetti WordPress / The Events Calendar
che forniscono comportamento richiamabile durante la deserializzazione.
Il PoC utilizza oggetti orientati ai callback e strutture di classi serializzate
per costruire il payload di ricerca.
---
## 8. Esecuzione di codice
L'impatto finale è l'esecuzione di codice in remoto.
Il PoC contiene uno stadio di webshell di ricerca e una logica di
creazione di amministratore.
Per una verifica sicura della vulnerabilità, il confine di sicurezza importante è
già dimostrato dall'esecuzione riuscita della catena di
deserializzazione vulnerabile.
---
# Perché la vulnerabilità è critica
La combinazione di:```text
Unauthenticated
+
Remote
+
PHP Object Injection
+
RCE
crea un percorso di attacco ad alto impatto.
Un attaccante non ha bisogno di:
Il principale prerequisito ambientale è che il percorso vulnerabile di rendering di eventi/commenti sia raggiungibile.
Il repository contiene un'implementazione di ricerca basata su Python.
La PoC caricata è un runner asincrono attorno alla logica di ricerca originale.
Utilizza:```text Python aiohttp rich
L'implementazione esegue la catena di vulnerabilità attraverso una
consegna e verifica del payload per fasi.
Il sorgente del PoC descrive la propria architettura come:```text
payload building
|
v
stage 1
|
v
verification
|
v
stage 2
L'implementazione di ricerca include funzionalità per:
Il PoC contiene anche controlli consapevoli della piattaforma per ambienti Windows e Unix-like.
Lo strumento di ricerca può essere utilizzato contro una singola installazione WordPress autorizzata.
Concettualmente:```text Single URL | v Target Discovery | v Event Discovery | v Comment Delivery | v Vulnerability Trigger | v Verification
Un workflow a singolo target è utile per:
* Laboratori locali
* Sistemi di staging
* Riproduzione di CVE
* Test dei fornitori
* Penetration testing autorizzato
* Ricerca sulla sicurezza
---
# Elenco di URL
Il runner asincrono supporta anche un elenco di URL.
Il formato di input è:```text
one URL per line
Esempio:```text https://lab-wordpress-01.example https://lab-wordpress-02.example https://lab-wordpress-03.example
Le righe vuote e i commenti possono essere ignorati.
Il runner carica i target e li elabora in modo concorrente utilizzando il
numero di thread/concorrenza configurato.
---
# Elaborazione concorrente
Il PoC supporta l'elaborazione concorrente di più target.
Concettualmente:```text
URL LIST
|
+-----------+-----------+
| | |
v v v
Worker 1 Worker 2 Worker 3
| | |
v v v
Target Target Target
| | |
+-----------+-----------+
|
v
Results
L'implementazione utilizza un semaforo asincrono per controllare il livello di concorrenza.
La concorrenza predefinita configurata nel runner è 20.
Il runner asincrono può creare due file di risultato:```text shells.txt admins.txt
`shells.txt` contiene gli URL delle shell caricate scoperte.
`admins.txt` contiene le informazioni sui risultati degli amministratori nel formato:```text
url | user | pass
[!WARNING] Questi file possono contenere credenziali estremamente sensibili e artefatti di post-exploitation.
Non pubblicare mai i file di risultato generati su GitHub.
Per la ricerca pubblica sulle vulnerabilità, mantieni questi file al di fuori del repository
Git e aggiungili a .gitignore.
.gitignore consigliato```gitignoreshells.txt admins.txt
For responsible vulnerability validation:
START
|
v
Verifica la versione del plugin
|
v
Verifica i prerequisiti
|
v
Conferma che i commenti siano abilitati
|
v
Conferma che gli eventi espongano i commenti
|
v
Riproduci in un laboratorio
|
v
Conferma il comportamento vulnerabile
|
v
Registra evidenze e log
|
v
Interrompi / divulga```
Use the minimum level of interaction required to prove the finding.
---
# Important Prerequisites
The Wordfence advisory identifies the following important condition:
```text
I commenti devono essere abilitati
e
i commenti devono essere visibili sugli eventi```
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
Sistema operativo
Utente di esecuzione corrente
Directory di lavoro corrente
Document root
Software del server
Host HTTP
Informazioni 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
PHP Object Graph
|
v
Oggetto serializzato
|
v
Codifica Base64
|
v
Blocco widget legacy
|
v
WordPress do_blocks()
|
v
The Events Calendar
|
v
Deserializzazione dell'oggetto```
---
# 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
Directory di lavoro corrente
Utente di esecuzione
Document root
Informazioni sul server
Informazioni su 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
Esecuzione di codice in remoto
+
Accesso amministratore WordPress persistente```
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
Versione del plugin
+
Evento raggiungibile
+
Consegna dei commenti
+
Rendering dell'hash di moderazione
+
Elaborazione del widget vulnerabile
+
Prova di esecuzione controllata```
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
Log del server web
+
Log di WordPress
+
Attività del database
+
Integrità dei file
+
Account amministratore```
---
# Indicators of Compromise
Potential indicators include:
```text
Account amministratore imprevisti
Directory di plugin impreviste
File PHP imprevisti
File sospetti in wp-content/uploads/
Commenti di eventi imprevisti
Richieste anomale di moderation-hash
Richieste impreviste relative ai widget
Esecuzione PHP imprevista```
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 reali degli obiettivi
credenziali generate
file webshell
output phpinfo catturato
dump del database
informazioni sull'ambiente del server
dati di test privati```
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
Commenti sugli eventi
+
URL con hash di moderazione di WordPress
+
Rendering degli eventi 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
Validazione insufficiente del widget
+
Comportamento dei metodi magici di PHP
+
Attributo di integrità contraffatto
+
do_blocks()
+
Commenti sugli eventi pubblici
+
Accesso a 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
Vulnerabilità di The Events Calendar
RCE di The Events Calendar
PHP Object Injection di The Events Calendar
WordPress
CVE-2026-78006 POC
Sicurezza di WordPress
Vulnerabilità di WordPress
RCE di WordPress
PHP Object Injection
Deserializzazione PHP
RCE non autenticato
Esecuzione di codice in remoto
CVE
Sicurezza dei plugin di WordPress
RCE dei plugin di WordPress
is_safe_widget_instance
enable_rendering_widget_copied
do_blocks
Commenti di WordPress
hash di moderazione
legacy-widget
ricerca sulla sicurezza
PoC
Proof of Concept
penetration testing```