---
title: "Supabase RLS using (true): o que a política permite"
description: "O que uma política do Supabase com using (true) ou with check (true) deixou fazer à chave pública e a outro utilizador no meu teste local, e como a corrigir."
url: "https://madsalt.tech/pt/notes/supabase-rls-using-true/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-12
---

# Supabase RLS using (true): o que a política permite

Em resumo

`using (true)` corresponde a todas as linhas de todas as funções que a política nomeia. No meu teste local, uma política de select com isso deu à chave pública as 3 linhas de 3, e uma política `for all` deixou um utilizador com sessão iniciada alterar e apagar as encomendas de outro. O RLS esteve ligado o tempo todo. Troque `true` por uma condição sobre quem faz o pedido e não trate um Advisor verde como prova para leituras: o lint dele ignora as políticas de select.

O meu [verificador de segurança do Supabase](https://madsalt.tech/pt/tools/supabase-security-check/) tem uma regra chamada "Políticas que permitem todas as linhas". Existe porque é isto que costuma vir logo depois de alguém ligar o RLS. A app fica vazia, porque [o RLS sem política não devolve nada](https://madsalt.tech/pt/notes/supabase-rls-disabled-in-public/), e a política mais rápida que traz os dados de volta é `using (true)`. O ecrã volta a funcionar e o RLS continua a aparecer como ligado, por isso parece estar terminado.

## O que significa using (true) numa política do Supabase?

Uma política é uma condição que o Postgres verifica para cada linha. `using` decide que linhas existentes uma função pode ver, atualizar ou apagar. `with check` decide que linhas novas ou alteradas pode escrever. `true` é uma condição que todas as linhas cumprem, por isso a política deixa de separar as linhas de uns das de outros.

Se a política não tem cláusula `to`, aplica-se a todas as funções, incluindo `anon`, a função por trás da publishable key que qualquer pessoa pode copiar da sua página.

## O que permitiu cada política no meu teste?

Criei uma tabela `orders` numa stack local do Supabase (CLI 2.109.1, Postgres 17.6) com dois utilizadores: a Alice é dona de 2 encomendas falsas e o Bob de 1. O RLS estava ligado em todas as linhas desta tabela. Chamei a Data API como o faz um browser.

![RLS sempre ligado, três resultados diferentes. Supabase local, 3 linhas de encomendas falsas. Leitura, sem sessão: Publishable key → select using (true) → 3 de 3 linhas; Escrita, com sessão do Bob: Token do Bob → for all using (true) → Linha da Alice alterada; Mesma escrita, política de dono: Token do Bob → auth.uid() = user_id → 0 linhas alteradas.](https://madsalt.tech/charts/pt/supabase-rls-using-true.svg)

*A minha reprodução numa stack local do Supabase, 2 de novembro de 2026.*

| Política em `orders`                                      | Publishable key, sem sessão | Bob, com sessão                                      |
| --------------------------------------------------------- | --------------------------- | ---------------------------------------------------- |
| Sem política                                              | 0 linhas                    | 0 linhas                                             |
| `for select using (true)`                                 | 3 de 3 linhas               | 3 de 3 linhas                                        |
| `for all to authenticated using (true) with check (true)` | 0 linhas                    | 3 de 3 linhas, alterou 1 da Alice, apagou 1 da Alice |
| Políticas de dono com `(select auth.uid()) = user_id`     | 0 linhas                    | A sua 1 linha, alterou 0 da Alice, apagou 0 da Alice |

A terceira linha é a que as pessoas não veem. Juntar `to authenticated` parece a versão segura, e o teste sem sessão passa. Mas o registo costuma estar aberto, por isso qualquer pessoa pode passar a `authenticated` em um minuto.

## Porque pode uma política de insert aberta parecer segura?

Experimentei também `for insert to anon with check (true)` sem política de select, a configuração de um formulário de contacto. O mesmo insert deu duas respostas diferentes consoante um header:

| Header no `POST`                | Resposta            | Linha escrita? |
| ------------------------------- | ------------------- | -------------- |
| `Prefer: return=minimal`        | `201 Created`       | Sim            |
| `Prefer: return=representation` | `401`, code `42501` | Não            |

Com `return=representation`, o pedido também tem de voltar a ler a linha nova, e nenhuma política de select o permite. Assim, um teste que use esse header relata uma recusa, e um script que o omita escreve a linha. Teste a escrita em si e depois conte as linhas da tabela.

## Como se encontram estas políticas?

Execute isto no SQL editor:

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

Só encontra a forma literal. No meu teste, uma política escrita `with check (1 = 1)` ficou guardada como `(1 = 1)` e esta consulta não a apanhou, por isso leia também o resto de `pg_policies`.

O Security Advisor do Supabase tem um lint para isto, `rls_policy_always_true`. Segundo o [pull request de um lint relacionado](https://github.com/supabase/splinter/pull/169), cobre só comandos de escrita, pelo que uma política de leitura com `using (true)` não aparece lá. A regra do meu verificador olha para o mesmo risco do lado da escrita. Nas leituras, confira você mesmo os resultados dessa consulta.

## Como se corrige?

Troque `true` por uma condição sobre quem faz o pedido, uma política por comando. Estas são as políticas da última linha do meu teste:

```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);
```

## Quando é que using (true) está bem?

Para dados que são mesmo públicos, como uma lista de artigos publicados ou uma tabela de preços. Então escreva-o da forma mais estreita possível: `for select to anon using (true)`, sem grants de escrita e sem nenhuma coluna nessa tabela que não poria na página inicial. Um formulário de contacto pode manter `with check (true)` no insert sem política de select, e o Advisor continuará a listá-lo. Anote o motivo na migração.

Para provar que as políticas reais se mantêm, execute cada uma com dois utilizadores diferentes. Os passos estão em [como testar o Supabase RLS](https://madsalt.tech/pt/blog/how-to-test-supabase-rls/), e há mais padrões em [Exemplos de RLS policy no Supabase](https://madsalt.tech/pt/blog/supabase-rls-policy-examples/).

Se preferir que uma pessoa percorra a aplicação inteira e não só uma definição, faço uma [auditoria de âmbito fixo](https://madsalt.tech/pt/services/vibe-coded-app-audit/) com um veredicto de manter, reparar ou reescrever para cada parte.

## O meu caso semelhante

Apliquei as migrações de 1.170 projetos públicos do Supabase a bases de dados novas: dos 568 que correram sem erros, 134 (23,6 %) tinham uma tabela com RLS desligado que a chave pública conseguia ler e alterar. O método e as consultas estão no [estudo de código aberto sobre o Supabase](https://madsalt.tech/pt/blog/open-source-supabase-projects-security-study/).

Não tem a certeza de que as suas políticas restringem mesmo alguma coisa? Escreva-me e testamo-las.

As suas políticas restringem alguma coisa?

Diga-me o que tem agora e o que precisa. Respondo com a opção que eu escolheria.

[Fale comigo](https://madsalt.tech/pt/#contact)
