---
title: "Supabase Vault: come i segreti arrivano alla chiave pubblica"
description: "Supabase Vault cifra i segreti, ma un grant o una funzione wrapper può consegnarli alla chiave pubblica. Cosa ha mostrato il mio test locale e come evitarlo."
url: "https://madsalt.tech/it/notes/supabase-vault-secrets/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-13
---

# Supabase Vault: come i segreti arrivano alla chiave pubblica

In breve

Supabase Vault conserva i segreti cifrati e li decifra tramite la vista `vault.decrypted_secrets`. Di default possono leggerla solo `service_role` e `postgres`; sul mio stack locale `anon` e `authenticated` non avevano alcun accesso allo schema `vault`. I segreti trapelano in due modi: un grant su Vault a un ruolo client, oppure una funzione `SECURITY DEFINER` in uno schema esposto che restituisce un valore decifrato. La mia funzione di prova ha restituito un segreto finto alla chiave pubblica con `200`; dopo aver revocato `EXECUTE` ha risposto `42501`.

Il mio [checker di sicurezza per Supabase](https://madsalt.tech/it/tools/supabase-security-check/) gratuito ha una regola per ciascun percorso di fuga: "Segreti del Vault leggibili dai ruoli dell’API", giudicata critica quando `anon` può leggerli, e "Funzioni security definer richiamabili dall’API". Questa nota mostra perché la seconda conta per Vault.

## Cosa protegge Supabase Vault?

La [guida a Vault](https://supabase.com/docs/guides/database/vault) di Supabase lo descrive come una tabella di segreti conservati con cifratura autenticata, leggibili in forma decifrata tramite una vista. Il segreto resta cifrato su disco, nei backup e nella replica. La guida indica anche la condizione su cui tutto poggia: chiunque abbia accesso alla vista ha accesso ai segreti decifrati, quindi l'accesso va limitato in ogni momento con i privilegi SQL.

## Chi può leggerlo di default?

Su uno stack Supabase locale (CLI 2.109.1, Postgres 17.6) ho salvato un valore finto con `vault.create_secret` e controllato ogni ruolo:

| Ruolo           | Usage sullo schema `vault` | Select su `vault.decrypted_secrets` |
| --------------- | -------------------------- | ----------------------------------- |
| `anon`          | no                         | no                                  |
| `authenticated` | no                         | no                                  |
| `service_role`  | sì                         | sì                                  |

Lo schema `vault` non fa nemmeno parte degli schemi esposti della Data API di default. Di serie, quindi, la chiave pubblica non può raggiungere Vault.

## Come trapela comunque un segreto?

Il motivo abituale è un'app che ha bisogno del segreto. Una funzione è il modo più breve per darglielo:

![Cosa può ottenere da Vault la chiave pubblica. Supabase locale, un segreto finto, publishable key. Di default: Publishable key → schema vault → bloccato; Una funzione definer restituisce il segreto: Publishable key → rpc/get_api_key → 200, segreto; EXECUTE revocato ai ruoli client: Publishable key → rpc, senza EXECUTE → 401, 42501.](https://madsalt.tech/charts/it/supabase-vault-secrets.svg)

*La mia riproduzione su uno stack Supabase locale, 23 ottobre 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' $$;
```

`SECURITY DEFINER` la esegue con i diritti del proprietario, quindi può leggere Vault. Nei progetti esistenti le funzioni in `public` ricevono di default `EXECUTE` per `anon` e `authenticated`, e `public` è esposto, quindi la Data API la serve come `/rest/v1/rpc/get_api_key`:

| Richiesta con la publishable key                                     | Risultato                                                 |
| -------------------------------------------------------------------- | --------------------------------------------------------- |
| `POST /rest/v1/rpc/get_api_key`                                      | `200`, il valore finto decifrato                          |
| come sopra, dopo `revoke execute … from public, anon, authenticated` | `401`, 42501 "permission denied for function get_api_key" |

Il secondo percorso di fuga è un grant: qualcuno aggiunge `vault` agli schemi esposti o concede a un ruolo client `usage` e `select` per far funzionare una query. È il caso che il checker giudica critico.

## Come si usa Vault in sicurezza?

- Legga i segreti solo lato server: in funzioni del database che non li restituiscono mai, in trigger e webhook, o in Edge Function che usano la secret key.
- Se una funzione deve leggere un segreto, la tenga in uno schema non esposto, oppure revochi `EXECUTE` a `public`, `anon` e `authenticated` e lo conceda solo al ruolo che ne ha bisogno.
- Non restituisca mai un valore decifrato da una funzione che il client può chiamare. Restituisca invece il risultato dell'uso del segreto, come la risposta di una chiamata API.
- Non aggiunga mai `vault` agli schemi esposti; cosa apre quell'elenco l'ho spiegato in [Supabase exposed schemas](https://madsalt.tech/it/notes/supabase-exposed-schemas/).

Anche le funzioni sono un'API, e il resto di quella regola, compresi `search_path` e la gestione di `NULL`, è nella mia [checklist di sicurezza per le app Lovable](https://madsalt.tech/it/blog/lovable-app-security-checklist/). Come il `search_path` di una funzione wrapper possa essere rivolto contro di essa è in [Supabase Function Search Path Mutable: cosa significa](https://madsalt.tech/it/notes/supabase-function-search-path-mutable/).

Se preferite che una persona esamini l'intera app e non una sola impostazione, faccio un [audit dell'app a perimetro fisso](https://madsalt.tech/it/services/vibe-coded-app-audit/) con un verdetto per ogni parte: tenere, riparare o riscrivere.

## Il mio caso simile

Un'azienda per cui ho costruito pagava migliaia di dollari al mese per un prodotto documentale enterprise. La sua piattaforma ora costa qualche centinaio al mese, con ruoli per documenti, moduli, report e un portale clienti, e solo le funzioni che il team usa. Vedi il [caso della piattaforma documentale per cantieri](https://madsalt.tech/it/work/construction-document-platform/).

Non sa dove sono archiviati i suoi segreti? Mi scriva e li controlleremo.

Dove sono archiviati i suoi segreti?

Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.

[Mi scriva](https://madsalt.tech/it/#contact)
