---
title: "Segurança Supabase vs Firebase: os mesmos ataques nos dois"
description: "Os mesmos ataques de acesso num Supabase local e nos emuladores do Firebase. Ambos começam fechados; muda a forma como falha uma regra errada."
url: "https://madsalt.tech/pt/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-06
---

# Segurança Supabase vs Firebase: os mesmos ataques nos dois

TL;DR

Ambos começam fechados: uma tabela nova do Supabase respondeu `401` a um visitante até eu lhe dar permissões, e uma base de dados nova do Firebase com regras deny-all respondeu `403`. A diferença está na forma como um erro falha. Quando o utilizador A atualizou ou apagou dados do utilizador B sob uma policy só do dono, o Supabase respondeu `200` com zero linhas e sem erro; o Firebase recusou com `403`. Em contrapartida, o Firebase deixou A passar uma encomenda a B com `200` quando a regra de update só verificava o dono antigo, enquanto o Supabase recusou o mesmo movimento com `403`. Abertos (um grant a `anon` com RLS desligado, ou `if true`), ambos deram a um visitante as três linhas e deixaram-no apagar uma. A chave pública sozinha não abre nada em nenhum; decidem as regras.

Sou o Denys, Forward Deployed Engineer. A maioria das apps que corrijo corre em Supabase ou Firebase, e quem escolhe entre os dois pergunta qual é mais seguro. Comparações de funcionalidades e preços não respondem a isso, por isso enviei aos dois os mesmos pedidos.

**Como testei.** Supabase com uma stack local (CLI 2.109.1, Postgres 17.6) e Firebase com o Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore e Storage), ambos a 6 de novembro de 2026. Chamadas REST simples como visitante e como dois utilizadores autenticados A e B, com dados inventados: as encomendas `a1` e `a2` são de A, `b1` é de B. Nada tocou num projeto real.

## Como protegem os dados o Supabase e o Firebase?

O Supabase guarda os dados em Postgres. Um grant decide se os papéis da API chegam sequer a tocar numa tabela, e as policies de row level security (RLS), escritas em SQL, decidem que linhas cada pedido vê e escreve. O Firebase guarda os dados no Firestore e no Cloud Storage, e as regras de segurança, uma linguagem à parte, decidem por caminho e por pedido se uma leitura ou escrita é permitida.

Portanto ambos têm controlo de acesso, e a pergunta é o que cada um te deixa errar. As regras do Firebase são tratadas a fundo em [exemplos de regras de segurança do Firebase](https://madsalt.tech/pt/blog/firebase-security-rules-examples/), as do Supabase em [exemplos de policies RLS do Supabase](https://madsalt.tech/pt/blog/supabase-rls-policy-examples/).

## O que faz cada um com um projeto novo?

| Pedido                          | Supabase, tabela nova, nada concedido | Firebase, regras deny-all |
| ------------------------------- | ------------------------------------- | ------------------------- |
| O visitante lista os dados      | `401`, permission denied (42501)      | `403`                     |
| Um utilizador autenticado lista | `403`, permission denied (42501)      | `403`                     |
| Coleção sem regra para ela      | não se aplica                         | `403`                     |

Uma configuração acabada de criar está fechada nos dois. No Supabase isso é recente: as tabelas criadas depois de 30 de outubro de 2026 já não recebem grants da Data API automaticamente, e a minha CLI já se comportava assim, por isso o primeiro pedido falhou pelo grant em falta, não por uma policy. Contei a mudança em [a mudança de grants de 30 de outubro](https://madsalt.tech/pt/blog/supabase-october-30-grant-change/). Uma base de dados Firebase criada em modo de produção começa com regras deny-all.

## O que acontece quando fica aberto?

| Pedido de um visitante | Supabase, grant a `anon`, RLS desligado | Firebase, `allow read, write: if true` |
| ---------------------- | --------------------------------------- | -------------------------------------- |
| Listar os dados        | `200`, as 3 linhas                      | `200`, os 3 documentos                 |
| Adicionar um registo   | `201`                                   | `200`                                  |
| Apagar um registo      | `200`, linha apagada                    | `200`, documento apagado               |

Os estados abertos não são a mesma coisa. No Supabase é preciso um grant deliberado a `anon` e o RLS desligado, o padrão que alguns tutoriais e ferramentas de IA escrevem para um erro desaparecer. No Firebase é o modo de teste, de onde partem muitos tutoriais. O resultado é idêntico: qualquer pessoa com os identificadores públicos da app pode ler e apagar os dados. Ligar o RLS sem policy voltou a fechar a tabela do Supabase (`200` com 0 linhas para um visitante e para A, e `403` ao inserir).

## O que acontece quando um utilizador toca nos dados de outro?

Aqui comportam-se de forma diferente. Ambos tinham uma regra só do dono: policies do Supabase em `owner_id = auth.uid()`, regras do Firebase em `resource.data.ownerId == request.auth.uid`.

| Pedido de A                     | Supabase                        | Firebase                                  |
| ------------------------------- | ------------------------------- | ----------------------------------------- |
| Lista tudo                      | `200`, só as 2 linhas de A      | `403`, consulta a toda a coleção recusada |
| Lista com filtro pelo seu id    | `200`, 2 linhas de A            | `200`, 2 documentos de A                  |
| Filtra pelo id de B             | `200`, 0 linhas                 | `403`                                     |
| Lê o registo de B               | `200`, 0 linhas                 | `403`                                     |
| Atualiza o registo de B         | `200`, 0 linhas, sem erro       | `403`                                     |
| Apaga o registo de B            | `200`, 0 linhas, sem erro       | `403`                                     |
| Cria um registo pertencente a B | `403`, violação de row security | `403`                                     |

![O mesmo pedido, dois backends. O utilizador A edita dados do utilizador B, pela API REST de cada um. Supabase, policy só do dono: Utilizador A → edita dados de B → 200 \[\] → 0 linhas, sem erro; Firebase, regra só do dono: Utilizador A → edita dados de B → 403 → erro devolvido.](https://madsalt.tech/charts/pt/supabase-vs-firebase-security.svg)

*Figura 1. Os meus testes, 6 de novembro de 2026: stack Supabase local (CLI 2.109.1) e emuladores Firebase (CLI 15.35.0).*

Nenhum divulgou os dados de B. O que muda é a resposta. O Supabase filtra as linhas que uma policy esconde, por isso uma escrita que não encontrou nada é um sucesso com zero linhas, e uma app que lê "sem erro" como "guardado" diz ao utilizador que a edição funcionou. O Firebase verifica o próprio pedido: uma consulta que poderia devolver documentos que a regra nega é recusada por inteiro, e uma escrita no documento de outro é um erro que a app não pode ignorar. O preço é que cada consulta de listagem no Firebase tem de levar o filtro que a regra espera.

## Pode um utilizador oferecer os seus dados ou tornar-se admin?

| Pedido de A                                                      | Supabase                                                                 | Firebase                                                           |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------ |
| Muda o dono do seu registo para B, sem verificar o valor novo    | `403` (uma policy update sem verificação reutiliza o seu próprio filtro) | `200`, e B leu-o depois com `200`                                  |
| O mesmo, com verificação explícita do novo dono                  | `403`                                                                    | `403`                                                              |
| Define o seu próprio `role` como `admin`, edição de si permitida | `200`, o papel agora é `admin`                                           | `200`, e a leitura por A da encomenda de B passou de `403` a `200` |
| O mesmo, depois da correção                                      | `403` com grant de coluna só em `display_name`; nome `200`               | `403` com uma regra que compara o papel                            |

A passagem de dono mostra os valores por omissão diferentes: no Postgres uma policy só com cláusula `using` aplica-a também à linha nova, enquanto uma regra update do Firebase só verifica o que lá escreveres. Escrevi-a como fazem muitos exemplos, verificando o dono antigo, e o Firebase aceitou o novo.

O caso do papel falha igual nos dois, e é o que mais vejo em código gerado: uma regra "os utilizadores podem editar o seu próprio perfil" que inclui a coluna do papel. O Supabase fecha-o com um grant de coluna ou um trigger, o Firebase com uma regra que compara `request.resource.data.role` com o valor guardado.

## O que permite a chave pública sozinha?

Ambos os produtos põem um identificador público em cada cliente. No Supabase, a chave publishable (anon) chegou à listagem do esquema da API com `200`, que nomeava as duas tabelas que eu tinha concedido a `anon`, e os dados devolvidos seguiram os grants e o RLS: 3 linhas com RLS desligado, 0 com RLS ligado. A chave secret devolveu as 3 linhas com RLS ligado, porque `service_role` ignora as policies, e tem de ficar no servidor; os detalhes estão em [anon key vs service role key](https://madsalt.tech/pt/blog/supabase-anon-key-vs-service-role-key/).

No Firebase, a chave de API pública deixou-me criar um utilizador anónimo no emulador Auth (`200` e um ID token). Isso não é uma falha por si, porque as regras continuam a decidir o que esse utilizador vê, mas significa que "autenticado" não é um sinal de confiança quando o registo está aberto. As regras que só verificam `request.auth != null` estão abertas a qualquer pessoa.

## E o armazenamento de ficheiros?

| Pedido                                      | Supabase Storage, bucket privado                     | Firebase Storage                                                               |
| ------------------------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------ |
| Nada configurado, A lê o ficheiro de B      | `400` not_found                                      | `403` (regras deny-all)                                                        |
| Regra só do dono, A lista a pasta de B      | `200`, 0 ficheiros                                   | `403`                                                                          |
| Regra só do dono, A lê o ficheiro de B      | `400` not_found                                      | `403`                                                                          |
| Regra só do dono, A carrega para B          | `400`, violação de row security                      | `403`                                                                          |
| Regra só do dono, A na sua pasta            | lista `200`, 1 ficheiro; leitura `200`; upload `200` | lista `200`, 1 ficheiro; leitura `200`; escrita `200`                          |
| A regra é "qualquer utilizador autenticado" | não testado                                          | A leu o ficheiro de B, listou os 3 ficheiros e sobrescreveu o de B, tudo `200` |

Repete-se o mesmo padrão: o Supabase esconde o que não podes ver, por isso o ficheiro de outro parece não existir, e o Firebase recusa abertamente. A regra "qualquer utilizador autenticado" é a versão de armazenamento do erro do mero login, e deixou um desconhecido sobrescrever o scan do passaporte de alguém. Os detalhes do Firebase, incluindo os download tokens, estão em [regras do Firebase Storage](https://madsalt.tech/pt/blog/firebase-storage-rules/).

## Qual é mais seguro?

Nenhum é seguro ou inseguro por omissão; ambos começaram fechados. Diferem em onde um erro se esconde:

| Pergunta                             | Supabase                                 | Firebase                                           |
| ------------------------------------ | ---------------------------------------- | -------------------------------------------------- |
| Onde vivem as regras de acesso       | Grants e policies em SQL                 | Linguagem de regras por caminho                    |
| Uma escrita negada sobre outro       | `200` com zero linhas em update e delete | `403`                                              |
| Uma lista que inclui dados de outros | Filtrada em silêncio                     | Recusada, salvo se a consulta corresponder à regra |
| Novo dono num update                 | Verificado por omissão                   | Só se escreveres a verificação                     |
| O que abre tudo por engano           | Um grant a `anon` com RLS desligado      | Modo de teste ou `if true`                         |
| Chave de servidor                    | A chave secret ignora todas as policies  | O Admin SDK ignora as regras                       |

As recusas do Firebase são mais ruidosas e os seus erros têm forma de regra: uma verificação em falta sobre o valor novo, um campo de papel que o utilizador pode editar. O silêncio do Supabase nas escritas negadas é aquilo em volta do qual é preciso desenhar, e os seus erros têm forma de policy: RLS desligado, uma policy sempre verdadeira. Se a tua equipa não vai ler nenhum dos dois, nenhum te salva. Se vai, o `403` do Firebase nota-se mais facilmente nos testes, e o SQL do Supabase consegue exprimir regras que dependem dos dados, como o nível de MFA ou a pertença a uma empresa. Escolhas o que escolheres, testa como dois utilizadores; o método que uso está em [como testar o RLS do Supabase](https://madsalt.tech/pt/blog/how-to-test-supabase-rls/). Fiz a mesma comparação com outro backend em [segurança Appwrite vs Supabase](https://madsalt.tech/pt/blog/appwrite-vs-supabase/).

## Como verificar cada um?

A [verificação de segurança do Supabase](https://madsalt.tech/pt/tools/supabase-security-check/) gratuita lê o teu projeto só em leitura e assinala tabelas com RLS desligado, policies sempre verdadeiras, policies de escrita para visitantes e grants que dão mais do que as policies sugerem. O [verificador de regras do Firebase](https://madsalt.tech/pt/tools/firebase-rules-checker/) gratuito lê regras coladas sem tocar no teu projeto e assinala o modo de teste, o acesso só com login e papéis que o utilizador escreve. Nenhum substitui executar os pedidos acima como visitante e como segundo utilizador.

**Limites.** Uma stack Supabase local e uma execução do emulador do Firebase, via REST, com dados inventados. O emulador do Firebase não é produção e não testei o Realtime Database, o Firebase App Check (o Emulator Suite não o inclui), o Supabase Realtime, funções nem preços. As tuas próprias regras e policies decidem o resultado.

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

Está a escolher um backend para uma aplicação com dados privados? Escreva-me e vemos qual serve e como o blindar.

Um backend para dados privados?

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)
