Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/deadexpl0it/cve-2026-78006-poc
Strumenti DifensiviMeccanismi di PersistenzaAnalisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebPost-ExploitSicurezza WebPenetration TestingSviluppo PayloadTrojan di Accesso Remoto
GitHubdeadexpl0it/cve-2026-78006-poc
15h 39m faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →

CVE-2026-78006-POC

POC per CVE-2026-78006 The Events Calendar <= 6.17.4 - Iniezione di Oggetti PHP non Autenticata con Esecuzione di Codice Remoto

Vedi Repository
Condividi

CVE-2026-78006-POC

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

💙 Supporta il Progetto

Se apprezzi il mio lavoro, considera di supportare il progetto tramite USDT (TRC20): TQBA72kakjCZLnJt8fJYcD7dyQCEpzNtVN

The Events Calendar — Iniezione di Oggetti PHP non Autenticata con RCE

PoC di Ricerca sulla Sicurezza

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()
  • La gestione dei metodi magici PHP durante la deserializzazione degli oggetti
  • unserialize()
  • Il template V2 per evento singolo
  • do_blocks()
  • La funzionalità di hash di moderazione dei commenti di WordPress
  • 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.


    Riepilogo della Vulnerabilità

    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

    root@kitploit:~
    ---
    
    # 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.


    Perché l'autenticazione non è richiesta

    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

    root@kitploit:~
    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
    

    3. Rendering degli Eventi

    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()

    root@kitploit:~
    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:

    • Un account amministratore
    • Una password WordPress valida
    • Cracking della password
    • Credenziali privilegiate esistenti

    Il principale prerequisito ambientale è che il percorso vulnerabile di rendering di eventi/commenti sia raggiungibile.


    PoC di Ricerca

    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

    root@kitploit:~
    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
    

    Capacità del PoC

    L'implementazione di ricerca include funzionalità per:

    • Elaborazione del target
    • Scoperta degli eventi
    • Consegna dei commenti
    • Costruzione di oggetti PHP serializzati
    • Costruzione di blocchi widget
    • Verifica della vulnerabilità
    • Raccolta di informazioni sull'ambiente
    • Consegna del payload basata su fasi
    • Creazione dell'amministratore
    • Distribuzione del webshell
    • Raccolta dei risultati
    • Elaborazione concorrente di più URL

    Il PoC contiene anche controlli consapevoli della piattaforma per ambienti Windows e Unix-like.


    Target singolo

    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

    root@kitploit:~
    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

    root@kitploit:~
    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.


    Output

    Il runner asincrono può creare due file di risultato:```text shells.txt admins.txt

    root@kitploit:~
    `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```gitignore

    PoC results

    shells.txt admins.txt

    Research Workflow

    For responsible vulnerability validation:

    root@kitploit:~
    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```
    
    Scarica lo strumento