Sécurité et mise en ligne

Supabase et RLS : l'erreur qui expose les données de tes utilisateurs

Publié le Mis à jour le 8 min de lecture

Lire en : English

Sommaire
  1. Pourquoi la clé publique de Supabase ne protège-t-elle rien ?
  2. Quelle est l'erreur qui expose les données ?
  3. Comment savoir en 2 minutes si ta base est exposée ?
  4. Étape 1 : le Security Advisor
  5. Étape 2 : le test avec la clé publique
  6. Quelles règles RLS écrire pour une table d'utilisateurs ?
  7. Quels pièges de RLS l'IA ne voit pas ?
  8. Quel prompt donner à l'IA pour corriger le RLS sans tout casser ?
  9. Et si l'app a besoin d'accéder à toutes les données ?
  10. Questions fréquentes
  11. Questions fréquentes
  12. Sources

Le Supabase RLS (Row Level Security) est la seule chose qui sépare les données de tes utilisateurs du reste d'Internet. Ton app parle directement à la base depuis le navigateur, avec une clé que n'importe qui peut lire. Si une table n'a pas de règles RLS, ou des règles trop larges, un inconnu peut la lire en une requête. Voici comment vérifier, corriger et tester.

Pourquoi la clé publique de Supabase ne protège-t-elle rien ?

La clé publique de Supabase n'est pas un mot de passe : c'est un badge visiteur. La documentation de Supabase décrit la clé publishable (sb_publishable_..., ou l'ancienne clé anon) comme « sans danger à exposer en ligne », justement parce que ce qu'elle permet est limité par le RLS.

Concrètement, une app générée par Lovable ou Bolt contient l'URL de ton projet et cette clé dans son code JavaScript. N'importe quel visiteur peut les copier depuis l'onglet Réseau de son navigateur et interroger l'API REST de ta base directement, sans passer par ton interface.

Ce qui décide alors de la réponse :

Situation de la tableCe qu'obtient un inconnu avec la clé publique
RLS désactivéLecture et écriture de toutes les lignes, selon les droits accordés au rôle
RLS activé, aucune règleRien : tout est refusé par défaut
RLS activé, règle using (true) pour anonToutes les lignes, en lecture
RLS activé, règle basée sur auth.uid()Seulement ses propres lignes, s'il est connecté

La documentation Supabase est explicite sur le deuxième cas : une fois le RLS activé, aucune donnée n'est accessible via l'API avec la clé publique tant que tu n'as pas créé de règles.

Quelle est l'erreur qui expose les données ?

L'erreur la plus fréquente n'est pas d'oublier le RLS, c'est de le contourner pour faire marcher l'app. Le scénario se répète :

  1. Tu actives le RLS (ou l'outil le fait).
  2. L'app n'affiche plus rien, puisque tout est refusé par défaut.
  3. Tu demandes à l'IA de corriger. Elle écrit une règle using (true), ou désactive le RLS, ou bascule sur la clé secrète.
  4. L'app remarche. Les données sont ouvertes à tous.

C'est le type de faille décrit dans la CVE-2025-48757, notée 9,3 sur 10 : des règles RLS insuffisantes dans des sites générés par Lovable jusqu'au 15 avril 2025 permettaient à des attaquants non connectés de lire ou d'écrire dans les tables. Lovable conteste, en rappelant que chaque client est responsable de la protection des données de son app. Dans les deux lectures, la conclusion pour toi est la même : la vérification t'appartient.

Comment savoir en 2 minutes si ta base est exposée ?

Le plus rapide est d'utiliser le Security Advisor de Supabase, puis de confirmer avec un test manuel.

Étape 1 : le Security Advisor

Dans le tableau de bord Supabase, ouvre Advisors, puis Security Advisor. Les alertes à traiter en priorité :

Étape 2 : le test avec la clé publique

Récupère l'URL du projet et la clé publique dans l'onglet Réseau de ton site (F12), puis lance dans un terminal :

curl "https://TON-PROJET.supabase.co/rest/v1/profiles?select=*" \
  -H "apikey: TA_CLE_PUBLIQUE"

Remplace profiles par chacune de tes tables. Une table privée doit renvoyer [] ou une erreur. Si tu vois des e-mails, des noms ou des commandes, la table est ouverte.

Quelles règles RLS écrire pour une table d'utilisateurs ?

La règle de base : une politique par opération, chacune limitée au rôle authenticated et à la ligne qui appartient à l'utilisateur. Voici un modèle pour une table notes avec une colonne user_id :

-- 1. Activer le RLS
alter table public.notes enable row level security;

-- 2. Lire ses propres notes
create policy "Lire ses notes"
on public.notes for select
to authenticated
using ( (select auth.uid()) = user_id );

-- 3. Créer une note à son nom uniquement
create policy "Créer ses notes"
on public.notes for insert
to authenticated
with check ( (select auth.uid()) = user_id );

-- 4. Modifier ses propres notes
create policy "Modifier ses notes"
on public.notes for update
to authenticated
using ( (select auth.uid()) = user_id )
with check ( (select auth.uid()) = user_id );

-- 5. Supprimer ses propres notes
create policy "Supprimer ses notes"
on public.notes for delete
to authenticated
using ( (select auth.uid()) = user_id );

-- 6. Index pour les performances
create index on public.notes (user_id);

Trois détails tirés de la documentation Supabase :

Quels pièges de RLS l'IA ne voit pas ?

Même avec le RLS activé partout, cinq erreurs reviennent dans les apps générées.

  1. **La règle fourre-tout for all.** Supabase la déconseille : une seule règle pour toutes les opérations rend les erreurs difficiles à voir. Écris-en une par opération.
  2. **Les rôles dans user_metadata.** Un utilisateur connecté peut modifier ses propres user_metadata. Si ta règle admin vérifie user_metadata.role = 'admin', n'importe qui peut se déclarer admin. Utilise app_metadata, que seul le serveur modifie.
  3. Les vues qui contournent tout. Une vue s'exécute par défaut avec les droits de son créateur. Sur Postgres 15 et plus, crée-la avec with (security_invoker = true).
  4. **Les fonctions security definer exposées.** Une fonction de ce type s'exécute avec des droits élevés. Elle doit fixer search_path = '' et ne pas se trouver dans un schéma exposé par l'API.
  5. **Le null silencieux.** Pour un visiteur non connecté, auth.uid() vaut null, et la comparaison null = user_id n'est jamais vraie. C'est sûr, mais si tu écris des conditions plus complexes avec des or, ajoute explicitement auth.uid() is not null.

Un dernier point technique : les droits (grant) et les règles RLS sont deux couches différentes. La documentation Supabase rappelle que, sur un projet existant, les nouvelles tables du schéma public donnent tous les droits aux rôles anon et authenticated, et qu'ajouter des règles ne retire pas ces droits. Le RLS reste la protection principale ; les droits sont une ceinture en plus.

Quel prompt donner à l'IA pour corriger le RLS sans tout casser ?

Le bon prompt interdit explicitement les raccourcis dangereux. Colle-le dans Lovable, Bolt, Cursor ou Claude Code :

Audite la sécurité Supabase de ce projet, table par table.
Pour chaque table du schéma public :
1. Indique si le RLS est activé et liste les règles existantes.
2. Propose une migration SQL qui active le RLS et crée une règle par
   opération (select, insert, update, delete), limitée au rôle
   authenticated et à (select auth.uid()) = user_id, sauf si la table
   contient des données explicitement publiques : demande-moi lesquelles.
3. Ajoute un index sur chaque colonne utilisée dans les règles.

Interdictions :
- ne désactive jamais le RLS ;
- n'utilise pas using (true) sur une table qui contient des données
  d'utilisateurs ;
- n'utilise jamais la clé service_role ou une clé secrète côté client ;
- ne stocke aucun rôle dans user_metadata.

Si une fonctionnalité casse après la migration, explique pourquoi et
propose une règle précise, pas un contournement.

Après la migration, refais le test curl sur chaque table, puis le test des deux comptes : connecte-toi avec un compte A, crée une donnée, et vérifie qu'un compte B ne la voit pas. Ce sont les deux vérifications de base de notre checklist de sécurité avant mise en ligne.

Et si l'app a besoin d'accéder à toutes les données ?

Certaines opérations doivent réellement lire toutes les lignes : un tableau de bord admin, un export, un traitement planifié. La solution n'est pas d'ouvrir les règles, c'est de déplacer l'opération côté serveur.

La gestion des clés côté serveur est détaillée dans Clés API : pourquoi elles ne doivent jamais être dans le front, et la gestion des comptes dans l'authentification sans faille. Pour débuter avec Supabase de zéro, vois Supabase pour débutants ; si tu construis avec Lovable, notre avis complet sur Lovable détaille son intégration Supabase. Et pour vérifier le reste du code généré, sans être développeur : tester le code de l'IA.

Questions fréquentes

Questions fréquentes

Le RLS de Supabase est-il activé par défaut ?

Ne le suppose jamais. Selon la façon dont la table a été créée (éditeur de tables, requête SQL, migration générée par l'IA), le RLS peut être activé ou non. Ouvre le Security Advisor de Supabase, qui signale chaque table du schéma public sans RLS avec l'alerte rls_disabled_in_public, et vérifie table par table.

Pourquoi mon app n'affiche plus rien après avoir activé le RLS ?

Parce qu'une table avec RLS mais sans règle refuse tout par défaut : c'est le comportement prévu. Il faut maintenant écrire des règles qui autorisent exactement ce qui est nécessaire, par exemple la lecture de ses propres lignes avec auth.uid() = user_id. Ne demande pas à l'IA de « débloquer » l'app sans préciser : elle risque de désactiver le RLS ou d'écrire une règle using (true).

La clé anon visible dans mon code est-elle une faille ?

Non. La clé publique (anon ou publishable) est conçue pour être visible dans le navigateur. Elle ne permet que ce que tes règles RLS autorisent. La faille, c'est une table sans RLS ou avec une règle trop large. La clé à ne jamais exposer est la clé secrète (service_role ou sb_secret), qui contourne toutes les règles. Si elle se trouve dans ton front, régénère-la.

Le RLS ralentit-il les requêtes ?

Il peut, sur de grosses tables, si les règles sont mal écrites. La documentation Supabase recommande deux réflexes : entourer les fonctions comme auth.uid() d'un (select ...) pour qu'elles soient calculées une seule fois par requête, et créer un index sur chaque colonne utilisée dans les règles, comme user_id. Pour une app de quelques milliers de lignes, l'impact est négligeable.

Lovable ou Bolt configurent-ils le RLS correctement ?

Ils créent souvent des règles, et Lovable vérifie les tables sans RLS dans son scan avant publication. Mais l'outil ne connaît pas tes intentions : il ne sait pas quelles données doivent être publiques ou privées. La CVE-2025-48757 montre que des apps générées ont été publiées avec des règles insuffisantes. Vérifie toujours avec le Security Advisor et un test curl avec la clé publique.

Sources