---
title: "Supabase Vault: wie Secrets zum öffentlichen Key lecken"
description: "Supabase Vault verschlüsselt Secrets, doch ein Grant oder eine Wrapper-Funktion kann sie dem öffentlichen Key geben. Mein Test und wie Sie es vermeiden."
url: "https://madsalt.tech/de/notes/supabase-vault-secrets/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/de/about/"
language: "de"
published: 2026-11-13
---

# Supabase Vault: wie Secrets zum öffentlichen Key lecken

Kurz gesagt

Supabase Vault speichert Secrets verschlüsselt und entschlüsselt sie über die View `vault.decrypted_secrets`. Standardmäßig können nur `service_role` und `postgres` sie lesen; auf meinem lokalen Stack hatten `anon` und `authenticated` überhaupt keinen Zugriff auf das Schema `vault`. Secrets lecken auf zwei Wegen: durch einen Grant auf Vault an eine Client-Rolle oder durch eine `SECURITY DEFINER`-Funktion in einem exponierten Schema, die einen entschlüsselten Wert zurückgibt. Meine Testfunktion gab dem öffentlichen Key ein erfundenes Secret mit `200` zurück; nach dem Entzug von `EXECUTE` antwortete sie `42501`.

Mein kostenloser [Supabase-Sicherheitscheck](https://madsalt.tech/de/tools/supabase-security-check/) hat für jeden Leck-Weg eine Regel: "Vault-Secrets für API-Rollen lesbar", kritisch eingestuft, wenn `anon` sie lesen kann, und "Security-Definer-Funktionen, die über die API aufrufbar sind". Diese Notiz zeigt, warum die zweite bei Vault wichtig ist.

## Was schützt Supabase Vault?

Der [Vault-Leitfaden](https://supabase.com/docs/guides/database/vault) von Supabase beschreibt es als Tabelle von Secrets mit authentifizierter Verschlüsselung, die entschlüsselt über eine View lesbar ist. Das Secret bleibt auf der Platte, in Backups und in der Replikation verschlüsselt. Der Leitfaden nennt auch die Bedingung, auf der alles ruht: Wer Zugriff auf die View hat, hat Zugriff auf die entschlüsselten Secrets, der Zugriff muss also jederzeit über SQL-Rechte begrenzt sein.

## Wer kann es standardmäßig lesen?

Auf einem lokalen Supabase-Stack (CLI 2.109.1, Postgres 17.6) legte ich mit `vault.create_secret` einen erfundenen Wert ab und prüfte jede Rolle:

| Rolle           | Usage auf Schema `vault` | Select auf `vault.decrypted_secrets` |
| --------------- | ------------------------ | ------------------------------------ |
| `anon`          | nein                     | nein                                 |
| `authenticated` | nein                     | nein                                 |
| `service_role`  | ja                       | ja                                   |

Das Schema `vault` gehört außerdem standardmäßig nicht zu den exponierten Schemas der Data API. Von Haus aus erreicht der öffentliche Key Vault also nicht.

## Wie leckt ein Secret trotzdem?

Der übliche Grund ist eine App, die das Secret braucht. Eine Funktion ist der kürzeste Weg, es ihr zu geben:

![Was der öffentliche Key aus Vault holen kann. Lokales Supabase, ein erfundenes Secret, publishable key. Standard: Publishable key → Schema vault → kein Zugriff; Eine Definer-Funktion gibt das Secret zurück: Publishable key → rpc/get_api_key → 200, Secret; EXECUTE für Client-Rollen entzogen: Publishable key → rpc, kein EXECUTE → 401, 42501.](https://madsalt.tech/charts/de/supabase-vault-secrets.svg)

*Meine Nachstellung auf einem lokalen Supabase-Stack, 23. Oktober 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` führt sie mit den Rechten des Eigentümers aus, sie kann also Vault lesen. In bestehenden Projekten haben Funktionen in `public` standardmäßig `EXECUTE` für `anon` und `authenticated`, und `public` ist exponiert, die Data API liefert sie also als `/rest/v1/rpc/get_api_key` aus:

| Anfrage mit dem publishable key                                    | Ergebnis                                                  |
| ------------------------------------------------------------------ | --------------------------------------------------------- |
| `POST /rest/v1/rpc/get_api_key`                                    | `200`, der entschlüsselte erfundene Wert                  |
| dasselbe, nach `revoke execute … from public, anon, authenticated` | `401`, 42501 "permission denied for function get_api_key" |

Der zweite Leck-Weg ist ein Grant: Jemand nimmt `vault` in die exponierten Schemas auf oder gibt einer Client-Rolle `usage` und `select`, damit eine Abfrage funktioniert. Das ist der Fall, den der Check kritisch einstuft.

## Wie nutzen Sie Vault sicher?

- Lesen Sie Secrets nur serverseitig: in Datenbankfunktionen, die sie nie zurückgeben, in Triggern und Webhooks oder in Edge Functions, die den secret key nutzen.
- Muss eine Funktion ein Secret lesen, legen Sie sie in ein Schema, das nicht exponiert ist, oder entziehen Sie `EXECUTE` von `public`, `anon` und `authenticated` und vergeben es nur an die Rolle, die es braucht.
- Geben Sie nie einen entschlüsselten Wert aus einer Funktion zurück, die der Client aufrufen kann. Geben Sie stattdessen das Ergebnis der Nutzung des Secrets zurück, etwa die Antwort eines API-Aufrufs.
- Nehmen Sie `vault` nie in die exponierten Schemas auf; was diese Liste öffnet, habe ich in [Supabase Exposed Schemas](https://madsalt.tech/de/notes/supabase-exposed-schemas/) erklärt.

Funktionen sind auch eine API, und der Rest dieser Regel, einschließlich `search_path` und `NULL`-Behandlung, steht in meiner [Sicherheits-Checkliste für Lovable-Apps](https://madsalt.tech/de/blog/lovable-app-security-checklist/). Wie sich der `search_path` einer Wrapper-Funktion gegen sie wenden lässt, steht in [Supabase Function Search Path Mutable: was die Warnung heißt](https://madsalt.tech/de/notes/supabase-function-search-path-mutable/).

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

Ein Unternehmen, für das ich gebaut habe, zahlte mehrere tausend Dollar im Monat für ein Dokumentenprodukt für Großunternehmen. Die eigene Plattform kostet heute einige hundert im Monat, mit Rollen für Dokumente, Formulare, Berichte und ein Kundenportal und nur den Funktionen, die das Team nutzt. Siehe die [Fallstudie zur Bau-Dokumentenplattform](https://madsalt.tech/de/work/construction-document-platform/).

Unsicher, wo Ihre Secrets gespeichert sind? Schreiben Sie mir, und wir prüfen sie.

Wo sind Ihre Secrets gespeichert?

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)
