---
title: "Supabase service role key leaked: cosa fare, in ordine"
description: "Cosa ha aperto una service role key Supabase trapelata nel mio test locale, e l'ordine per sostituirla, ritirare la vecchia e controllare i danni senza fermo."
url: "https://madsalt.tech/it/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-14
---

# Supabase service role key leaked: cosa fare, in ordine

In breve

Una service role key trapelata salta la RLS e può usare l'Auth admin API. Nel mio test locale ha letto 3 righe su 3 nonostante policy riservate al proprietario, ha modificato la riga di un altro utente e ha elencato tutti gli utenti. Corregga la causa della fuga, crei una nuova secret key, sposti su di essa ogni componente, ritiri la vecchia chiave, poi controlli cosa è cambiato mentre era fuori. Se qualcuno la sta usando in questo momento, la ritiri per prima e accetti il fermo.

Il mio [scanner di segreti](https://madsalt.tech/it/tools/secret-scanner/) gratuito legge l'HTML di una pagina pubblica e i file di script collegati, alla ricerca di chiavi API, token e URL di database che un visitatore potrebbe copiare, compresa la chiave `service_role` di Supabase; i valori sono mostrati mascherati. Questa nota riguarda cosa fare se la chiave è trapelata.

Quando prendo in carico un'app Supabase, questa chiave è la prima cosa che cerco nel JavaScript compilato. La differenza tra le due chiavi è in [anon key vs service role key](https://madsalt.tech/it/blog/supabase-anon-key-vs-service-role-key/). Questa nota è per il giorno brutto, quando quella segreta è comparsa in un bundle, in un repository pubblico o in un log.

## Cosa può fare qualcuno con la chiave trapelata?

Ho verificato su uno stack Supabase locale (CLI 2.109.1, Postgres 17.6), su una tabella con RLS attiva, policy riservate al proprietario e 3 ordini finti, più un elenco di utenti di prova.

![Cosa ha aperto la chiave trapelata. Supabase locale, RLS attiva, policy del proprietario. Lettura della tabella: Secret key → orders, RLS attiva → 3 righe su 3; Elenco degli utenti: Secret key → Auth admin API → 200, tutti elencati; Stessa chiamata, chiave pubblica: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/it/supabase-service-role-key-leaked.svg)

*Il mio test su uno stack Supabase locale, 2 novembre 2026.*

| Richiesta                      | Publishable key | Chiave secret o `service_role`   |
| ------------------------------ | --------------- | -------------------------------- |
| Leggere `orders`               | 0 righe         | 3 righe su 3                     |
| Modificare la riga di un altro | Non provato     | 1 riga modificata                |
| `GET /auth/v1/admin/users`     | `403`           | `200`, tutti gli utenti elencati |

La vecchia chiave `service_role` e la nuova chiave `sb_secret_` si sono comportate allo stesso modo in tutti e tre i casi.

Due risultati potrebbero dare un falso conforto:

- Su questo stack, una nuova tabella ha dato ai ruoli dell'API solo `TRUNCATE`, `REFERENCES` e `TRIGGER`. Quindi la secret key ha ricevuto `403` con codice `42501` finché non ho eseguito un `GRANT`. Questo non rende innocua una fuga: la chiamata Auth admin ha risposto `200` nello stesso momento. La modifica dietro a questo è in [Supabase 42501 permission denied](https://madsalt.tech/it/notes/supabase-42501-permission-denied/).
- La [guida alle API keys](https://supabase.com/docs/guides/getting-started/api-keys) di Supabase dice che una secret key usata da un browser riceve `401`, e aggiunge che un attaccante può comunque usarla da altri strumenti. Il mio stack locale ha risposto `200` a una richiesta con header da browser, quindi qui non sono riuscito a riprodurre quel blocco.

## Qual è l'ordine giusto per sostituire la chiave?

Questi passaggi seguono la [guida di Supabase per ruotare una chiave trapelata](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Non li ho eseguiti su un progetto ospitato per questa nota.

1. **Corregga la causa.** Tolga la chiave dal bundle, dal repository o dal log, altrimenti la nuova chiave trapelerà allo stesso modo. Eliminarla dall'ultimo commit di Git non basta, perché la cronologia la contiene ancora.
2. **Crei una nuova secret key** in Settings → API Keys.
3. **Sostituisca la vecchia chiave ovunque**: server, job cron, Edge Function, Database Webhooks e chiamate `pg_net`. Un webhook che inviava la vecchia chiave in `Authorization: Bearer` ora invia la nuova nell'header `apikey`.
4. **Se la fuga era la vecchia chiave `service_role`, sposti anche i suoi client su una publishable key.** Disattivare le vecchie chiavi spegne insieme `anon` e `service_role`, quindi un client ancora su `anon` smette di funzionare.
5. **Confermi che niente usi più la vecchia chiave.** La pagina API Keys ha indicatori dell'ultimo utilizzo per questo.
6. **La ritiri.** Elimini una secret key, il che non si può annullare, oppure disattivi le vecchie chiavi.
7. **Per una vecchia chiave, revochi anche il vecchio segreto JWT**, tramite la [guida alle JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). Le vecchie chiavi sono token firmati da quel segreto, quindi tutto ciò che si fida ancora di esso può accettare la chiave trapelata.

L'eccezione è un attacco in corso. In quel caso la guida dice di ritirare subito la chiave, anche se i componenti che la usano smettono di funzionare finché non la sostituisce.

Se dopo aver disattivato le vecchie chiavi ha dimenticato un client, sposti quel client su una nuova chiave. Riattivare le vecchie chiavi fa tornare anche la chiave trapelata.

## Come si controlla cosa è successo mentre era fuori?

Supabase non può dirle dalla sola chiave chi la possedeva, quindi cerchi i risultati. Cominci dagli account nuovi o modificati:

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

Cerchi account che non riconosce e ruoli che nessuno ha assegnato. Poi confronti le sue tabelle importanti con l'ultimo backup precedente alla fuga. Se questa frase l'ha fatta dubitare di averne uno, legga [Supabase backups](https://madsalt.tech/it/notes/supabase-backups/). I dati personali dei suoi utenti potrebbero essere stati leggibili, quindi controlli se le sue regole sulla protezione dei dati richiedono di segnalarlo.

## Come si tiene piccola la prossima fuga?

Usi una secret key separata per componente, come raccomanda la guida alle API keys, così una fuga significa una sola rotazione. Tenga la chiave lontana da qualsiasi cosa con un prefisso `NEXT_PUBLIC_` o `VITE_`, perché quelle variabili vanno al browser. E cerchi `sb_secret_` e `service_role` in ogni build di produzione prima che venga rilasciata. Su un sito online, lo [scanner di segreti](https://madsalt.tech/it/tools/secret-scanner/) gratuito esegue la stessa ricerca su una pagina pubblica e sugli script che collega.

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

Ho applicato le migrazioni di 1.170 progetti Supabase pubblici a database nuovi: dei 568 che sono andati a buon fine, 134 (23,6 %) avevano una tabella con RLS disattivato che la chiave pubblica poteva leggere e modificare. Metodo e query sono nello [studio open source su Supabase](https://madsalt.tech/it/blog/open-source-supabase-projects-security-study/).

Teme che una chiave sia trapelata? Mi scriva e la ruoteremo e controlleremo cosa ha esposto.

Teme che una chiave sia trapelata?

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

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