Aller au contenu

Supabase RLS using (true) : ce que la politique autorise

Supabase

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. Que signifie using (true) dans une politique Supabase ?
  2. Qu’est-ce que chaque politique autorisait dans mon test ?
  3. Pourquoi une politique d’insertion ouverte peut-elle sembler sûre ?
  4. Comment trouver ces politiques ?
  5. Comment le corriger ?
  6. Quand using (true) convient-il ?
  7. Mon cas similaire

En bref

using (true) correspond à chaque ligne pour tous les rôles que la politique nomme. Dans mon test local, une politique select avec cette condition a donné à la clé publique les 3 lignes sur 3, et une politique for all a permis à un utilisateur connecté de modifier et de supprimer les commandes d’un autre. La RLS était activée tout du long. Remplacez true par une condition sur l’appelant, et ne voyez pas dans un Advisor au vert une preuve pour les lectures : son lint pour ce cas ignore les politiques select.

Mon audit de sécurité Supabase a une règle appelée « Politiques qui autorisent toutes les lignes ». Elle existe parce que c’est ce qui suit d’ordinaire l’activation de la RLS. L’application se vide, car la RLS sans politique ne renvoie rien, et la politique la plus rapide pour ramener les données est using (true). L’écran refonctionne et la RLS reste affichée comme activée, donc cela a l’air terminé.

Que signifie using (true) dans une politique Supabase ?

Une politique est une condition que Postgres vérifie pour chaque ligne. using décide quelles lignes existantes un rôle peut voir, modifier ou supprimer. with check décide quelles lignes nouvelles ou modifiées il peut écrire. true est une condition que toute ligne satisfait : la politique ne sépare donc plus les lignes de l’un de celles des autres.

Si la politique n’a pas de clause to, elle s’applique à tous les rôles, y compris anon, le rôle derrière la publishable key que n’importe qui peut copier depuis votre page.

Qu’est-ce que chaque politique autorisait dans mon test ?

J’ai créé une table orders sur un stack Supabase local (CLI 2.109.1, Postgres 17.6) avec deux utilisateurs : Alice possède 2 fausses commandes et Bob en possède 1. La RLS était activée dans chaque ligne de ce tableau. J’ai appelé la Data API comme le fait un navigateur.

RLS activée à chaque fois, trois résultats différents. Supabase local, 3 lignes de fausses commandes. Lecture, déconnecté: Publishable key → select using (true) → 3 lignes sur 3; Écriture, connecté comme Bob: Jeton de Bob → for all using (true) → Ligne d'Alice modifiée; Même écriture, politique propriétaire: Jeton de Bob → auth.uid() = user_id → 0 ligne modifiée.
Ma reproduction sur un stack Supabase local, 2 novembre 2026.
Politique sur orders Publishable key, déconnecté Bob, connecté
Aucune politique 0 ligne 0 ligne
for select using (true) 3 lignes sur 3 3 lignes sur 3
for all to authenticated using (true) with check (true) 0 ligne 3 lignes sur 3, 1 ligne d’Alice modifiée, 1 ligne d’Alice supprimée
Politiques propriétaire avec (select auth.uid()) = user_id 0 ligne Sa seule ligne, 0 ligne d’Alice modifiée, 0 ligne d’Alice supprimée

La troisième ligne est celle que l’on rate. Ajouter to authenticated paraît être la version sûre, et le test déconnecté passe. Mais l’inscription est souvent ouverte, donc n’importe qui peut devenir authenticated en une minute.

Pourquoi une politique d’insertion ouverte peut-elle sembler sûre ?

J’ai aussi essayé for insert to anon with check (true) sans politique select, le montage d’un formulaire de contact. Le même insert a donné deux réponses différentes selon un seul en-tête :

En-tête sur le POST Réponse Ligne écrite ?
Prefer: return=minimal 201 Created Oui
Prefer: return=representation 401, code 42501 Non

Avec return=representation, la requête doit aussi relire la nouvelle ligne, et aucune politique select ne le permet. Un test qui utilise cet en-tête signale donc un refus, alors qu’un script qui l’omet écrit la ligne. Testez l’écriture elle-même, puis comptez les lignes de la table.

Comment trouver ces politiques ?

Exécutez ceci dans l’éditeur SQL :

select tablename, policyname, cmd, roles, qual, with_check
from pg_policies
where schemaname = 'public'
  and (qual = 'true' or with_check = 'true');

Elle ne trouve que la forme littérale. Dans mon test, une politique écrite with check (1 = 1) a été stockée sous la forme (1 = 1) et cette requête ne l’a pas retrouvée : lisez donc aussi le reste de pg_policies.

Le Security Advisor de Supabase a un lint pour cela, rls_policy_always_true. Selon la pull request d’un lint voisin, il ne couvre que les commandes d’écriture : une politique de lecture avec using (true) n’y apparaîtra donc pas. La règle de mon audit regarde le même risque du côté de l’écriture. Pour les lectures, vérifiez vous-même les résultats de cette requête.

Comment le corriger ?

Remplacez true par une condition sur l’appelant, une politique par commande. Voici les politiques de la dernière ligne de mon test :

create policy own_read on public.orders
for select to authenticated
using ((select auth.uid()) = user_id);

create policy own_upd on public.orders
for update to authenticated
using ((select auth.uid()) = user_id)
with check ((select auth.uid()) = user_id);

create policy own_del on public.orders
for delete to authenticated
using ((select auth.uid()) = user_id);

Quand using (true) convient-il ?

Pour des données réellement publiques, comme une liste d’articles publiés ou une grille de prix. Écrivez-la alors de la façon la plus étroite possible : for select to anon using (true), aucun droit d’écriture, et aucune colonne dans cette table que vous ne mettriez pas sur la page d’accueil. Un formulaire de contact peut garder with check (true) sur l’insertion sans politique select, et l’Advisor continuera de le signaler. Notez la raison dans la migration.

Pour prouver que les vraies politiques tiennent, exécutez chacune avec deux utilisateurs différents. Les étapes sont dans comment tester Supabase RLS, et d’autres modèles dans Supabase RLS policy : exemples testés via l’API.

Si vous voulez qu’une personne passe en revue toute l’application plutôt qu’un seul réglage, je fais un audit d’application à périmètre fixe avec un verdict conserver, réparer ou réécrire pour chaque partie.

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.

Vous ne savez pas si vos politiques restreignent vraiment quelque chose ? Écrivez-moi et nous les testerons.

Vos politiques restreignent-elles quelque chose ?

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

© 2026 Denys Zaichenko. Article original : https://madsalt.tech/fr/notes/supabase-rls-using-true/