Articoli approfonditi sulla tecnologia che plasma il futuro.

App generate con l'IA senza row-level security

Passaporti e oltre 200.000 messaggi privati esposti da app IA su Supabase per via della row-level security mancante. Ecco come controllare le tue.

App generate dall'IA identiche su un nastro trasportatore, ciascuna con una porta aperta che perde documenti.
Quando ogni app è costruita dallo stesso template, una sola serratura mancante apre migliaia di porte.

159.041 app. Tante sono le applicazioni web generate con l'IA che un team di ricercatori ha estratto dall'archivio Common Crawl, controllandole per un singolo, banale difetto: si potevano leggere i record del database senza effettuare il login? Per 7.403 dei siti analizzati in profondità la risposta era sì — tabelle con indirizzi email erano leggibili da chiunque le chiedesse. Scavando ancora, sono emersi nomi completi e date di nascita, dati di pagamento, codici di biglietti, esportazioni interne di WhatsApp, riassunti generati dall'IA della posta di un property manager, oltre 200.000 messaggi privati di un forum di lifestyle e, nel caso peggiore, più di mille record con numeri di passaporto, date di scadenza e nazionalità. La causa alla radice, caso dopo caso, era la row-level security di Supabase mancante, e sfruttarla non richiedeva nulla di più esotico degli strumenti per sviluppatori del browser.

Meglio essere precisi sui numeri, perché vengono citati male. Dei 159.041 progetti Lovable identificati, 34.545 usavano Supabase come database. Di questi, 24.664 inviavano i record del database al browser nel momento stesso in cui la pagina si caricava — senza login, senza alcuna interazione. Questo, di per sé, non è un bug; molti dati sono pensati per essere pubblici. Quindi i ricercatori hanno fatto richieste aggiuntive di sola lettura usando la stessa identica chiave API che ogni sito includeva nel proprio JavaScript, e hanno guardato cosa tornava indietro. Record con indirizzi email comparivano in 10.560 tabelle su 7.403 siti, cioè il 30% dei siti esaminati da vicino. Non è un tasso di violazioni confermato, e i ricercatori lo specificano con attenzione: alcuni di quegli indirizzi sono caselle di contatto pubbliche o dati di test. Ma i casi verificati a mano erano inequivocabili. Clienti veri. Passaporti veri. Messaggi privati veri.

Row-Level Security di Supabase è l'unico cancello

Per capire perché continua a succedere, bisogna capire il patto che Supabase stipula con te. Ottieni un database Postgres con un'API REST generata automaticamente davanti, e il tuo frontend parla direttamente con il database. Non c'è un livello backend che imponga l'autorizzazione: nessun middleware Express, nessun permission mixin di Django, niente. Il browser possiede una chiave API anon, pubblica per design e inclusa nel bundle JavaScript. Una seconda chiave, service_role, aggira tutto e non deve mai toccare il client.

Poiché il client si connette direttamente al database, è il database stesso a dover decidere cosa ogni richiesta può vedere. Questo meccanismo è la row-level security di Postgres: policy per tabella che filtrano quali righe un determinato ruolo può leggere o modificare. Ecco la parte che fa male: se la RLS non è attivata su una tabella, la chiave pubblica anon può leggere e scrivere ogni riga della tabella. Punto. La tabella potrebbe essere tranquillamente un file JSON statico sulla tua CDN.

create table profiles (
id uuid primary key default gen_random_uuid(),
full_name text,
email text,
date_of_birth date
);
-- This is the line that decides whether the table is public:
alter table profiles enable row level security;
-- Without it, the shipped anon key reads and writes every row.
# The "attack": the same request the app makes, minus the login
curl "https://your-project.supabase.co/rest/v1/profiles?select=*" \
-H "apikey: eyJhbGciOi..." \
-H "Authorization: Bearer eyJhbGciOi..."

Guarda di nuovo quel comando curl. Non è un exploit in nessun senso significativo. È la stessa richiesta che fa il frontend legittimo, riprodotta senza una sessione utente. La chiave API non è stata rubata: è stata pubblicata, servita a ogni visitatore come parte del codice stesso del sito. L'unica cosa che separa quella richiesta dai passaporti dei tuoi clienti è un'impostazione di Postgres che nessuno ha attivato. Per questo continuo a dire che le esposizioni di Lovable non sono state "hackerate". Sono state lasciate aperte.

Perché i generatori di app con IA producono controllo d'accesso difettoso

La domanda ovvia: perché il generatore non attiva semplicemente la RLS? Perché dal suo punto di vista niente è rotto. L'app funziona. L'anteprima si carica, i record appaiono, la demo impressiona il fondatore che l'ha fatta nascere con un prompt. Il controllo d'accesso mancante è un fallimento silenzioso: un'app senza RLS si comporta esattamente come una correttamente protetta, finché qualcuno non autorizzato non si presenta. Non esiste uno stack trace per "uno sconosciuto in un altro paese sta leggendo la tua tabella dei messaggi". Un generatore ottimizzato per "funziona?" investirà sistematicamente troppo poco in "chi altro può farlo funzionare?".

C'è anche un problema di specifica. "Costruiscimi una piattaforma di prenotazioni per il mio ristorante" non contiene nessuna informazione su chi dovrebbe poter leggere la tabella delle prenotazioni. Uno sviluppatore umano colma quella lacuna con convenzioni, esperienza accumulata e domande scomode alla riunione di avvio. Un LLM la colma con la continuazione statisticamente più comune, e il codice di tutorial Supabase più diffuso su internet ha la RLS disattivata, perché i tutorial la disattivano per mantenere breve il percorso felice. Questo è il divario tra specifica e implementazione che fa sempre il suo lavoro: il bug vive esattamente dove il prompt tace.

Poi c'è la questione dei default, e Supabase ha una sua parte di responsabilità. Per anni, le nuove tabelle create dalla dashboard avevano la RLS disattivata a meno che non sapessi di doverla attivare, un compromesso deliberato di onboarding, dato che nulla uccide lo slancio di un tutorial come le query che restituiscono risultati vuoti. Dopo critiche prolungate, Supabase ha spostato i nuovi progetti verso la RLS di default, ma quelli esistenti hanno mantenuto la configurazione originale. Aggiungi un generatore addestrato su anni di codice precedente al cambio di default, e ottieni una pipeline che produce tabelle esposte in modo affidabile.

Infine, il fattore umano. La promessa di Lovable è che non serve alcuna conoscenza tecnica, e i suoi termini attribuiscono saldamente al cliente la responsabilità dell'applicazione e dei suoi dati. È in quel divario che sono nate le 7.403 app che perdevano dati. Un fondatore non tecnico non può controllare ciò che non sa leggere. Non sa che la RLS esiste, non sa che la chiave anon è pubblica, e il momento allegro del "la tua app è online!" non gli dà motivo di chiedere. Il marketing diceva che l'aereo vola da solo. Le clausole in piccolo dicevano che il pilota sono loro.

Un solo schema difettoso, migliaia di bersagli identici

Ciò che rende tutto davvero pericoloso non è una singola app che perde, ma l'omogeneità. I generatori di IA producono schemi di integrazione ricorrenti: la stessa configurazione del client, le stesse convenzioni sulle tabelle, lo stesso URL del progetto Supabase nello stesso bundle JavaScript. Questo abbatte la curva dei costi per l'attaccante. Scrivi uno script che riconosce un sito costruito con Lovable, estrae l'URL di Supabase e la chiave anon, elenca le tabelle esposte ed esegue select=* su ciascuna, e funziona su migliaia di app con pochissime modifiche. Il controllo d'accesso difettoso è in cima alla OWASP Top 10 da anni; ciò che è nuovo è la scala industriale con cui istanze identiche di questo difetto possono essere prodotte e raccolte.

Alcuni professionisti contestano di chiamarlo affatto "violazione": i siti stessi hanno distribuito la chiave e servito i dati, quindi usarla non è un accesso non autorizzato, e l'atto di pubblicare era la fuga di dati. Tecnicamente, sulla terminologia hanno un punto. Ma è pedanteria che conta solo per attribuire colpe, e non significa nulla per la persona il cui numero di passaporto è finito nella risposta JSON di uno sconosciuto. Nessuno ha acconsentito a quell'architettura.

L'app funzionava perfettamente. Questo era il problema: funzionava perfettamente per tutti.

Le conseguenze legali ricadono dove ricadono sempre: su chi ha rilasciato l'app. Secondo il GDPR, il proprietario dell'app è il titolare del trattamento, e questa ricerca è nata in Germania riguardando una piattaforma svedese e documenti d'identità di cittadini UE. Numeri di passaporto, nomi e nazionalità sono un kit di partenza per il furto d'identità; 200.000 messaggi privati sono un serbatoio per ricatti e phishing. Se le autorità apriranno procedimenti è una questione aperta, ma se sei un fondatore che ha costruito in stile "vibe coding" un database clienti e se n'è andato, "l'ha fatto l'IA" non è una difesa che un garante della privacy accetterà.

Una fila di case identiche, ciascuna con una chiave sotto lo zerbino, mentre una figura le raccoglie.
Codice generato e omogeneo significa che un solo playbook d'attacco funziona contro un'intera fila di app.

Come controllare le configurazioni Supabase generate prima del rilascio

Se hai rilasciato, o ereditato, un'app generata con l'IA su Supabase, ecco l'audit che eseguo io. Richiede un pomeriggio. Fallo prima che dati reali dei clienti si avvicinino anche lontanamente all'app.

  1. Inventaria le tabelle esposte. Esegui la query RLS qui sotto nell'editor SQL. Ogni tabella dello schema public con RLS disattivata è leggibile e scrivibile da chiunque tramite la chiave anon distribuita.
  2. Leggi ogni policy. Avere la RLS attiva non significa nulla se la policy è using (true). I generatori adorano emettere policy che consentono tutto, perché zittiscono gli errori durante lo sviluppo.
  3. Riproduci l'app come uno sconosciuto. Copia la chiave anon dal JavaScript distribuito e colpisci ogni endpoint REST senza sessione. Le righe che tornano indietro sono pubbliche. Era questa la tua intenzione?
  4. Controlla i bucket di storage. Un bucket marcato come pubblico trasforma ogni file al suo interno in un URL recuperabile. Album di foto e scansioni di documenti d'identità non hanno nulla da fare lì.
  5. Cerca service_role nel bundle client. Che la chiave anon sia distribuita va bene; che lo sia quella di servizio è una catastrofe. Il tuo client API distribuito è un caveau di credenziali: controllalo.
-- Tables exposed via the API with RLS disabled (each one is public)
select schemaname, tablename
from pg_tables
where schemaname = 'public'
and rowsecurity = false;
-- The subtler failure: RLS enabled, but what do the policies allow?
select schemaname, tablename, policyname, cmd, qual
from pg_policies
where schemaname = 'public';

La seconda query è quella più interessante. Troverai tabelle con RLS attiva ma zero policy, il che fallisce in modo sicuro e di solito significa che una funzionalità si è rotta silenziosamente e qualcuno l'ha "sistemata" allentando qualcos'altro. E troverai policy come questa, che ho ormai visto in abbastanza codebase generati da riconoscerla a colpo d'occhio:

-- The policy generators emit when a query fails during development:
create policy "allow all" on messages for all using (true);
-- It silences the error and publishes the table. Reject it on sight.
-- What a real policy looks like:
create policy "users read their own messages"
on messages for select
to authenticated
using (auth.uid() = sender_id or auth.uid() = recipient_id);

Il pattern using (true) merita un'attenzione particolare perché è l'equivalente, nel codice generato, di commentare un controllo di autenticazione per far passare un test. Esiste perché il generatore ha incontrato un errore di permessi, ha correttamente diagnosticato una policy mancante e ne ha scritta una nel modo più pigro possibile. Quando la trovi, non limitarti a stringere la policy: chiediti perché la tabella fosse raggiungibile in quel percorso di codice. E ripeti l'intero audit dopo ogni rigenerazione significativa. I builder di IA riscrivono volentieri il tuo schema, e le policy strette di ieri non sopravvivono al prompt di oggi "fai mostrare nella dashboard tutti gli utenti".

Gli scanner di sicurezza aiutano, ma a decidere sono i default

Va detto a loro merito: il team di sicurezza di Lovable ha risposto direttamente alla ricerca. Indicano la RLS insufficiente come causa alla radice, scansionano automaticamente ogni app prima della pubblicazione, offrono una scansione SAST più approfondita e permettono agli utenti di correggere i risultati con un clic, attivare la correzione automatica o bloccare del tutto la pubblicazione in caso di risultati critici, gratuitamente per tutti. È un kit ragionevole, e più di quanto offra la maggior parte dei builder di app.

Ma nota cosa implica uno scanner pre-pubblicazione: il generatore ha prodotto il difetto per primo, e ora esiste un secondo sistema per intercettarlo. Il tasso di rilevamento dello scanner misura quanto spesso l'output predefinito sia insicuro. Ho già scritto di come gli scanner di sicurezza IA stanno riscuotendo il nostro debito tecnico: sono utili, ma trattano i sintomi. La soluzione duratura è una generazione deny-by-default: ogni tabella creata con RLS attiva, ogni tabella con una policy esplicita, anche se quella policy è "nega tutto" finché l'utente non sceglie di aprire di più. Lo stato insicuro dovrebbe essere quello che richiede sforzo. Oggi è il contrario, e 24.664 app che trasmettono record del database al caricamento della pagina sono ciò che costa questa inversione.

Una lente d'ingrandimento su una griglia di dati luminosa, con alcune righe evidenziate come esposte.
Controllare gli schemi generati significa verificare ogni tabella: le righe esposte raramente si annunciano da sole.

La lezione per chi rilascia app costruite con l'IA

L'IA non ha inventato il controllo d'accesso difettoso. IDOR e autorizzazioni mancanti sono in cima alle liste delle vulnerabilità da molto prima che qualcuno facesse nascere un'app con un prompt. Ciò che l'IA ha cambiato è il volume e chi opera: ha industrializzato una modalità di guasto nota e ha messo il pulsante di deploy nelle mani di persone che non riescono a distinguere una policy RLS da una regola CSS. Il dato del 30% di questa ricerca non è uno scandalo su una sola piattaforma. È un'anteprima di ogni ecosistema in cui il codice generato incontra un database pubblico con un modello di sicurezza opt-in.

Quindi tratta ogni app generata con l'IA come tratteresti codice di un fornitore non verificato, perché è esattamente questo. Esegui le query di cui sopra prima del lancio e dopo ogni modifica importante. Se l'app conterrà dati regolamentati o di identità e nessuno in azienda sa leggere una policy di Postgres, paga qualcuno che sappia farlo: un pomeriggio di revisione esperta costa meno che spiegare i numeri di passaporto a un garante. Il no-code ha eliminato la sintassi. Non ha eliminato la responsabilità, e non la eliminerà mai.