In breve
Ho preso 1.170 repository GitHub pubblici che contengono migration Supabase, ho applicato ciascuno a un database Supabase nuovo in una sandbox offline e ho eseguito sul risultato le stesse 15 regole di database che il mio controllo gratuito esegue sui progetti in produzione. 568 progetti sono stati applicati senza errori: 15.624 tabelle in public. 134 di questi (23,6%) hanno almeno una tabella con RLS disattivata che la chiave pubblica può leggere e modificare. L’8,8% ha una policy che permette a un visitatore non autenticato di aggiornare o eliminare qualsiasi riga, il 10,9% gli lascia inserire qualsiasi cosa e il 12,0% espone una view che salta la RLS. I progetti creati con Lovable lasciano meno tabelle senza RLS (9,1%), ma scrivono true nelle policy da due a tre volte più spesso. Su un progetto creato dopo il cambiamento di Supabase del 30 ottobre, le stesse migration ne lasciano aperto il 3,6% invece del 22,7%. Tre query SQL alla fine mostrano a che punto è il suo progetto.
La maggior parte dei consigli sulla sicurezza di Supabase dice la stessa cosa: attivi la RLS, scriva le policy, controlli l’Advisor. Volevo sapere con che frequenza i progetti reali sbagliano davvero, misurato ogni volta nello stesso modo, e non sulle poche app che la gente posta su Reddit. GitHub pubblico ha migliaia di progetti Supabase con tutta la cronologia delle migration, quindi ne ho costruiti il più possibile e ho guardato il database che quelle migration lasciano.
Come ho testato 568 progetti?
Ho cercato su GitHub file SQL sotto supabase/migrations che contengono create table, suddivisi per dimensione del file per superare il limite della ricerca. Ne sono usciti 8.914 repository, fork esclusi. Da lì ho preso un campione pseudocasuale fisso, ordinato per un hash del nome del repository, e ho scaricato di ciascuno solo la cartella delle migration e il package.json.
| Passaggio | Progetti |
|---|---|
| Repository con migration Supabase (ricerca di codice GitHub, 7 novembre 2026) | 8.914 |
| Campione scaricato | 1.170 |
| Misurati, dopo aver rimosso i duplicati esatti | 1.168 |
| Template e repository di Supabase stessa rimossi | 9 |
| Migration che si fermano con un errore su un database nuovo | 567 |
Nessuna tabella in public |
8 |
| Usano il trigger RLS automatico di Supabase (esclusi, vedi limiti) | 16 |
| Analizzati | 568 |
Ogni progetto è stato eseguito nel proprio database nuovo dentro un container Docker senza accesso alla rete, costruito da un dump di uno stack Supabase locale (CLI 2.109.1, Postgres 17.6, con i veri schemi auth e storage). Le migration sono state eseguite in ordine di nome file come ruolo postgres, che su Supabase non è superuser, lo stesso ruolo che usa supabase db push. Nulla proveniente da un repository è stato eseguito fuori da quel container.
Sul database risultante ho eseguito le query di catalogo e le 15 regole di database del mio controllo di sicurezza Supabase, senza modifiche. Le impostazioni che vivono fuori dal database, come la conferma dell’email o la protezione dalle password compromesse, non si vedono dalle migration, quindi quelle regole sono escluse.
Quasi la metà dei progetti si ferma con un errore prima dell’ultima migration. Le cause abituali sono dati seed che puntano a utenti che esistono solo nel progetto dell’autore, oggetti creati a mano nel dashboard e citati più tardi, e migration che non hanno mai funzionato su un database pulito. Riporto solo i progetti che sono stati applicati senza errori.
Cosa ho trovato?
| Risultato | Tutti (568) | Creati con Lovable (66) | Altri (502) |
|---|---|---|---|
| Almeno una tabella con RLS disattivata che la chiave pubblica può leggere e modificare | 23,6% | 9,1% | 25,5% |
Una policy permette ai visitatori non autenticati di aggiornare o eliminare qualsiasi riga (using (true)) |
8,8% | 15,2% | 8,0% |
Una policy permette ai visitatori non autenticati di inserire qualsiasi cosa (with check (true)) |
10,9% | 28,8% | 8,6% |
Una view in public che salta la RLS delle sue tabelle |
12,0% | 7,6% | 12,5% |
| Una policy di storage aperta ai visitatori non autenticati | 5,3% | 12,1% | 4,4% |
| Una colonna dal nome apparentemente sensibile raggiungibile tramite l’API | 10,0% | 16,7% | 9,2% |
Una policy che si fida di user_metadata |
0,7% | 0% | 0,8% |
Su tutte le 15.624 tabelle, l’8,5% ha la RLS disattivata. Sembra poco finché non si conta per progetto: un’app su quattro ha almeno una tabella così e, con i grant predefiniti che Supabase ha usato fino al 30 ottobre 2026, la chiave pubblica può leggere e scrivere ogni riga.
Tabelle su cui nessuno ha attivato la RLS
In ciascuno dei cinque progetti che ho aperto a mano, nessuna migration ha mai eseguito alter table … enable row level security sulla tabella aperta. Un progetto aveva 31 tabelle e la RLS su nessuna. Quello che contengono queste tabelle varia: elenchi di riferimento come i paesi, ma anche contatori, eventi, vendite e profili. La nota RLS disabled in public spiega cosa significa l’avviso dell’Advisor e come chiuderlo senza rompere l’app.
Policy che dicono true
Una policy con using (true) su update o delete significa che qualsiasi visitatore con la sua chiave pubblica può modificare o rimuovere ogni riga. L’8,8% dei progetti ne ha almeno una. with check (true) su insert è più comune, 10,9%, e a volte è voluto, per una lista d’attesa o un modulo di contatto. Ho contato solo il true letterale: una policy che chiama una funzione di supporto come is_member(team_id) è protetta dentro la funzione, quindi non rientra in questi numeri. La nota su using (true) mostra come distinguere il caso voluto dall’errore.
View che saltano la RLS
Una view in public viene eseguita con i diritti del suo proprietario, a meno che non sia creata con security_invoker = true, quindi restituisce righe che le policy della tabella stessa nasconderebbero. Il 12,0% dei progetti ne ha almeno una.
I progetti creati con Lovable sono peggiori?
Non nel modo che mi aspettavo. Ho contato un progetto come creato con Lovable quando il suo package.json elenca lovable-tagger o almeno la metà dei suoi file di migration ha i nomi <timestamp>_<uuid>.sql di Lovable. Questi progetti lasciano meno tabelle senza RLS, 9,1% contro 25,5%. Scrivono true nelle policy molto più spesso: il 15,2% permette a chiunque di aggiornare o eliminare righe, il 28,8% permette a chiunque di inserire e il 12,1% apre una policy di storage ai visitatori non autenticati. Solo 66 progetti Lovable sono stati applicati senza errori, mentre 152 si sono fermati con un errore, spesso sui dati seed degli utenti dell’autore, quindi consideri la colonna Lovable come una direzione, con un margine di circa otto punti in entrambi i sensi.
Il cambiamento del 30 ottobre risolve il problema?
Il breaking change di Supabase smette di dare grant automatici ai ruoli dell’API sulle nuove tabelle di public; ho provato cosa rompe in questo articolo. Ho eseguito 433 dei progetti una seconda volta con i nuovi default, come parte un progetto creato dopo il passaggio. 194 di questi sono stati applicati senza errori entrambe le volte.
| Gli stessi 194 progetti | Vecchi default | Nuovi default |
|---|---|---|
| Almeno una tabella con RLS disattivata che la chiave pubblica può leggere e modificare | 44 (22,7%) | 7 (3,6%) |
Quindi sì, per le nuove tabelle chiude la maggior parte del divario: una tabella a cui nessuno ha dato un grant è irraggiungibile, con o senza RLS. I sette progetti che restano aperti concedono loro stessi l’accesso ai ruoli dell’API nelle proprie migration, il che riporta subito la vecchia esposizione. E il passaggio cambia solo ciò che ricevono le nuove tabelle: un progetto che ha già una tabella aperta la tiene aperta, quindi la prima query qui sotto conta su ogni progetto esistente.
Come mi sono assicurato che i numeri siano giusti?
Prima di fidarmi di qualsiasi risultato, ho costruito un progetto di prova con sei problemi piantati (una tabella con RLS disattivata, policy using (true), una view senza security_invoker, una funzione security definer che chiunque può chiamare, una policy che legge user_metadata, un bucket pubblico con upload anonimi) e due tabelle protette correttamente. La pipeline doveva trovare tutti e sei e nessuna delle due. Le prime esecuzioni non ci sono riuscite: le regole hanno bisogno dell’elenco degli schemi dell’API, che un progetto in produzione fornisce e una sandbox no, e il ruolo admin della sandbox stampava uid() invece di auth.uid() nelle policy, il che faceva sembrare aperte policy sicure. Entrambi i problemi sono corretti, ho misurato di nuovo tutti i progetti e ho aperto a mano dei campioni di ogni risultato.
Cosa questo studio non può vedere
- Le migration non sono il database in produzione. Tutto ciò che è stato cambiato nel dashboard e mai scritto in una migration qui è invisibile, in entrambe le direzioni.
- I progetti che pubblicano le migration su GitHub non sono tutti i progetti Supabase. Molti sono progetti di studio e progetti personali.
- Quasi la metà del campione non è stata applicata senza errori e non è nei numeri. Quei progetti potrebbero essere più sicuri o meno sicuri.
- I progetti che hanno attivato il trigger RLS automatico di Supabase ottengono la RLS sulle nuove tabelle senza che nessuna migration lo dica. Ho escluso i 16 che lo citano; altri potrebbero usarlo senza lasciare traccia nei file.
- I nomi dei repository non sono pubblicati. I dati provengono da informazioni pubbliche e non personali, secondo la clausola sulla ricerca delle Acceptable Use Policies di GitHub.
Come controllare il suo progetto?
Esegua queste query nello SQL Editor. Ciascuna ha restituito esattamente il problema piantato nel mio progetto di prova e nient’altro.
Tabelle con RLS disattivata, e se la chiave pubblica può raggiungerle:
select c.relname as table_name,
has_table_privilege('anon', c.oid, 'select') as anon_can_read,
has_table_privilege('anon', c.oid, 'insert,update,delete') as anon_can_write
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind in ('r', 'p') and not c.relrowsecurity
order by 1;
Policy che permettono ai visitatori non autenticati di scrivere senza alcuna condizione:
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public'
and cmd in ('INSERT', 'UPDATE', 'DELETE', 'ALL')
and roles && array['anon', 'public']::name[]
and (qual = 'true' or with_check = 'true')
order by 1, 2;
View che saltano la RLS:
select c.relname as view_name
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind = 'v'
and not exists (
select 1 from unnest(coalesce(c.reloptions, '{}')) as o
where o ~* '^security_invoker=(true|on|yes|1)$'
)
order by 1;
Un risultato vuoto su tutte e tre è un buon inizio, non un certificato di salute. Come attivare la RLS copre la prima query, esempi di policy RLS la seconda, e come testare la RLS mostra come dimostrare che un utente non può leggere le righe di un altro. Per il quadro più ampio, veda Supabase è sicuro? e la checklist di sicurezza per Lovable.
Il mio caso simile
Costruendo un sistema di time tracking per una società di revisione ho trovato 4 errori che nessuno schermo mostrava, tra cui un cliente riservato che trapelava dai totali dei report e dai conteggi delle etichette. Ogni regola di accesso ora sta nel database ed è testata prima di ogni rilascio; la storia completa è nel caso della società di revisione.
Vuole sapere a che punto è il suo progetto? Mi scriva e lo controlleremo allo stesso modo.
A che punto è il suo progetto?
Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.
Mi scrivaFonti
- Ricerca di codice e dati dei repository di GitHub, 7 novembre 2026; campione e pipeline descritti sopra.
- Supabase, Securing your API: default privileges, letto il 7 novembre 2026.
- Supabase, Breaking change: tables not exposed to the Data and GraphQL API automatically.
- Supabase, Event triggers: automatically enable RLS.
- GitHub, Acceptable Use Policies, section 7.