---
title: "Supabase service role key divulgada: o que fazer, por ordem"
description: "O que uma service role key divulgada do Supabase abriu no meu teste local, e a ordem para a substituir, retirar a antiga e verificar os danos sem uma paragem."
url: "https://madsalt.tech/pt/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-14
---

# Supabase service role key divulgada: o que fazer, por ordem

Em resumo

Uma service role key divulgada ignora o RLS e pode usar a Auth admin API. No meu teste local, leu 3 linhas de 3 com políticas só para o dono, alterou a linha de outro utilizador e listou todos os utilizadores. Corrija a causa da fuga, crie uma nova secret key, passe todos os componentes para ela, retire a chave antiga e depois verifique o que mudou enquanto esteve exposta. Se alguém está a usar a chave neste momento, retire-a primeiro e aceite a indisponibilidade.

O meu [scanner de segredos](https://madsalt.tech/pt/tools/secret-scanner/) gratuito lê o HTML de uma página pública e os ficheiros de script que ela liga, à procura de chaves API, tokens e URLs de bases de dados que um visitante podia copiar, incluindo a chave `service_role` do Supabase; os valores são mostrados mascarados. Esta nota trata do que fazer se a chave vazou.

Quando assumo uma app Supabase, esta chave é a primeira coisa que procuro no JavaScript compilado. A diferença entre as duas chaves está em [anon key vs service role key](https://madsalt.tech/pt/blog/supabase-anon-key-vs-service-role-key/). Esta nota é para o dia mau, quando a chave secreta apareceu num bundle, num repositório público ou num log.

## O que pode alguém fazer com a chave divulgada?

Verifiquei numa stack local do Supabase (CLI 2.109.1, Postgres 17.6), numa tabela com RLS ligado, políticas só para o dono e 3 encomendas falsas, mais uma lista de utilizadores de teste.

![O que a chave divulgada abriu. Supabase local, RLS ligado, políticas só para o dono. Ler a tabela: Secret key → orders, com RLS → 3 de 3 linhas; Listar utilizadores: Secret key → Auth admin API → 200, todos os utilizadores; Mesma chamada, chave pública: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/pt/supabase-service-role-key-leaked.svg)

*O meu teste numa stack local do Supabase, 2 de novembro de 2026.*

| Pedido                     | Publishable key | Chave secret ou `service_role` |
| -------------------------- | --------------- | ------------------------------ |
| Ler `orders`               | 0 linhas        | 3 de 3 linhas                  |
| Atualizar a linha de outro | Não testado     | 1 linha alterada               |
| `GET /auth/v1/admin/users` | `403`           | `200`, todos os utilizadores   |

A chave antiga `service_role` e a nova `sb_secret_` comportaram-se da mesma forma nos três casos.

Dois resultados podem dar uma falsa tranquilidade:

- Uma tabela nova nesta stack deu às funções da API apenas `TRUNCATE`, `REFERENCES` e `TRIGGER`. Por isso a secret key recebeu `403` com o código `42501` até eu executar um `GRANT`. Isso não torna a fuga inofensiva: a chamada da Auth admin respondeu `200` nesse mesmo momento. A mudança por trás disto está em [Supabase 42501 permission denied](https://madsalt.tech/pt/notes/supabase-42501-permission-denied/).
- O [guia de API keys](https://supabase.com/docs/guides/getting-started/api-keys) do Supabase diz que uma secret key usada num browser recebe `401`, e acrescenta que um atacante ainda a pode usar a partir de outras ferramentas. A minha stack local respondeu `200` a um pedido com headers de browser, por isso não consegui reproduzir aqui esse bloqueio.

## Qual é a ordem certa para substituir a chave?

Estes passos seguem o [guia do Supabase para rodar uma chave divulgada](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Não os executei num projeto alojado para esta nota.

1. **Corrija a causa.** Retire a chave do bundle, do repositório ou do log, ou a nova chave fugirá da mesma forma. Apagá-la do último commit do Git não chega, porque o histórico ainda a guarda.
2. **Crie uma nova secret key** em Settings → API Keys.
3. **Substitua a chave antiga em todo o lado**: servidores, cron jobs, Edge Functions, Database Webhooks e chamadas `pg_net`. Um webhook que enviava a chave antiga em `Authorization: Bearer` passa a enviar a nova no header `apikey`.
4. **Se a fuga foi da `service_role` key antiga, passe também os seus clientes para uma publishable key.** Desativar as chaves antigas desliga `anon` e `service_role` em conjunto, por isso um cliente ainda em `anon` deixa de funcionar.
5. **Confirme que nada usa a chave antiga.** A página API Keys tem indicadores de último uso para isso.
6. **Retire-a.** Apague uma secret key, o que não se pode desfazer, ou desative as chaves antigas.
7. **Para uma chave antiga, revogue também o JWT secret antigo**, pelo [guia de JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). As chaves antigas são tokens assinados por esse segredo, por isso tudo o que ainda confie nele pode aceitar a chave divulgada.

A exceção é um ataque em curso. Nesse caso o guia diz para retirar a chave de imediato, mesmo que os componentes que a usam deixem de funcionar até a substituir.

Se falhou algum cliente depois de desativar as chaves antigas, passe-o para uma chave nova. Voltar a ligar as chaves antigas traz de volta também a chave divulgada.

## Como verificar o que aconteceu enquanto esteve exposta?

O Supabase não consegue dizer, só pela chave, quem a teve, por isso procure os resultados. Comece pelas contas novas ou alteradas:

```sql
select email, created_at, last_sign_in_at, raw_app_meta_data
from auth.users
order by created_at desc
limit 50;
```

Procure contas que não reconhece e funções que ninguém atribuiu. Depois compare as suas tabelas importantes com a última cópia de segurança anterior à fuga. Se essa frase o deixou em dúvida sobre se existe uma, leia [Supabase backups](https://madsalt.tech/pt/notes/supabase-backups/). Os dados pessoais dos seus utilizadores podem ter sido legíveis, por isso verifique se as suas regras de proteção de dados exigem que o comunique.

## Como manter a próxima fuga pequena?

Use uma secret key separada por componente, o que o guia de API keys recomenda, para que uma fuga signifique uma só rotação. Mantenha a chave fora de tudo o que tenha prefixo `NEXT_PUBLIC_` ou `VITE_`, já que isso vai para o browser. E procure `sb_secret_` e `service_role` em cada build de produção antes de a publicar. Num site em produção, o [scanner de segredos](https://madsalt.tech/pt/tools/secret-scanner/) gratuito faz a mesma pesquisa numa página pública e nos scripts que ela liga.

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

Receia que uma chave tenha vazado? Escreva-me e rodamo-la e verificamos o que expôs.

Receia que uma chave tenha vazado?

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)
