TL;DR
Entrambi partono chiusi: una nuova tabella Supabase rispondeva 401 a un ospite finché non l’ho abilitata, e un nuovo database Firebase con regole deny-all rispondeva 403. La differenza sta nel modo in cui fallisce un errore. Quando l’utente A ha aggiornato o cancellato i dati dell’utente B con una policy solo-proprietario, Supabase ha risposto 200 con zero righe e nessun errore; Firebase ha rifiutato con 403. Firebase, invece, ha lasciato che A cedesse un ordine a B con 200 quando la regola update controllava solo il vecchio proprietario, mentre Supabase ha rifiutato la stessa mossa con 403. Lasciati aperti (un grant ad anon con RLS disattivato, oppure if true), entrambi hanno dato a un ospite tutte e tre le righe e gli hanno lasciato cancellarne una. La sola chiave pubblica non apre nulla in nessuno dei due; decidono le regole.
Sono Denys, Forward Deployed Engineer. La maggior parte delle app che sistemo gira su Supabase o su Firebase, e chi sceglie tra i due chiede quale sia più sicuro. I confronti di funzioni e prezzi non rispondono, quindi ho mandato a entrambi le stesse richieste.
Come ho testato. Supabase con uno stack locale (CLI 2.109.1, Postgres 17.6) e Firebase con il Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore e Storage), entrambi il 6 novembre 2026. Semplici chiamate REST come ospite e come due utenti autenticati A e B, con dati inventati: gli ordini a1 e a2 sono di A, b1 è di B. Niente ha toccato un progetto reale.
Come proteggono i dati Supabase e Firebase?
Supabase tiene i dati in Postgres. Un grant decide se i ruoli dell’API possono toccare una tabella, e le policy di row level security (RLS), scritte in SQL, decidono quali righe ogni richiesta vede e scrive. Firebase tiene i dati in Firestore e Cloud Storage, e le regole di sicurezza, un linguaggio a parte, decidono per percorso e per richiesta se una lettura o scrittura è consentita.
Quindi entrambi hanno un controllo degli accessi, e la domanda è cosa ti lascia sbagliare ciascuno. Le regole di Firebase sono trattate a fondo in esempi di regole di sicurezza Firebase, quelle di Supabase in esempi di policy RLS Supabase.
Cosa fa ciascuno con un progetto nuovo?
| Richiesta | Supabase, tabella nuova, niente concesso | Firebase, regole deny-all |
|---|---|---|
| L’ospite elenca i dati | 401, permission denied (42501) |
403 |
| Un utente autenticato elenca i dati | 403, permission denied (42501) |
403 |
| Collezione senza regola per essa | non applicabile | 403 |
Una configurazione appena creata è chiusa su entrambi. Su Supabase è una novità: le tabelle create dopo il 30 ottobre 2026 non ricevono più i grant della Data API in automatico, e la mia CLI si comportava già così, quindi la prima richiesta è fallita per il grant mancante, non per una policy. Il cambiamento l’ho raccontato in il cambio dei grant del 30 ottobre. Un database Firebase creato in modalità produzione parte con regole deny-all.
Cosa succede quando viene lasciato aperto?
| Richiesta di un ospite | Supabase, grant ad anon, RLS disattivato |
Firebase, allow read, write: if true |
|---|---|---|
| Elencare i dati | 200, tutte e 3 le righe |
200, tutti e 3 i documenti |
| Aggiungere un record | 201 |
200 |
| Cancellare un record | 200, riga cancellata |
200, documento cancellato |
Gli stati aperti non sono la stessa cosa. Su Supabase servono un grant deliberato ad anon e l’RLS disattivato, lo schema che alcuni tutorial e strumenti di IA scrivono per far sparire un errore. Su Firebase è la modalità di test, da cui partono molti tutorial. Il risultato è identico: chiunque abbia gli identificatori pubblici dell’app può leggere e cancellare i dati. Attivare l’RLS senza policy ha richiuso la tabella Supabase (200 con 0 righe per un ospite e per A, e 403 all’inserimento).
Cosa succede quando un utente tocca i dati di un altro?
Qui si comportano in modo diverso. Entrambi avevano una regola solo-proprietario: policy Supabase su owner_id = auth.uid(), regole Firebase su resource.data.ownerId == request.auth.uid.
| Richiesta di A | Supabase | Firebase |
|---|---|---|
| Elenca tutto | 200, solo le 2 righe di A |
403, query su tutta la collezione rifiutata |
| Elenca con filtro sul proprio id | 200, 2 righe di A |
200, 2 documenti di A |
| Filtra sull’id di B | 200, 0 righe |
403 |
| Legge il record di B | 200, 0 righe |
403 |
| Aggiorna il record di B | 200, 0 righe, nessun errore |
403 |
| Cancella il record di B | 200, 0 righe, nessun errore |
403 |
| Crea un record di proprietà di B | 403, violazione di row security |
403 |
Nessuno dei due ha fatto trapelare i dati di B. Cambia la risposta. Supabase filtra le righe che una policy nasconde, quindi una scrittura che non ha trovato nulla è un successo con zero righe, e un’app che legge “nessun errore” come “salvato” dice all’utente che la modifica è riuscita. Firebase controlla la richiesta stessa: una query che potrebbe restituire documenti negati dalla regola viene rifiutata per intero, e una scrittura sul documento altrui è un errore che l’app non può non vedere. Il prezzo è che ogni query di elenco su Firebase deve portare il filtro che la regola si aspetta.
Un utente può regalare i propri dati o farsi admin?
| Richiesta di A | Supabase | Firebase |
|---|---|---|
| Cambia il proprietario del proprio record in B, senza controllo sul nuovo valore | 403 (una policy update senza controllo riusa il proprio filtro) |
200, e B l’ha poi letto con 200 |
| Lo stesso, con controllo esplicito sul nuovo proprietario | 403 |
403 |
Imposta il proprio role su admin, modifica di sé consentita |
200, il ruolo ora è admin |
200, e la lettura da parte di A dell’ordine di B è passata da 403 a 200 |
| Lo stesso, dopo la correzione | 403 con un grant di colonna solo su display_name; nome 200 |
403 con una regola che confronta il ruolo |
Il passaggio di proprietà mostra i diversi valori predefiniti: in Postgres una policy con la sola clausola using la applica anche alla riga nuova, mentre una regola update di Firebase controlla solo ciò che ci scrivi. L’ho scritta come fanno molti esempi, controllando il vecchio proprietario, e Firebase ha accettato il nuovo.
Il caso del ruolo fallisce allo stesso modo su entrambi, ed è quello che vedo più spesso nel codice generato: una regola “gli utenti possono modificare il proprio profilo” che include la colonna del ruolo. Supabase lo chiude con un grant di colonna o un trigger, Firebase con una regola che confronta request.resource.data.role con il valore salvato.
Cosa permette la sola chiave pubblica?
Entrambi i prodotti mettono un identificatore pubblico in ogni client. Su Supabase la chiave publishable (anon) ha raggiunto l’elenco dello schema dell’API con 200, che nominava le due tabelle che avevo concesso ad anon, e i dati restituiti seguivano grant e RLS: 3 righe con RLS disattivato, 0 con RLS attivo. La chiave secret ha restituito tutte e 3 le righe con RLS attivo, perché service_role salta le policy, e deve restare sul server; i dettagli sono in anon key vs service role key.
Su Firebase la chiave API pubblica mi ha lasciato creare un utente anonimo nell’emulatore Auth (200 e un ID token). Non è un buco in sé, perché le regole decidono comunque cosa vede quell’utente, ma significa che “autenticato” non è un segnale di fiducia quando la registrazione è aperta. Le regole che controllano solo request.auth != null sono aperte a chiunque.
E l’archiviazione di file?
| Richiesta | Supabase Storage, bucket privato | Firebase Storage |
|---|---|---|
| Niente configurato, A legge il file di B | 400 not_found |
403 (regole deny-all) |
| Regola solo-proprietario, A elenca la cartella di B | 200, 0 file |
403 |
| Regola solo-proprietario, A legge il file di B | 400 not_found |
403 |
| Regola solo-proprietario, A carica da B | 400, violazione di row security |
403 |
| Regola solo-proprietario, A nella propria cartella | elenco 200, 1 file; lettura 200; upload 200 |
elenco 200, 1 file; lettura 200; scrittura 200 |
| La regola è “qualsiasi utente autenticato” | non testato | A ha letto il file di B, elencato tutti e 3 i file e sovrascritto quello di B, tutto 200 |
Torna lo stesso schema: Supabase nasconde ciò che non puoi vedere, quindi il file di un altro sembra mancare, e Firebase rifiuta apertamente. La regola “qualsiasi utente autenticato” è la versione storage dell’errore del solo login e ha lasciato che un estraneo sovrascrivesse la scansione del passaporto di qualcuno. I dettagli su Firebase, token di download inclusi, sono in regole di Firebase Storage.
Quale dei due è più sicuro?
Nessuno è sicuro o insicuro per impostazione predefinita; entrambi sono partiti chiusi. Differiscono per dove si nasconde un errore:
| Domanda | Supabase | Firebase |
|---|---|---|
| Dove vivono le regole di accesso | Grant e policy SQL | Linguaggio di regole per percorso |
| Una scrittura negata su altri | 200 con zero righe su update e delete |
403 |
| Un elenco che include dati altrui | Filtrato in silenzio | Rifiutato se la query non corrisponde alla regola |
| Nuovo proprietario in un update | Controllato per impostazione predefinita | Solo se scrivi il controllo |
| Cosa apre tutto per errore | Un grant ad anon con RLS disattivato |
Modalità di test o if true |
| Chiave server | La chiave secret salta tutte le policy | L’Admin SDK salta le regole |
I rifiuti di Firebase sono più rumorosi e i suoi errori hanno la forma di una regola: un controllo mancante sul valore nuovo, un campo ruolo che l’utente può modificare. Il silenzio di Supabase sulle scritture negate è ciò attorno a cui bisogna progettare, e i suoi errori hanno la forma di una policy: RLS disattivato, una policy sempre vera. Se il tuo team non leggerà nessuno dei due, nessuno ti salva. Se lo farà, il 403 di Firebase si nota più facilmente nei test, e l’SQL di Supabase sa esprimere regole che dipendono dai dati, come il livello MFA o l’appartenenza a un’azienda. Qualunque tu scelga, testa come due utenti; il metodo che uso è in come testare l’RLS di Supabase. Lo stesso confronto con un altro backend l’ho fatto in sicurezza Appwrite vs Supabase.
Come si controlla ciascuno?
Il controllo di sicurezza Supabase gratuito legge il tuo progetto in sola lettura e segnala tabelle con RLS disattivato, policy sempre vere, policy di scrittura per ospiti e grant che danno più di quanto le policy lascino intendere. Il verificatore di regole Firebase gratuito legge regole incollate senza toccare il tuo progetto e segnala modalità di test, accesso solo con login e ruoli scritti dall’utente. Nessuno sostituisce l’esecuzione delle richieste qui sopra come ospite e come secondo utente.
Limiti. Uno stack Supabase locale e un’esecuzione dell’emulatore Firebase, via REST, su dati inventati. L’emulatore Firebase non è la produzione e non ho testato Realtime Database, Firebase App Check (l’Emulator Suite non lo include), Supabase Realtime, funzioni né prezzi. Le tue regole e policy decidono il risultato.
Il mio caso simile
Ho applicato le migrazioni di 1.170 progetti Supabase pubblici a database nuovi: dei 568 che sono andati a buon fine, 134 (23,6 %) avevano una tabella con RLS disattivato che la chiave pubblica poteva leggere e modificare. Metodo e query sono nello studio open source su Supabase.
Sta scegliendo un backend per un’app con dati privati? Mi scriva e vedremo quale si adatta e come blindarlo.
Un backend per dati privati?
Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.
Mi scriva