---
title: "Supabase RLS : 1 app open source sur 4 a une table ouverte"
description: "J'ai appliqué les migrations de 568 projets Supabase open source et testé 15 règles de sécurité. 24 % laissent une table que tout le monde peut modifier."
url: "https://madsalt.tech/fr/blog/open-source-supabase-projects-security-study/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-08
---

# Supabase RLS : 1 app open source sur 4 a une table ouverte

En bref

J'ai pris 1 170 dépôts GitHub publics qui contiennent des migrations Supabase, j'ai appliqué chacun à une base Supabase vierge dans un bac à sable sans réseau, puis j'ai lancé les mêmes 15 règles de base de données que mon vérificateur gratuit exécute sur des projets en ligne. 568 projets se sont appliqués sans erreur : 15 624 tables dans `public`. **134 d'entre eux (23,6 %) ont au moins une table sans RLS que la clé publique peut lire et modifier.** 8,8 % ont une policy qui permet à un visiteur non connecté de modifier ou supprimer n'importe quelle ligne, 10,9 % lui laissent tout insérer, et 12,0 % exposent une vue qui contourne la RLS. Les projets créés dans Lovable laissent moins de tables sans RLS (9,1 %), mais écrivent `true` dans leurs policies deux à trois fois plus souvent. Sur un projet créé après le changement de Supabase du 30 octobre, les mêmes migrations en laissent 3,6 % ouvertes au lieu de 22,7 %. Trois requêtes SQL à la fin montrent où en est votre propre projet.

La plupart des conseils de sécurité Supabase disent la même chose : activer la RLS, écrire des policies, consulter l'Advisor. Je voulais savoir à quelle fréquence les vrais projets se trompent, mesurée de la même façon à chaque fois, et non sur les quelques applis que des gens postent sur Reddit. GitHub public contient des milliers de projets Supabase avec tout leur historique de migrations ; j'ai donc construit tous ceux que j'ai pu et regardé la base que laissent les migrations.

## Comment ai-je testé 568 projets ?

J'ai cherché sur GitHub les fichiers SQL sous `supabase/migrations` qui contiennent `create table`, en découpant la recherche par taille de fichier pour passer la limite. Cela a donné 8 914 dépôts, forks exclus. J'en ai tiré un échantillon pseudo-aléatoire fixe, ordonné par un hash du nom du dépôt, et je n'ai téléchargé de chacun que le dossier de migrations et le `package.json`.

| Étape                                                                           | Projets |
| ------------------------------------------------------------------------------- | ------- |
| Dépôts avec des migrations Supabase (recherche de code GitHub, 7 novembre 2026) | 8 914   |
| Échantillon téléchargé                                                          | 1 170   |
| Mesurés, après suppression des doublons exacts                                  | 1 168   |
| Templates et dépôts de Supabase lui-même retirés                                | 9       |
| Migrations qui s'arrêtent sur une erreur sur une base vierge                    | 567     |
| Aucune table dans `public`                                                      | 8       |
| Utilisent le trigger RLS automatique de Supabase (exclus, voir les limites)     | 16      |
| **Analysés**                                                                    | **568** |

Chaque projet a tourné dans sa propre base vierge, dans un conteneur Docker sans accès réseau, construite à partir d'un dump d'une stack Supabase locale (CLI 2.109.1, Postgres 17.6, avec les vrais schémas `auth` et `storage`). Les migrations ont été exécutées dans l'ordre des noms de fichiers avec le rôle `postgres`, qui n'est pas superuser chez Supabase, le rôle qu'utilise aussi `supabase db push`. Rien d'un dépôt n'a jamais été exécuté en dehors de ce conteneur.

Sur la base obtenue, j'ai lancé les requêtes de catalogue et les 15 règles de base de données de mon [vérificateur de sécurité Supabase](https://madsalt.tech/fr/tools/supabase-security-check/), sans les modifier. Les réglages situés hors de la base, comme la confirmation d'e-mail ou la protection contre les mots de passe compromis, ne se voient pas dans des migrations ; ces règles sont donc exclues.

Presque la moitié des projets s'arrêtent sur une erreur avant la dernière migration. Les causes habituelles : des données de seed qui pointent vers des utilisateurs qui n'existent que dans le projet de l'auteur, des objets créés à la main dans le dashboard puis référencés plus tard, et des migrations qui n'ont jamais fonctionné sur une base propre. Je ne rapporte que les projets qui se sont appliqués sans erreur.

## Qu'ai-je trouvé ?

![568 projets Supabase open source : part par constat. Pourcentage de projets. Migrations appliquées à une base vierge, novembre 2026. RLS off, ouvert à la clé publique: 23,60; Vue qui contourne la RLS: 12; N'importe qui peut tout insérer: 10,90; Colonne sensible accessible: 10; N'importe qui peut modifier ou supprimer: 8,80; Storage ouvert aux non-connectés: 5,30; Policy fait confiance à user_metadata: 0,70.](https://madsalt.tech/charts/fr/open-source-supabase-projects-security-study.svg)

*Source : mon étude de 1 168 dépôts GitHub publics avec migrations Supabase, 568 appliqués sans erreur, 7-8 novembre 2026.*

| Constat                                                                                                     | Tous (568) | Créés dans Lovable (66) | Autres (502) |
| ----------------------------------------------------------------------------------------------------------- | ---------- | ----------------------- | ------------ |
| Au moins une table sans RLS que la clé publique peut lire et modifier                                       | **23,6 %** | 9,1 %                   | 25,5 %       |
| Une policy laisse des visiteurs non connectés modifier ou supprimer n'importe quelle ligne (`using (true)`) | **8,8 %**  | 15,2 %                  | 8,0 %        |
| Une policy laisse des visiteurs non connectés tout insérer (`with check (true)`)                            | 10,9 %     | 28,8 %                  | 8,6 %        |
| Une vue dans `public` qui contourne la RLS de ses tables                                                    | 12,0 %     | 7,6 %                   | 12,5 %       |
| Une policy de storage ouverte aux visiteurs non connectés                                                   | 5,3 %      | 12,1 %                  | 4,4 %        |
| Une colonne au nom d'apparence sensible, accessible via l'API                                               | 10,0 %     | 16,7 %                  | 9,2 %        |
| Une policy qui fait confiance à `user_metadata`                                                             | 0,7 %      | 0 %                     | 0,8 %        |

Sur l'ensemble des 15 624 tables, 8,5 % n'ont pas de RLS. Cela paraît peu, jusqu'à ce qu'on compte par projet : une appli sur quatre a au moins une telle table, et avec les grants par défaut que Supabase utilisait jusqu'au 30 octobre 2026, la clé publique peut lire et écrire chaque ligne de cette table.

### Des tables où personne n'a activé la RLS

Dans chacun des cinq projets que j'ai ouverts à la main, aucune migration n'a jamais exécuté `alter table … enable row level security` sur la table ouverte. Un projet avait 31 tables et la RLS sur aucune. Ce que contiennent ces tables varie : des listes de référence comme les pays, mais aussi des compteurs, des événements, des ventes et des profils. La note [RLS disabled in public](https://madsalt.tech/fr/notes/supabase-rls-disabled-in-public/) explique ce que signifie l'avertissement de l'Advisor et comment le corriger sans casser l'appli.

### Des policies qui disent `true`

Une policy avec `using (true)` sur `update` ou `delete` signifie que tout visiteur qui a votre clé publique peut modifier ou supprimer chaque ligne. 8,8 % des projets en ont au moins une. `with check (true)` sur `insert` est plus fréquent, 10,9 %, et parfois voulu, pour une liste d'attente ou un formulaire de contact. Je n'ai compté que le `true` littéral : une policy qui appelle une fonction d'aide comme `is_member(team_id)` est protégée dans la fonction, et n'entre donc pas dans ces chiffres. La [note](https://madsalt.tech/fr/notes/supabase-rls-using-true/) sur `using (true)` montre comment distinguer le cas voulu de l'accident.

### Des vues qui contournent la RLS

Une vue dans `public` s'exécute avec les droits de son propriétaire, sauf si elle est créée avec `security_invoker = true` ; elle renvoie alors des lignes que les policies de la table elle-même cacheraient. 12,0 % des projets en ont au moins une.

## Les projets créés dans Lovable sont-ils pires ?

Pas comme je m'y attendais. J'ai compté un projet comme créé dans Lovable quand son `package.json` liste `lovable-tagger` ou qu'au moins la moitié de ses fichiers de migration portent les noms `<timestamp>_<uuid>.sql` propres à Lovable. Ces projets laissent moins de tables sans RLS, 9,1 % contre 25,5 %. En revanche, ils écrivent `true` dans leurs policies bien plus souvent : 15,2 % laissent n'importe qui modifier ou supprimer des lignes, 28,8 % laissent n'importe qui insérer, et 12,1 % ouvrent une policy de storage aux visiteurs non connectés. Seuls 66 projets Lovable se sont appliqués sans erreur, tandis que 152 se sont arrêtés sur une erreur, souvent sur des données de seed pour les propres utilisateurs de l'auteur ; la colonne Lovable indique donc une tendance, avec une marge d'environ huit points dans un sens ou dans l'autre.

## Le changement du 30 octobre règle-t-il le problème ?

Le [breaking change](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically) de Supabase cesse d'accorder automatiquement des grants aux rôles de l'API sur les nouvelles tables de `public` ; ce qu'il casse, je l'ai testé dans [cet article](https://madsalt.tech/fr/blog/supabase-october-30-grant-change/). J'ai relancé 433 des projets une seconde fois avec les nouveaux défauts, comme démarre un projet créé après le basculement. 194 d'entre eux se sont appliqués sans erreur les deux fois.

| Les mêmes 194 projets                                                 | Anciens défauts | Nouveaux défauts |
| --------------------------------------------------------------------- | --------------- | ---------------- |
| Au moins une table sans RLS que la clé publique peut lire et modifier | 44 (22,7 %)     | 7 (3,6 %)        |

![Les mêmes 194 projets avant et après le 30 octobre. Pourcentage avec une table sans RLS que la clé publique peut lire et modifier. Anciens privilèges par défaut: 22,70; Nouveaux privilèges par défaut: 3,60.](https://madsalt.tech/charts/fr/open-source-supabase-projects-security-study-oct30.svg)

*Source : mon étude, novembre 2026 : les mêmes migrations appliquées avec les anciens et les nouveaux privilèges par défaut de Supabase.*

Donc oui, pour les nouvelles tables il ferme l'essentiel de l'écart : une table à laquelle personne n'a accordé de droits est inaccessible, RLS ou non. Les sept projets qui restent ouverts accordent eux-mêmes l'accès aux rôles de l'API dans leurs migrations, ce qui ramène aussitôt l'ancienne exposition. Et le basculement ne change que ce que reçoivent les nouvelles tables : un projet qui a déjà une table ouverte la garde ouverte, la première requête ci-dessous compte donc toujours sur chaque projet existant.

## Comment me suis-je assuré que les chiffres sont justes ?

Avant de croire un résultat, j'ai construit un projet de test avec six problèmes plantés (une table sans RLS, des policies `using (true)`, une vue sans `security_invoker`, une fonction security definer que tout le monde peut appeler, une policy qui lit `user_metadata`, un bucket public avec des uploads anonymes) et deux tables correctement sécurisées. Le pipeline devait trouver les six et aucune des deux autres. Les premiers essais n'y sont pas arrivés : les règles ont besoin de la liste des schémas de l'API, qu'un projet en ligne fournit et qu'un bac à sable ne fournit pas, et le rôle admin du bac à sable affichait `uid()` au lieu de `auth.uid()` dans les policies, ce qui faisait paraître ouvertes des policies sûres. Les deux sont corrigés, chaque projet a été mesuré de nouveau, et j'ai ouvert à la main des échantillons de chaque constat.

## Ce que cette étude ne peut pas voir

- Les migrations ne sont pas la base en production. Tout ce qui a été modifié dans le dashboard sans jamais être écrit dans une migration est invisible ici, dans les deux sens.
- Les projets qui publient leurs migrations sur GitHub ne sont pas tous des projets Supabase. Beaucoup sont des projets d'apprentissage ou des projets perso.
- Près de la moitié de l'échantillon ne s'est pas appliquée sans erreur et n'est pas dans les chiffres. Ces projets peuvent être plus sûrs ou moins sûrs.
- Les projets qui ont activé le [trigger RLS automatique](https://supabase.com/docs/guides/database/postgres/event-triggers) de Supabase obtiennent la RLS sur les nouvelles tables sans qu'aucune migration ne le dise. J'ai exclu les 16 qui y font référence ; d'autres l'utilisent peut-être sans trace dans leurs fichiers.
- Les noms des dépôts ne sont pas publiés. Les données viennent d'informations publiques et non personnelles, au titre de la clause de recherche des [Acceptable Use Policies de GitHub](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).

## Comment vérifier votre propre projet ?

Lancez ces requêtes dans le SQL Editor. Chacune a renvoyé exactement le problème planté sur mon projet de test, et rien d'autre.

Les tables sans RLS, et si la clé publique peut y accéder :

```sql
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;
```

Les policies qui laissent des visiteurs non connectés écrire sans aucune condition :

```sql
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;
```

Les vues qui contournent la RLS :

```sql
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 résultat vide aux trois est un bon début, pas un certificat de bonne santé. [Comment activer la RLS](https://madsalt.tech/fr/blog/how-to-enable-rls-in-supabase/) traite la première requête, les [exemples de policies RLS](https://madsalt.tech/fr/blog/supabase-rls-policy-examples/) la deuxième, et [comment tester la RLS](https://madsalt.tech/fr/blog/how-to-test-supabase-rls/) montre comment prouver qu'un utilisateur ne peut pas lire les lignes d'un autre. Pour la vue d'ensemble, voir [Supabase est-il sûr](https://madsalt.tech/fr/blog/is-supabase-secure/) et la [checklist de sécurité d'une appli Lovable](https://madsalt.tech/fr/blog/lovable-app-security-checklist/).

## Mon cas similaire

En construisant un outil de suivi du temps pour un cabinet d'audit, j'ai trouvé 4 erreurs qu'aucun écran ne montrait, dont un client confidentiel qui fuyait par les totaux des rapports et les compteurs d'étiquettes. Chaque règle d'accès vit désormais dans la base de données et est testée avant chaque déploiement ; toute l'histoire est dans le [cas du cabinet d'audit](https://madsalt.tech/fr/work/audit-firm-time-tracking/).

Vous voulez savoir où en est votre propre projet ? Écrivez-moi et nous le vérifierons de la même façon.

Où en est votre projet ?

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)

## Sources

- Recherche de code GitHub et données des dépôts, 7 novembre 2026 ; échantillon et pipeline décrits ci-dessus.
- Supabase, [Securing your API: default privileges](https://supabase.com/docs/guides/api/securing-your-api), consulté le 7 novembre 2026.
- Supabase, [Breaking change: tables not exposed to the Data and GraphQL API automatically](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically).
- Supabase, [Event triggers: automatically enable RLS](https://supabase.com/docs/guides/database/postgres/event-triggers).
- GitHub, [Acceptable Use Policies, section 7](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).
