---
title: "Supabase RLS: 1 de 4 apps open source deja una tabla abierta"
description: "Apliqué las migraciones de 568 proyectos Supabase open source y pasé 15 reglas de seguridad. El 24 % deja una tabla que cualquiera lee y modifica."
url: "https://madsalt.tech/es/blog/open-source-supabase-projects-security-study/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/es/about/"
language: "es"
published: 2026-11-08
---

# Supabase RLS: 1 de 4 apps open source deja una tabla abierta

En resumen

Tomé 1.170 repositorios públicos de GitHub que guardan migraciones de Supabase, apliqué cada uno a una base de datos Supabase nueva en un sandbox sin conexión y ejecuté sobre el resultado las mismas 15 reglas de base de datos que mi checker gratuito ejecuta en proyectos en vivo. 568 proyectos se aplicaron sin errores: 15.624 tablas en `public`. **134 de ellos (23,6 %) tienen al menos una tabla con RLS desactivado que la clave pública puede leer y modificar.** El 8,8 % tiene una policy que permite a un visitante sin sesión actualizar o borrar cualquier fila, el 10,9 % le deja insertar lo que quiera y el 12,0 % expone una vista que se salta la RLS. Los proyectos hechos en Lovable dejan menos tablas sin RLS (9,1 %), pero escriben `true` en las policies dos o tres veces más a menudo. En un proyecto creado después del cambio de Supabase del 30 de octubre, las mismas migraciones dejan abierto el 3,6 % en lugar del 22,7 %. Tres consultas SQL al final muestran cómo está su propio proyecto.

La mayoría de los consejos de seguridad de Supabase dicen lo mismo: active RLS, escriba policies, revise el Advisor. Yo quería saber con qué frecuencia se equivocan de verdad los proyectos reales, medido siempre de la misma manera, y no con las pocas apps que la gente publica en Reddit. GitHub público tiene miles de proyectos Supabase con todo su historial de migraciones, así que construí todos los que pude y miré la base de datos que dejan esas migraciones.

## ¿Cómo probé 568 proyectos?

Busqué en GitHub archivos SQL bajo `supabase/migrations` que contuvieran `create table`, divididos por tamaño de archivo para superar el límite de la búsqueda. Salieron 8.914 repositorios, sin forks. De ahí tomé una muestra seudoaleatoria fija, ordenada por un hash del nombre del repositorio, y descargué solo la carpeta de migraciones y el `package.json` de cada uno.

| Paso                                                                                            | Proyectos |
| ----------------------------------------------------------------------------------------------- | --------- |
| Repositorios con migraciones de Supabase (búsqueda de código de GitHub, 7 de noviembre de 2026) | 8.914     |
| Muestra descargada                                                                              | 1.170     |
| Medidos, tras quitar duplicados exactos                                                         | 1.168     |
| Plantillas y repositorios propios de Supabase eliminados                                        | 9         |
| Migraciones que se detienen con un error en una base de datos nueva                             | 567       |
| Sin tablas en `public`                                                                          | 8         |
| Usan el trigger automático de RLS de Supabase (excluidos, ver límites)                          | 16        |
| **Analizados**                                                                                  | **568**   |

Cada proyecto se ejecutó en su propia base de datos nueva dentro de un contenedor Docker sin acceso a la red, construida a partir de un volcado de un stack local de Supabase (CLI 2.109.1, Postgres 17.6, con los esquemas reales `auth` y `storage`). Las migraciones se ejecutaron por orden de nombre de archivo con el rol `postgres`, que en Supabase no es superusuario, el mismo rol que usa `supabase db push`. Nada de ningún repositorio se ejecutó fuera de ese contenedor.

Sobre la base de datos resultante ejecuté las consultas de catálogo y las 15 reglas de base de datos de mi [Supabase security checker](https://madsalt.tech/es/tools/supabase-security-check/), sin cambios. Los ajustes que viven fuera de la base de datos, como la confirmación de correo o la protección contra contraseñas filtradas, no se ven desde las migraciones, así que esas reglas quedan fuera.

Casi la mitad de los proyectos se detiene con un error antes de la última migración. Las causas habituales son datos semilla que apuntan a usuarios que existen solo en el proyecto de su autor, objetos creados a mano en el dashboard y referenciados después, y migraciones que nunca funcionaron en una base de datos limpia. Informo solo de los proyectos que se aplicaron sin errores.

## ¿Qué encontré?

![568 proyectos Supabase open source: peso de cada hallazgo. Porcentaje de proyectos. Migraciones aplicadas a una base de datos nueva, noviembre de 2026. RLS off, abierto a la clave pública: 23,60; Vista que se salta la RLS: 12; Cualquiera puede insertar lo que quiera: 10,90; Columna sensible accesible: 10; Cualquiera edita o borra cualquier fila: 8,80; Storage abierto a visitantes sin sesión: 5,30; Policy que confía en user_metadata: 0,70.](https://madsalt.tech/charts/es/open-source-supabase-projects-security-study.svg)

*Fuente: mi estudio de 1.168 repositorios públicos de GitHub con migraciones de Supabase, 568 aplicados sin errores, 7-8 de noviembre de 2026.*

| Hallazgo                                                                                       | Todos (568) | Hechos en Lovable (66) | Otros (502) |
| ---------------------------------------------------------------------------------------------- | ----------- | ---------------------- | ----------- |
| Al menos una tabla con RLS desactivado que la clave pública puede leer y modificar             | **23,6 %**  | 9,1 %                  | 25,5 %      |
| Una policy permite a visitantes sin sesión actualizar o borrar cualquier fila (`using (true)`) | **8,8 %**   | 15,2 %                 | 8,0 %       |
| Una policy permite a visitantes sin sesión insertar lo que quieran (`with check (true)`)       | 10,9 %      | 28,8 %                 | 8,6 %       |
| Una vista en `public` que se salta la RLS de sus tablas                                        | 12,0 %      | 7,6 %                  | 12,5 %      |
| Una policy de storage abierta a visitantes sin sesión                                          | 5,3 %       | 12,1 %                 | 4,4 %       |
| Una columna con nombre de apariencia sensible accesible por la API                             | 10,0 %      | 16,7 %                 | 9,2 %       |
| Una policy que confía en `user_metadata`                                                       | 0,7 %       | 0 %                    | 0,8 %       |

Entre las 15.624 tablas, el 8,5 % tiene RLS desactivado. Suena poco hasta que se cuenta por proyecto: una de cada cuatro apps tiene al menos una tabla así y, con los grants por defecto que Supabase usó hasta el 30 de octubre de 2026, la clave pública puede leer y escribir cada fila de ella.

### Tablas en las que nadie activó RLS

En cada uno de los cinco proyectos que abrí a mano, ninguna migración ejecutó nunca `alter table … enable row level security` sobre la tabla abierta. Un proyecto tenía 31 tablas y RLS en ninguna. Lo que guardan estas tablas varía: listas de referencia como países, pero también contadores, eventos, ventas y perfiles. La nota [RLS disabled in public](https://madsalt.tech/es/notes/supabase-rls-disabled-in-public/) explica qué significa la advertencia del Advisor y cómo cerrarla sin romper la app.

### Policies que dicen `true`

Una policy con `using (true)` en `update` o `delete` significa que cualquier visitante con su clave pública puede cambiar o borrar cada fila. El 8,8 % de los proyectos tiene al menos una. `with check (true)` en `insert` es más común, 10,9 %, y a veces es deliberado, para una lista de espera o un formulario de contacto. Conté solo el `true` literal: una policy que llama a una función auxiliar como `is_member(team_id)` está protegida dentro de la función, así que no entra en estas cifras. La [nota](https://madsalt.tech/es/notes/supabase-rls-using-true/) sobre `using (true)` muestra cómo distinguir el caso deliberado del accidente.

### Vistas que se saltan la RLS

Una vista en `public` se ejecuta con los permisos de su propietario salvo que se cree con `security_invoker = true`, así que devuelve filas que las policies de la propia tabla ocultarían. El 12,0 % de los proyectos tiene al menos una.

## ¿Son peores los proyectos hechos en Lovable?

No de la manera que esperaba. Conté un proyecto como hecho en Lovable cuando su `package.json` lista `lovable-tagger` o al menos la mitad de sus archivos de migración llevan los nombres `<timestamp>_<uuid>.sql` de Lovable. Esos proyectos dejan menos tablas sin RLS, 9,1 % frente a 25,5 %. Escriben `true` en las policies con mucha más frecuencia: el 15,2 % deja a cualquiera actualizar o borrar filas, el 28,8 % deja a cualquiera insertar y el 12,1 % abre una policy de storage a visitantes sin sesión. Solo 66 proyectos de Lovable se aplicaron sin errores, mientras que 152 se detuvieron con un error, a menudo por datos semilla de los usuarios del propio autor, así que tome la columna de Lovable como una dirección, con un margen de unos ocho puntos en cualquier sentido.

## ¿Lo arregla el cambio del 30 de octubre?

El [breaking change](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically) de Supabase deja de dar grants automáticos a los roles de la API en las tablas nuevas de `public`; probé qué rompe en [este artículo](https://madsalt.tech/es/blog/supabase-october-30-grant-change/). Ejecuté 433 de los proyectos una segunda vez con los nuevos defaults, como empieza un proyecto creado después del cambio. 194 de ellos se aplicaron sin errores las dos veces.

| Los mismos 194 proyectos                                                           | Defaults antiguos | Defaults nuevos |
| ---------------------------------------------------------------------------------- | ----------------- | --------------- |
| Al menos una tabla con RLS desactivado que la clave pública puede leer y modificar | 44 (22,7 %)       | 7 (3,6 %)       |

![Los mismos 194 proyectos antes y después del 30 de octubre. Porcentaje con una tabla con RLS desactivado que la clave pública puede leer y modificar. Privilegios por defecto antiguos: 22,70; Privilegios por defecto nuevos: 3,60.](https://madsalt.tech/charts/es/open-source-supabase-projects-security-study-oct30.svg)

*Fuente: mi estudio, noviembre de 2026: las mismas migraciones con los privilegios por defecto antiguos y nuevos de Supabase.*

Así que sí, para las tablas nuevas cierra la mayor parte de la brecha: una tabla a la que nadie dio grant es inalcanzable, con RLS o sin él. Los siete proyectos que siguen abiertos dan ellos mismos acceso a los roles de la API en sus migraciones, lo que devuelve la exposición antigua tal cual. Y el cambio solo afecta a lo que reciben las tablas nuevas: un proyecto que ya tiene una tabla abierta la sigue teniendo abierta, así que la primera consulta de abajo importa en todo proyecto existente.

## ¿Cómo me aseguré de que las cifras son correctas?

Antes de fiarme de ningún resultado, construí un proyecto de prueba con seis problemas plantados (una tabla con RLS desactivado, policies `using (true)`, una vista sin `security_invoker`, una función security definer que cualquiera puede llamar, una policy que lee `user_metadata`, un bucket público con subidas anónimas) y dos tablas correctamente protegidas. El pipeline tenía que encontrar los seis y ninguna de las dos. Las primeras ejecuciones no lo lograron: las reglas necesitan la lista de esquemas de la API, que un proyecto en vivo proporciona y un sandbox no, y el rol de administrador del sandbox mostraba `uid()` en lugar de `auth.uid()` en las policies, lo que hacía que policies seguras parecieran abiertas. Ambos problemas están corregidos, medí de nuevo todos los proyectos y abrí a mano muestras de cada hallazgo.

## Lo que este estudio no puede ver

- Las migraciones no son la base de datos en vivo. Todo lo que se cambió en el dashboard y nunca se escribió en una migración es invisible aquí, en ambos sentidos.
- Los proyectos que publican sus migraciones en GitHub no son todos los proyectos Supabase. Muchos son proyectos de aprendizaje y proyectos personales.
- Casi la mitad de la muestra no se aplicó sin errores y no está en las cifras. Esos proyectos podrían ser más seguros o menos.
- Los proyectos que activaron el [trigger automático de RLS](https://supabase.com/docs/guides/database/postgres/event-triggers) de Supabase obtienen RLS en las tablas nuevas sin que ninguna migración lo diga. Excluí los 16 que lo mencionan; otros pueden usarlo sin dejar rastro en sus archivos.
- No se publican los nombres de los repositorios. Los datos proceden de información pública y no personal, bajo la cláusula de investigación de las [Acceptable Use Policies de GitHub](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).

## ¿Cómo comprobar su propio proyecto?

Ejecute estas consultas en el SQL Editor. Cada una devolvió exactamente el problema plantado en mi proyecto de prueba y nada más.

Tablas con RLS desactivado, y si la clave pública puede llegar a ellas:

```sql
select c.relname as table_name,
       has_table_privilege('anon', c.oid, 'select') as anon_can_read,
       has_table_privilege('anon', c.oid, 'insert,update,delete') as anon_can_write
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind in ('r', 'p') and not c.relrowsecurity
order by 1;
```

Policies que dejan escribir a visitantes sin sesión sin ninguna condición:

```sql
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public'
  and cmd in ('INSERT', 'UPDATE', 'DELETE', 'ALL')
  and roles && array['anon', 'public']::name[]
  and (qual = 'true' or with_check = 'true')
order by 1, 2;
```

Vistas que se saltan la RLS:

```sql
select c.relname as view_name
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind = 'v'
  and not exists (
    select 1 from unnest(coalesce(c.reloptions, '{}')) as o
    where o ~* '^security_invoker=(true|on|yes|1)$'
  )
order by 1;
```

Un resultado vacío en las tres es un buen comienzo, no un certificado de salud limpio. [Cómo activar RLS](https://madsalt.tech/es/blog/how-to-enable-rls-in-supabase/) cubre la primera consulta, [ejemplos de policies RLS](https://madsalt.tech/es/blog/supabase-rls-policy-examples/) la segunda, y [cómo probar RLS](https://madsalt.tech/es/blog/how-to-test-supabase-rls/) muestra cómo demostrar que un usuario no puede leer las filas de otro. Para el panorama más amplio, vea [¿es seguro Supabase?](https://madsalt.tech/es/blog/is-supabase-secure/) y la [checklist de seguridad de Lovable](https://madsalt.tech/es/blog/lovable-app-security-checklist/).

## Mi caso similar

Al construir un control de horas para una firma de auditoría encontré 4 errores que ninguna pantalla mostraba, entre ellos un cliente confidencial que se filtraba por los totales de los informes y los contadores de etiquetas. Cada regla de acceso vive ahora en la base de datos y se prueba antes de cada despliegue; la historia completa está en el [caso de la firma de auditoría](https://madsalt.tech/es/work/audit-firm-time-tracking/).

¿Quiere saber cómo está su propio proyecto? Escríbame y lo revisaremos de la misma forma.

¿Cómo está su proyecto?

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)

## Fuentes

- Búsqueda de código y datos de repositorios de GitHub, 7 de noviembre de 2026; muestra y pipeline descritos arriba.
- Supabase, [Securing your API: default privileges](https://supabase.com/docs/guides/api/securing-your-api), consultado el 7 de noviembre de 2026.
- Supabase, [Breaking change: tables not exposed to the Data and GraphQL API automatically](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically).
- Supabase, [Event triggers: automatically enable RLS](https://supabase.com/docs/guides/database/postgres/event-triggers).
- GitHub, [Acceptable Use Policies, section 7](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).
