---
title: "Supabase service role key leaked : que faire, dans l'ordre"
description: "Ce que la service role key Supabase divulguée a ouvert dans mon test local, et l'ordre pour la remplacer, retirer l'ancienne et vérifier les dégâts."
url: "https://madsalt.tech/fr/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-14
---

# Supabase service role key leaked : que faire, dans l'ordre

En bref

Une service role key divulguée contourne la RLS et peut utiliser l'Auth admin API. Dans mon test local, elle a lu 3 lignes sur 3 malgré des politiques réservées au propriétaire, a modifié la ligne d'un autre utilisateur et a listé tous les utilisateurs. Corrigez la cause de la fuite, créez une nouvelle secret key, basculez-y chaque composant, retirez l'ancienne clé, puis vérifiez ce qui a changé pendant qu'elle était dehors. Si quelqu'un s'en sert en ce moment, retirez-la d'abord et acceptez l'interruption.

Mon [scanner de secrets](https://madsalt.tech/fr/tools/secret-scanner/) gratuit lit le HTML d'une page publique et les fichiers de script qu'elle charge, à la recherche de clés API, de tokens et d'URL de base de données qu'un visiteur pourrait copier, dont la clé `service_role` de Supabase ; les valeurs sont affichées masquées. Cette note explique quoi faire si la clé a fuité.

Quand je reprends une application Supabase, cette clé est la première chose que je cherche dans le JavaScript compilé. La différence entre les deux clés est dans [anon key vs service role key](https://madsalt.tech/fr/blog/supabase-anon-key-vs-service-role-key/). Cette note est pour le mauvais jour, quand la clé secrète est apparue dans un bundle, un dépôt public ou un log.

## Que peut faire quelqu'un avec la clé divulguée ?

J'ai vérifié sur un stack Supabase local (CLI 2.109.1, Postgres 17.6), sur une table avec la RLS activée, des politiques réservées au propriétaire et 3 fausses commandes, plus une liste d'utilisateurs de test.

![Ce que la clé divulguée a ouvert. Supabase local, RLS activée, politiques propriétaire. Lire la table: Secret key → orders, RLS activée → 3 lignes sur 3; Lister les utilisateurs: Secret key → Auth admin API → 200, tous listés; Même appel, clé publique: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/fr/supabase-service-role-key-leaked.svg)

*Mon test sur un stack Supabase local, 2 novembre 2026.*

| Requête                      | Publishable key | Clé secrète ou `service_role`       |
| ---------------------------- | --------------- | ----------------------------------- |
| Lire `orders`                | 0 ligne         | 3 lignes sur 3                      |
| Modifier la ligne d'un autre | Non essayé      | 1 ligne modifiée                    |
| `GET /auth/v1/admin/users`   | `403`           | `200`, tous les utilisateurs listés |

L'ancienne clé `service_role` et la nouvelle clé `sb_secret_` se sont comportées de la même façon dans les trois cas.

Deux résultats pourraient donner un faux réconfort :

- Sur ce stack, une nouvelle table n'a donné aux rôles de l'API que `TRUNCATE`, `REFERENCES` et `TRIGGER`. La secret key a donc reçu `403` avec le code `42501` dessus jusqu'à ce que j'exécute un `GRANT`. Cela ne rend pas une fuite inoffensive : l'appel Auth admin a répondu `200` au même moment. Le changement à l'origine de cela est dans [Supabase 42501 permission denied](https://madsalt.tech/fr/notes/supabase-42501-permission-denied/).
- Le [guide des API keys](https://supabase.com/docs/guides/getting-started/api-keys) de Supabase dit qu'une secret key utilisée depuis un navigateur reçoit `401`, et ajoute qu'un attaquant peut quand même s'en servir depuis d'autres outils. Mon stack local a répondu `200` à une requête avec des en-têtes de navigateur, je n'ai donc pas pu reproduire ce blocage ici.

## Quel est le bon ordre pour remplacer la clé ?

Ces étapes suivent le [guide de Supabase pour renouveler une clé divulguée](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Je ne les ai pas exécutées sur un projet hébergé pour cette note.

1. **Corrigez la cause.** Retirez la clé du bundle, du dépôt ou du log, sinon la nouvelle clé fuira de la même façon. La supprimer du dernier commit de Git ne suffit pas, car l'historique la contient encore.
2. **Créez une nouvelle secret key** dans Settings → API Keys.
3. **Remplacez l'ancienne clé partout** : serveurs, tâches cron, Edge Functions, Database Webhooks et appels `pg_net`. Un webhook qui envoyait l'ancienne clé dans `Authorization: Bearer` envoie maintenant la nouvelle dans l'en-tête `apikey`.
4. **Si la fuite concernait l'ancienne clé `service_role`, passez aussi vos clients à une publishable key.** Désactiver les anciennes clés désactive `anon` et `service_role` ensemble : un client encore sur `anon` cesse donc de fonctionner.
5. **Confirmez que plus rien n'utilise l'ancienne clé.** La page API Keys a des indicateurs de dernière utilisation pour cela.
6. **Retirez-la.** Supprimez une secret key, ce qui est irréversible, ou désactivez les anciennes clés.
7. **Pour une ancienne clé, révoquez aussi l'ancien secret JWT**, via le [guide des JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). Les anciennes clés sont des jetons signés par ce secret : tout ce qui lui fait encore confiance peut donc accepter la clé divulguée.

L'exception est une attaque en cours. Le guide dit alors de retirer la clé tout de suite, même si les composants qui l'utilisent cessent de fonctionner jusqu'à son remplacement.

Si vous avez oublié un client après avoir désactivé les anciennes clés, basculez ce client sur une nouvelle clé. Réactiver les anciennes clés fait aussi revenir la clé divulguée.

## Comment vérifier ce qui s'est passé pendant qu'elle était dehors ?

Supabase ne peut pas vous dire, à partir de la seule clé, qui la détenait : cherchez donc les résultats. Commencez par les comptes nouveaux ou modifiés :

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

Cherchez les comptes que vous ne reconnaissez pas et les rôles que personne n'a attribués. Comparez ensuite vos tables importantes à la dernière sauvegarde d'avant la fuite. Si cette phrase vous a fait douter d'en avoir une, lisez [Supabase backups](https://madsalt.tech/fr/notes/supabase-backups/). Les données personnelles de vos utilisateurs ont pu être lisibles : vérifiez donc si vos règles de protection des données exigent de le signaler.

## Comment limiter la prochaine fuite ?

Utilisez une secret key distincte par composant, ce que recommande le guide des API keys, pour qu'une fuite ne demande qu'une seule rotation. Gardez la clé hors de tout ce qui porte un préfixe `NEXT_PUBLIC_` ou `VITE_`, puisque ces variables vont au navigateur. Et cherchez `sb_secret_` et `service_role` dans chaque build de production avant sa livraison. Sur un site en ligne, le [scanner de secrets](https://madsalt.tech/fr/tools/secret-scanner/) gratuit effectue la même recherche sur une page publique et les scripts qu'elle charge.

Si vous voulez qu'une personne passe en revue toute l'application plutôt qu'un seul réglage, je fais un [audit d'application à périmètre fixe](https://madsalt.tech/fr/services/vibe-coded-app-audit/) avec un verdict conserver, réparer ou réécrire pour chaque partie.

## Mon cas similaire

J'ai appliqué les migrations de 1 170 projets Supabase publics à des bases neuves : sur les 568 qui se sont exécutées sans erreur, 134 (23,6 %) avaient une table avec RLS désactivé que la clé publique pouvait lire et modifier. La méthode et les requêtes sont dans [l'étude open source sur Supabase](https://madsalt.tech/fr/blog/open-source-supabase-projects-security-study/).

Vous craignez qu'une clé ait fuité ? Écrivez-moi et nous la ferons tourner et vérifierons ce qu'elle a exposé.

Vous craignez qu'une clé ait fuité ?

Dites-moi ce que vous avez aujourd'hui et ce qu'il vous faut. Je vous répondrai avec l'option que je choisirais.

[Me contacter](https://madsalt.tech/fr/#contact)
