---
title: "Supabase RLS using (true): qué permite la política"
description: "Qué hicieron la clave pública y otro usuario con una política de Supabase con using (true) o with check (true) en mi prueba local, y cómo corregirla."
url: "https://madsalt.tech/es/notes/supabase-rls-using-true/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/es/about/"
language: "es"
published: 2026-11-12
---

# Supabase RLS using (true): qué permite la política

En resumen

`using (true)` coincide con todas las filas de todos los roles que nombra la política. En mi prueba local, una política select con esa condición dio a la clave pública las 3 filas de 3, y una política `for all` dejó que un usuario con sesión iniciada modificara y borrara los pedidos de otro. RLS estuvo activado todo el tiempo. Sustituya `true` por una condición sobre quien llama, y no tome un Advisor en verde como prueba para las lecturas: su lint para esto se salta las políticas select.

Mi [verificador de seguridad de Supabase](https://madsalt.tech/es/tools/supabase-security-check/) tiene una regla llamada "Políticas que permiten todas las filas". Existe porque esto es lo que suele venir justo después de activar RLS. La app se queda vacía, porque [RLS sin política no devuelve nada](https://madsalt.tech/es/notes/supabase-rls-disabled-in-public/), y la política más rápida que devuelve los datos es `using (true)`. La pantalla vuelve a funcionar y RLS sigue figurando como activado, así que parece terminado.

## ¿Qué significa using (true) en una política de Supabase?

Una política es una condición que Postgres comprueba fila por fila. `using` decide qué filas existentes puede ver, actualizar o borrar un rol. `with check` decide qué filas nuevas o modificadas puede escribir. `true` es una condición que toda fila cumple, así que la política deja de separar las filas de unos de las de otros.

Si la política no tiene cláusula `to`, se aplica a todos los roles, y eso incluye `anon`, el rol que hay detrás de la publishable key que cualquiera puede copiar de su página.

## ¿Qué permitió cada política en mi prueba?

Creé una tabla `orders` en un stack local de Supabase (CLI 2.109.1, Postgres 17.6) con dos usuarios: Alice tiene 2 pedidos falsos y Bob tiene 1. RLS estaba activado en todas las filas de esta tabla. Llamé a la Data API como lo hace un navegador.

![RLS siempre activado, tres resultados distintos. Supabase local, 3 filas de pedidos falsos. Lectura, sin sesión: Publishable key → select using (true) → 3 de 3 filas; Escritura, con sesión como Bob: Token de Bob → for all using (true) → Fila de Alice modificada; Misma escritura, política de dueño: Token de Bob → auth.uid() = user_id → 0 filas modificadas.](https://madsalt.tech/charts/es/supabase-rls-using-true.svg)

*Mi reproducción en un stack local de Supabase, 2 de noviembre de 2026.*

| Política en `orders`                                      | Publishable key, sin sesión | Bob, con sesión                                   |
| --------------------------------------------------------- | --------------------------- | ------------------------------------------------- |
| Sin política                                              | 0 filas                     | 0 filas                                           |
| `for select using (true)`                                 | 3 de 3 filas                | 3 de 3 filas                                      |
| `for all to authenticated using (true) with check (true)` | 0 filas                     | 3 de 3 filas, cambió 1 de Alice, borró 1 de Alice |
| Políticas de dueño con `(select auth.uid()) = user_id`    | 0 filas                     | Su 1 fila, cambió 0 de Alice, borró 0 de Alice    |

La tercera fila es la que la gente pasa por alto. Añadir `to authenticated` parece la versión segura, y la prueba sin sesión la pasa. Pero el registro suele estar abierto, así que cualquiera puede ser `authenticated` en un minuto.

## ¿Por qué una política de inserción abierta puede parecer segura?

También probé `for insert to anon with check (true)` sin política select, la configuración de un formulario de contacto. El mismo insert dio dos respuestas distintas según una cabecera:

| Cabecera en el `POST`           | Respuesta             | ¿Fila escrita? |
| ------------------------------- | --------------------- | -------------- |
| `Prefer: return=minimal`        | `201 Created`         | Sí             |
| `Prefer: return=representation` | `401`, código `42501` | No             |

Con `return=representation` la petición también tiene que volver a leer la fila nueva, y ninguna política select lo permite. Por eso una prueba que usa esa cabecera informa de un rechazo, y un script que omite la cabecera escribe la fila. Pruebe la escritura en sí y después cuente las filas de la tabla.

## ¿Cómo se encuentran estas políticas?

Ejecute esto en el editor SQL:

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

Solo encuentra la forma literal. En mi prueba, una política escrita como `with check (1 = 1)` se guardó como `(1 = 1)` y esta consulta no la detectó, así que lea también el resto de `pg_policies`.

El Security Advisor de Supabase tiene un lint para esto, `rls_policy_always_true`. Según el [pull request de un lint relacionado](https://github.com/supabase/splinter/pull/169), cubre solo los comandos de escritura, así que una política de lectura con `using (true)` no aparecerá ahí. La regla de mi verificador mira el mismo riesgo desde el lado de la escritura. Para las lecturas, revise usted mismo los resultados de esa consulta.

## ¿Cómo se corrige?

Sustituya `true` por una condición sobre quien llama, una política por comando. Estas son las políticas de la última fila de mi prueba:

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

## ¿Cuándo está bien using (true)?

Para datos que de verdad son públicos, como una lista de artículos publicados o una tabla de precios. Entonces escríbala de la forma más estrecha posible: `for select to anon using (true)`, sin grants de escritura y sin ninguna columna en esa tabla que no pondría en la página de inicio. Un formulario de contacto puede mantener `with check (true)` en el insert sin política select, y el Advisor seguirá listándolo. Anote el motivo en la migración.

Para demostrar que las políticas reales se sostienen, ejecute cada una con dos usuarios distintos. Los pasos están en [cómo probar Supabase RLS](https://madsalt.tech/es/blog/how-to-test-supabase-rls/), y hay más patrones en [Políticas RLS de Supabase: ejemplos probados con la API](https://madsalt.tech/es/blog/supabase-rls-policy-examples/).

Si prefiere que una persona revise la aplicación entera y no solo un ajuste, hago una [auditoría de alcance fijo](https://madsalt.tech/es/services/vibe-coded-app-audit/) con un veredicto de conservar, reparar o reescribir para cada parte.

## Mi caso similar

Apliqué las migraciones de 1.170 proyectos públicos de Supabase a bases de datos nuevas: de los 568 que se ejecutaron sin errores, 134 (23,6 %) tenían una tabla con RLS desactivado que la clave pública podía leer y modificar. El método y las consultas están en [el estudio de código abierto sobre Supabase](https://madsalt.tech/es/blog/open-source-supabase-projects-security-study/).

¿No está seguro de que sus políticas restrinjan algo de verdad? Escríbame y las probaremos.

¿Restringen algo sus políticas?

Cuénteme lo que tiene ahora y lo que necesita. Le responderé con la opción que yo elegiría.

[Escríbame](https://madsalt.tech/es/#contact)
