---
title: "Supabase et RLS : l'erreur qui expose les données de tes utilisateurs"
description: "Une table Supabase sans RLS est lisible par n'importe qui avec la clé publique de ton site. Le test en 2 minutes et les règles SQL à copier."
url: "https://vibe-code.blog/blog/supabase-rls"
lang: "fr"
author: "Thierry Gustin"
published: "2026-11-02"
updated: "2026-11-21"
---

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

> **L’essentiel** — Dans une app Supabase, la clé publique est visible par tous dans le navigateur ; seules les règles Row Level Security (RLS) empêchent un inconnu de lire ou modifier tes tables. L'erreur classique est une table sans RLS, ou avec une règle using (true) ajoutée pour « débloquer » l'app. Active le RLS sur chaque table, écris une règle par opération basée sur auth.uid(), puis teste avec la clé publique.

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](https://supabase.com/) 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](https://lovable.dev/) ou [Bolt](https://bolt.new/) 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 table | Ce 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ègle | Rien : tout est refusé par défaut |
| RLS activé, règle `using (true)` pour `anon` | Toutes 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](https://nvd.nist.gov/vuln/detail/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.

> **La clé secrète n'est jamais une solution** — La clé `service_role` (ou `sb_secret_...`) contourne tout le RLS. Supabase refuse les nouvelles clés secrètes envoyées depuis un navigateur (erreur 401), mais une clé qui a fuité reste utilisable depuis un terminal, et l'ancienne clé `service_role` ne bénéficie pas de ce blocage. Si l'IA l'a mise côté client, régénère-la.

## 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é :

- `rls_disabled_in_public` (niveau ERROR) : une table du schéma `public` n'a pas le RLS, donc toute personne qui connaît l'URL du projet peut lire, insérer, modifier et supprimer ses lignes.
- `policy_exists_rls_disabled` : tu as écrit des règles, mais le RLS n'est pas activé, donc elles ne servent à rien.
- `security_definer_view` : une vue s'exécute avec les droits de son créateur et contourne le RLS.

### É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 :

```bash
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` :

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

- `using` filtre les lignes existantes ; `with check` contrôle les lignes créées ou modifiées. Pour `update`, il faut les deux, sinon un utilisateur pourrait réattribuer sa note à quelqu'un d'autre.
- Entourer `auth.uid()` d'un `(select ...)` permet à Postgres de calculer la valeur une fois par requête au lieu d'une fois par ligne.
- La règle `update` a besoin d'une règle `select` correspondante pour fonctionner.

> **Données publiques** — Pour des données vraiment publiques (catalogue produits, articles publiés), une règle `for select to anon using (true)` est légitime. Elle ne doit jamais concerner une table qui contient des données personnelles.

## 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](https://cursor.com/) ou Claude Code :

```text
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](https://vibe-code.blog/blog/securite-vibe-coding).

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

- **Edge Function ou route API** : le code serveur utilise la clé secrète, stockée en variable d'environnement, et vérifie lui-même que l'appelant est admin. Le navigateur n'appelle que cette fonction.
- **Règle admin basée sur `app_metadata`** : si l'admin doit utiliser l'interface normale, écris une règle qui vérifie un rôle stocké dans `app_metadata`.

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](https://vibe-code.blog/blog/cles-api-securite), 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](https://vibe-code.blog/blog/lovable-avis) 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](https://vibe-code.blog/blog/tester-code-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

- [Row Level Security — Supabase Docs](https://supabase.com/docs/guides/database/postgres/row-level-security)
- [Understanding API keys — Supabase Docs](https://supabase.com/docs/guides/api/api-keys)
- [Database Advisors — Supabase Docs](https://supabase.com/docs/guides/database/database-advisors)
- [CVE-2025-48757 — NIST National Vulnerability Database](https://nvd.nist.gov/vuln/detail/CVE-2025-48757)
- [Security — Lovable Documentation](https://docs.lovable.dev/features/security)
- [OWASP Top 10:2025 — OWASP Foundation](https://top10.owasp.org/2025/)

— Thierry Gustin, Formateur en intelligence artificielle (GustinAI) · 21 novembre 2026
