1. Home
  2. iThink
  3. Cyber Security
  4. Vibe coding WordPress: 30 controlli di sicurezza per plugin
Cyber Security

Vibe coding WordPress: 30 controlli di sicurezza per plugin

Codice PHP di un tema WordPress che registra l'area dei widget
Immagine: doki7 · Pixabay · Licenza dei contenuti Pixabay

In cinque minuti un'AI ti scrive un plugin WooCommerce che funziona. Il campo si salva, lo shortcode si vede, l'endpoint REST risponde con un JSON pulito. Il cliente è contento, tu pure. Il problema del vibe coding su WordPress è che "funziona" e "è sicuro" sono due test diversi: l'AI fa passare il primo, il secondo non lo fa nessuno, perché nessuno sa che va fatto.

In questo articolo trovi il metodo che uso io prima di mandare online un plugin, un tema o un sito WordPress nato in vibe coding: 30 controlli, ognuno con verifica, correzione e prova. L'ho trasformato in una skill per Claude Code, /wp-secure-launch, che puoi scaricare gratis (le istruzioni sono in fondo all'articolo), ma puoi seguirlo anche a mano. Se il tuo progetto non è WordPress, la versione per le altre applicazioni web è nella guida ai 30 controlli di sicurezza per il vibe coding.

Perché il vibe coding su WordPress è più rischioso

Vibe coding vuol dire descrivere a un'AI quello che vuoi (Claude, ChatGPT, Cursor) e accettare il codice che produce, spesso senza leggerlo riga per riga. Se vuoi capire meglio il metodo, ne parlo nel primo capitolo della serie vibe coding per professionisti.

Su WordPress il danno non resta chiuso nel plugin: un plugin custom gira con gli stessi privilegi del core, dentro un sito che magari ha WooCommerce, ordini, clienti e pagamenti. Un endpoint AJAX scritto male espone tutto il negozio.

I numeri vanno nella stessa direzione. Nel report State of WordPress Security in 2026 Patchstack ha contato 11.334 nuove vulnerabilità tra core, plugin e temi WordPress nel 2025, il 42% in più dell'anno prima, e scrive che il vibe coding si sta fondendo con WordPress, con agenzie che generano plugin con l'AI su richiesta, e che la superficie d'attacco delle applicazioni crescerà. A dicembre 2025 la società di sicurezza Tenzai ha fatto costruire le stesse tre applicazioni a cinque strumenti di AI coding (Claude Code, OpenAI Codex, Cursor, Replit e Devin): nelle 15 applicazioni ha trovato 69 vulnerabilità, e tutti e cinque gli strumenti ne hanno prodotte.

L'AI ottimizza per "far funzionare". La sicurezza è un requisito che devi chiedere tu e poi verificare.

L'errore che vedo più spesso: "c'è il nonce, quindi è sicuro"

Se hai fatto scrivere un plugin a un'AI, apri il file e cerca wp_ajax_. Molto probabilmente troverai una cosa così:

add_action( 'wp_ajax_aggiorna_prezzo', 'rb_aggiorna_prezzo' );

function rb_aggiorna_prezzo() {
    check_ajax_referer( 'rb_nonce', 'nonce' );
    update_post_meta( $_POST['product_id'], '_price', $_POST['price'] );
    wp_send_json_success();
}

Sembra a posto: c'è il nonce. Ma il nonce protegge dal CSRF, non decide chi può fare cosa. Qualunque utente loggato che riesca a leggere il nonce, anche un semplice cliente registrato al tuo negozio, può chiamare questa funzione e cambiare il prezzo di un prodotto. E leggerlo è facile: spesso il plugin lo stampa nelle pagine del sito con wp_localize_script(). In più l'ID e il prezzo arrivano dal browser senza essere validati.

La versione corretta controlla il permesso, valida i dati e passa dalle funzioni di WooCommerce, che aggiornano anche il prezzo di listino e le tabelle di ricerca dei prodotti:

function rb_aggiorna_prezzo() {
    check_ajax_referer( 'rb_nonce', 'nonce' );

    if ( ! current_user_can( 'manage_woocommerce' ) ) {
        wp_send_json_error( 'Non autorizzato', 403 );
    }

    $product_id = absint( $_POST['product_id'] ?? 0 );
    $raw_price  = $_POST['price'] ?? null;
    $price      = is_scalar( $raw_price ) ? wc_format_decimal( wp_unslash( $raw_price ) ) : '';
    $product    = $product_id ? wc_get_product( $product_id ) : false;

    if ( ! $product || ! is_numeric( $price ) || (float) $price < 0 ) {
        wp_send_json_error( 'Dati non validi', 400 );
    }

    $product->set_regular_price( $price );
    $product->save();
    wp_send_json_success();
}

Bastano poche righe in più, e fanno la differenza tra un plugin che funziona e un plugin che puoi dare a un cliente. Lo stesso vale per le REST route: un permission_callback => '__return_true' su un endpoint che scrive dati è una porta aperta.

I 6 principi prima dei 30 controlli

  1. Il browser è territorio nemico. Tutto quello che arriva dal client ($_GET, $_POST, $_COOKIE, header, prezzi, ruoli, ID, campi nascosti) si può falsificare. Le decisioni si prendono sul server.
  2. Quello che scrive l'utente è un dato, mai un comando. Né SQL, né HTML, né shell, né percorsi di file.
  3. Il nonce non è un permesso. Protegge dal CSRF; chi può fare cosa lo decide current_user_can().
  4. Un segreto finito su Git è compromesso, anche se hai cancellato il commit. Si revoca e si rigenera.
  5. Prima trovo, poi sistemo, poi dimostro con un test. Nessun controllo è "ok" senza una prova ripetibile.
  6. Mai stampare un segreto, nemmeno nel report: solo file, riga, tipo e ultimi 4 caratteri. E mai una chiamata di prova con una chiave trovata.

La checklist: 30 controlli WordPress in 5 fasi

Per ogni controllo trovi tre cose: perché conta, cosa fare per sistemarlo e come verificarlo con una prova che puoi ripetere. Nei comandi sostituisci tuosito.it con il tuo dominio. I numeri sono quelli della skill, così ritrovi ogni controllo nel report che ti consegna; le fasi li raggruppano nell'ordine in cui conviene affrontarli. Come si scrive un report che porti a un piano d'azione, e come si ripete la prova dopo la correzione, lo trovi in Report e retest: dal laboratorio al piano d'azione.

Una regola prima di iniziare: i test attivi (password sbagliate, raffiche di richieste, upload di prova, payload di iniezione) si fanno in staging o in locale, con utenti di prova, mai sull'account admin vero del sito in produzione. E prima di toccare wp-config.php, .htaccess o il database fai un backup.

Prima dei controlli a mano lancio gli strumenti automatici, che danno una base in pochi minuti:

  • Plugin Check, lo strumento ufficiale di WordPress.org: wp plugin check tuo-plugin, solo in locale o in staging, perché alcuni controlli girano sul sito.
  • PHPCS con le regole di WordPress: phpcs --standard=WordPress wp-content/plugins/tuo-plugin. Le regole WordPress.Security segnalano nonce mancanti, output senza escaping e input non sanitizzato.
  • Semgrep per l'analisi statica: semgrep --config auto wp-content/plugins/tuo-plugin. Scarica le regole da internet: sul codice riservato di un cliente chiedi prima.
  • gitleaks per i segreti e composer audit o npm audit per le dipendenze, come nei controlli 25 e 22.

Gli scanner però vedono il codice, non la logica: un nonce o un prepare() vicino a una riga non vuol dire che proteggano proprio quell'operazione. Per questo i 30 controlli si fanno comunque tutti.

L'ordine conta. Si parte dai segreti esposti, perché sono il danno più immediato e una chiave Stripe o OpenAI nel codice del browser può costarti soldi nel giro di ore.

Fase 1: segreti e configurazione

2. Chiavi API fuori dagli script del frontend

  • Perché: tutto quello che passa da wp_localize_script(), da un file JavaScript del tema o da un attributo HTML lo legge chiunque, basta "Visualizza sorgente". Se una chiave OpenAI o Stripe è esposta, la usano altri e il conto lo paghi tu.
  • Cosa fare: sposta le chiamate che usano un segreto in una REST route o in un'azione AJAX del plugin, che legge la chiave da una costante in wp-config.php o da una variabile d'ambiente. Nel browser lascia solo le chiavi pubblicabili per natura: Stripe pk_, Google Maps limitata al tuo dominio.
  • Come verificarlo: cerca nel plugin con grep -rlE "sk_live_|sk_test_|sk-proj-|sk-ant-|AKIA[0-9A-Z]{16}" wp-content/plugins/tuo-plugin wp-content/themes/tuo-tema. L'opzione -l stampa solo i nomi dei file, così la chiave non finisce a schermo. Poi apri il sorgente di una pagina pubblica e cerca gli stessi prefissi: non deve comparire nulla.

12. Chiavi salvate nelle opzioni del database

  • Perché: l'AI salva spesso la chiave API con update_option() e la stampa di nuovo nella pagina delle impostazioni del plugin. Chi legge il database, un backup o il sorgente di quella pagina la trova in chiaro.
  • Cosa fare: dove puoi, metti le chiavi in costanti di wp-config.php (define( 'TUO_PLUGIN_API_KEY', '...' );) invece che nelle opzioni. Se devono stare nelle opzioni, salvale con autoload a no e nella pagina delle impostazioni mostra solo gli ultimi 4 caratteri, con un campo per sostituire la chiave senza rivederla. Se il plugin usa un file .env, deve stare fuori dalla cartella pubblica, non dentro quella del plugin.
  • Come verificarlo: apri la pagina delle impostazioni del plugin e guarda il sorgente HTML: il campo della chiave non deve contenere il valore completo. curl -sI https://tuosito.it/wp-content/plugins/tuo-plugin/.env deve rispondere 403 o 404.

21. WP_DEBUG e messaggi di errore disattivati in produzione

  • Perché: gli errori mostrati a schermo rivelano percorsi del server, versioni e nomi delle tabelle. Per chi attacca il tuo sito sono una mappa.
  • Cosa fare: in wp-config.php imposta WP_DEBUG e WP_DEBUG_DISPLAY a false e DISALLOW_FILE_EDIT a true. Se ti serve il log, usa WP_DEBUG_LOG con un percorso fuori dalla cartella pubblica. Se gli aggiornamenti passano da un altro flusso (un deploy da Git, per esempio), aggiungi DISALLOW_FILE_MODS. Togli SCRIPT_DEBUG e cancella file come phpinfo.php.
  • Come verificarlo: provoca un errore (un URL che non esiste, un parametro sbagliato in una chiamata AJAX). Devi vedere una pagina generica, senza percorsi né stack trace. curl -sI https://tuosito.it/wp-content/debug.log deve rispondere 403 o 404.

24. Esposizione di file sensibili e directory listing

  • Perché: backup, .env, cartelle .git e copie di wp-config.php dimenticati nella root sono il modo più semplice per prendersi un sito, perché contengono le password del database e le chiavi.
  • Cosa fare: aggiungi regole in .htaccess o Nginx che bloccano i file che iniziano con il punto e i backup, e disattiva l'elenco delle cartelle (Options -Indexes su Apache, autoindex off su Nginx; le regole che uso le trovi nella guida su come proteggere WordPress con .htaccess). Sposta backup e dump fuori dalla cartella pubblica, oppure cancellali dal server.
  • Come verificarlo: lancia il comando qui sotto. Devono rispondere tutti 403 o 404; se uno risponde 200, non aprirlo a schermo: controlla dimensione e tipo con curl -s -o /dev/null -w '%{size_download} %{content_type}\n' seguito dall'indirizzo. Se è una pagina HTML può essere il 404 «morbido» di WordPress; se è il file vero, toglilo subito.
for f in .env .git/config .git/HEAD wp-config.php.bak wp-config.php~ backup.zip dump.sql wp-content/debug.log readme.html .DS_Store phpinfo.php wp-content/uploads/; do
  echo "$f $(curl -s -o /dev/null -w '%{http_code}' https://tuosito.it/$f)"
done

25. Secret scanning della cronologia Git e rotazione delle chiavi

  • Perché: se cancelli una chiave con un nuovo commit, la chiave resta nella storia del repository e chi lo clona la trova.
  • Cosa fare: in quest'ordine. 1) Revoca la chiave dal pannello del fornitore; se è uscita la password del database o le chiavi segrete (salt) di wp-config.php, cambiale: le salt nuove disconnettono tutti gli utenti, ed è quello che vuoi. 2) Generane una nuova e mettila solo nelle variabili del server. 3) Aggiorna il sito online e controlla che funzioni. 4) Solo dopo, se vuoi, pulisci la storia con git filter-repo.
  • Come verificarlo: gitleaks detect --no-git --source . --redact controlla il codice attuale e non deve trovare nulla. gitleaks detect --source . --redact controlla tutta la cronologia (e ti dice anche se wp-config.php o un dump del database sono mai finiti in un commit): lì la vecchia chiave resta finché non riscrivi la storia, ed è normale se l'hai già revocata. La revoca la confermi dal pannello del fornitore, senza fare chiamate con la chiave trovata.

Fase 2: identità e accessi

1. Autenticazione affidata al core di WordPress

  • Perché: l'AI a volte crea un login proprio, con una tabella utenti e un controllo della password scritti da zero, o protegge una pagina con un parametro nell'URL. Sono difese che si aggirano in pochi minuti.
  • Cosa fare: usa gli utenti e le sessioni del core (wp_signon(), is_user_logged_in(), wp_get_current_user()) e i ruoli di WordPress. Ogni endpoint protetto controlla la sessione sul server. Se un'applicazione esterna deve chiamare il sito, usa le Application Password del core, non chiavi inventate dal plugin.
  • Come verificarlo: curl -i https://tuosito.it/wp-json/tuo-plugin/v1/dati senza cookie deve rispondere 401 o 403.

3. Controllo di accesso a livello di oggetto (IDOR) su ordini e contenuti

  • Perché: è tra le falle più comuni. Cambio ?order_id=1024 in 1025 e leggo l'ordine di un altro cliente, con indirizzo e telefono. Ai sensi del GDPR (art. 4, punto 12) è una violazione dei dati personali.
  • Cosa fare: ogni funzione che restituisce un ordine, un post privato o un dato dell'utente controlla il proprietario, mai solo l'ID arrivato dal browser. Sui contenuti usa le capability per oggetto: current_user_can( 'edit_post', $post_id ) o current_user_can( 'read_post', $post_id ). Su WooCommerce carica l'ordine con wc_get_order( absint( $id ) ) e controlla il proprietario: if ( ! $order || ! is_user_logged_in() || $order->get_customer_id() !== get_current_user_id() ) { wp_die( '', 403 ); }. Per lo staff la capability giusta è edit_shop_orders, non edit_posts (sul singolo ordine esiste anche la meta capability edit_shop_order, da usare con l'ID dell'ordine). Il controllo is_user_logged_in() serve per gli ordini senza registrazione: lì l'ID cliente vale 0, come quello di un visitatore anonimo, e il confronto da solo passerebbe. Per mostrare un ordine a un cliente non registrato usa la chiave dell'ordine che arriva nel link, verificata con $order->key_is_valid( wc_clean( wp_unslash( $_GET['key'] ?? '' ) ) ).
  • Come verificarlo: crea due clienti di prova e con il cliente A chiedi un ordine del cliente B. La risposta deve essere 403 o 404.

5. Hashing delle password con le funzioni del core

  • Perché: se il database esce (un backup rubato, una SQL injection), le password in chiaro o in MD5 si leggono subito. E la gente usa la stessa password ovunque.
  • Cosa fare: su WordPress usa gli utenti del core e wp_hash_password() / wp_check_password(), mai tabelle utenti parallele generate dall'AI. Se il plugin deve salvare altre credenziali (per esempio di un servizio esterno), non sono password da verificare ma segreti: vedi il controllo 12.
  • Come verificarlo: guarda il campo user_pass della tabella utenti. Deve iniziare con $wp$2y$ (WordPress 6.8 e successivi), $2y$ o $argon2id$. $P$ è il formato vecchio di WordPress e viene aggiornato al login successivo; 32 caratteri esadecimali senza prefisso sono un MD5 semplice, da sostituire.

9. Protezione dal brute force su wp-login.php e XML-RPC

  • Perché: i bot provano migliaia di password su wp-login.php e su xmlrpc.php. Senza un limite prima o poi indovinano, e tu non te ne accorgi.
  • Cosa fare: conta gli errori per la coppia IP più utente con l'hook wp_login_failed e un transient (contando solo per utente, chiunque potrebbe bloccare l'admin da fuori); il blocco vero lo fai nel filtro authenticate con priorità superiore a 20, che restituisce un errore quando la soglia è superata (a priorità più bassa il controllo della password del core lo scavalca). Al quinto errore blocca l'accesso per 15 minuti e manda un avviso all'admin via email o Telegram. Dietro Cloudflare o un proxy leggi l'IP reale dalla configurazione del server, non dall'header X-Forwarded-For che manda il client. Il messaggio d'errore deve essere generico ("credenziali non valide"): WordPress di suo dice se l'utente esiste, e lo cambi con il filtro login_errors. Se non usi XML-RPC, bloccalo con una regola sul server per xmlrpc.php: il filtro xmlrpc_enabled spegne solo i metodi con login, pingback.ping resta attivo.
  • Come verificarlo: in staging, con un utente di prova, sbaglia la password 5 volte: il blocco deve scattare e la notifica deve arrivarti.

10. Capability check su AJAX, admin-post e REST route

  • Perché: spesso l'AI "protegge" una pagina admin togliendola dal menu, ma l'URL, l'azione AJAX o la REST route restano chiamabili da chiunque.
  • Cosa fare: metti current_user_can() con la capability giusta all'inizio di ogni funzione admin, AJAX e admin_post_: manage_options per le impostazioni del sito, manage_woocommerce per quelle del negozio, edit_shop_orders per gli ordini, oppure una capability del plugin. Ogni REST route deve avere un permission_callback vero: mai __return_true su endpoint che scrivono dati. Attenzione agli hook wp_ajax_nopriv_ e admin_post_nopriv_: sono aperti anche ai visitatori non loggati, e l'AI li aggiunge spesso «per far funzionare» una chiamata.
  • Come verificarlo: accedi con un utente "cliente" e chiama le azioni admin, dal browser o con curl usando il suo cookie. Per le REST route manda anche l'header X-WP-Nonce con il nonce wp_rest di quell'utente: senza, WordPress ignora il cookie e risponde 401 anche quando l'endpoint richiede solo un utente loggato, e il 403 che cerchi non arriva mai. Per admin-ajax.php servono il cookie e il nonce nel parametro. Devi ricevere 403.

16. Attributi dei cookie di autenticazione: Secure, HttpOnly, SameSite

  • Perché: senza HttpOnly uno script XSS può rubare la sessione. Senza Secure il cookie può passare in chiaro. Senza SameSite sei più esposto al CSRF.
  • Cosa fare: WordPress mette già HttpOnly e, sui siti in HTTPS, Secure; SameSite no: lo aggiungi dal server, per esempio con Header edit Set-Cookie su Apache, impostando SameSite=Lax, poi prova un checkout completo con il ritorno dal gateway di pagamento: alcuni ritorni da 3D Secure o PayPal arrivano in POST da un altro dominio e possono perdere la sessione. Se il plugin crea cookie propri, imposta i tre flag con le opzioni di setcookie().
  • Come verificarlo: fai un login vero con un utente di prova, per esempio curl -si -d 'log=prova&pwd=…' https://tuosito.it/wp-login.php | grep -i '^set-cookie', oppure guarda i cookie negli strumenti per sviluppatori del browser. I cookie wordpress_logged_in_ e wordpress_sec_ devono avere i tre flag; wordpress_test_cookie non è un cookie di sessione e puoi ignorarlo.

17. Nonce contro il CSRF su form e azioni

  • Perché: un admin loggato visita una pagina malevola che manda un form al tuo sito, e l'azione parte con i suoi permessi.
  • Cosa fare: metti wp_nonce_field() nei form e check_admin_referer() o check_ajax_referer() nelle azioni; per le REST route il nonce wp_rest lo controlla il core. Nessuna azione che cancella o modifica dati deve partire con una richiesta GET, come un link «elimina» senza nonce.
  • Come verificarlo: rimanda la stessa richiesta POST senza nonce, poi con il nonce di un altro utente. Deve essere rifiutata tutte e due le volte.

18. Scadenza e uso singolo dei link di reset password

  • Perché: un link che non scade o si può riusare, trovato in una casella email violata, vale quanto una password.
  • Cosa fare: usa il reset del core, che crea un token monouso salvato come hash. Il link vale 24 ore: lo accorci a 15-60 minuti con il filtro password_reset_expiration. La pagina «password dimenticata» del core dice se l'utente esiste: rendi il messaggio uguale nei due casi. Dopo un reset chiudi tutte le sessioni con WP_Session_Tokens::get_instance( $user_id )->destroy_all(); se la password la cambia l'utente già loggato, tieni solo la sua con destroy_others( wp_get_session_token() ). Se il plugin ha un reset proprio, deve rispettare le stesse regole.
  • Come verificarlo: usa lo stesso link due volte, oppure dopo la scadenza. Deve essere rifiutato.

28. Autenticazione a due fattori per amministratori e shop manager

  • Perché: una password rubata con il phishing o ritrovata in un vecchio leak basta per entrare nella bacheca, installare un plugin malevolo e prendersi il sito.
  • Cosa fare: attiva il secondo fattore (app di autenticazione o chiave fisica) per tutti gli utenti con ruolo amministratore o shop manager, con un plugin affidabile come Two Factor, mantenuto da contributori di WordPress. Fai lo stesso su hosting, DNS, accesso FTP o SSH e account email dell'amministratore.
  • Come verificarlo: wp user list --role=administrator e wp user list --role=shop_manager ti danno l'elenco. Entra con ciascun account da una sessione nuova: deve chiedere il secondo fattore.

Fase 3: input, output e dati

6. Sanitizzazione e validazione degli input sul server

  • Perché: la validazione in HTML o JavaScript la toglie chiunque con gli strumenti del browser o con curl.
  • Cosa fare: sul server controlla tipo, lunghezza, formato e valori ammessi con absint(), sanitize_text_field(), sanitize_textarea_field(), sanitize_email(), sanitize_key(), sanitize_file_name(), esc_url_raw(), is_email() e liste di valori consentiti; nei plugin WooCommerce c'è anche wc_clean(). Sui dati di $_POST e $_GET usa prima wp_unslash(). Per le REST route definisci args con type, required, sanitize_callback e validate_callback. Tutto quello che non è previsto va rifiutato.
  • Come verificarlo: invia con curl campi vuoti, troppo lunghi, del tipo sbagliato o un array al posto di una stringa (campo[]=x). Devi ricevere un errore 400 con un messaggio pulito, senza warning di PHP.

7. Escaping dell'output contro l'XSS

  • Perché: se un nome o un commento contiene uno script, quello script gira nel browser di chi lo legge, admin compreso. Le conseguenze: furto della sessione, redirect, malware.
  • Cosa fare: fai l'escaping nel momento in cui stampi, con esc_html(), esc_attr(), esc_url(), esc_js(), esc_textarea(), wp_kses_post() o wp_kses() secondo il contesto. Vale anche per opzioni e meta, attributi degli shortcode, blocchi Gutenberg con rendering lato server, pagine admin del plugin e dati dei clienti WooCommerce (nome, email, indirizzo: esc_html( $order->get_billing_email() )). Nel JavaScript del plugin evita innerHTML con dati degli utenti.
  • Come verificarlo: scrivi <script>alert(1)</script> e "><img src=x onerror=alert(1)> in un campo, in un'impostazione del plugin e in un attributo di shortcode. Deve apparire come testo, senza nessun popup.

11. $wpdb->prepare() su ogni query personalizzata

  • Perché: con una variabile concatenata nella query, chi scrive nel form può riscriverla e leggere, modificare o cancellare il tuo database.
  • Cosa fare: usa $wpdb->prepare( "SELECT * FROM {$wpdb->prefix}tabella WHERE id = %d", $id ), oppure i metodi $wpdb->insert(), update() e delete() che preparano da soli. Nei LIKE passa il valore da $wpdb->esc_like(). Per i nomi di tabella e colonna, da WordPress 6.2, c'è il segnaposto %i; per l'ordinamento scelto dall'utente resta più sicura una lista di valori ammessi. Quando bastano, preferisci WP_Query e le API del core.
  • Come verificarlo: metti ', ' OR '1'='1 e 1 AND 1=2 nei parametri. Non devono comparire dati in più né errori SQL a schermo. Mai payload che cancellano o modificano dati, nemmeno in staging.

19. Upload sicuri nella cartella uploads

  • Perché: un file "foto.jpg" che in realtà è PHP, se finisce in una cartella dove il PHP viene eseguito, dà il controllo totale del server.
  • Cosa fare: passa dagli strumenti del core (wp_handle_upload(), media_handle_upload()), ammetti solo i tipi previsti controllati con wp_check_filetype_and_ext() e il filtro upload_mimes, imposta un peso massimo lato server e impedisci l'esecuzione di PHP nella cartella uploads con una regola sul server. Dai ai file un nome casuale. Gli SVG vanno vietati o ripuliti.
  • Come verificarlo: in staging carica un file PHP innocuo rinominato .jpg (per esempio con dentro solo <?php echo 'test';), un file troppo grande e un SVG con uno script. Devono essere rifiutati tutti e tre. Poi metti un file .php di prova in uploads e aprilo con curl: non deve essere eseguito. A fine prova cancella dal server qualsiasi file di test rimasto.

20. Prezzi, carrello e stato degli ordini confermati dal server

  • Perché: se il totale arriva dal browser, un cliente può pagare 1 € un prodotto da 500 €. Se l'ordine risulta "pagato" quando si apre la pagina di ringraziamento, basta aprire quella pagina.
  • Cosa fare: lascia a WooCommerce il calcolo di prezzi, sconti e totali e non accettare prezzi nei dati del carrello inviati dal client; se devi cambiare un prezzo con woocommerce_before_calculate_totals, usa solo valori calcolati sul server. Lo stato "pagato" lo imposta solo il webhook del gateway (Stripe, PayPal), dopo averne verificato la firma: con Stripe la verifichi sul corpo grezzo della richiesta e rifiuti le richieste troppo vecchie. Le vecchie notifiche IPN di PayPal non hanno firma e vanno riconfermate a PayPal. Il pagamento lo segni con $order->payment_complete(), e gestisci anche i webhook arrivati due volte. Leggi e scrivi gli ordini con wc_get_order() e i metodi dell'oggetto ($order->update_meta_data(), poi $order->save()), non con update_post_meta(): con l'archiviazione degli ordini ad alte prestazioni (HPOS) gli ordini non stanno più nella tabella dei post. Non salvare mai numeri di carta o CVV: ci pensa il gateway, tu conservi al massimo il token e le ultime 4 cifre.
  • Come verificarlo: modifica il prezzo nella richiesta: il server deve usare quello vero. Manda un webhook con firma falsa: deve essere rifiutato. Apri la pagina di ringraziamento di un ordine non pagato: lo stato non deve cambiare.

30. Privilegi minimi per utente del database, ruoli e chiavi API

  • Perché: l'AI tende a usare le credenziali più potenti perché "così funziona": l'utente root di MySQL in wp-config.php, il ruolo amministratore per un collaboratore che deve solo scrivere articoli, chiavi API con accesso a tutto.
  • Cosa fare: l'utente MySQL di WordPress ha permessi solo sul suo database. Ogni persona ha il ruolo minimo che le serve, e le capability personalizzate del plugin vanno solo ai ruoli che le usano. Le chiavi API dei servizi collegati hanno il minimo degli ambiti (per esempio chiavi Stripe con restrizioni). Le Application Password vanno create per singolo uso e revocate quando non servono più. Le capability che il plugin aggiunge vanno tolte quando lo disinstalli.
  • Come verificarlo: wp user list --role=administrator deve mostrare solo chi deve davvero amministrare il sito. Per ogni chiave API scrivi che cosa può fare.

Fase 4: trasporto e perimetro

4. HTTPS forzato su frontend e bacheca

  • Perché: senza HTTPS password e cookie viaggiano in chiaro su qualsiasi Wi-Fi pubblico. In più Chrome segna i siti in HTTP come «Non sicuro».
  • Cosa fare: imposta il redirect 301 da http a https sul server o sulla CDN. Metti siteurl e home in https e attiva FORCE_SSL_ADMIN. Per i contenuti misti (immagini e script salvati nel database con http://) usa wp search-replace: prima wp db export, poi una prova con --dry-run, poi la sostituzione vera.
  • Come verificarlo: curl -sI http://tuosito.it deve rispondere 301 verso https.

13. Rate limiting su login, form ed endpoint costosi

  • Perché: senza limite un bot può provare password all'infinito, riempirti il form di spam o consumare in una notte il credito della tua API di intelligenza artificiale.
  • Cosa fare: limita le richieste per IP e per account su login, registrazione, reset password, form contatti, admin-ajax.php ed endpoint costosi. Puoi farlo con Cloudflare o un WAF, con limit_req di Nginx o con un transient nel plugin.
  • Come verificarlo: in staging manda una raffica di richieste con il comando qui sotto, dopo aver sostituito /endpoint con l'indirizzo da provare. Evita gli endpoint che mandano email o consumano credito. Superata la soglia devono arrivare risposte 429.
for i in $(seq 1 50); do
  curl -s -o /dev/null -w "%{http_code}\n" -X POST https://tuosito.it/endpoint
done

14. CORS sulle REST route del plugin

  • Perché: con Access-Control-Allow-Origin: * qualsiasi sito può leggere le risposte pubbliche delle tue API. Il caso grave è un'API che ripete l'origine di chi chiama insieme a Access-Control-Allow-Credentials: true: allora un sito qualsiasi legge dal browser dei tuoi utenti anche i loro dati.
  • Cosa fare: sulle REST route WordPress ripete di suo l'origine con le credenziali e protegge le chiamate autenticate con il nonce X-WP-Nonce. Se le tue route usano un altro tipo di autenticazione, o se il plugin aggiunge header CORS propri, togli il filtro del core dentro l'azione rest_api_init, con priorità maggiore di 10, e metti il tuo con un elenco esplicito dei domini ammessi: remove_filter( 'rest_pre_serve_request', 'rest_send_cors_headers' ); seguito dal tuo add_filter(). Il core aggiunge quel filtro proprio in rest_api_init: se lo togli prima, non succede niente.
  • Come verificarlo: curl -s -D - -o /dev/null -H "Origin: https://evil.example" https://tuosito.it/wp-json/tuo-plugin/v1/dati mostra gli header. Su un WordPress standard vedrai l'origine ripetuta: controlla allora che senza nonce la risposta non contenga dati privati.

15. HTTP security header

  • Perché: sono difese del browser contro XSS, clickjacking e MIME sniffing. Non costano nulla e si attivano con poche righe di configurazione.
  • Cosa fare: aggiungi HSTS, Content-Security-Policy (parti in modalità Report-Only se usi Pixel e GTM), X-Content-Type-Options: nosniff, X-Frame-Options: SAMEORIGIN o frame-ancestors 'self' nella CSP (con DENY si rompono personalizzazione del tema, anteprime e page builder), Referrer-Policy: strict-origin-when-cross-origin e una Permissions-Policy minima. Togli X-Powered-By. Su HSTS usa includeSubDomains solo se tutti i sottodomini sono in HTTPS. Le righe pronte le trovi nella guida agli header di sicurezza HTTP con .htaccess.
  • Come verificarlo: curl -sI https://tuosito.it, oppure il test su securityheaders.com.

8. Registro delle attività e degli eventi di sicurezza

  • Perché: se succede qualcosa e non hai log, non sai cosa è successo, quando, né da dove. Però anche un log con le password dentro è una falla.
  • Cosa fare: registra login riusciti e falliti, cambi password, cambi di ruolo, installazione di plugin e temi, accessi admin ed errori 5xx, con un plugin di activity log o con gli hook del core (wp_login, wp_login_failed, set_user_role, activated_plugin, upgrader_process_complete). Tieni i log fuori dalla cartella pubblica e maschera password, token e dati delle carte. Decidi ogni quanto ruotare i log e per quanto tempo conservarli.
  • Come verificarlo: fai un login sbagliato e cerca la riga nel log: deve esserci l'evento, ma non la password.

Fase 5: dipendenze, resilienza, revisione e test

22. Core, plugin e temi senza vulnerabilità note

  • Perché: una parte importante dei siti WordPress violati cade per un plugin non aggiornato, non per il codice custom.
  • Cosa fare: aggiorna core, plugin e temi, ed esegui composer audit e npm audit se il plugin ha dipendenze. Parti dalle vulnerabilità critiche e alte, e dopo ogni aggiornamento importante controlla che il sito funzioni. Se il codice l'ha scritto un'AI, controlla anche che i pacchetti esistano davvero: ne parlo nell'articolo sulle dipendenze inventate dai modelli.
  • Come verificarlo: wp core check-update, wp plugin list --update=available e wp theme list --update=available dicono cosa va aggiornato, non cosa è vulnerabile: un plugin abbandonato non ha aggiornamenti e resta scoperto. Confronta quindi l'elenco di plugin e temi con un database di vulnerabilità (Patchstack o WPScan) e segnala quelli chiusi o tolti dalla directory di WordPress.org, poi rilancia gli audit. Non devono restare vulnerabilità alte o critiche aperte senza una motivazione scritta.

23. Plugin e temi inutilizzati rimossi

  • Perché: un plugin disattivato ma ancora sul server si può raggiungere direttamente via URL, e le sue vulnerabilità restano.
  • Cosa fare: elimina plugin e temi che non usi, dopo un backup e uno per uno, mai con un comando che cancella tutto in automatico. Tieni il tema genitore se usi un child theme e un tema predefinito di riserva. Togli anche file di test, vecchi shortcode e route REST di prova lasciati dall'AI.
  • Come verificarlo: wp plugin list --status=inactive deve restituire un elenco vuoto, e il sito deve ancora funzionare.

29. Backup completi e prova di ripristino

  • Perché: un malware, un errore dell'AI che cancella una tabella o un aggiornamento andato male si recuperano solo con un backup. E un backup mai ripristinato non dà nessuna garanzia.
  • Cosa fare: fai backup automatici di database e wp-content, cifrati, conservati fuori dal server di produzione e con almeno una copia che chi attacca il server non può cancellare. Scrivi chi ripristina, in quanto tempo e da quale copia.
  • Come verificarlo: ripristina l'ultimo backup su un ambiente di prova, con email, cron, gateway di pagamento e webhook disattivati, e controlla che il sito parta, che gli ordini recenti ci siano e che il login funzioni. Segna data e durata del ripristino nel report.

26. Revisione della logica del plugin con occhi da attaccante

  • Perché: gli scanner trovano gli errori tecnici, non quelli di logica, come un coupon riusabile all'infinito o un checkout in cui si salta il pagamento.
  • Cosa fare: rileggi il codice cercando questi casi: step del checkout che si possono saltare, coupon riutilizzabili, quantità negative e prodotti a 0 €, ruolo che si cambia via parametro (wp_update_user(), wp_insert_user() o update_user_meta() con dati del form, una registrazione che accetta il campo role), vecchi endpoint di test rimasti attivi (permission_callback => '__return_true'), URL forniti dall'utente e richiesti dal server (SSRF, usa wp_safe_remote_get()), percorsi con ../, unserialize() o maybe_unserialize() su input dell'utente, wp_redirect() verso URL esterni (usa wp_safe_redirect()), funzioni chiamate con un nome preso dalla richiesta (call_user_func()), extract() sui dati del form, webhook senza firma. Se il plugin usa un modello di AI, cerca anche la prompt injection dai contenuti del sito: la risposta del modello non deve mai finire eseguita come codice, in una query o nell'HTML senza escaping.
  • Come verificarlo: per ogni caso scrivi la richiesta che lo sfrutterebbe e controlla che venga rifiutata.

27. Test di regressione di sicurezza e report finale

  • Perché: "l'ho controllato" non è una prova, e alla prossima modifica fatta con l'AI il controllo potrebbe saltare di nuovo.
  • Cosa fare: raccogli tutti i comandi di verifica in uno script security-tests.sh, in test PHPUnit o in comandi WP-CLI, e rilanciali prima di ogni rilascio. Scrivi il report con il verdetto, lo stato di ogni controllo e le azioni ancora aperte.
  • Come verificarlo: lo script deve girare dall'inizio alla fine e ogni riga deve dare il risultato atteso.

Come fare i 30 controlli, passo per passo

Su un sito WordPress con un paio di plugin custom, fare i 30 controlli a mano richiede da mezza giornata a una giornata. La sequenza che seguo è questa:

  1. Ricognizione: capisci cosa hai davanti (plugin, tema classico o a blocchi, child theme, sito intero; con o senza WooCommerce; versioni di WordPress e PHP), poi fai l'elenco di tutto ciò che riceve dati dall'esterno. Nel tuo plugin basta cercare wp_ajax_, wp_ajax_nopriv_, admin_post_, register_rest_route, add_shortcode, i blocchi con render_callback, wp_schedule_event, $_FILES e le letture dirette di $_GET, $_POST e $_REQUEST. Poi lancia gli strumenti automatici.
  2. Segreti per primi: fase 1 completa, e revoca subito le chiavi trovate, prima di sistemare qualsiasi altra cosa.
  3. Accessi e dati: fasi 2 e 3, con due utenti di prova (un admin e un cliente) per ripetere ogni richiesta con entrambi. Per ogni punto di ingresso segui il dato fino a dove viene usato: database, pagina, file.
  4. Perimetro: fase 4 in staging e poi, solo con controlli di lettura come curl -sI, in produzione, perché header, HTTPS e CORS dipendono dal server.
  5. Dipendenze, backup e revisione: fase 5, poi lo script di test e il report.

Con la skill /wp-secure-launch in Claude Code buona parte della ricerca è automatica: l'agente mappa azioni AJAX, REST route, shortcode e upload, cerca le chiavi esposte, applica le correzioni e scrive i test. Restano a te le decisioni che non si possono delegare, come la revoca delle chiavi presso i fornitori. Alla fine ottieni un report con un verdetto (pronto, pronto con riserve, non pronto), la tabella dei 30 controlli con stato, gravità e prova, e l'elenco delle azioni che restano a te, in ordine di urgenza.

Errori da evitare

  • Fermarsi al nonce: protegge solo dal CSRF, quindi ogni azione ha bisogno anche di current_user_can().
  • Nascondere invece di chiudere: togliere una voce dal menu admin non impedisce a nessuno di chiamare l'URL o l'azione AJAX.
  • Usare wp_ajax_nopriv_ per comodità: l'AI lo aggiunge quando una chiamata "non funziona" da utente non loggato, e apre l'azione a tutto internet.
  • Cancellare il commit con la chiave: la chiave resta nella cronologia e nelle copie del repository. Va revocata.
  • Chiedere all'AI "è sicuro?": la risposta sarà quasi sempre sì. Chiedile invece di eseguire un controllo preciso e di mostrarti la prova.

Consigli pratici

  • Nel prompt chiedi esplicitamente nonce, capability, sanitizzazione in ingresso ed escaping in uscita: l'AI li aggiunge quando glieli chiedi, raramente da sola.
  • Tieni un utente "cliente" di prova sempre attivo sul tuo staging: è il modo più rapido per scoprire azioni admin aperte.
  • Rilancia security-tests.sh dopo ogni sessione di vibe coding, non solo prima del primo lancio: ogni nuovo prompt può togliere un controllo.
  • Plugin Check lo trovi nella directory di WordPress.org: installalo sul sito locale o di staging, non in produzione.

Scarica la skill /wp-secure-launch

La skill che uso io è scaricabile gratis. È un pacchetto per Claude che fa i 30 controlli sul tuo sito o plugin WordPress, applica le correzioni, scrive i test e ti consegna il report finale.

  1. Scarica il file wp-secure-launch.zip.
  2. Installala. In Claude Code estrai la cartella in ~/.claude/skills/ (oppure in .claude/skills/ dentro il progetto). Nell'app Claude carica lo zip nella sezione Skill delle impostazioni.
  3. Avviala. Apri il progetto e scrivi /wp-secure-launch, oppure chiedi "il plugin è pronto per il lancio?".

WP Secure Launch è creata da me e distribuita con licenza CC BY 4.0: puoi usarla e modificarla anche per lavoro, citando l'autore.

Domande frequenti

Un plugin WordPress creato con ChatGPT o Claude è sicuro?

Può esserlo, ma non per default. Di solito il codice generato funziona e salta i controlli che WordPress lascia allo sviluppatore: permessi (current_user_can), nonce, sanificazione in ingresso ed escaping in uscita. Va verificato prima di andare online.

Il nonce di WordPress basta a proteggere un endpoint AJAX?

No. Il nonce impedisce che un'azione parta da un altro sito (CSRF), ma non controlla chi è l'utente. Serve sempre anche un controllo di capability.

Un plugin WooCommerce fatto con l'AI può toccare ordini e pagamenti?

Sì, ed è il caso in cui i controlli contano di più: ordini letti da altri clienti (controllo 3), prezzi presi dal browser e stati di pagamento non verificati (controllo 20). Fai quei due controlli per primi dopo i segreti.

Ho trovato una API key in un vecchio commit. Basta cancellarlo?

No. Copie del repository, fork e sistemi di CI possono averla già. Revocala presso il fornitore, generane una nuova, aggiorna il deploy e solo dopo pulisci la storia di Git.

Questa checklist sostituisce un penetration test?

No. Copre gli errori più comuni del codice generato dall'AI ed è il minimo prima di un lancio. Per e-commerce con volumi importanti o dati sensibili serve anche un penetration test esterno.

Vuoi che il controllo lo faccia io?

Se hai un sito o un plugin WordPress nato in vibe coding e stai per andare online, posso eseguire i 30 controlli sul tuo progetto e consegnarti il report con le correzioni: è il lavoro che faccio nel servizio di sicurezza per siti WordPress. Scrivimi dalla pagina contatti.

E se vuoi capire come ragiona chi attacca, è tutto in Vita da Hacker.

Fonti

Condividi LinkedIn Facebook X WhatsApp Telegram Email
Cybersecurity per PMI

Quanto è esposta la tua azienda?

Un hacker etico certificato trova le falle prima di chi attacca e ti dice come chiuderle, partendo dalla più pericolosa.

Marketing & Google Ads

Le tue campagne stanno bruciando budget?

Raccontami obiettivi e numeri attuali: ti dico dove intervenire per primo.

Coding & debugging

Codice scritto con l’AI? Funziona oggi. Reggerà domani?

Audit del debito tecnico e della sicurezza di app e siti, debugging e code review.

iLife · crescita personale

Riprogramma la tua vita con il metodo di un hacker etico

Percorsi one-to-one per capire dove sei, scegliere la direzione e arrivarci con metodo.

Digital Agency

Dove sta frenando il tuo business?

Una consulenza per capire cosa sistemare prima: sicurezza, tecnologia, marketing o persone.

Continua a leggere

Tutti gli articoli del blog

Rocco Balzamà
Parli direttamente con me

Il prossimo passo?
Parliamone.

Raccontami cosa vuoi proteggere, costruire o far crescere. Ti aiuto a capire da dove partire.

Di cosa mi occupo

Da oltre trent'anni faccio tre cose. Cerco le falle della tua azienda prima che le trovi chi vuole entrare. Imposto il marketing perché i risultati si possano misurare. E aiuto persone e aziende a capire chi sono, prima ancora di decidere cosa vendere.

Da remoto e in presenzaLavoro da remoto tramite call e videocall. Quando il progetto lo richiede, intervengo anche in presenza.
Seguimi sui social
Certified Ethical HackerSicurezza informatica dal 1993
Gli strumenti con cui lavoro
  • Google Ads
  • Meta
  • WordPress
  • WooCommerce
  • Shopify
  • TikTok
Strumenti gratuiti