Read this article in English →
security · · · Streatix

Supabase RLS deaktiviert: So leakte unsere Lovable-App

Wie eine Lovable-Referenz-App mit deaktivierter Supabase-RLS live ging, warum wir zuerst falsch suchten und welche drei SQL-Statements das Leck schließen.

Wir auditieren KI-generierte Codebasen. Um herauszufinden, was diese Tools standardmäßig ausliefern, bauen wir außerdem absichtlich fehlerhafte Referenz-Apps. Bei einer davon, einem mit Lovable generierten, mandantenfähigen Rechnungs-SaaS, war Supabase RLS deaktiviert, auf jeder Tabelle: Am ersten Tag gab die App die Daten aller Nutzer an jeden anderen Nutzer preis. Der Fix bestand aus drei SQL-Statements. Den Bug zu finden, kostete uns fast einen ganzen Nachmittag, vor allem weil wir an der falschen Stelle gesucht haben.

Wir haben gebaut, was ein Gründer bauen würde

Die Referenz-App ist absichtlich klein: Next.js App Router im Frontend, Supabase für Auth und Postgres, deployt auf Vercel. Dazu drei Tabellen (users, invoices, customers) mit den user_id-Fremdschlüsseln, die man erwarten würde. Zwei Testkonten, Alice und Bob, mit jeweils einer Handvoll Rechnungen im eigenen Dashboard.

Unser Prompt an Lovable lautete: „build a multi-tenant invoicing tool with user accounts and an invoice list“. Das Ergebnis haben wir übernommen und deployt. Kein Schema-Review, kein Blick ins Supabase-Dashboard. Wir wollten sehen, was der Default liefert, wenn man nichts anfasst.

Der Login funktionierte. Das Dashboard zeigte Alices Rechnungen, wenn Alice sich einloggte, und Bobs Rechnungen bei Bob. Jeder sah seine eigenen Daten und sonst nichts. Als Demo lief das sauber.

Die Entscheidung, die Lovable uns abgenommen hat

Lovable legte das Schema mit user_id-Spalten an jeder Tabelle an, die Mandantenfähigkeit brauchte: invoices.user_id, customers.user_id. Die API-Routen filterten nach dem authentifizierten Nutzer. An jedem select hing ein .eq('user_id', user.id).

Das wirkte beruhigend. Das Datenmodell kannte Mandanten, die Query-Schicht nutzte sie, und wir gingen davon aus, dass Row Level Security die Zeilenzugehörigkeit in der Datenbank selbst erzwingt. Wozu sonst gäbe es die user_id-Spalte?

Genau diese Annahme war der Bug.

Das Symptom: Ein curl-Befehl liefert alle Rechnungen

Wir loggten Alice ein, kopierten ihr Session-Cookie und machten einen manuellen Test:

curl https://reference-app.test/api/invoices \
  -H "Cookie: sb-access-token=ALICE_TOKEN"

Zurück kamen Alices Rechnungen. Fünf Zeilen, wie erwartet.

Dann probierten wir etwas, das das Dashboard nie tun würde: die gültige Session plus ein Query-Parameter, den das Frontend gar nicht sendet. Beim Überfliegen des Route-Handlers war uns eine ausnutzbare Zeile aufgefallen:

// app/api/invoices/route.ts
export async function GET(request: Request) {
  const supabase = createServerClient()
  const { data: { user } } = await supabase.auth.getUser()
  const userId = new URL(request.url).searchParams.get('user_id') ?? user.id
  const { data } = await supabase
    .from('invoices')
    .select('*')
    .eq('user_id', userId)
  return NextResponse.json({ invoices: data })
}

Die Zeile searchParams.get('user_id') ?? user.id erlaubt dem Client, die user_id für den Filter zu überschreiben. Schlampig, und genau die Art Zeile, die ein Prompt wie „let admins view other users’ invoices“ nahelegt, wenn er die Autorisierungsregeln nicht ausbuchstabiert.

Also probierten wir es aus:

curl "https://reference-app.test/api/invoices?user_id=BOB_USER_ID" \
  -H "Cookie: sb-access-token=ALICE_TOKEN"

Bobs Rechnungen kamen zurück. Alice, eingeloggt, las Bobs Daten.

Das allein ist schon ein ernster Bug in der API-Schicht, eine fehlende Autorisierungsprüfung, die wir in jedem Audit melden würden. Er führte uns außerdem zum eigentlichen Problem.

Unsere erste, falsche Theorie

Wir hielten den Route-Handler für die Ursache. Also: Query-Parameter ignorieren, immer die ID des authentifizierten Nutzers verwenden, Patch ausliefern. Ein normaler Audit-Befund auf der Auth-Schicht.

Wir wollten ihn schon so ablegen, als jemand im Team stutzte: „Moment. Selbst wenn die API fehlerhaft ist, warum gibt Supabase Zeilen zurück, die nicht Alice gehören? Müsste die Datenbank das nicht ablehnen?“

Also prüften wir das. Statt über die App gingen wir direkt auf den REST-Endpoint von Supabase, nur mit dem anon-Key (auf neueren Projekten dem Publishable Key), demselben öffentlichen Schlüssel, der ohnehin im Browser liegt:

curl "$SUPABASE_URL/rest/v1/invoices?user_id=eq.BOB_USER_ID" \
  -H "apikey: $SUPABASE_ANON_KEY"

Bobs Zeilen kamen zurück. Kein Autorisierungsfehler, keine Filterung. Das allein ist schon das Indiz: Eine Tabelle mit aktivierter RLS, aber ohne passende Policy liefert nichts (Default Deny). Wenn also Zeilen an die anon-Rolle zurückkommen, greift RLS gar nicht. Ein einfaches SELECT im SQL-Editor hätte das verdeckt, denn Dashboard-Queries laufen als Admin-Rolle postgres und liefern trotzdem Zeilen. Man müsste zuerst SET ROLE anon absetzen, um zu sehen, was ein Fremder sieht. Der anonyme REST-Pfad ist der, den ein Fremder tatsächlich erreicht, und der stand offen.

Damit war klar: Das eigentliche Problem lag nicht in der API-Schicht.

Supabase RLS deaktiviert: Die Datenbank wusste nichts von Mandanten

Wir öffneten das Supabase-Dashboard, gingen zur Tabelle invoices und sahen ins Authentication-Panel. Ganz oben stand ein einzelner Schalter:

Enable Row Level Security

RLS prevents anonymous access to rows by default.

Der Schalter stand auf „Aus“.

Wir prüften die anderen Tabellen. customers: aus. users: aus. Jede Tabelle, die Lovable angelegt hatte, lief mit deaktivierter RLS.

Das ist der Fehler, den wir heute Open-Database-Default nennen. Eine per rohem SQL angelegte Tabelle startet ohne RLS, Lovables Migration schaltete sie nicht ein, und die Datenbank wurde zum öffentlichen Lese-Endpoint für jeden, der den anon-Key hat. Den hat der Browser jedes Besuchers bereits.

Die user_id-Spalten, die Lovable angelegt hatte, sind Dekoration. Sie dienen der API-Schicht als Filter. Ohne RLS erzwingt die Datenbank nichts.

Die Ursache: Zwei Systeme verlassen sich aufeinander

Der Supabase-Default hängt davon ab, wie die Tabelle entsteht. Tabellen aus dem Dashboard haben RLS standardmäßig aktiviert; Tabellen aus dem SQL-Editor oder aus anderen Tools müssen sie explizit einschalten, und eine generierte Migration nimmt diesen zweiten Weg. Die RLS-Dokumentation fordert dazu auf, RLS zu aktivieren, und sagt auch, dass danach über die API keine Daten mehr erreichbar sind, bis Policies existieren. Wir vermuten, dass der SQL-Pfad wegen genau dieser Hürde offen bleibt: RLS an, keine Policies, keine Ergebnisse, und wer gerade ein neues Projekt aufsetzt, weiß nicht, warum.

Außerdem ändert Supabase den Plattform-Default so, dass neue Tabellen nur noch per Opt-in über die Data API erreichbar sind; die Standardrechte unterscheiden sich inzwischen je nach Projektalter und Einstellungen. Auf einem Projekt ohne automatische Freigabe würde diese Tabelle auf den curl von oben erst antworten, wenn jemand einer Rolle Zugriff gewährt. Das verkleinert das Zeitfenster, ersetzt aber keine Policy. Sobald die Rolle das Recht hat, ist die Tabelle wieder offen.

Auch Lovable, das auf Supabase aufsetzt, aktivierte RLS nicht. Die Migration für unsere Referenz-App sieht so aus:

CREATE TABLE invoices (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id uuid REFERENCES users(id),
  amount integer NOT NULL,
  customer_email text NOT NULL,
  created_at timestamptz DEFAULT now()
);

Kein ENABLE ROW LEVEL SECURITY. Kein CREATE POLICY. Das Schema kennt Mandanten über die user_id-Spalte, erzwingt aber nichts.

Beide Seiten haben vertretbare Gründe. Der SQL-Pfad stellt sich einem neuen Projekt nicht in den Weg. In unserem Prompt stand nichts von Row Level Security, und Lovable generierte, was verlangt war. Am Ende stehen ein funktionierendes Dashboard, Code, der nach Mandantenfähigkeit aussieht, und eine Datenbank, die von Mandanten nichts weiß.

Der Fix: Drei SQL-Statements schalten Row Level Security ein

Ein ALTER und zwei Policies bringen die Datenbank in Einklang mit dem Datenmodell, das sie nur vorgibt zu haben:

-- 1. Enable RLS on the table
ALTER TABLE invoices ENABLE ROW LEVEL SECURITY;

-- 2. Allow users to read only their own rows
CREATE POLICY "Users read own invoices"
  ON invoices
  FOR SELECT
  USING (auth.uid() = user_id);

-- 3. Allow users to insert only rows owned by themselves
CREATE POLICY "Users insert own invoices"
  ON invoices
  FOR INSERT
  WITH CHECK (auth.uid() = user_id);

Die USING-Klausel greift bei SELECT (und auf der Leseseite von UPDATE und DELETE). Sie ist nur für Zeilen wahr, bei denen auth.uid(), die Supabase-Funktion für die User-ID aus dem JWT, zur user_id-Spalte passt. Alle anderen Zeilen fallen lautlos weg.

Die WITH CHECK-Klausel greift bei INSERT und UPDATE. Sie lehnt jede Zeile ab, deren user_id nicht zum authentifizierten Nutzer passt. Das blockiert den anderen häufigen Bug: Clients, die beim Insert eine fremde user_id setzen.

Das Gleiche wiederholt man für customers und jede weitere mandantenabhängige Tabelle. Wo nötig, kommen UPDATE- und DELETE-Policies nach demselben Muster dazu.

Danach kommt derselbe anon-Key-Aufruf leer zurück, und auch Bobs Zeilen mit Alices JWT abzufragen liefert nichts. Der API-Exploit von oben funktioniert nicht mehr, obwohl der fehlerhafte Handler noch im Code steht. Die Datenbank lehnt ab.

Ein zweiter Fix: Schreiben Sie den Negativtest

Der Negativtest, der diesen Bug von Anfang an gefunden hätte:

// __tests__/rls.test.ts
import { describe, it, expect } from 'vitest'
import { createClient } from '@supabase/supabase-js'

describe('RLS enforcement on invoices', () => {
  // A client authenticated as Alice: the public anon key plus Alice's access
  // token. PostgREST runs the query as the `authenticated` role with
  // auth.uid() resolving to Alice's id, exactly what a stranger's browser does.
  const alice = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
    global: { headers: { Authorization: `Bearer ${ALICE_ACCESS_TOKEN}` } },
  })

  it("user A cannot read user B's invoices via direct query", async () => {
    const { data } = await alice
      .from('invoices')
      .select('*')
      .eq('user_id', BOB_USER_ID)

    expect(data).toEqual([])
  })

  it('user A cannot insert an invoice owned by user B', async () => {
    const { error } = await alice
      .from('invoices')
      .insert({ user_id: BOB_USER_ID, amount: 100, customer_email: 'x@x.com' })

    expect(error).toBeTruthy()
  })
})

Gegen die fehlerhafte Version der App wäre dieser Test bei der ersten Assertion rot geworden. Lovable hat ihn uns nicht geschrieben, und im Prompt stand auch nichts davon.

Eine Query zeigt, welche Tabellen noch ohne RLS laufen

Dafür muss man sich nicht Tabelle für Tabelle durchs Dashboard klicken:

SELECT schemaname, tablename, rowsecurity
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY rowsecurity, tablename;

rowsecurity ist wahr, wenn Row Security aktiviert ist. Jedes false in public braucht eine Begründung. Der Security Advisor von Supabase meldet denselben Zustand als Lint der Stufe Error, 0013_rls_disabled_in_public, mit der Warnung, dass jeder mit der Projekt-URL die Daten dieser Tabelle lesen, ändern und löschen kann. Beide Prüfungen sagen nur, dass RLS an ist. Eine USING (true)-Policy besteht diese Query und diesen Lint.

Ein unsicherer Waffenstillstand

RLS löst das Muster „falscher Nutzer liest falsche Zeile“. Mehrere benachbarte Probleme löst es nicht, und eine saubere Policy macht noch keine gehärtete mandantenfähige Datenbank. Das fängt RLS nicht ab:

  • Service-Role-Keys umgehen RLS komplett. Leakt das Client-Bundle den service_role-Key (auf neueren Projekten einen Secret Key), schützen die Policies oben nichts, denn diese Rolle hat BYPASSRLS. Derselbe Key in einem Route-Handler umgeht die Policies by Design, was ein eigener Befund ist. RLS zu reparieren, ohne geleakte Service-Keys zu rotieren, ist ein halber Fix.
  • Leaks über Joins. Hat invoices RLS, customers aber nicht, und die API joint beide, kommen die Kundenzeilen ungeschützt zurück. RLS gilt pro Tabelle, die Abdeckung muss vollständig sein.
  • Policies, die richtig aussehen und es nicht sind. Eine USING (true)-Policy sieht aus wie eine Policy und lässt alles durch. Eine Policy, die user_id mit einem nicht existierenden JWT-Claim vergleicht, lässt still gar nichts durch, und das wird oft „repariert“, indem man sie lockert. Damit ist der Zweck dahin.
  • Performance. RLS-Policies ohne Index können aus günstigen Queries Table Scans machen. Ein Rollout kann das Security-Problem lösen und am selben Nachmittag das Latenzbudget sprengen.
  • Storage ist eine eigene Grenze. RLS schützt Tabellenzeilen, keine gespeicherten Dateien. Ein öffentlicher Supabase-Storage-Bucket oder ein von der App geöffneter S3-Bucket liefert Dokumente an jeden mit der URL aus, egal wie streng die Zeilen-Policies sind. Öffentliche S3-Buckets sind derselbe Fehler eine Schicht weiter.
  • Lovable-Security endet nicht beim eigenen Schema. CVE-2025-48757 beschreibt unzureichende RLS in von Lovable generierten Sites bis zum 15. April 2025. Lovable bestreitet das mit der Begründung, jeder Kunde sei selbst für den Schutz der Daten seiner Anwendung verantwortlich. Lovables Dokumentation beschreibt inzwischen einen Quick Scan, der nach Tabellen ohne Row Level Security sucht; ob er diese Referenz-App melden würde, haben wir nicht getestet. Ein Fehler in der Plattform selbst ist noch einmal eine andere Grenze, wie das 76-Tage-Datenleck bei Lovable zeigt.

Unser Audit für eine App in diesem Zustand würde den API-Bug, die fehlende RLS, die fehlenden Policies im Schema und mindestens drei der Folge- und Randprobleme oben melden. Die drei Statements sind der Punkt, an dem diese Arbeit anfängt.

Die Spalten behaupten Mandantenfähigkeit, die Datenbank nicht

Eine mit Lovable gebaute App mit user_id-Spalten sieht mandantenfähig aus. Das Datenmodell sagt es. Der Query-Code sagt es. Die Datenbank tut es im Default nicht.

Wenn Sie das für Ihre eigene App wollen

Dreißigminütiges Audit, kostenlos. Wir rufen dieselben Endpunkte per curl auf und lesen dieselben Dateien. Liste in Ihrem Postfach binnen achtundvierzig Stunden.

Kostenloses Audit buchen