---
title: "Supabase Vault: como os segredos chegam à chave pública"
description: "O Supabase Vault guarda segredos cifrados, mas um grant ou uma função intermédia pode entregá-los à chave pública. O que o meu teste mostrou e como evitar."
url: "https://madsalt.tech/pt/notes/supabase-vault-secrets/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-13
---

# Supabase Vault: como os segredos chegam à chave pública

Em resumo

O Supabase Vault guarda os segredos cifrados e decifra-os através da vista `vault.decrypted_secrets`. Por omissão, só o `service_role` e o `postgres` a podem ler; na minha stack local, o `anon` e o `authenticated` não tinham qualquer acesso ao schema `vault`. Os segredos vazam de duas maneiras: um grant sobre o Vault a uma função de cliente, ou uma função `SECURITY DEFINER` num schema exposto que devolve um valor decifrado. A minha função de teste devolveu um segredo fictício à chave pública com `200`; depois de revogar o `EXECUTE`, respondeu `42501`.

O meu [verificador de segurança do Supabase](https://madsalt.tech/pt/tools/supabase-security-check/) gratuito tem uma regra para cada via de fuga: "Segredos do Vault legíveis pelos papéis da API", classificada como crítica quando o `anon` os consegue ler, e "Funções security definer chamáveis a partir da API". Esta nota mostra porque é que a segunda importa para o Vault.

## O que protege o Supabase Vault?

O [guia do Vault](https://supabase.com/docs/guides/database/vault) do Supabase descreve-o como uma tabela de segredos guardados com cifragem autenticada, legíveis em forma decifrada através de uma vista. O segredo continua cifrado em disco, nas cópias de segurança e na replicação. O guia dá também a condição de que tudo depende: quem tiver acesso à vista tem acesso aos segredos decifrados, por isso o acesso a ela tem de ser sempre limitado por privilégios SQL.

## Quem o pode ler por omissão?

Numa stack local do Supabase (CLI 2.109.1, Postgres 17.6) guardei um valor fictício com `vault.create_secret` e verifiquei cada função:

| Função          | Usage no schema `vault` | Select em `vault.decrypted_secrets` |
| --------------- | ----------------------- | ----------------------------------- |
| `anon`          | não                     | não                                 |
| `authenticated` | não                     | não                                 |
| `service_role`  | sim                     | sim                                 |

O schema `vault` também não está, por omissão, nos schemas expostos da Data API. Por isso, de origem, a chave pública não chega ao Vault.

## Como é que um segredo vaza, apesar disso?

O motivo habitual é uma app que precisa do segredo. Uma função é o caminho mais curto para lho dar:

![O que a chave pública consegue tirar do Vault. Supabase local, um segredo fictício, publishable key. Valores por omissão: Publishable key → schema vault → sem acesso; Uma função definer devolve o segredo: Publishable key → rpc/get_api_key → 200, segredo; EXECUTE revogado às funções de cliente: Publishable key → rpc, sem EXECUTE → 401, 42501.](https://madsalt.tech/charts/pt/supabase-vault-secrets.svg)

*A minha reprodução numa stack local do Supabase, 23 de outubro de 2026.*

```sql
create function public.get_api_key() returns text
language sql security definer set search_path = ''
as $$ select decrypted_secret from vault.decrypted_secrets where name = 'demo_api_key' $$;
```

O `SECURITY DEFINER` executa-a com os direitos do dono, por isso consegue ler o Vault. Em projetos existentes, as funções em `public` recebem `EXECUTE` para o `anon` e o `authenticated` por omissão, e o `public` está exposto, pelo que a Data API a serve como `/rest/v1/rpc/get_api_key`:

| Pedido com a publishable key                                         | Resultado                                                 |
| -------------------------------------------------------------------- | --------------------------------------------------------- |
| `POST /rest/v1/rpc/get_api_key`                                      | `200`, o valor fictício decifrado                         |
| igual, depois de `revoke execute … from public, anon, authenticated` | `401`, 42501 "permission denied for function get_api_key" |

A segunda via de fuga é um grant: alguém junta o `vault` aos schemas expostos ou dá a uma função de cliente `usage` e `select` para que uma consulta funcione. Esse é o caso que o verificador classifica como crítico.

## Como usar o Vault em segurança?

- Leia os segredos apenas do lado do servidor: em funções da base de dados que nunca os devolvam, em triggers e webhooks, ou em Edge Functions que usem a secret key.
- Se uma função tiver de ler um segredo, mantenha-a num schema que não esteja exposto, ou revogue o `EXECUTE` a `public`, `anon` e `authenticated` e conceda-o apenas à função que precisa dele.
- Nunca devolva um valor decifrado a partir de uma função que o cliente possa chamar. Devolva antes o resultado de usar o segredo, como a resposta de uma chamada a uma API.
- Nunca junte o `vault` aos schemas expostos; expliquei o que essa lista abre em [Supabase exposed schemas](https://madsalt.tech/pt/notes/supabase-exposed-schemas/).

As funções também são uma API, e o resto dessa regra, incluindo o `search_path` e o tratamento de `NULL`, está na minha [lista de segurança para apps Lovable](https://madsalt.tech/pt/blog/lovable-app-security-checklist/). Como o `search_path` de uma função wrapper pode ser virado contra ela está em [Supabase "function search path mutable": o que significa](https://madsalt.tech/pt/notes/supabase-function-search-path-mutable/).

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

Uma empresa para quem construí pagava milhares de dólares por mês por um produto documental empresarial. A plataforma própria custa agora centenas por mês, com funções para documentos, formulários, relatórios e um portal de clientes, e só as funcionalidades que a equipa usa. Veja o [caso da plataforma documental de obra](https://madsalt.tech/pt/work/construction-document-platform/).

Não sabe onde estão guardados os seus segredos? Escreva-me e verificamo-los.

Onde estão guardados os seus segredos?

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)
