---
title: "Supabase RLS using (true): hvad policyen tillader"
description: "Hvad en Supabase-policy med using (true) lod den offentlige nøgle og en anden bruger gøre i min lokale test, og hvordan du finder og retter den."
url: "https://madsalt.tech/da/notes/supabase-rls-using-true/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/da/about/"
language: "da"
published: 2026-11-12
---

# Supabase RLS using (true): hvad policyen tillader

TL;DR

`using (true)` matcher hver række for hver rolle, som policyen nævner. I min lokale test gav en select-policy med den den offentlige nøgle alle 3 af 3 rækker, og en `for all`-policy lod én indlogget bruger ændre og slette en anden brugers ordrer. RLS var slået til hele tiden. Erstat `true` med en betingelse for den, der kalder, og regn ikke et grønt Advisor-resultat for bevis ved læsning: dens lint for dette springer select-policies over.

Mit [Supabase sikkerhedstjek](https://madsalt.tech/da/tools/supabase-security-check/) har en regel, der hedder "Politikker, der tillader alle rækker". Den findes, fordi det er det, der som regel kommer lige efter, at nogen slår RLS til. Appen bliver tom, fordi [RLS uden policy ikke returnerer noget](https://madsalt.tech/da/notes/supabase-rls-disabled-in-public/), og den hurtigste policy, der får dataene tilbage, er `using (true)`. Skærmen virker igen, og RLS vises stadig som slået til, så det ser færdigt ud.

## Hvad betyder using (true) i en Supabase-policy?

En policy er en betingelse, som Postgres tjekker for hver række. `using` afgør, hvilke eksisterende rækker en rolle kan se, opdatere eller slette. `with check` afgør, hvilke nye eller ændrede rækker den må skrive. `true` er en betingelse, som hver række består, så policyen holder op med at skille nogens rækker fra alle andres.

Hvis policyen ikke har en `to`-klausul, gælder den for alle roller, og det inkluderer `anon`, rollen bag den publishable key, som enhver kan kopiere fra din side.

## Hvad tillod hver policy i min test?

Jeg lavede en tabel `orders` på en lokal Supabase (CLI 2.109.1, Postgres 17.6) med to brugere: Alice ejer 2 falske ordrer, og Bob ejer 1. RLS var slået til i hver række i denne tabel. Jeg kaldte Data API'et, som en browser gør det.

![RLS slået til hver gang, tre forskellige resultater. Lokal Supabase, 3 rækker falske ordrer. Læsning, logget ud: Publishable key → select using (true) → 3 af 3 rækker; Skrivning, logget ind som Bob: Bobs token → for all using (true) → Alices række ændret; Samme skrivning, ejer-policy: Bobs token → auth.uid() = user_id → 0 rækker ændret.](https://madsalt.tech/charts/da/supabase-rls-using-true.svg)

*Min genskabelse på en lokal Supabase, 2. november 2026.*

| Policy på `orders`                                        | Publishable key, logget ud | Bob, logget ind                                          |
| --------------------------------------------------------- | -------------------------- | -------------------------------------------------------- |
| Ingen policy                                              | 0 rækker                   | 0 rækker                                                 |
| `for select using (true)`                                 | 3 af 3 rækker              | 3 af 3 rækker                                            |
| `for all to authenticated using (true) with check (true)` | 0 rækker                   | 3 af 3 rækker, ændrede 1 af Alices, slettede 1 af Alices |
| Ejer-policies med `(select auth.uid()) = user_id`         | 0 rækker                   | Hans 1 række, ændrede 0 af Alices, slettede 0 af Alices  |

Den tredje række er den, folk overser. At tilføje `to authenticated` føles som den sikre version, og testen uden login består. Men tilmelding er som regel åben, så enhver kan blive `authenticated` på et minut.

## Hvorfor kan en åben insert-policy se sikker ud?

Jeg prøvede også `for insert to anon with check (true)` uden select-policy, altså opsætningen til en kontaktformular. Den samme insert gav to forskellige svar afhængigt af én header:

| Header på `POST`                | Svar                | Række skrevet? |
| ------------------------------- | ------------------- | -------------- |
| `Prefer: return=minimal`        | `201 Created`       | Ja             |
| `Prefer: return=representation` | `401`, code `42501` | Nej            |

Med `return=representation` skal forespørgslen også læse den nye række tilbage, og ingen select-policy tillader det. Så en test, der bruger den header, melder en afvisning, og et script, der udelader headeren, skriver rækken. Test selve skrivningen, og tæl derefter rækkerne i tabellen.

## Hvordan finder du disse policies?

Kør dette i SQL-editoren:

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

Den finder kun den bogstavelige form. I min test blev en policy skrevet som `with check (1 = 1)` gemt som `(1 = 1)`, og denne forespørgsel ramte den ikke, så læs også resten af `pg_policies`.

Supabases Security Advisor har en lint til dette, `rls_policy_always_true`. Ifølge [pull requesten til en beslægtet lint](https://github.com/supabase/splinter/pull/169) dækker den kun skrivekommandoer, så en læse-policy med `using (true)` dukker ikke op der. Reglen i mit tjek ser på den samme risiko fra skrivesiden. Ved læsning skal du selv tjekke resultaterne af den forespørgsel.

## Hvordan retter du det?

Erstat `true` med en betingelse for den, der kalder, én policy pr. kommando. Det er policies fra den sidste række i min 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);
```

## Hvornår er using (true) i orden?

For data, der virkelig er offentlige, som en liste over udgivne artikler eller en pristabel. Skriv den så snævert, du kan: `for select to anon using (true)`, ingen skriverettigheder og ingen kolonne i den tabel, du ikke ville sætte på forsiden. En kontaktformular kan beholde `with check (true)` på insert uden select-policy, og Advisor vil fortsat nævne den. Skriv årsagen i migreringen.

For at bevise, at de rigtige policies holder, så kør hver af dem som to forskellige brugere. Trinnene står i [sådan tester du Supabase RLS](https://madsalt.tech/da/blog/how-to-test-supabase-rls/), og flere mønstre står i [Supabase RLS policy-eksempler](https://madsalt.tech/da/blog/supabase-rls-policy-examples/).

Hvis en person skal gennemgå hele appen frem for én indstilling, laver jeg en [gennemgang af appen med fast omfang](https://madsalt.tech/da/services/vibe-coded-app-audit/) med dommen behold, reparér eller skriv om for hver del.

## Min lignende sag

Jeg kørte migreringerne fra 1.170 offentlige Supabase-projekter på nye databaser: af de 568, der kørte rent igennem, havde 134 (23,6 %) en tabel med RLS slået fra, som den offentlige nøgle kunne læse og ændre. Metoden og forespørgslerne står i [undersøgelsen af open source-projekter på Supabase](https://madsalt.tech/da/blog/open-source-supabase-projects-security-study/).

Usikker på, om dine policies faktisk begrænser noget? Skriv til mig, så tester vi dem.

Begrænser dine policies noget?

Fortæl mig, hvad du har nu, og hvad du har brug for. Jeg svarer med den løsning, jeg selv ville vælge.

[Skriv til mig](https://madsalt.tech/da/#contact)
