---
title: "Supabase service role key geleakt: Reihenfolge der Schritte"
description: "Was ein geleakter service role key in meinem lokalen Test öffnete und in welcher Reihenfolge Sie ihn ersetzen, sperren und den Schaden ohne Ausfall prüfen."
url: "https://madsalt.tech/de/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/de/about/"
language: "de"
published: 2026-11-14
---

# Supabase service role key geleakt: Reihenfolge der Schritte

Kurz gesagt

Ein geleakter service role key umgeht RLS und kann die Auth admin API nutzen. In meinem lokalen Test las er 3 von 3 Zeilen unter reinen Owner-Policies, änderte die Zeile eines anderen Nutzers und listete alle Nutzer auf. Beheben Sie die Ursache des Lecks, erstellen Sie einen neuen secret key, stellen Sie jede Komponente darauf um, sperren Sie den alten Key und prüfen Sie dann, was sich in der Zwischenzeit geändert hat. Wird der Key gerade benutzt, sperren Sie ihn zuerst und nehmen den Ausfall in Kauf.

Mein kostenloser [Secret-Scanner](https://madsalt.tech/de/tools/secret-scanner/) liest das HTML einer öffentlichen Seite und die verlinkten Skriptdateien und sucht nach API-Keys, Tokens und Datenbank-URLs, die ein Besucher kopieren könnte, darunter der Supabase-Key `service_role`; Werte zeigt er maskiert an. Diese Notiz handelt davon, was zu tun ist, wenn der Key draußen ist.

Wenn ich eine Supabase-App übernehme, ist dieser Key das Erste, wonach ich im gebauten JavaScript suche. Den Unterschied zwischen den beiden Keys erklärt [anon key vs service role key](https://madsalt.tech/de/blog/supabase-anon-key-vs-service-role-key/). Diese Notiz ist für den schlechten Tag, an dem der geheime in einem Bundle, einem öffentlichen Repo oder einem Log auftauchte.

## Was kann jemand mit dem geleakten Key tun?

Ich habe es auf einem lokalen Supabase-Stack (CLI 2.109.1, Postgres 17.6) geprüft, an einer Tabelle mit RLS an, reinen Owner-Policies und 3 erfundenen Bestellungen, dazu eine Testliste von Nutzern.

![Was der geleakte Key öffnete. Lokales Supabase, RLS an, reine Owner-Policies. Tabelle lesen: Secret key → orders, RLS an → 3 von 3 Zeilen; Nutzer auflisten: Secret key → Auth admin API → 200, alle Nutzer; Gleicher Aufruf, öffentlicher Key: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/de/supabase-service-role-key-leaked.svg)

*Mein Test auf einem lokalen Supabase-Stack, 2. November 2026.*

| Anfrage                    | Publishable key | Secret oder `service_role` key |
| -------------------------- | --------------- | ------------------------------ |
| `orders` lesen             | 0 Zeilen        | 3 von 3 Zeilen                 |
| Zeile eines anderen ändern | Nicht versucht  | 1 Zeile geändert               |
| `GET /auth/v1/admin/users` | `403`           | `200`, alle Nutzer aufgelistet |

Der alte `service_role` key und der neue `sb_secret_` key verhielten sich in allen drei Fällen gleich.

Zwei Ergebnisse könnten falsche Sicherheit geben:

- Eine neue Tabelle gab den API-Rollen auf diesem Stack nur `TRUNCATE`, `REFERENCES` und `TRIGGER`. Der secret key bekam darauf also `403` mit dem Code `42501`, bis ich ein `GRANT` ausführte. Das macht ein Leck nicht harmlos: Der Auth-admin-Aufruf antwortete im selben Moment mit `200`. Die Änderung dahinter steht in [Supabase 42501 permission denied](https://madsalt.tech/de/notes/supabase-42501-permission-denied/).
- Supabases [Leitfaden zu API Keys](https://supabase.com/docs/guides/getting-started/api-keys) sagt, dass ein aus dem Browser benutzter secret key `401` bekommt, und ergänzt, dass ein Angreifer ihn weiterhin aus anderen Tools nutzen kann. Mein lokaler Stack antwortete auf eine Anfrage mit Browser-Headern mit `200`, diese Sperre konnte ich hier also nicht nachstellen.

## Welche Reihenfolge ist richtig, um den Key zu ersetzen?

Diese Schritte folgen Supabases [Leitfaden zum Rotieren eines geleakten Keys](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Ich habe sie für diese Notiz nicht auf einem gehosteten Projekt ausgeführt.

1. **Beheben Sie die Ursache.** Entfernen Sie den Key aus Bundle, Repo oder Log, sonst leakt der neue auf dieselbe Weise. Ihn aus dem letzten Git-Commit zu löschen reicht nicht, denn die Historie enthält ihn weiter.
2. **Erstellen Sie einen neuen secret key** unter Settings → API Keys.
3. **Ersetzen Sie den alten Key überall**: Server, Cron-Jobs, Edge Functions, Database Webhooks und `pg_net`-Aufrufe. Ein Webhook, der den alten Key in `Authorization: Bearer` schickte, schickt jetzt den neuen Key im Header `apikey`.
4. **War der alte `service_role` key das Leck, stellen Sie auch Ihre Clients auf einen publishable key um.** Das Deaktivieren der alten Keys schaltet `anon` und `service_role` zusammen ab, ein Client, der noch auf `anon` steht, hört also auf zu funktionieren.
5. **Bestätigen Sie, dass nichts den alten Key benutzt.** Die Seite API Keys hat dafür Anzeigen zur letzten Nutzung.
6. **Sperren Sie ihn.** Löschen Sie einen secret key, was sich nicht rückgängig machen lässt, oder deaktivieren Sie die alten Keys.
7. **Bei einem alten Key widerrufen Sie auch das alte JWT-Secret**, über den [Leitfaden zu JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). Alte Keys sind mit diesem Secret signierte Tokens, alles, was ihm noch vertraut, kann also den geleakten Key akzeptieren.

Die Ausnahme ist ein laufender Angriff. Dann sagt der Leitfaden, den Key sofort zu sperren, auch wenn die Komponenten, die ihn nutzen, nicht mehr funktionieren, bis Sie ihn ersetzen.

Haben Sie nach dem Deaktivieren der alten Keys einen Client vergessen, stellen Sie diesen Client auf einen neuen Key um. Die alten Keys wieder einzuschalten bringt auch den geleakten Key zurück.

## Wie prüfen Sie, was passiert ist, während er draußen war?

Supabase kann Ihnen allein anhand des Keys nicht sagen, wer ihn hielt, suchen Sie also nach den Folgen. Beginnen Sie mit neuen oder geänderten Konten:

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

Suchen Sie nach Konten, die Sie nicht kennen, und Rollen, die niemand vergeben hat. Vergleichen Sie dann Ihre wichtigen Tabellen mit dem letzten Backup von vor dem Leck. Wenn Sie dieser Satz verunsichert hat, ob es eines gibt, lesen Sie [Supabase Backups](https://madsalt.tech/de/notes/supabase-backups/). Die personenbezogenen Daten Ihrer Nutzer waren womöglich lesbar, prüfen Sie also, ob Ihre Datenschutzregeln eine Meldung verlangen.

## Wie halten Sie das nächste Leck klein?

Verwenden Sie je Komponente einen eigenen secret key, was der Leitfaden zu API Keys empfiehlt, sodass ein Leck eine Rotation bedeutet. Halten Sie den Key aus allem mit dem Präfix `NEXT_PUBLIC_` oder `VITE_` heraus, denn das geht an den Browser. Und durchsuchen Sie jeden Produktions-Build vor der Auslieferung nach `sb_secret_` und `service_role`. Auf einer Live-Site führt der kostenlose [Secret-Scanner](https://madsalt.tech/de/tools/secret-scanner/) dieselbe Suche für eine öffentliche Seite und die von ihr verlinkten Skripte aus.

Soll ein Mensch die ganze App durchgehen statt nur eine Einstellung, biete ich ein [App-Audit mit festem Umfang](https://madsalt.tech/de/services/vibe-coded-app-audit/) an, mit dem Urteil behalten, reparieren oder neu schreiben für jeden Teil.

## Mein ähnlicher Fall

Ich habe die Migrationen von 1.170 öffentlichen Supabase-Projekten auf frische Datenbanken angewendet: Von den 568, die sauber durchliefen, hatten 134 (23,6 %) eine Tabelle mit ausgeschaltetem RLS, die der öffentliche Schlüssel lesen und ändern konnte. Methode und Abfragen stehen in [der Open-Source-Supabase-Studie](https://madsalt.tech/de/blog/open-source-supabase-projects-security-study/).

Sorge, dass ein Schlüssel geleakt ist? Schreiben Sie mir, und wir rotieren ihn und prüfen, was er preisgab.

Sorge, dass ein Schlüssel geleakt ist?

Schreiben Sie mir, was Sie jetzt haben und was Sie brauchen. Ich antworte mit der Option, die ich wählen würde.

[Schreiben Sie mir](https://madsalt.tech/de/#contact)
