secaudit.eu
Protezione

Broken access control nei plugin WordPress: come evitarlo

Broken access control nei plugin WordPress: come proteggere handler AJAX, admin-post e REST con capability check, nonce corretti e verifica del proprietario.

A cura della , CortexRouter 7 min di lettura

Anche in: English Deutsch Français Español Polski Português Türkçe

La maggior parte dei bug di broken access control nei plugin WordPress nasce da una riga mancante: un controllo di capability che nessuno ha scritto. L'handler funziona, il nonce viene verificato, la funzione va in produzione e qualsiasi Subscriber (Abbonato) autenticato può richiamarla. Questo articolo è rivolto agli sviluppatori di plugin e temi e alle agenzie che scrivono plugin su misura. Illustra i pattern di codice all'origine di questi bug e i controlli che li prevengono.

Perché il broken access control è in cima alle vulnerabilità sfruttate nei plugin WordPress

Lo State of WordPress Security in 2026 di Patchstack è il report di un vendor e riguarda i dati del 2025. Indica il broken access control come la categoria più sfruttata. Lo stesso report ha conteggiato 11.334 nuove vulnerabilità nell'ecosistema WordPress, il 91 % delle quali nei plugin. Per le falle più sfruttate, la mediana ponderata del tempo prima dello sfruttamento di massa è stata di 5 ore. Se rilasci una falla, non avrai giorni per correggerla.

Per un plugin, broken access control significa un handler di richieste che modifica o rivela dati senza verificare chi sta chiedendo e che cosa quella persona possa toccare. Ogni handler deve rispondere a quattro domande, in quest'ordine:

  1. L'utente è autenticato? Si salta questo passaggio solo se l'azione è davvero pubblica.
  2. Ha il permesso di farlo? È il controllo di capability.
  3. Voleva davvero farlo? È il controllo del nonce contro il CSRF.
  4. Può toccare proprio questo oggetto? È il controllo di proprietà, o di meta-capability, sull'ID.
Diagramma: quattro controlli che un handler WordPress esegue prima di agire
Ogni handler supera quattro varchi prima di agire. Il varco del nonce dimostra solo l'intenzione, non il permesso.

Prima di tutto, individuare ogni punto di ingresso del plugin

Non si possono mettere in sicurezza handler che non si conoscono. Ogni punto in cui una richiesta raggiunge il vostro codice è una porta. Rientrano qui gli hook wp_ajax_ e wp_ajax_nopriv_, gli hook admin_post_ e admin_post_nopriv_ e le chiamate a register_rest_route(). Ci sono poi gli handler agganciati a init o template_redirect che leggono $_POST o $_GET, e gli shortcode o i blocchi che elaborano input di moduli.

Eseguite questi comandi dalla directory principale del plugin:

# Registered entry points
grep -rnE "wp_ajax_|admin_post_|register_rest_route" --include='*.php' .

# Public ones deserve a second look
grep -rn "wp_ajax_nopriv_\|admin_post_nopriv_\|__return_true" --include='*.php' .

# Raw request data read anywhere
grep -rn '\$_POST\|\$_GET\|\$_REQUEST' --include='*.php' .

Riportate i risultati in una tabella, con una riga per ogni punto di ingresso, e conservatela nel repository accanto al codice:

Entry pointTipoChi può chiamarlo
myplugin_save_settingsAJAXmanage_options
myplugin_exportadmin-postmyplugin_export_entries
GET /myplugin/v1/statsRESTPubblico, sola lettura

Se per un punto di ingresso non riuscite a compilare l'ultima colonna, avete trovato il primo bug.

Handler AJAX: wp_ajax_nopriv_ e il current_user_can() mancante

wp_ajax_nopriv_{action} rende un'azione raggiungibile senza alcun login. Registratelo solo per azioni davvero pubbliche, come una ricerca nel front end. Spesso gli sviluppatori lo aggiungono «perché il modulo funzioni anche per gli ospiti» e dimenticano che l'handler cancella o esporta dati.

Nemmeno wp_ajax_{action} da solo è un controllo dei permessi. Significa che qualsiasi utente autenticato può richiamare l'azione, Subscriber compresi. Non fate affidamento su is_admin(): restituisce true per ogni richiesta a admin-ajax.php e admin-post.php, perché questi file vengono caricati nel contesto di amministrazione. Dice dove è arrivata la richiesta, non chi l'ha inviata.

Un handler che risponde a tutte le domande:

add_action( 'wp_ajax_myplugin_delete_entry', 'myplugin_ajax_delete_entry' );
// Deliberately no wp_ajax_nopriv_ hook.

function myplugin_ajax_delete_entry() {
    if ( ! current_user_can( 'myplugin_manage_entries' ) ) {
        wp_send_json_error( array( 'message' => 'Forbidden' ), 403 );
    }

    // Dies with a 403 if the nonce is missing or invalid.
    check_ajax_referer( 'myplugin_delete_entry', 'nonce' );

    $entry_id = isset( $_POST['entry_id'] ) ? absint( $_POST['entry_id'] ) : 0;
    // ...ownership check and the actual work follow (see below).

    wp_send_json_success();
}

I controlli di capability e di nonce possono essere eseguiti in qualsiasi ordine. Conta che entrambi vengano eseguiti prima che l'handler legga o scriva qualcosa. Usate una capability personalizzata come myplugin_manage_entries quando l'azione non deve dipendere dai pieni diritti di amministratore. manage_options va bene quando l'accesso spetta solo agli amministratori.

Gli handler admin_post_ seguono le stesse regole. Cambia soltanto la risposta:

add_action( 'admin_post_myplugin_export', 'myplugin_handle_export' );

function myplugin_handle_export() {
    if ( ! current_user_can( 'myplugin_export_entries' ) ) {
        wp_die( esc_html__( 'You are not allowed to do this.', 'myplugin' ), '', array( 'response' => 403 ) );
    }
    check_admin_referer( 'myplugin_export' ); // pairs with wp_nonce_field( 'myplugin_export' )
    // ...
}

I nonce proteggono dal CSRF, non dall'utente sbagliato

Un nonce dimostra che la richiesta proviene da un modulo o da un link generato dal vostro plugin. Non dimostra che l'utente abbia il diritto di eseguire l'azione. Lo afferma anche il manuale per sviluppatori di WordPress. Eppure molti plugin vulnerabili considerano ancora un wp_verify_nonce() superato come un'autorizzazione.

Un nonce non può essere un'autorizzazione per tre motivi:

  • Chiunque riesca a caricare la pagina che stampa il nonce può leggerlo nel sorgente. Se il nonce compare in ogni schermata di amministrazione, o nel front end, ce l'ha anche un Subscriber.
  • I nonce non sono monouso. Per impostazione predefinita un nonce resta valido fino a 24 ore.
  • I nonce creati per visitatori non autenticati sono condivisi tra tutti i visitatori non autenticati, quindi proteggono pochissimo.

Abbinate a ogni controllo del nonce un controllo di capability. Generate il nonce solo nelle schermate mostrate agli utenti che possiedono la capability corrispondente. Usate un nome di azione specifico per ogni operazione, come myplugin_delete_entry_42 o almeno myplugin_delete_entry, invece di un unico myplugin_nonce per l'intero plugin.

Rotte REST: scrivere una permission_callback che controlli davvero

'permission_callback' => '__return_true' significa «chiunque su internet». Usatela solo per dati pubblici in sola lettura, già visibili altrove sul sito. Mai su rotte che scrivono o cancellano, né su rotte che restituiscono dati personali o impostazioni.

add_action( 'rest_api_init', function () {
    register_rest_route( 'myplugin/v1', '/entries/(?P<id>\d+)', array(
        'methods'             => WP_REST_Server::EDITABLE,
        'callback'            => 'myplugin_rest_update_entry',
        'permission_callback' => function ( WP_REST_Request $request ) {
            return current_user_can( 'edit_post', (int) $request['id'] );
        },
        'args'                => array(
            'id'    => array(
                'validate_callback' => function ( $value ) {
                    return is_numeric( $value );
                },
                'sanitize_callback' => 'absint',
            ),
            'title' => array(
                'type'              => 'string',
                'sanitize_callback' => 'sanitize_text_field',
            ),
        ),
    ) );
} );

Un controllo non superato deve restituire false o un WP_Error. WordPress risponde allora con 401 alle richieste anonime e con 403 agli utenti autenticati privi di permesso. Non eseguite il controllo dei permessi dentro callback: la logica si divide e le revisioni diventano più difficili. Il manuale della REST API sugli endpoint personalizzati approfondisce la validazione di args.

Le richieste REST con autenticazione tramite cookie, inviate dal vostro JavaScript, devono inviare un nonce wp_rest nell'header X-WP-Nonce. Senza di esso WordPress tratta la richiesta come non autenticata. È una protezione CSRF, non un'autorizzazione, quindi la permission_callback deve comunque eseguire il controllo. L'endpoint nativo degli utenti e la fuga dei nomi utente sono un tema a parte, trattato in enumerazione degli utenti in WordPress.

Non fidarsi mai dell'ID di un oggetto proveniente dalla richiesta

È il pattern dell'insecure direct object reference. Un handler prende dalla richiesta l'ID di un articolo, di un ordine, di una voce o di un file e lo usa senza verificare a chi appartenga. Il controllo di capability viene superato perché l'utente può modificare alcune voci, e nulla gli impedisce di modificare qualsiasi voce.

Per articoli e custom post type usate le meta-capability con l'ID, per esempio current_user_can( 'edit_post', $post_id ) o current_user_can( 'delete_post', $post_id ). Senza l'ID, WordPress non può collegare il controllo ad autore, stato e tipo dell'articolo. Chiamare current_user_can( 'edit_post' ) da solo dà un risultato privo di significato.

Per le tabelle personalizzate, inserite il controllo di proprietà direttamente nella query:

global $wpdb;
$table   = $wpdb->prefix . 'myplugin_entries';
$deleted = $wpdb->query(
    $wpdb->prepare(
        "DELETE FROM {$table} WHERE id = %d AND owner_id = %d",
        $entry_id,
        get_current_user_id()
    )
);

if ( ! $deleted ) {
    wp_send_json_error( array( 'message' => 'Not found' ), 404 );
}

Restituire 404 invece di 403 evita di confermare che la voce di un altro utente esista. Per le azioni su «il mio account», ricavate l'utente da get_current_user_id() e non accettate mai user_id dalla richiesta.

Prendiamo un plugin per moduli di contatto che salva le voci nel database. L'azione «esporta voci» è registrata su wp_ajax_ con un controllo del nonce e nient'altro. Qualsiasi Subscriber registrato può allora scaricare ogni messaggio inviato tramite il sito. Quando qualcuno sfrutta quella falla, ogni sito colpito subisce una violazione dei dati personali ai sensi del GDPR, con l'obbligo di notifica entro 72 ore che ne consegue.

Checklist di revisione del controllo degli accessi per ogni rilascio

  • Ogni punto di ingresso è elencato con il pubblico a cui è destinato.
  • Nessun hook nopriv esiste senza una motivazione scritta nel codice.
  • Ogni handler chiama current_user_can() prima di leggere o scrivere dati.
  • I nonce usano nomi di azione specifici e vengono verificati in ogni handler.
  • Nessuna rotta REST che scrive, cancella o restituisce dati privati usa __return_true.
  • Gli ID degli oggetti sono verificati con meta-capability o con una colonna del proprietario.
  • Le capability personalizzate vengono aggiunte all'attivazione e rimosse alla disinstallazione.
  • Il percorso di errore restituisce 401/403 (o 404) senza divulgare dati né stack trace.
  • Test automatici confermano che una richiesta di un Subscriber e una non autenticata vengono rifiutate per ogni azione privilegiata.
  • Ogni diff viene controllato alla ricerca di nuovi hook, nuove rotte e nuove letture di $_POST/$_GET.

Con la configurazione PHPUnit di WordPress questi test costano poco:

public function test_subscriber_cannot_update_entry() {
    wp_set_current_user( self::factory()->user->create( array( 'role' => 'subscriber' ) ) );
    $request  = new WP_REST_Request( 'POST', '/myplugin/v1/entries/' . $this->post_id );
    $response = rest_get_server()->dispatch( $request );
    $this->assertSame( 403, $response->get_status() );
}

Il plugin gratuito Security Audit & Compliance di secaudit.eu include un'analisi delle vulnerabilità del codice (taint analysis) di plugin e temi. Va considerato un secondo paio d'occhi, non un sostituto della revisione.

Quando arriva una segnalazione: gestione delle vulnerabilità e CRA

Un plugin o un tema a pagamento venduto a clienti nell'UE è un prodotto con elementi digitali ai sensi del Cyber Resilience Act, e chi lo vende è il fabbricante. Dall'11 settembre 2026 le vulnerabilità attivamente sfruttate devono essere notificate tramite la Single Reporting Platform dell'ENISA. Le scadenze sono: preallarme entro 24 ore, notifica entro 72 ore e relazione finale entro 14 giorni dalla disponibilità di una correzione. Dall'11 dicembre 2027 sono obbligatori un processo di gestione delle vulnerabilità e una politica di divulgazione coordinata. I dettagli sono nella nostra guida al CRA per chi vende plugin.

Rendetevi facili da contattare con un file security.txt e una casella di posta che qualcuno legga davvero. Quando arriva una segnalazione, correggete il problema e rilasciate la versione. Scrivete nel changelog una riga che indichi chiaramente la correzione di sicurezza e invitate i clienti ad aggiornare. I consigli per i titolari dei siti su come applicare gli aggiornamenti sono in Plugin WordPress vulnerabili: verificare, aggiornare, sostituire.

Il passo da fare oggi: eseguite i tre comandi grep indicati sopra sul vostro plugin e compilate la tabella dei punti di ingresso.

FAQ

is_user_logged_in() basta per proteggere un'azione?

No. Anche un Subscriber è autenticato. is_user_logged_in() risponde solo alla prima delle quattro domande, quindi aggiungete sempre un controllo di capability.

Un nonce può essere riutilizzato?

Sì, entro la sua durata, che per impostazione predefinita arriva a 24 ore. Un nonce non è un token monouso e non è un permesso: abbinatelo a current_user_can().

Ci si può fidare del ruolo Subscriber?

No. In molti siti chiunque può registrarsi come Subscriber (Impostazioni > Generali > Iscrizione). Considerate gli account Subscriber non attendibili e verificate con essi ogni azione privilegiata.

Questo articolo ha carattere informativo generale e non costituisce consulenza legale.

Controlla il tuo sito

Security Audit & Compliance è il plugin WordPress di secaudit.eu: cerca malware, spam nascosto, file core modificati e codice vulnerabile, e collega i risultati all’art. 32 del GDPR, all’art. 21 della NIS2 e alla OWASP Top 10.

Scopri cosa controlla il plugin
Redazione di secaudit.eu

Le guide di secaudit.eu sulla sicurezza di WordPress e sulla conformità alle norme UE sono scritte con strumenti di IA e confrontate automaticamente con il nostro elenco di fonti prima della pubblicazione. secaudit.eu è pubblicato da CortexRouter, un progetto libero e open source.

Scritto con l’aiuto dell’IA e confrontato automaticamente con il nostro elenco di fonti prima della pubblicazione. Questo articolo è un’informazione generale e non una consulenza legale.