- Home
- iThink
- Cyber Security
- Vibe coding WordPress: 30 controlli di sicurezza per plugin
Vibe coding WordPress: 30 controlli di sicurezza per plugin
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
- 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. - Quello che scrive l'utente è un dato, mai un comando. Né SQL, né HTML, né shell, né percorsi di file.
- Il nonce non è un permesso. Protegge dal CSRF; chi può fare cosa lo decide
current_user_can(). - Un segreto finito su Git è compromesso, anche se hai cancellato il commit. Si revoca e si rigenera.
- Prima trovo, poi sistemo, poi dimostro con un test. Nessun controllo è "ok" senza una prova ripetibile.
- 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 regoleWordPress.Securitysegnalano 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 auditonpm auditper 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.phpo da una variabile d'ambiente. Nel browser lascia solo le chiavi pubblicabili per natura: Stripepk_, 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-lstampa 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 conautoloadanoe 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/.envdeve 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.phpimpostaWP_DEBUGeWP_DEBUG_DISPLAYafalseeDISALLOW_FILE_EDITatrue. Se ti serve il log, usaWP_DEBUG_LOGcon un percorso fuori dalla cartella pubblica. Se gli aggiornamenti passano da un altro flusso (un deploy da Git, per esempio), aggiungiDISALLOW_FILE_MODS. TogliSCRIPT_DEBUGe cancella file comephpinfo.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.logdeve rispondere 403 o 404.
24. Esposizione di file sensibili e directory listing
- Perché: backup,
.env, cartelle.gite copie diwp-config.phpdimenticati 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
.htaccesso Nginx che bloccano i file che iniziano con il punto e i backup, e disattiva l'elenco delle cartelle (Options -Indexessu Apache,autoindex offsu 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 congit filter-repo. - Come verificarlo:
gitleaks detect --no-git --source . --redactcontrolla il codice attuale e non deve trovare nulla.gitleaks detect --source . --redactcontrolla tutta la cronologia (e ti dice anche sewp-config.phpo 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/datisenza 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=1024in1025e 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 )ocurrent_user_can( 'read_post', $post_id ). Su WooCommerce carica l'ordine conwc_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, nonedit_posts(sul singolo ordine esiste anche la meta capabilityedit_shop_order, da usare con l'ID dell'ordine). Il controllois_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_passdella 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.phpe suxmlrpc.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_failede un transient (contando solo per utente, chiunque potrebbe bloccare l'admin da fuori); il blocco vero lo fai nel filtroauthenticatecon 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'headerX-Forwarded-Forche 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 filtrologin_errors. Se non usi XML-RPC, bloccalo con una regola sul server perxmlrpc.php: il filtroxmlrpc_enabledspegne solo i metodi con login,pingback.pingresta 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 eadmin_post_:manage_optionsper le impostazioni del sito,manage_woocommerceper quelle del negozio,edit_shop_ordersper gli ordini, oppure una capability del plugin. Ogni REST route deve avere unpermission_callbackvero: mai__return_truesu endpoint che scrivono dati. Attenzione agli hookwp_ajax_nopriv_eadmin_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-Noncecon il noncewp_restdi 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. Peradmin-ajax.phpservono 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-Cookiesu Apache, impostandoSameSite=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 disetcookie(). - 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 cookiewordpress_logged_in_ewordpress_sec_devono avere i tre flag;wordpress_test_cookienon è 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 echeck_admin_referer()ocheck_ajax_referer()nelle azioni; per le REST route il noncewp_restlo 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 conWP_Session_Tokens::get_instance( $user_id )->destroy_all(); se la password la cambia l'utente già loggato, tieni solo la sua condestroy_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=administratorewp user list --role=shop_managerti 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'è anchewc_clean(). Sui dati di$_POSTe$_GETusa primawp_unslash(). Per le REST route definisciargscontype,required,sanitize_callbackevalidate_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()owp_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 evitainnerHTMLcon 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()edelete()che preparano da soli. NeiLIKEpassa 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, preferisciWP_Querye le API del core. - Come verificarlo: metti
',' OR '1'='1e1 AND 1=2nei 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 conwp_check_filetype_and_ext()e il filtroupload_mimes, imposta un peso massimo lato server e impedisci l'esecuzione di PHP nella cartellauploadscon 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.phpdi prova inuploadse 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 conwc_get_order()e i metodi dell'oggetto ($order->update_meta_data(), poi$order->save()), non conupdate_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=administratordeve 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
siteurlehomein https e attivaFORCE_SSL_ADMIN. Per i contenuti misti (immagini e script salvati nel database conhttp://) usawp search-replace: primawp db export, poi una prova con--dry-run, poi la sostituzione vera. - Come verificarlo:
curl -sI http://tuosito.itdeve 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.phped endpoint costosi. Puoi farlo con Cloudflare o un WAF, conlimit_reqdi Nginx o con un transient nel plugin. - Come verificarlo: in staging manda una raffica di richieste con il comando qui sotto, dopo aver sostituito
/endpointcon 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 aAccess-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'azionerest_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 tuoadd_filter(). Il core aggiunge quel filtro proprio inrest_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/datimostra 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: SAMEORIGINoframe-ancestors 'self'nella CSP (conDENYsi rompono personalizzazione del tema, anteprime e page builder),Referrer-Policy: strict-origin-when-cross-origine una Permissions-Policy minima. TogliX-Powered-By. Su HSTS usaincludeSubDomainssolo 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 auditenpm auditse 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=availableewp theme list --update=availabledicono 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=inactivedeve 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()oupdate_user_meta()con dati del form, una registrazione che accetta il camporole), vecchi endpoint di test rimasti attivi (permission_callback => '__return_true'), URL forniti dall'utente e richiesti dal server (SSRF, usawp_safe_remote_get()), percorsi con../,unserialize()omaybe_unserialize()su input dell'utente,wp_redirect()verso URL esterni (usawp_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:
- 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 conrender_callback,wp_schedule_event,$_FILESe le letture dirette di$_GET,$_POSTe$_REQUEST. Poi lancia gli strumenti automatici. - Segreti per primi: fase 1 completa, e revoca subito le chiavi trovate, prima di sistemare qualsiasi altra cosa.
- 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.
- 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. - 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.shdopo 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.
- Scarica il file wp-secure-launch.zip.
- 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. - 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
- Patchstack, State of WordPress Security in 2026: vulnerabilità di core, plugin e temi WordPress nel 2025.
- SecurityWeek, Vibe coding tested: AI agents nail SQLi but fail miserably on security controls: il test di Tenzai su cinque strumenti di AI coding, dicembre 2025.
- WordPress Developer Resources, Common APIs: Security: nonce, sanitizzazione, escaping e capability.
- WordPress Developer Resources, Plugin Security: il capitolo sulla sicurezza del manuale per chi scrive plugin.
- WooCommerce, Code Reference:
wc_get_order(),WC_Order,wc_clean().






