---
title: "Supabase RLS using (true) : ce que la politique autorise"
description: "Ce que using (true) ou with check (true) a permis à la clé publique et à un autre utilisateur dans mon test Supabase local, et comment le corriger."
url: "https://madsalt.tech/fr/notes/supabase-rls-using-true/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-12
---

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

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](https://madsalt.tech/fr/tools/supabase-security-check/) 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](https://madsalt.tech/fr/notes/supabase-rls-disabled-in-public/), 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.](https://madsalt.tech/charts/fr/supabase-rls-using-true.svg)

*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 :

```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](https://github.com/supabase/splinter/pull/169), 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 :

```sql
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](https://madsalt.tech/fr/blog/how-to-test-supabase-rls/), et d'autres modèles dans [Supabase RLS policy : exemples testés via l’API](https://madsalt.tech/fr/blog/supabase-rls-policy-examples/).

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](https://madsalt.tech/fr/services/vibe-coded-app-audit/) 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](https://madsalt.tech/fr/blog/open-source-supabase-projects-security-study/).

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](https://madsalt.tech/fr/#contact)
