In breve
using (true) corrisponde a ogni riga per ogni ruolo che la policy nomina. Nel mio test locale, una policy select con questa condizione ha dato alla chiave pubblica tutte e 3 le righe su 3, e una policy for all ha permesso a un utente connesso di modificare e cancellare gli ordini di un altro. La RLS era attiva per tutto il tempo. Sostituisca true con una condizione sul chiamante, e non consideri un Advisor verde una prova per le letture: il suo lint per questo caso salta le policy select.
Il mio checker di sicurezza per Supabase ha una regola chiamata “Policy che consentono ogni riga”. Esiste perché è ciò che di solito segue l’attivazione della RLS. L’app si svuota, perché la RLS senza policy non restituisce nulla, e la policy più rapida per riportare i dati è using (true). La schermata funziona di nuovo e la RLS risulta ancora attiva, quindi sembra finito.
Cosa significa using (true) in una policy Supabase?
Una policy è una condizione che Postgres controlla per ogni riga. using decide quali righe esistenti un ruolo può vedere, modificare o eliminare. with check decide quali righe nuove o modificate può scrivere. true è una condizione che ogni riga soddisfa, quindi la policy smette di separare le righe di qualcuno da quelle di tutti gli altri.
Se la policy non ha una clausola to, si applica a ogni ruolo, e questo include anon, il ruolo dietro la publishable key che chiunque può copiare dalla sua pagina.
Cosa consentiva ogni policy nel mio test?
Ho creato una tabella orders su uno stack Supabase locale (CLI 2.109.1, Postgres 17.6) con due utenti: Alice possiede 2 ordini finti e Bob ne possiede 1. La RLS era attiva in ogni riga di questa tabella. Ho chiamato la Data API come fa un browser.
Policy su orders |
Publishable key, non autenticato | Bob, autenticato |
|---|---|---|
| Nessuna policy | 0 righe | 0 righe |
for select using (true) |
3 righe su 3 | 3 righe su 3 |
for all to authenticated using (true) with check (true) |
0 righe | 3 righe su 3, 1 di Alice modificata, 1 di Alice eliminata |
Policy del proprietario con (select auth.uid()) = user_id |
0 righe | La sua unica riga, 0 di Alice modificate, 0 di Alice eliminate |
La terza riga è quella che la gente si perde. Aggiungere to authenticated sembra la versione sicura, e il test da non autenticato passa. Ma la registrazione di solito è aperta, quindi chiunque può diventare authenticated in un minuto.
Perché una policy di insert aperta può sembrare sicura?
Ho provato anche for insert to anon with check (true) senza policy select, la configurazione di un modulo di contatto. Lo stesso insert ha dato due risposte diverse a seconda di un solo header:
Header sul POST |
Risposta | Riga scritta? |
|---|---|---|
Prefer: return=minimal |
201 Created |
Sì |
Prefer: return=representation |
401, codice 42501 |
No |
Con return=representation la richiesta deve anche rileggere la nuova riga, e nessuna policy select lo consente. Quindi un test che usa quell’header segnala un rifiuto, mentre uno script che lo omette scrive la riga. Provi la scrittura stessa, poi conti le righe della tabella.
Come si trovano queste policy?
Esegua questo nell’editor SQL:
select tablename, policyname, cmd, roles, qual, with_check
from pg_policies
where schemaname = 'public'
and (qual = 'true' or with_check = 'true');
Trova solo la forma letterale. Nel mio test, una policy scritta with check (1 = 1) è stata memorizzata come (1 = 1) e questa query non l’ha trovata, quindi legga anche il resto di pg_policies.
Il Security Advisor di Supabase ha un lint per questo, rls_policy_always_true. Secondo la pull request di un lint affine copre solo i comandi di scrittura, quindi una policy di lettura con using (true) non vi comparirà. La regola del mio checker guarda lo stesso rischio dal lato della scrittura. Per le letture, controlli lei stesso i risultati di quella query.
Come si corregge?
Sostituisca true con una condizione sul chiamante, una policy per comando. Queste sono le policy dell’ultima riga del mio 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);
Quando using (true) va bene?
Per dati davvero pubblici, come un elenco di articoli pubblicati o una tabella dei prezzi. Allora la scriva nel modo più stretto possibile: for select to anon using (true), nessun grant di scrittura e nessuna colonna in quella tabella che non metterebbe nella home page. Un modulo di contatto può tenere with check (true) sull’insert senza policy select, e l’Advisor continuerà a segnalarlo. Annoti il motivo nella migrazione.
Per dimostrare che le policy vere reggono, esegua ciascuna come due utenti diversi. I passaggi sono in come testare la Supabase RLS, e altri schemi sono in Esempi di Supabase RLS policy, testati tramite API.
Se preferite che una persona esamini l’intera app e non una sola impostazione, faccio un audit dell’app a perimetro fisso con un verdetto per ogni parte: tenere, riparare o riscrivere.
Il mio caso simile
Ho applicato le migrazioni di 1.170 progetti Supabase pubblici a database nuovi: dei 568 che sono andati a buon fine, 134 (23,6 %) avevano una tabella con RLS disattivato che la chiave pubblica poteva leggere e modificare. Metodo e query sono nello studio open source su Supabase.
Non è sicuro che le sue policy limitino davvero qualcosa? Mi scriva e le testeremo.
Le sue policy limitano qualcosa?
Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.
Mi scriva