---
title: "Sicurezza Supabase vs Firebase: stessi attacchi su entrambi"
description: "Stessi attacchi di accesso su Supabase locale e sugli emulatori Firebase. Entrambi partono chiusi; cambia come fallisce una regola sbagliata."
url: "https://madsalt.tech/it/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-06
---

# Sicurezza Supabase vs Firebase: stessi attacchi su entrambi

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](https://madsalt.tech/it/blog/firebase-security-rules-examples/), quelle di Supabase in [esempi di policy RLS Supabase](https://madsalt.tech/it/blog/supabase-rls-policy-examples/).

## 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](https://madsalt.tech/it/blog/supabase-october-30-grant-change/). 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`                                         |

![Stessa richiesta, due backend. L'utente A modifica dati dell'utente B, tramite l'API REST di ciascuno. Supabase, policy solo-proprietario: Utente A → modifica dati di B → 200 \[\] → 0 righe, nessun errore; Firebase, regola solo-proprietario: Utente A → modifica dati di B → 403 → errore restituito.](https://madsalt.tech/charts/it/supabase-vs-firebase-security.svg)

*Figura 1. I miei test, 6 novembre 2026: stack Supabase locale (CLI 2.109.1) ed emulatori Firebase (CLI 15.35.0).*

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](https://madsalt.tech/it/blog/supabase-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](https://madsalt.tech/it/blog/firebase-storage-rules/).

## 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](https://madsalt.tech/it/blog/how-to-test-supabase-rls/). Lo stesso confronto con un altro backend l'ho fatto in [sicurezza Appwrite vs Supabase](https://madsalt.tech/it/blog/appwrite-vs-supabase/).

## Come si controlla ciascuno?

Il [controllo di sicurezza Supabase](https://madsalt.tech/it/tools/supabase-security-check/) 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](https://madsalt.tech/it/tools/firebase-rules-checker/) 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](https://madsalt.tech/it/blog/open-source-supabase-projects-security-study/).

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](https://madsalt.tech/it/#contact)
