Aller au contenu

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

Voir en MarkdownOuvrir dans ClaudeOuvrir dans ChatGPTOuvrir dans Perplexity

La question est aussi copiée. Si le chat reste vide, collez-la.

Sur cette page
  1. Comment ai-je testé 568 projets ?
  2. Qu’ai-je trouvé ?
    1. Des tables où personne n’a activé la RLS
    2. Des policies qui disent true
    3. Des vues qui contournent la RLS
  3. Les projets créés dans Lovable sont-ils pires ?
  4. Le changement du 30 octobre règle-t-il le problème ?
  5. Comment me suis-je assuré que les chiffres sont justes ?
  6. Ce que cette étude ne peut pas voir
  7. Comment vérifier votre propre projet ?
  8. Mon cas similaire
  9. Sources

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, 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.
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 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 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 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. 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.
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 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.

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 :

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 :

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 :

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 traite la première requête, les exemples de policies RLS la deuxième, et comment tester la 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 et la checklist de sécurité d’une appli Lovable.

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.

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

Sources

© 2026 Denys Zaichenko. Article original : https://madsalt.tech/fr/blog/open-source-supabase-projects-security-study/