---
title: "Supabase vs Firebase: los mismos ataques en ambos"
description: "Los mismos ataques de acceso contra un Supabase local y los emuladores de Firebase. Ambos arrancan cerrados; difieren en cómo falla una regla mal escrita."
url: "https://madsalt.tech/es/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/es/about/"
language: "es"
published: 2026-11-06
---

# Supabase vs Firebase: los mismos ataques en ambos

TL;DR

Ambos arrancan cerrados: una tabla nueva de Supabase respondió `401` a un invitado hasta que le di permisos, y una base de datos nueva de Firebase con reglas deny-all respondió `403`. La diferencia está en cómo falla un error. Cuando el usuario A actualizó o borró datos del usuario B bajo una política solo para el dueño, Supabase respondió `200` con cero filas y sin error; Firebase rechazó con `403`. En cambio, Firebase dejó que A pasara un pedido a B con `200` cuando la regla de update solo comprobaba al dueño anterior, mientras Supabase rechazó ese mismo movimiento con `403`. Abiertos (un grant a `anon` con RLS desactivado, o `if true`), ambos dieron a un invitado las tres filas y le dejaron borrar una. La clave pública por sí sola no abre nada en ninguno; deciden las reglas.

Soy Denys, Forward Deployed Engineer. La mayoría de las apps que arreglo funcionan sobre Supabase o Firebase, y quien elige entre ambos pregunta cuál es más seguro. Las comparaciones de funciones y precios no lo responden, así que envié a los dos las mismas peticiones.

**Cómo probé.** Supabase con un stack local (CLI 2.109.1, Postgres 17.6) y Firebase con el Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore y Storage), ambos el 6 de noviembre de 2026. Llamadas REST simples como invitado y como dos usuarios con sesión A y B, con datos inventados: los pedidos `a1` y `a2` son de A, `b1` es de B. Nada tocó un proyecto real.

## ¿Cómo protegen los datos Supabase y Firebase?

Supabase guarda los datos en Postgres. Un grant decide si los roles de la API pueden tocar una tabla, y las políticas de row level security (RLS), escritas en SQL, deciden qué filas ve y escribe cada petición. Firebase guarda los datos en Firestore y Cloud Storage, y las reglas de seguridad, un lenguaje aparte, deciden por ruta y por petición si una lectura o escritura está permitida.

Así que ambos tienen control de acceso, y la pregunta es qué te deja equivocarte cada uno. Las reglas de Firebase se tratan a fondo en [ejemplos de reglas de seguridad de Firebase](https://madsalt.tech/es/blog/firebase-security-rules-examples/); las de Supabase, en [ejemplos de políticas RLS de Supabase](https://madsalt.tech/es/blog/supabase-rls-policy-examples/).

## ¿Qué hace cada uno con un proyecto nuevo?

| Petición                              | Supabase, tabla nueva, sin permisos | Firebase, reglas deny-all |
| ------------------------------------- | ----------------------------------- | ------------------------- |
| El invitado lista los datos           | `401`, permission denied (42501)    | `403`                     |
| Un usuario con sesión lista los datos | `403`, permission denied (42501)    | `403`                     |
| Colección sin regla para ella         | no aplica                           | `403`                     |

Una configuración recién creada está cerrada en ambos. En Supabase eso es reciente: las tablas creadas después del 30 de octubre de 2026 ya no reciben grants de la Data API automáticamente, y mi CLI ya se comportaba así, de modo que la primera petición falló por el grant que faltaba, no por una política. Lo conté en [el cambio de grants del 30 de octubre](https://madsalt.tech/es/blog/supabase-october-30-grant-change/). Una base de datos de Firebase creada en modo producción arranca con reglas deny-all.

## ¿Qué pasa cuando se deja abierto?

| Petición de un invitado | Supabase, grant a `anon`, RLS desactivado | Firebase, `allow read, write: if true` |
| ----------------------- | ----------------------------------------- | -------------------------------------- |
| Listar los datos        | `200`, las 3 filas                        | `200`, los 3 documentos                |
| Añadir un registro      | `201`                                     | `200`                                  |
| Borrar un registro      | `200`, fila borrada                       | `200`, documento borrado               |

Los estados abiertos no son lo mismo. En Supabase hace falta un grant deliberado a `anon` y RLS desactivado, el patrón que escriben algunos tutoriales y herramientas de IA para que desaparezca un error. En Firebase es el modo de prueba, del que parten muchos tutoriales. El resultado es idéntico: cualquiera con los identificadores públicos de la app puede leer y borrar los datos. Activar RLS sin política volvió a cerrar la tabla de Supabase (`200` con 0 filas para un invitado y para A, y `403` al insertar).

## ¿Qué pasa cuando un usuario toca datos de otro?

Aquí se comportan distinto. Ambos tenían una regla solo para el dueño: políticas de Supabase sobre `owner_id = auth.uid()`, reglas de Firebase sobre `resource.data.ownerId == request.auth.uid`.

| Petición de A                     | Supabase                         | Firebase                                       |
| --------------------------------- | -------------------------------- | ---------------------------------------------- |
| Lista todo                        | `200`, solo las 2 filas de A     | `403`, consulta de toda la colección rechazada |
| Lista con filtro por su propio id | `200`, 2 filas de A              | `200`, 2 documentos de A                       |
| Filtra por el id de B             | `200`, 0 filas                   | `403`                                          |
| Lee el registro de B              | `200`, 0 filas                   | `403`                                          |
| Actualiza el registro de B        | `200`, 0 filas, sin error        | `403`                                          |
| Borra el registro de B            | `200`, 0 filas, sin error        | `403`                                          |
| Crea un registro cuyo dueño es B  | `403`, violación de row security | `403`                                          |

![La misma petición, dos backends. El usuario A edita datos del usuario B, por la API REST de cada uno. Supabase, política solo dueño: Usuario A → editar los datos de B → 200 \[\] → 0 filas, sin error; Firebase, regla solo dueño: Usuario A → editar los datos de B → 403 → error devuelto.](https://madsalt.tech/charts/es/supabase-vs-firebase-security.svg)

*Figura 1. Mis pruebas, 6 de noviembre de 2026: stack local de Supabase (CLI 2.109.1) y emuladores de Firebase (CLI 15.35.0).*

Ninguno filtró datos de B. Lo que cambia es la respuesta. Supabase filtra las filas que una política oculta, así que una escritura que no encontró nada es un éxito con cero filas, y una app que lee "sin error" como "guardado" le dice al usuario que su edición funcionó. Firebase comprueba la petición en sí: una consulta que podría devolver documentos que la regla niega se rechaza entera, y una escritura en un documento ajeno es un error que la app no puede pasar por alto. El precio es que cada consulta de listado en Firebase debe llevar el filtro que la regla espera.

## ¿Puede un usuario regalar sus datos o hacerse admin?

| Petición de A                                                    | Supabase                                                                | Firebase                                                              |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------- |
| Cambia el dueño de su registro a B, sin comprobar el valor nuevo | `403` (una política update sin comprobación reutiliza su propio filtro) | `200`, y B lo leyó después con `200`                                  |
| Lo mismo, con comprobación explícita del dueño nuevo             | `403`                                                                   | `403`                                                                 |
| Pone su propio `role` en `admin`, edición propia permitida       | `200`, el rol ahora es `admin`                                          | `200`, y la lectura que A hacía del pedido de B pasó de `403` a `200` |
| Lo mismo, tras la corrección                                     | `403` con un grant de columna solo sobre `display_name`; nombre `200`   | `403` con una regla que compara el rol                                |

El cambio de dueño muestra los valores por defecto distintos: en Postgres una política con solo cláusula `using` la aplica también a la fila nueva, mientras que una regla update de Firebase comprueba solo lo que tú escribas. La escribí como hacen muchos ejemplos, comprobando al dueño anterior, y Firebase aceptó al nuevo.

El caso del rol falla igual en ambos, y es el que más veo en código generado: una regla de "los usuarios pueden editar su propio perfil" que incluye la columna del rol. Supabase lo cierra con un grant de columna o un trigger, Firebase con una regla que compara `request.resource.data.role` con el valor guardado.

## ¿Qué permite la clave pública por sí sola?

Ambos productos ponen un identificador público en cada cliente. En Supabase la clave publishable (anon) llegó al listado del esquema de la API con `200`, que nombró las dos tablas que yo había dado a `anon`, y los datos devueltos siguieron los grants y el RLS: 3 filas con RLS desactivado, 0 con RLS activado. La clave secret devolvió las 3 filas con RLS activado, porque `service_role` se salta las políticas, y debe quedarse en el servidor; los detalles están en [anon key vs service role key](https://madsalt.tech/es/blog/supabase-anon-key-vs-service-role-key/).

En Firebase la clave de API pública me dejó crear un usuario anónimo en el emulador de Auth (`200` y un ID token). Eso no es un agujero por sí mismo, porque las reglas siguen decidiendo qué ve ese usuario, pero significa que "con sesión" no es una señal de confianza cuando el registro está abierto. Las reglas que solo comprueban `request.auth != null` están abiertas a cualquiera.

## ¿Y el almacenamiento de archivos?

| Petición                                   | Supabase Storage, bucket privado                    | Firebase Storage                                                                |
| ------------------------------------------ | --------------------------------------------------- | ------------------------------------------------------------------------------- |
| Nada configurado, A lee el archivo de B    | `400` not_found                                     | `403` (reglas deny-all)                                                         |
| Regla solo dueño, A lista la carpeta de B  | `200`, 0 archivos                                   | `403`                                                                           |
| Regla solo dueño, A lee el archivo de B    | `400` not_found                                     | `403`                                                                           |
| Regla solo dueño, A sube a la carpeta de B | `400`, violación de row security                    | `403`                                                                           |
| Regla solo dueño, A en su propia carpeta   | lista `200`, 1 archivo; lectura `200`; subida `200` | lista `200`, 1 archivo; lectura `200`; escritura `200`                          |
| La regla es "cualquier usuario con sesión" | no probado                                          | A leyó el archivo de B, listó los 3 archivos y sobrescribió el de B, todo `200` |

Aparece el mismo patrón: Supabase oculta lo que no puedes ver, así que el archivo de otro parece no existir, y Firebase rechaza de plano. La regla "cualquier usuario con sesión" es la versión de almacenamiento del error de solo-login, y dejó que un desconocido sobrescribiera el escaneo de pasaporte de alguien. Los detalles de Firebase, incluidos los download tokens, están en [reglas de Firebase Storage](https://madsalt.tech/es/blog/firebase-storage-rules/).

## ¿Cuál es más seguro?

Ninguno es seguro o inseguro por defecto; ambos arrancaron cerrados. Se diferencian en dónde se esconde un error:

| Pregunta                            | Supabase                                     | Firebase                                          |
| ----------------------------------- | -------------------------------------------- | ------------------------------------------------- |
| Dónde viven las reglas de acceso    | Grants y políticas en SQL                    | Lenguaje de reglas por ruta                       |
| Una escritura ajena denegada        | `200` con cero filas en update y delete      | `403`                                             |
| Un listado que incluye datos ajenos | Filtrado en silencio                         | Rechazado salvo que la consulta case con la regla |
| Dueño nuevo en un update            | Comprobado por defecto                       | Solo si escribes la comprobación                  |
| Qué lo abre todo por error          | Un grant a `anon` con RLS desactivado        | Modo de prueba o `if true`                        |
| Clave de servidor                   | La clave secret se salta todas las políticas | El Admin SDK se salta las reglas                  |

Los rechazos de Firebase son más ruidosos y sus errores tienen forma de regla: una comprobación que falta sobre el valor nuevo, un campo de rol que el usuario puede editar. El silencio de Supabase en las escrituras denegadas es lo que hay que diseñar alrededor, y sus errores tienen forma de política: RLS desactivado, una política siempre verdadera. Si tu equipo no va a leer ninguno de los dos, ninguno te salva. Si lo va a hacer, el `403` de Firebase se nota más fácil al probar, y el SQL de Supabase puede expresar reglas que dependen de los datos, como el nivel de MFA o la pertenencia a una empresa. Elijas lo que elijas, prueba como dos usuarios; el método que uso está en [cómo probar el RLS de Supabase](https://madsalt.tech/es/blog/how-to-test-supabase-rls/). Hice la misma comparación con otro backend en [Appwrite vs Supabase: seguridad](https://madsalt.tech/es/blog/appwrite-vs-supabase/).

## ¿Cómo se comprueba cada uno?

La [comprobación de seguridad de Supabase](https://madsalt.tech/es/tools/supabase-security-check/), gratuita, lee tu proyecto en solo lectura y señala tablas con RLS desactivado, políticas siempre verdaderas, políticas de escritura para invitados y grants que dan más de lo que implican las políticas. El [verificador de reglas de Firebase](https://madsalt.tech/es/tools/firebase-rules-checker/), gratuito, lee reglas pegadas sin tocar tu proyecto y señala el modo de prueba, el acceso solo con sesión y los roles que el usuario escribe. Ninguno sustituye ejecutar las peticiones de arriba como invitado y como segundo usuario.

**Límites.** Un stack local de Supabase y una ejecución del emulador de Firebase, por REST, con datos inventados. El emulador de Firebase no es producción y no probé Realtime Database, Firebase App Check (el Emulator Suite no lo incluye), Supabase Realtime, funciones ni precios. Tus propias reglas y políticas deciden el resultado.

## 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/).

¿Elige un backend para una aplicación con datos privados? Escríbame y veremos cuál encaja y cómo blindarlo.

¿Un backend para datos privados?

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)
