---
title: "Supabase RLS: Jede 4. Open-Source-App hat offene Tabelle"
description: "Ich habe die Migrationen von 568 Open-Source-Supabase-Projekten ausgeführt und 15 Sicherheitsregeln geprüft. 24 % lassen eine Tabelle offen, auch Lovable."
url: "https://madsalt.tech/de/blog/open-source-supabase-projects-security-study/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/de/about/"
language: "de"
published: 2026-11-08
---

# Supabase RLS: Jede 4. Open-Source-App hat offene Tabelle

Kurz gesagt

Ich habe 1.170 öffentliche GitHub-Repositories mit Supabase-Migrationen genommen, jede einzeln auf eine frische Supabase-Datenbank in einer Offline-Sandbox angewendet und dieselben 15 Datenbankregeln laufen lassen, die mein kostenloser Checker auf Live-Projekten prüft. 568 Projekte liefen sauber durch: 15.624 Tabellen in `public`. **134 davon (23,6 %) haben mindestens eine Tabelle mit ausgeschaltetem RLS, die der öffentliche Key lesen und ändern kann.** 8,8 % haben eine Policy, mit der ein nicht angemeldeter Besucher jede Zeile ändern oder löschen kann, 10,9 % lassen ihn beliebig einfügen, und 12,0 % stellen eine View bereit, die RLS umgeht. Projekte, die in Lovable erstellt wurden, lassen weniger Tabellen ohne RLS (9,1 %), schreiben aber zwei- bis dreimal so oft `true` in Policies. Bei einem Projekt, das nach Supabases Änderung vom 30. Oktober angelegt wird, lassen dieselben Migrationen 3,6 % statt 22,7 % offen. Drei SQL-Abfragen am Ende zeigen, wo Ihr eigenes Projekt steht.

Die meisten Supabase-Sicherheitstipps sagen dasselbe: RLS einschalten, Policies schreiben, den Advisor prüfen. Ich wollte wissen, wie oft echte Projekte das tatsächlich falsch machen, jedes Mal auf dieselbe Weise gemessen und nicht an den paar Apps, die Leute auf Reddit posten. Auf öffentlichem GitHub liegen Tausende Supabase-Projekte mit vollständiger Migrationshistorie. Also habe ich so viele gebaut, wie ich konnte, und mir die Datenbank angesehen, die die Migrationen hinterlassen.

## Wie habe ich 568 Projekte getestet?

Ich habe auf GitHub nach SQL-Dateien unter `supabase/migrations` gesucht, die `create table` enthalten, und die Suche nach Dateigröße aufgeteilt, um das Suchlimit zu umgehen. Das ergab 8.914 Repositories, Forks ausgeschlossen. Daraus habe ich eine feste Pseudo-Zufallsstichprobe gezogen, sortiert nach einem Hash des Repository-Namens, und von jedem nur den Migrationsordner und die `package.json` heruntergeladen.

| Schritt                                                                    | Projekte |
| -------------------------------------------------------------------------- | -------- |
| Repositories mit Supabase-Migrationen (GitHub-Codesuche, 7. November 2026) | 8.914    |
| Heruntergeladene Stichprobe                                                | 1.170    |
| Gemessen, nach Entfernen exakter Duplikate                                 | 1.168    |
| Templates und Supabases eigene Repositories entfernt                       | 9        |
| Migrationen, die auf einer frischen Datenbank mit einem Fehler stoppen     | 567      |
| Keine Tabellen in `public`                                                 | 8        |
| Nutzen Supabases automatischen RLS-Trigger (ausgeschlossen, siehe Grenzen) | 16       |
| **Analysiert**                                                             | **568**  |

Jedes Projekt lief in einer eigenen frischen Datenbank in einem Docker-Container ohne Netzwerkzugang, aufgebaut aus einem Dump eines lokalen Supabase-Stacks (CLI 2.109.1, Postgres 17.6, mit den echten Schemas `auth` und `storage`). Die Migrationen liefen in der Reihenfolge der Dateinamen als Rolle `postgres`, die bei Supabase kein Superuser ist, also die Rolle, die auch `supabase db push` nutzt. Nichts aus einem Repository wurde je außerhalb dieses Containers ausgeführt.

Auf der entstandenen Datenbank habe ich die Katalogabfragen und die 15 Datenbankregeln meines [Supabase Security Checkers](https://madsalt.tech/de/tools/supabase-security-check/) unverändert laufen lassen. Einstellungen, die außerhalb der Datenbank liegen, etwa E-Mail-Bestätigung oder Schutz vor geleakten Passwörtern, sind aus Migrationen nicht erkennbar, deshalb fehlen diese Regeln.

Fast die Hälfte der Projekte bricht vor der letzten Migration mit einem Fehler ab. Die üblichen Ursachen sind Seed-Daten, die auf Nutzer verweisen, die nur im Projekt des Autors existieren, im Dashboard von Hand angelegte Objekte, auf die später verwiesen wird, und Migrationen, die auf einer sauberen Datenbank nie funktioniert haben. Ich berichte nur über Projekte, die sauber durchliefen.

## Was habe ich gefunden?

![568 Open-Source-Supabase-Projekte: Anteil je Befund. Prozent der Projekte. Migrationen auf frischer Datenbank angewendet, November 2026. RLS aus, offen für den öffentlichen Key: 23,60; View umgeht RLS: 12; Jeder kann beliebig einfügen: 10,90; Sensible Spalte erreichbar: 10; Jeder kann Zeilen ändern oder löschen: 8,80; Storage offen für Nicht-Angemeldete: 5,30; Policy vertraut user_metadata: 0,70.](https://madsalt.tech/charts/de/open-source-supabase-projects-security-study.svg)

*Quelle: meine Studie von 1.168 öffentlichen GitHub-Repositories mit Supabase-Migrationen, 568 davon sauber angewendet, 7.-8. November 2026.*

| Befund                                                                                         | Alle (568) | In Lovable erstellt (66) | Andere (502) |
| ---------------------------------------------------------------------------------------------- | ---------- | ------------------------ | ------------ |
| Mindestens eine Tabelle mit ausgeschaltetem RLS, die der öffentliche Key lesen und ändern kann | **23,6 %** | 9,1 %                    | 25,5 %       |
| Eine Policy lässt nicht angemeldete Besucher jede Zeile ändern oder löschen (`using (true)`)   | **8,8 %**  | 15,2 %                   | 8,0 %        |
| Eine Policy lässt nicht angemeldete Besucher beliebig einfügen (`with check (true)`)           | 10,9 %     | 28,8 %                   | 8,6 %        |
| Eine View in `public`, die das RLS ihrer Tabellen umgeht                                       | 12,0 %     | 7,6 %                    | 12,5 %       |
| Eine Storage-Policy, die für nicht angemeldete Besucher offen ist                              | 5,3 %      | 12,1 %                   | 4,4 %        |
| Eine Spalte mit sensibel klingendem Namen, über die API erreichbar                             | 10,0 %     | 16,7 %                   | 9,2 %        |
| Eine Policy, die `user_metadata` vertraut                                                      | 0,7 %      | 0 %                      | 0,8 %        |

Über alle 15.624 Tabellen haben 8,5 % kein RLS. Das klingt wenig, bis man pro Projekt zählt: Jede vierte App hat mindestens eine solche Tabelle, und mit den Default-Grants, die Supabase bis zum 30. Oktober 2026 verwendete, kann der öffentliche Key jede Zeile davon lesen und schreiben.

### Tabellen, bei denen niemand RLS eingeschaltet hat

In jedem der fünf Projekte, die ich von Hand geöffnet habe, hat keine Migration je `alter table … enable row level security` auf der offenen Tabelle ausgeführt. Ein Projekt hatte 31 Tabellen und RLS auf keiner davon. Was in diesen Tabellen liegt, ist unterschiedlich: Referenzlisten wie Länder, aber auch Zähler, Events, Verkäufe und Profile. Die Notiz [RLS disabled in public](https://madsalt.tech/de/notes/supabase-rls-disabled-in-public/) erklärt, was die Advisor-Warnung bedeutet und wie Sie sie schließen, ohne die App zu zerbrechen.

### Policies, die `true` sagen

Eine Policy mit `using (true)` auf `update` oder `delete` heißt, dass jeder Besucher mit Ihrem öffentlichen Key jede Zeile ändern oder entfernen kann. 8,8 % der Projekte haben mindestens eine. `with check (true)` auf `insert` ist häufiger, 10,9 %, und manchmal gewollt, etwa bei einer Warteliste oder einem Kontaktformular. Ich habe nur das wörtliche `true` gezählt: Eine Policy, die eine Hilfsfunktion wie `is_member(team_id)` aufruft, wird in der Funktion abgesichert und steckt deshalb nicht in diesen Zahlen. Die [Notiz](https://madsalt.tech/de/notes/supabase-rls-using-true/) zu `using (true)` zeigt, wie Sie den gewollten Fall vom Versehen unterscheiden.

### Views, die RLS umgehen

Eine View in `public` läuft mit den Rechten ihres Eigentümers, es sei denn, sie wird mit `security_invoker = true` angelegt. Sie liefert dann Zeilen, die die Policies der Tabelle selbst verbergen würden. 12,0 % der Projekte haben mindestens eine.

## Sind in Lovable erstellte Projekte schlechter?

Nicht so, wie ich es erwartet hatte. Ein Projekt zählte ich als in Lovable erstellt, wenn seine `package.json` `lovable-tagger` auflistet oder mindestens die Hälfte seiner Migrationsdateien Lovables Namensschema `<timestamp>_<uuid>.sql` tragen. Diese Projekte lassen weniger Tabellen ohne RLS, 9,1 % gegenüber 25,5 %. Dafür schreiben sie deutlich öfter `true` in Policies: 15,2 % lassen jeden Zeilen ändern oder löschen, 28,8 % lassen jeden einfügen, und 12,1 % öffnen eine Storage-Policy für nicht angemeldete Besucher. Nur 66 Lovable-Projekte liefen sauber durch, während 152 mit einem Fehler stoppten, oft an Seed-Daten für die eigenen Nutzer des Autors. Verstehen Sie die Lovable-Spalte also als Tendenz, mit einer Spanne von etwa acht Punkten in beide Richtungen.

## Behebt die Änderung vom 30. Oktober das Problem?

Supabases [Breaking Change](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically) gibt neuen Tabellen in `public` keine automatischen Grants mehr für die API-Rollen; was dadurch bricht, habe ich in [diesem Beitrag](https://madsalt.tech/de/blog/supabase-october-30-grant-change/) getestet. Ich habe 433 der Projekte ein zweites Mal mit den neuen Defaults laufen lassen, so wie ein Projekt startet, das nach der Umstellung angelegt wird. 194 davon liefen beide Male sauber durch.

| Dieselben 194 Projekte                                                                         | Alte Defaults | Neue Defaults |
| ---------------------------------------------------------------------------------------------- | ------------- | ------------- |
| Mindestens eine Tabelle mit ausgeschaltetem RLS, die der öffentliche Key lesen und ändern kann | 44 (22,7 %)   | 7 (3,6 %)     |

![Dieselben 194 Projekte vor und nach dem 30. Oktober. Prozent mit einer Tabelle ohne RLS, die der öffentliche Key lesen und ändern kann. Alte Default-Privilegien: 22,70; Neue Default-Privilegien: 3,60.](https://madsalt.tech/charts/de/open-source-supabase-projects-security-study-oct30.svg)

*Quelle: meine Studie, November 2026: dieselben Migrationen mit alten und neuen Default-Privilegien von Supabase angewendet.*

Ja, bei neuen Tabellen schließt sie also den größten Teil der Lücke: Eine Tabelle, auf die niemand Rechte vergeben hat, ist unerreichbar, mit oder ohne RLS. Die sieben Projekte, die offen bleiben, vergeben den API-Rollen in ihren Migrationen selbst Zugriff, was die alte Offenheit sofort zurückbringt. Und die Umstellung ändert nur, was neue Tabellen bekommen: Ein Projekt, das schon eine offene Tabelle hat, behält sie offen, die erste Abfrage unten ist also bei jedem bestehenden Projekt weiter wichtig.

## Wie habe ich sichergestellt, dass die Zahlen stimmen?

Bevor ich einem Ergebnis traute, habe ich ein Testprojekt mit sechs eingebauten Problemen gebaut (eine Tabelle ohne RLS, `using (true)`-Policies, eine View ohne `security_invoker`, eine Security-Definer-Funktion, die jeder aufrufen kann, eine Policy, die `user_metadata` liest, ein öffentlicher Bucket mit anonymen Uploads) und zwei korrekt abgesicherten Tabellen. Die Pipeline musste alle sechs finden und keine der beiden. Die ersten Läufe schafften das nicht: Die Regeln brauchen die Liste der API-Schemas, die ein Live-Projekt liefert und eine Sandbox nicht, und die Admin-Rolle der Sandbox gab in Policies `uid()` statt `auth.uid()` aus, wodurch sichere Policies offen aussahen. Beides ist behoben, jedes Projekt wurde neu gemessen, und ich habe Stichproben jedes Befunds von Hand geöffnet.

## Was diese Studie nicht sehen kann

- Migrationen sind nicht die Live-Datenbank. Alles, was im Dashboard geändert und nie in eine Migration geschrieben wurde, ist hier unsichtbar, in beide Richtungen.
- Projekte, die ihre Migrationen auf GitHub veröffentlichen, sind nicht alle Supabase-Projekte. Viele sind Lernprojekte und Nebenprojekte.
- Fast die Hälfte der Stichprobe lief nicht sauber durch und steckt nicht in den Zahlen. Diese Projekte könnten sicherer oder unsicherer sein.
- Projekte, die Supabases [automatischen RLS-Trigger](https://supabase.com/docs/guides/database/postgres/event-triggers) eingeschaltet haben, bekommen RLS auf neuen Tabellen, ohne dass eine Migration das sagt. Ich habe die 16 ausgeschlossen, die ihn referenzieren; andere nutzen ihn womöglich ohne Spur in ihren Dateien.
- Repository-Namen werden nicht veröffentlicht. Die Daten stammen aus öffentlichen, nicht personenbezogenen Informationen unter der Forschungsklausel der [Acceptable Use Policies von GitHub](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).

## Wie prüfen Sie Ihr eigenes Projekt?

Führen Sie diese Abfragen im SQL Editor aus. Jede lieferte auf meinem Testprojekt genau das eingebaute Problem und sonst nichts.

Tabellen mit ausgeschaltetem RLS, und ob der öffentliche Key sie erreicht:

```sql
select c.relname as table_name,
       has_table_privilege('anon', c.oid, 'select') as anon_can_read,
       has_table_privilege('anon', c.oid, 'insert,update,delete') as anon_can_write
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind in ('r', 'p') and not c.relrowsecurity
order by 1;
```

Policies, die nicht angemeldeten Besuchern das Schreiben ohne jede Bedingung erlauben:

```sql
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public'
  and cmd in ('INSERT', 'UPDATE', 'DELETE', 'ALL')
  and roles && array['anon', 'public']::name[]
  and (qual = 'true' or with_check = 'true')
order by 1, 2;
```

Views, die RLS umgehen:

```sql
select c.relname as view_name
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind = 'v'
  and not exists (
    select 1 from unnest(coalesce(c.reloptions, '{}')) as o
    where o ~* '^security_invoker=(true|on|yes|1)$'
  )
order by 1;
```

Ein leeres Ergebnis bei allen dreien ist ein guter Anfang, kein Freibrief. [So aktivieren Sie RLS](https://madsalt.tech/de/blog/how-to-enable-rls-in-supabase/) behandelt die erste Abfrage, [RLS-Policy-Beispiele](https://madsalt.tech/de/blog/supabase-rls-policy-examples/) die zweite, und [wie man RLS testet](https://madsalt.tech/de/blog/how-to-test-supabase-rls/) zeigt, wie Sie beweisen, dass ein Nutzer die Zeilen eines anderen nicht lesen kann. Für das größere Bild siehe [ist Supabase sicher](https://madsalt.tech/de/blog/is-supabase-secure/) und die [Sicherheits-Checkliste für Lovable-Apps](https://madsalt.tech/de/blog/lovable-app-security-checklist/).

## Mein ähnlicher Fall

Beim Bau einer Zeiterfassung für eine Prüfungsgesellschaft fand ich 4 Fehler, die kein Bildschirm zeigte, darunter einen vertraulichen Mandanten, der durch Berichtssummen und Tag-Zähler durchsickerte. Jede Zugriffsregel liegt jetzt in der Datenbank und wird vor jedem Deployment getestet; die ganze Geschichte steht in der [Fallstudie zur Prüfungsgesellschaft](https://madsalt.tech/de/work/audit-firm-time-tracking/).

Sie wollen wissen, wo Ihr eigenes Projekt steht? Schreiben Sie mir, und wir prüfen es auf dieselbe Weise.

Wo steht Ihr Projekt?

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)

## Quellen

- GitHub-Codesuche und Repository-Daten, 7. November 2026; Stichprobe und Pipeline oben beschrieben.
- Supabase, [Securing your API: default privileges](https://supabase.com/docs/guides/api/securing-your-api), gelesen am 7. November 2026.
- Supabase, [Breaking change: tables not exposed to the Data and GraphQL API automatically](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically).
- Supabase, [Event triggers: automatically enable RLS](https://supabase.com/docs/guides/database/postgres/event-triggers).
- GitHub, [Acceptable Use Policies, section 7](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).
