- Home
- iThink
- Cyber Security
- Sicurezza vibe coding: 30 controlli per app web e API
Sicurezza vibe coding: 30 controlli per app web e API
In cinque minuti un'AI ti scrive un'app che funziona. Il form si salva, la dashboard si vede, l'API risponde con un JSON pulito. Il cliente è contento, tu pure. Il problema della sicurezza nel vibe coding è 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 qualsiasi progetto nato in vibe coding, che sia un'app Next.js con Supabase, un backend Node o Python, o un'applicazione PHP: 30 controlli, ognuno con verifica, correzione e prova. L'ho trasformato in una skill per Claude Code, /vibe-secure-launch, che puoi scaricare gratis (le istruzioni sono in fondo all'articolo), ma puoi seguirlo anche a mano. Se lavori su WordPress o WooCommerce, i controlli cambiano: per plugin e temi c'è la guida a parte sul vibe coding WordPress.
Cos'è il vibe coding e perché il codice generato va verificato
Vibe coding vuol dire descrivere a un'AI quello che vuoi (Claude, ChatGPT, Cursor, Lovable, Bolt, Replit) 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; per il debito che lascia nel codice c'è la pagina sull'audit del codice generato dall'AI.
Il modello ottimizza per far funzionare la richiesta. Autenticazione, permessi, validazione e gestione dei segreti sono requisiti che nessuno ha scritto nel prompt, quindi spesso mancano. Se l'app gestisce account, pagamenti o dati personali, basta un endpoint lasciato aperto per esporli tutti.
I numeri vanno nella stessa direzione. 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à, soprattutto errori di autorizzazione e di logica, e tutti e cinque gli strumenti ne hanno prodotte.
Non è colpa dell'AI. La sicurezza è un requisito che devi chiedere tu, e poi verificare.
L'errore che vedo più spesso: autenticato non vuol dire autorizzato
Il difetto più frequente nel codice generato è un endpoint che controlla se l'utente è loggato, o non controlla niente, e poi si fida dell'ID che arriva dal browser. In un backend Node con Express e Prisma l'AI scrive spesso una route così:
app.get('/api/orders/:id', async (req, res) => {
const order = await prisma.order.findUnique({ where: { id: req.params.id } });
res.json(order);
});
Chiunque conosca o indovini un ID legge l'ordine di un altro cliente, con indirizzo e telefono. La versione corretta richiede la sessione e filtra per il proprietario; requireAuth qui è il tuo middleware di sessione (se nello schema l'id è numerico, convertilo con Number(req.params.id)):
app.get('/api/orders/:id', requireAuth, async (req, res) => {
const order = await prisma.order.findFirst({
where: { id: req.params.id, userId: req.user.id },
});
if (!order) return res.status(404).end();
res.json(order);
});
Lo stesso errore ha una seconda forma: la funzione amministrativa che controlla solo il login. In Next.js l'AI scrive spesso una server action così (auth() è quella di Auth.js, db il tuo client del database):
'use server';
export async function updatePrice(productId, price) {
const session = await auth();
if (!session) throw new Error('Non autenticato');
await db.product.update({ where: { id: productId }, data: { price } });
}
Sembra a posto: c'è il controllo della sessione. Ma una server action è un endpoint POST pubblico, raggiungibile anche senza il pulsante che la usa: qualunque utente registrato, anche un semplice cliente, può chiamarla e cambiare il prezzo di un prodotto. La versione corretta controlla il ruolo sul server e valida i dati con Zod (il campo role lo aggiungi tu alla sessione, nella configurazione di Auth.js):
'use server';
import { z } from 'zod';
const Input = z.object({ productId: z.string().min(1), price: z.number().nonnegative() });
export async function updatePrice(raw) {
const session = await auth();
if (session?.user?.role !== 'admin') throw new Error('Non autorizzato');
const { productId, price } = Input.parse(raw);
await db.product.update({ where: { id: productId }, data: { price } });
}
In entrambi i casi bastano poche righe in più. È la differenza tra un progetto che funziona e un progetto che puoi dare a un cliente.
I 5 principi prima dei 30 controlli
- Il browser è territorio nemico. Tutto quello che arriva dal client (prezzi, ruoli, ID, campi nascosti, header) 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.
- 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.
La checklist di sicurezza vibe coding: 30 controlli in 5 fasi
Per ogni controllo trovi tre cose: perché conta, cosa fare per sistemarlo e come verificarlo con una prova che puoi ripetere. Gli esempi coprono gli stack che l'AI genera più spesso: Next.js e React, Node, Supabase, PHP e Python. 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.
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 configurazione del server, variabili d'ambiente o database fai un backup.
L'ordine conta. Si parte dai segreti esposti perché sono il danno più immediato: una chiave Stripe o OpenAI nel codice del browser può costarti soldi nel giro di ore.
Fase 1: segreti e configurazione
2. Segreti fuori dal bundle client
- Perché: tutto quello che sta nel JavaScript 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 su un endpoint server (una API route di Next.js, una route Express, una Edge Function di Supabase) che legge la chiave da una variabile d'ambiente. Nel browser lascia solo le chiavi pubblicabili per natura: Stripe
pk_, Supabaseanoncon RLS attiva, Google Maps limitata al tuo dominio. - Come verificarlo: fai la build di produzione e cerca nel codice generato con
grep -rlE "sk_live_|sk_test_|sk-proj-|sk-ant-|AKIA[0-9A-Z]{16}|eyJ[A-Za-z0-9_-]{20,}\.eyJ" dist/ build/ .next/static/. L'opzione-lstampa solo i nomi dei file, così la chiave non finisce a schermo. Non deve uscire nessun file; se escono tokeneyJ…di Supabase, decodifica la parte centrale: la chiave con ruoloanonè pubblica, quella conservice_rolenon deve esserci.
12. Separazione tra variabili d'ambiente pubbliche e segrete
- Perché: i prefissi
NEXT_PUBLIC_,VITE_,REACT_APP_edEXPO_PUBLIC_dicono al builder di copiare il valore dentro il codice del browser. L'AI li usa spesso perché così "funziona subito". - Cosa fare: togli il prefisso alle variabili segrete e usale solo lato server. Aggiungi
.enval.gitignoree crea un.env.examplecon i nomi delle variabili ma senza valori. - Come verificarlo:
grep -rnoE --exclude-dir=node_modules --exclude-dir=.git "(NEXT_PUBLIC|VITE|REACT_APP|EXPO_PUBLIC|PUBLIC)_[A-Z_]*(SECRET|KEY|TOKEN|PASSWORD)" .stampa solo i nomi delle variabili, senza i valori, e deve restituire solo chiavi pubblicabili.
21. 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 Node usa
NODE_ENV=productione un gestore di errori che risponde con un messaggio generico; in PHPdisplay_errorsaOff; in DjangoDEBUG = False. Non pubblicare le source map e cancella file comephpinfo.phpo route di debug. - Come verificarlo: provoca un errore (un URL che non esiste, un parametro sbagliato). Devi vedere una pagina generica, senza percorsi né stack trace.
24. Esposizione di file sensibili e directory listing
- Perché: backup,
.enve cartelle.gitdimenticati nella root pubblica sono il modo più semplice per prendersi un sito, perché contengono le password del database e le chiavi. - Cosa fare: aggiungi regole sul server che bloccano i file che iniziano con il punto e i backup, e disattiva l'elenco delle cartelle (
Options -Indexessu Apache,autoindex offsu Nginx; per Apache le regole che uso sono nella guida alla sicurezza di .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 del file e, se è quello vero, toglilo subito.
for f in .env .git/config .git/HEAD backup.zip dump.sql debug.log phpinfo.php config.php.bak; 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. 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 . --redactcontrolla il codice attuale e non deve trovare nulla.gitleaks detect --source . --redactcontrolla tutta la cronologia: 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 lato server e gestione delle sessioni
- Perché: un controllo della password scritto in JavaScript, o una pagina protetta solo dal router del frontend, si aggira dalla console del browser in pochi secondi.
- Cosa fare: usa un sistema di autenticazione affidabile (Supabase Auth, Firebase Authentication, Auth.js, sessioni server del tuo framework). Ogni endpoint protetto deve controllare la sessione sul server, l'ID di sessione va rigenerato al login e il logout deve invalidarla davvero.
- Come verificarlo:
curl -i https://tuosito.it/api/dati-privatisenza cookie né token deve rispondere 401 o 403.
3. Controllo di accesso a livello di oggetto (IDOR)
- Perché: è la falla più comune. Cambio
?order_id=1024in1025e leggo l'ordine di un altro cliente, con indirizzo e telefono. Ai sensi del GDPR è una violazione dei dati personali. - Cosa fare: ogni query deve filtrare per l'utente della sessione, mai per un ID arrivato dal browser senza controllo, come nell'esempio Express qui sopra. Su Supabase:
alter table ordini enable row level security;più una policy conuser_id = auth.uid(). - Come verificarlo: crea due utenti di prova e con l'utente A chiedi una risorsa dell'utente B. La risposta deve essere 403 o 404.
5. Hashing delle password con algoritmi adattivi
- 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: usa Argon2id o bcrypt:
password_hash()in PHP, le librerieargon2obcryptin Node. Meglio ancora, lascia le password al servizio di autenticazione (Supabase Auth, Firebase Authentication) e non creare tabelle utenti parallele generate dall'AI. - Come verificarlo: guarda il campo password nel tuo database. Deve iniziare con
$argon2id$oppure$2y$o$2b$(bcrypt). Se trovi 32 caratteri esadecimali senza prefisso è un MD5 semplice, se ne trovi 40 uno SHA-1: tutti e due vanno sostituiti.
9. Protezione dal brute force: blocco temporaneo e notifica
- Perché: i bot provano migliaia di password sulle pagine di login. Senza un limite prima o poi indovinano, e tu non te ne accorgi.
- Cosa fare: conta i tentativi falliti per la coppia IP più account; 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-Forche manda il client. Il messaggio d'errore deve essere generico ("credenziali non valide"). - Come verificarlo: in staging, con un utente di prova, sbaglia la password 5 volte: il blocco deve scattare e la notifica deve arrivarti.
10. Autorizzazione per ruolo sulle funzioni amministrative
- Perché: spesso l'AI "protegge" una pagina admin togliendola dal menu, ma l'URL o l'API restano chiamabili da chiunque.
- Cosa fare: controlla il ruolo sul server all'inizio di ogni route e azione amministrativa, con un middleware in Express o dentro il route handler e la server action in Next.js. In Next.js il middleware da solo non basta: è un primo filtro, il controllo va ripetuto dove si leggono e si scrivono i dati.
- Come verificarlo: accedi con un utente normale e chiama le azioni admin, dal browser o con curl usando la sua sessione. Devi ricevere 403.
16. Attributi dei cookie di sessione: 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: imposta
Secure; HttpOnly; SameSite=Laxsui cookie di sessione e non salvare i token di sessione nel localStorage. In Express li imposti nelle opzioni diexpress-session(cookie: { secure: true, httpOnly: true, sameSite: 'lax' }); dietro un proxy serve ancheapp.set('trust proxy', 1), altrimenti il cookie Secure non parte. - Come verificarlo: fai un login vero con un utente di prova e guarda le righe
Set-Cookiedella risposta (con curl egrep -i '^set-cookie') oppure i cookie negli strumenti per sviluppatori del browser. I cookie di sessione devono avere i tre flag.
17. Protezione CSRF
- 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: usa un token anti-CSRF sulle azioni che cambiano dati (il middleware del tuo framework; le server action di Next.js confrontano già l'header
Origincon l'host), cookie SameSite e un controllo dell'headerOriginsugli endpoint sensibili. Nessuna azione che cancella o modifica dati deve partire con una richiesta GET. - Come verificarlo: rimanda la stessa richiesta POST senza token. Deve essere rifiutata.
18. Token di reset password monouso e a scadenza
- Perché: un link che non scade o si può riusare, trovato in una casella email violata, vale quanto una password.
- Cosa fare: usa un token casuale, salvato come hash, valido una sola volta e per 15-60 minuti. Al cambio password chiudi le altre sessioni. Rispondi allo stesso modo sia che l'email esista sia che no.
- Come verificarlo: usa lo stesso link due volte, oppure dopo la scadenza. Deve essere rifiutato.
28. Autenticazione a più fattori sugli account privilegiati
- Perché: una password rubata con il phishing o ritrovata in un vecchio leak basta per entrare nel pannello admin, nel database o nel provider di hosting. Il secondo fattore ferma la gran parte di questi accessi.
- Cosa fare: attiva l'MFA (app di autenticazione o chiave fisica, non SMS dove puoi evitarlo) sugli account admin dell'applicazione e su tutto ciò che sta intorno: hosting, DNS, repository Git, Supabase o Firebase, Stripe, account email dell'amministratore.
- Come verificarlo: fai l'elenco degli account privilegiati e, per ognuno, prova un login da una sessione nuova: deve chiedere il secondo fattore.
Fase 3: input, output e dati
6. Validazione server-side degli input
- 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: in Node con uno schema Zod o Valibot, in PHP con
filter_var(), in Python con Pydantic. Tutto quello che non è previsto va rifiutato. - Come verificarlo: invia con curl campi vuoti, troppo lunghi o del tipo sbagliato. Devi ricevere un errore 400 con un messaggio pulito.
7. Prevenzione XSS con output encoding contestuale
- 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, secondo il contesto. React e Vue lo fanno da soli: evita
dangerouslySetInnerHTMLev-html, oppure passa il contenuto da DOMPurify. In PHP usahtmlspecialchars(); nei template di Django e Jinja2 lascia attivo l'autoescape e non usare|safesu dati degli utenti. - Come verificarlo: scrivi
"><img src=x onerror=alert(1)>in un campo. Deve apparire come testo, senza nessun popup.
11. Query parametrizzate contro la SQL injection
- Perché: con una variabile concatenata nella query, chi scrive nel form può riscriverla e leggere, modificare o cancellare il tuo database.
- Cosa fare: usa query parametrizzate o un ORM: segnaposto
$1o?in Node, PDO con prepared statement in PHP, i parametri dicursor.execute()in Python. Attenzione alle query "raw" che l'AI scrive dentro gli ORM con le template string. - Come verificarlo: metti
'e' OR '1'='1nei 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: allowlist dei tipi, limiti di dimensione, nessuna esecuzione
- Perché: un file "foto.jpg" che in realtà è uno script, se finisce in una cartella dove il server lo esegue, dà il controllo totale del server.
- Cosa fare: ammetti solo i tipi previsti, controllati sul contenuto reale e non solo sull'estensione (leggendo i primi byte del file, non il tipo dichiarato dal browser). Imposta un peso massimo lato server, dai ai file un nome casuale, salvali fuori dalla cartella eseguibile o su uno storage a oggetti privato. 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; a fine prova cancella dal server qualsiasi file di test rimasto.
20. Integrità dei pagamenti: prezzi calcolati sul server e webhook firmati
- 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: il server ricalcola prezzi, sconti e totali partendo dal catalogo. Lo stato "pagato" lo imposta solo il webhook di Stripe o PayPal, dopo averne verificato la firma: con Stripe la verifichi sul corpo grezzo della richiesta, prima di qualsiasi conversione in JSON, e rifiuti le richieste troppo vecchie. Le vecchie notifiche IPN di PayPal non hanno firma e vanno riconfermate a PayPal. Gestisci anche i webhook arrivati due volte.
- Come verificarlo: modifica il prezzo nella richiesta: il server deve usare quello vero. Manda un webhook con firma falsa: deve essere rifiutato.
30. Privilegio minimo per database, chiavi API e storage
- Perché: l'AI tende a usare le credenziali più potenti perché "così funziona": l'utente root del database, la chiave
service_roledi Supabase, una chiave AWS con accesso a tutto, un bucket pubblico. Se una di queste esce, chi la trova può fare tutto. - Cosa fare: l'applicazione si collega al database con un utente che ha solo i permessi che le servono. Le chiavi API hanno il minimo degli ambiti (chiavi Stripe con restrizioni, policy IAM limitate, token con scadenza). I bucket di storage sono privati di default e i file si servono con URL firmati a scadenza.
- Come verificarlo: per ogni credenziale scrivi che cosa può fare e controlla i permessi dell'utente del database (in MySQL con
SHOW GRANTS FOR CURRENT_USER();): non devono comparireALL PRIVILEGES,DROPoGRANTse l'app non ne ha bisogno. Apri l'URL diretto di un file privato senza firma: deve rispondere 403.
Fase 4: trasporto e perimetro
4. HTTPS ovunque con redirect permanente
- 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 ed elimina i contenuti misti.
- Come verificarlo:
curl -sI http://tuosito.itdeve rispondere 301 verso https.
13. Rate limiting per IP e per account
- 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 ed endpoint costosi. Puoi farlo con Cloudflare o un WAF, con
limit_reqdi Nginx, con express-rate-limit o con il middleware della tua piattaforma. - 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 con allowlist delle origini
- 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: scrivi un elenco esplicito dei domini ammessi: produzione e, se serve, staging. In Express usa il pacchetto
corscon la lista nell'opzioneorigin; non ripetere mai l'origine ricevuta senza controllarla quandocredentialsè attivo. - Come verificarlo:
curl -s -D - -o /dev/null -H "Origin: https://evil.example" https://tuosito.it/api/non deve restituire l'headerAccess-Control-Allow-Originper quell'origine.
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-ancestorsnella CSP, Referrer-Policy e Permissions-Policy. TogliX-Powered-By. Su HSTS usaincludeSubDomainssolo se tutti i sottodomini sono in HTTPS. Su Apache le righe pronte sono nella guida agli header di sicurezza HTTP con .htaccess; in Next.js li imposti innext.config.js, in Express con helmet. - Come verificarlo:
curl -sI https://tuosito.it, oppure il test su securityheaders.com.
8. Security logging con mascheramento dei dati sensibili
- 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, accessi admin ed errori 5xx. 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. Analisi delle dipendenze vulnerabili (SCA)
- Perché: una parte importante delle violazioni passa da una libreria non aggiornata, non dal codice scritto per il progetto.
- Cosa fare: esegui
npm audit,composer auditopip-audite aggiorna partendo dalle vulnerabilità critiche e alte; dopo ogni aggiornamento importante controlla che tutto 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: rilancia gli audit. Non devono restare vulnerabilità alte o critiche aperte senza una motivazione scritta.
23. Riduzione della superficie d'attacco
- Perché: un pacchetto, una route o un servizio che non usi resta raggiungibile, e le sue vulnerabilità restano con lui.
- Cosa fare: dopo un backup, togli dipendenze, route di prova e funzioni non usate; per i pacchetti Node usa
npx kniponpx depcheck. - Come verificarlo: la build e i test devono ancora funzionare, e le route tolte devono rispondere 404.
29. Backup cifrati e prova di ripristino
- Perché: un ransomware, un errore dell'AI che cancella una tabella o un aggiornamento andato male si recuperano solo con un backup. E un backup mai ripristinato è una speranza, non una garanzia.
- Cosa fare: fai backup automatici di database e file, 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, pagamenti e webhook disattivati, e controlla che l'applicazione parta e che i dati siano quelli attesi. Segna data e durata del ripristino nel report.
26. Revisione della logica applicativa 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, ruolo che si cambia via parametro, vecchi endpoint di test rimasti attivi, URL forniti dall'utente e richiesti dal server (SSRF), percorsi con
../, comandi di sistema costruiti con input dell'utente, deserializzazione di dati non fidati, redirect aperti, webhook senza firma. - 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.sho in test automatici 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'app o un sito con qualche funzione custom, fare i 30 controlli a mano richiede da mezza giornata a una giornata. La sequenza che seguo è questa:
- Ricognizione: identifica lo stack e fai l'elenco di tutto ciò che riceve dati dall'esterno: route API, server action, form, upload, webhook. In un progetto Next.js parti da
app/apie dalle server action; in Express dalle chiamateapp.geteapp.post; in Django daurls.py, in FastAPI dai router; in PHP dalle letture dirette di$_GET,$_POSTe$_REQUEST. - 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 utente normale) per ripetere ogni richiesta con entrambi.
- 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 /vibe-secure-launch in Claude Code buona parte della ricerca è automatica: l'agente mappa endpoint, form e upload, cerca le chiavi esposte, applica le correzioni e scrive i test. Tu resti responsabile delle decisioni che non si possono delegare, come la revoca delle chiavi presso i fornitori. Alla fine ottieni un report con un verdetto chiaro (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
- Confondere autenticazione e autorizzazione: sapere chi è l'utente non dice che cosa può fare. Ogni azione ha bisogno del suo controllo di permesso.
- Nascondere invece di chiudere: togliere una voce dal menu non impedisce a nessuno di chiamare l'URL o l'API.
- Cancellare il commit con la chiave: la chiave resta nella cronologia e nelle copie del repository. Va revocata.
- Fidarsi del prezzo che arriva dal browser: il totale si ricalcola sempre sul server.
- 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 controllo dei permessi, validazione degli input, escaping dell'output e segreti solo lato server: l'AI li aggiunge quando glieli chiedi, raramente da sola.
- Tieni un utente "normale" di prova sempre attivo sul tuo staging: è il modo più rapido per scoprire funzioni admin aperte.
- Rilancia
security-tests.shdopo ogni sessione di vibe coding, non solo prima del primo lancio: ogni nuovo prompt può togliere un controllo. - Passa il codice anche da uno scanner statico come Semgrep (
semgrep --config auto .): trova molte injection e chiamate pericolose, non gli errori di logica.
Scarica la skill /vibe-secure-launch
La skill che uso io è scaricabile gratis. È un pacchetto per Claude che fa i 30 controlli sul tuo progetto, applica le correzioni, scrive i test e ti consegna il report finale.
- Scarica il file vibe-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
/vibe-secure-launch, oppure chiedi "è pronto per il lancio?".
Vibe 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'app creata con Lovable, Bolt o Cursor è sicura?
Può esserlo, ma non per default. Di solito il codice generato funziona e salta i controlli che nessuno ha chiesto: autorizzazione per ogni risorsa, validazione sul server, segreti fuori dal browser, header di sicurezza. Va verificato prima di andare online.
Uso Next.js: basta proteggere le pagine nel middleware?
No. Il middleware è un primo filtro, ma route handler e server action si possono chiamare direttamente con una richiesta POST. Il controllo di sessione e di ruolo va ripetuto dentro ognuno. Nel 2025 una vulnerabilità di Next.js (CVE-2025-29927) permetteva perfino di saltare il middleware con un header.
Uso Supabase: qual è il controllo più importante?
Attivare la Row Level Security su tutte le tabelle, con policy legate a auth.uid(), e verificare che la chiave service_role non sia mai nel codice del browser.
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'app web, un SaaS o un'API nati 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 del penetration test. Scrivimi dalla pagina contatti.
E se vuoi capire come ragiona chi attacca, è tutto in Vita da Hacker.
Fonti
- 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.
- Supabase, Row Level Security: documentazione ufficiale.






