---
title: "Supabase vs Firebase : les mêmes attaques sur les deux"
description: "Les mêmes attaques d’accès sur Supabase en local et les émulateurs Firebase. Les deux démarrent fermés ; une règle erronée échoue différemment."
url: "https://madsalt.tech/fr/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-06
---

# Supabase vs Firebase : les mêmes attaques sur les deux

TL;DR

Les deux démarrent fermés : une nouvelle table Supabase répondait `401` à un visiteur tant que je ne l’avais pas ouverte, et une nouvelle base Firebase avec des règles deny-all répondait `403`. La différence tient à la façon dont une erreur échoue. Quand l’utilisateur A a modifié ou supprimé les données de l’utilisateur B sous une politique réservée au propriétaire, Supabase a répondu `200` avec zéro ligne et sans erreur ; Firebase a refusé avec `403`. En revanche, Firebase a laissé A céder une commande à B avec `200` quand la règle update ne vérifiait que l’ancien propriétaire, là où Supabase refusait le même geste avec `403`. Ouvertes (un grant à `anon` avec RLS désactivé, ou `if true`), les deux ont donné à un visiteur les trois lignes et lui ont laissé en supprimer une. La clé publique seule n’ouvre rien dans aucune des deux ; ce sont les règles qui décident.

Je suis Denys, Forward Deployed Engineer. La plupart des applications que je répare tournent sur Supabase ou Firebase, et ceux qui hésitent entre les deux demandent laquelle est la plus sûre. Les comparatifs de fonctions et de prix n’y répondent pas, alors j’ai envoyé aux deux les mêmes requêtes.

**Comment j’ai testé.** Supabase avec une pile locale (CLI 2.109.1, Postgres 17.6) et Firebase avec le Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore et Storage), les deux le 6 novembre 2026. De simples appels REST en visiteur et en deux utilisateurs connectés A et B, avec des données inventées : les commandes `a1` et `a2` appartiennent à A, `b1` à B. Rien n’a touché un vrai projet.

## Comment Supabase et Firebase protègent-ils les données ?

Supabase met les données dans Postgres. Un grant décide si les rôles de l’API peuvent toucher une table, et les politiques de row level security (RLS), écrites en SQL, décident quelles lignes chaque requête voit et écrit. Firebase met les données dans Firestore et Cloud Storage, et les règles de sécurité, un langage à part, décident par chemin et par requête si une lecture ou une écriture est permise.

Les deux ont donc un contrôle d’accès, et la question est ce que chacun vous laisse rater. Les règles de Firebase sont détaillées dans [exemples de règles de sécurité Firebase](https://madsalt.tech/fr/blog/firebase-security-rules-examples/), celles de Supabase dans [exemples de politiques RLS Supabase](https://madsalt.tech/fr/blog/supabase-rls-policy-examples/).

## Que fait chacun d’un nouveau projet ?

| Requête                         | Supabase, nouvelle table, rien accordé | Firebase, règles deny-all |
| ------------------------------- | -------------------------------------- | ------------------------- |
| Un visiteur liste les données   | `401`, permission denied (42501)       | `403`                     |
| Un utilisateur connecté liste   | `403`, permission denied (42501)       | `403`                     |
| Collection sans règle pour elle | sans objet                             | `403`                     |

Une installation neuve est fermée des deux côtés. Chez Supabase, c’est récent : les tables créées après le 30 octobre 2026 ne reçoivent plus de grants Data API automatiquement, et ma CLI se comportait déjà ainsi, donc la première requête a échoué sur le grant manquant, pas sur une politique. J’ai décrit le changement dans [le changement de grants du 30 octobre](https://madsalt.tech/fr/blog/supabase-october-30-grant-change/). Une base Firebase créée en mode production démarre avec des règles deny-all.

## Que se passe-t-il quand on la laisse ouverte ?

| Requête d’un visiteur       | Supabase, grant à `anon`, RLS désactivé | Firebase, `allow read, write: if true` |
| --------------------------- | --------------------------------------- | -------------------------------------- |
| Lister les données          | `200`, les 3 lignes                     | `200`, les 3 documents                 |
| Ajouter un enregistrement   | `201`                                   | `200`                                  |
| Supprimer un enregistrement | `200`, ligne supprimée                  | `200`, document supprimé               |

Les états ouverts ne sont pas la même chose. Chez Supabase, il faut un grant délibéré à `anon` et le RLS désactivé, le schéma que certains tutoriels et outils d’IA écrivent pour faire disparaître une erreur. Chez Firebase, c’est le mode test, d’où partent beaucoup de tutoriels. Le résultat est identique : quiconque détient les identifiants publics de l’application peut lire et effacer les données. Activer le RLS sans politique a refermé la table Supabase (`200` avec 0 ligne pour un visiteur et pour A, et `403` à l’insertion).

## Que se passe-t-il quand un utilisateur touche aux données d’un autre ?

C’est là qu’ils se comportent différemment. Les deux avaient une règle réservée au propriétaire : des politiques Supabase sur `owner_id = auth.uid()`, des règles Firebase sur `resource.data.ownerId == request.auth.uid`.

| Requête de A                           | Supabase                           | Firebase                                       |
| -------------------------------------- | ---------------------------------- | ---------------------------------------------- |
| Liste tout                             | `200`, seulement les 2 lignes de A | `403`, requête sur toute la collection refusée |
| Liste avec un filtre sur son propre id | `200`, 2 lignes de A               | `200`, 2 documents de A                        |
| Filtre sur l’id de B                   | `200`, 0 ligne                     | `403`                                          |
| Lit l’enregistrement de B              | `200`, 0 ligne                     | `403`                                          |
| Modifie l’enregistrement de B          | `200`, 0 ligne, pas d’erreur       | `403`                                          |
| Supprime l’enregistrement de B         | `200`, 0 ligne, pas d’erreur       | `403`                                          |
| Crée un enregistrement appartenant à B | `403`, violation de row security   | `403`                                          |

![Même requête, deux backends. L’utilisateur A modifie des données de l’utilisateur B, via chaque API REST. Supabase, politique propriétaire seul: Utilisateur A → modifier les données de B → 200 \[\] → 0 ligne, pas d’erreur; Firebase, règle propriétaire seul: Utilisateur A → modifier les données de B → 403 → erreur renvoyée.](https://madsalt.tech/charts/fr/supabase-vs-firebase-security.svg)

*Figure 1. Mes tests, 6 novembre 2026 : pile Supabase locale (CLI 2.109.1) et émulateurs Firebase (CLI 15.35.0).*

Aucune n’a divulgué les données de B. C’est la réponse qui diffère. Supabase filtre les lignes qu’une politique masque, donc une écriture qui n’a rien trouvé est un succès à zéro ligne, et une application qui lit « pas d’erreur » comme « enregistré » dit à l’utilisateur que sa modification a marché. Firebase vérifie la requête elle-même : une requête qui pourrait renvoyer des documents que la règle refuse est rejetée en entier, et une écriture dans le document d’un autre est une erreur que l’application ne peut pas manquer. Le prix : chaque requête de liste côté Firebase doit porter le filtre que la règle attend.

## Un utilisateur peut-il céder ses données ou se faire admin ?

| Requête de A                                                                        | Supabase                                                                   | Firebase                                                                   |
| ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
| Change le propriétaire de son enregistrement en B, sans vérifier la nouvelle valeur | `403` (une politique update sans vérification réutilise son propre filtre) | `200`, puis B l’a lu avec `200`                                            |
| Pareil, avec une vérification explicite du nouveau propriétaire                     | `403`                                                                      | `403`                                                                      |
| Met son propre `role` à `admin`, modification de soi permise                        | `200`, le rôle est maintenant `admin`                                      | `200`, et la lecture par A de la commande de B est passée de `403` à `200` |
| Pareil, après correction                                                            | `403` avec un grant de colonne limité à `display_name` ; nom `200`         | `403` avec une règle qui compare le rôle                                   |

Le transfert de propriétaire montre les valeurs par défaut différentes : dans Postgres, une politique avec seulement une clause `using` l’applique aussi à la nouvelle ligne, alors qu’une règle update de Firebase ne vérifie que ce que vous y écrivez. Je l’ai écrite comme beaucoup d’exemples, en vérifiant l’ancien propriétaire, et Firebase a accepté le nouveau.

Le cas du rôle échoue pareil des deux côtés, et c’est celui que je vois le plus dans le code généré : une règle « les utilisateurs peuvent modifier leur propre profil » qui inclut la colonne du rôle. Supabase le ferme avec un grant de colonne ou un trigger, Firebase avec une règle qui compare `request.resource.data.role` à la valeur stockée.

## Que permet la clé publique seule ?

Les deux produits mettent un identifiant public dans chaque client. Chez Supabase, la clé publishable (anon) a atteint le listing du schéma de l’API avec `200`, qui nommait les deux tables que j’avais accordées à `anon`, et les données renvoyées suivaient les grants et le RLS : 3 lignes avec RLS désactivé, 0 avec RLS activé. La clé secret a renvoyé les 3 lignes avec RLS activé, car `service_role` ignore les politiques, et elle doit rester côté serveur ; les détails sont dans [anon key vs service role key](https://madsalt.tech/fr/blog/supabase-anon-key-vs-service-role-key/).

Chez Firebase, la clé d’API publique m’a laissé créer un utilisateur anonyme dans l’émulateur Auth (`200` et un jeton d’ID). Ce n’est pas une faille en soi, car les règles décident encore de ce que cet utilisateur voit, mais cela signifie que « connecté » n’est pas un signal de confiance quand l’inscription est ouverte. Les règles qui ne vérifient que `request.auth != null` sont ouvertes à tous.

## Et le stockage de fichiers ?

| Requête                                          | Supabase Storage, bucket privé                       | Firebase Storage                                                                    |
| ------------------------------------------------ | ---------------------------------------------------- | ----------------------------------------------------------------------------------- |
| Rien configuré, A lit le fichier de B            | `400` not_found                                      | `403` (règles deny-all)                                                             |
| Règle propriétaire seul, A liste le dossier de B | `200`, 0 fichier                                     | `403`                                                                               |
| Règle propriétaire seul, A lit le fichier de B   | `400` not_found                                      | `403`                                                                               |
| Règle propriétaire seul, A téléverse chez B      | `400`, violation de row security                     | `403`                                                                               |
| Règle propriétaire seul, A dans son dossier      | liste `200`, 1 fichier ; lecture `200` ; envoi `200` | liste `200`, 1 fichier ; lecture `200` ; écriture `200`                             |
| La règle est « tout utilisateur connecté »       | non testé                                            | A a lu le fichier de B, listé les 3 fichiers et écrasé celui de B, le tout en `200` |

Le même schéma revient : Supabase masque ce que vous ne devez pas voir, donc le fichier d’un autre semble absent, et Firebase refuse net. La règle « tout utilisateur connecté » est la version stockage de l’erreur du simple login, et elle a laissé un inconnu écraser le scan de passeport de quelqu’un. Les détails Firebase, jetons de téléchargement compris, sont dans [règles Firebase Storage](https://madsalt.tech/fr/blog/firebase-storage-rules/).

## Lequel est le plus sûr ?

Aucun n’est sûr ou dangereux par défaut ; les deux ont démarré fermés. Ils diffèrent par l’endroit où se cache une erreur :

| Question                                  | Supabase                                   | Firebase                                         |
| ----------------------------------------- | ------------------------------------------ | ------------------------------------------------ |
| Où vivent les règles d’accès              | Grants et politiques SQL                   | Langage de règles par chemin                     |
| Une écriture refusée sur autrui           | `200` avec zéro ligne en update et delete  | `403`                                            |
| Une liste qui inclut les données d’autrui | Filtrée en silence                         | Refusée sauf si la requête correspond à la règle |
| Nouveau propriétaire lors d’un update     | Vérifié par défaut                         | Seulement si vous écrivez la vérification        |
| Ce qui ouvre tout par erreur              | Un grant à `anon` avec RLS désactivé       | Mode test ou `if true`                           |
| Clé serveur                               | La clé secret ignore toutes les politiques | L’Admin SDK ignore les règles                    |

Les refus de Firebase sont plus bruyants et ses erreurs ont la forme d’une règle : une vérification manquante sur la nouvelle valeur, un champ de rôle que l’utilisateur peut modifier. Le silence de Supabase sur les écritures refusées est ce autour de quoi il faut concevoir, et ses erreurs ont la forme d’une politique : RLS désactivé, une politique toujours vraie. Si votre équipe ne lit ni l’un ni l’autre, aucun ne vous sauve. Si elle le fait, le `403` de Firebase se remarque plus facilement en test, et le SQL de Supabase sait exprimer des règles qui dépendent des données, comme le niveau de MFA ou l’appartenance à une société. Quel que soit votre choix, testez en deux utilisateurs ; la méthode que j’emploie est dans [comment tester le RLS de Supabase](https://madsalt.tech/fr/blog/how-to-test-supabase-rls/). J’ai fait la même comparaison avec un autre backend dans [Appwrite vs Supabase : sécurité](https://madsalt.tech/fr/blog/appwrite-vs-supabase/).

## Comment vérifier chacun ?

Le [contrôle de sécurité Supabase](https://madsalt.tech/fr/tools/supabase-security-check/) gratuit lit votre projet en lecture seule et signale les tables sans RLS, les politiques toujours vraies, les politiques d’écriture pour visiteurs et les grants qui donnent plus que ne le laissent entendre les politiques. Le [vérificateur de règles Firebase](https://madsalt.tech/fr/tools/firebase-rules-checker/) gratuit lit des règles collées sans toucher à votre projet et signale le mode test, l’accès réservé aux connectés et les rôles que l’utilisateur écrit lui-même. Aucun ne remplace l’exécution des requêtes ci-dessus en visiteur et en second utilisateur.

**Limites.** Une pile Supabase locale et une exécution de l’émulateur Firebase, en REST, sur des données inventées. L’émulateur Firebase n’est pas la production et je n’ai pas testé Realtime Database, Firebase App Check (l’Emulator Suite ne l’inclut pas), Supabase Realtime, les fonctions ni les prix. Vos propres règles et politiques décident du résultat.

## Mon cas similaire

J'ai appliqué les migrations de 1 170 projets Supabase publics à des bases neuves : sur les 568 qui se sont exécutées sans erreur, 134 (23,6 %) avaient une table avec RLS désactivé que la clé publique pouvait lire et modifier. La méthode et les requêtes sont dans [l'étude open source sur Supabase](https://madsalt.tech/fr/blog/open-source-supabase-projects-security-study/).

Vous choisissez un backend pour une application avec des données privées ? Écrivez-moi et nous verrons lequel convient et comment le verrouiller.

Un backend pour des données privées ?

Dites-moi ce que vous avez aujourd'hui et ce qu'il vous faut. Je vous répondrai avec l'option que je choisirais.

[Me contacter](https://madsalt.tech/fr/#contact)
