Lovable-App prüfen lassen - Wir prüfen Datenzugriff, Funktionen, Geheimnisse und Betrieb Ihrer Lovable-App, greifen auf Wunsch eine Testinstanz an und liefern bestätigte Befunde mit Beleg. Erstgespräch buchen · Pentest zum Festpreis
Lovable erzeugt aus einer Beschreibung eine lauffähige Webanwendung mit Datenbank, Anmeldung und Dateiablage. Wer damit echte Nutzer und echte Daten bedient, trägt die Verantwortung für die Zugriffsregeln der App. Dieser Beitrag zeigt, woraus eine Lovable-App besteht, welche Lücken die Dokumentation von Lovable und Supabase selbst nennen, welche Fälle öffentlich dokumentiert sind und wie Sie die App vor dem Go-live selbst prüfen. Stand: 19. November 2026.
Inhaltsverzeichnis
- Lovable App Sicherheit: kurz beantwortet
- Wie eine Lovable-App aufgebaut ist
- Die häufigsten Lücken in Lovable-Apps
- Dokumentierte Berichte und Vorfälle
- Prüfliste vor dem Go-live
- Was Lovables eigene Sicherheitsprüfung abdeckt und was nicht
- DSGVO: was technisch zu klären ist
- Verbreitete Irrtümer
- Stand und Methodik
- Unser Vorgehen bei WZ-IT
- Weiterführende Guides
Lovable App Sicherheit: kurz beantwortet
Die Plattform und die damit gebaute App sind zwei verschiedene Dinge. Lovable betreibt die Plattform und bietet Sicherheitsprüfungen an. Für die App, ihre Datenzugriffsregeln, Funktionen und Geheimnisse ist der Betreiber verantwortlich: Laut Lovable-Dokumentation sind Sie dafür verantwortlich, dass Ihre App die für ihren Einsatz angemessenen Sicherheitsanforderungen erfüllt. Supabase beschreibt die Verantwortung für das Backend als geteilt (Shared Responsibility Model): Zugriffsrechte, Daten und Geheimnisse liegen beim Kunden. Das beschreibt die technische und vertragliche Aufgabenverteilung zwischen Plattform und Betreiber, keine abschließende Aussage zur Haftung.
| Frage | Antwort |
|---|---|
| Wer verantwortet die App? | Der Betreiber für Zugriffsregeln, Funktionen und Geheimnisse der App (Lovable: Security overview, Supabase: Shared Responsibility Model) |
| Häufigste Lücke laut Lovable | Fehlende oder zu weite Row-Level-Security-Regeln (Lovable: Supabase-Integration: "Missing RLS policies are the most common way app data gets exposed") |
| Ist der Schlüssel im Browser-Code ein Leck? | Nein, wenn es der publishable Key ist. Der Secret- oder service_role-Key darf nie dorthin (Supabase: API keys) |
| Was prüft Lovable selbst? | Quick Scan bei jedem Veröffentlichen, Deep Scan auf Anforderung. Beide können laut Lovable keine vollständige Sicherheit garantieren |
| Was tun vor dem Go-live? | Prüfliste abarbeiten. Bei sensiblen Daten empfiehlt Lovable eine zusätzliche professionelle Prüfung |
Wie eine Lovable-App aufgebaut ist
Laut Lovable-Dokumentation besteht eine App aus drei Schichten. Das Sicherheitsmodell folgt dieser Trennung.
| Schicht | Was dort läuft | Folge für die Sicherheit |
|---|---|---|
| Frontend | Läuft im Browser des Nutzers und kann dort eingesehen und verändert werden | Keine Sicherheitsentscheidungen und keine Geheimnisse im Frontend |
| Backend-Code | Serverseitig als Edge Functions bei älteren React-Vite-Apps, bei neuen Apps ab 13. Mai 2026 (TanStack Start) als Serverfunktionen und API-Routen in der App. Eine auf TanStack Start umgestellte App kann beides enthalten (Lovable: Edge functions) | Jede Funktion ist von außen aufrufbar und muss den Aufrufer prüfen |
| Datenbank | PostgreSQL mit Row Level Security (RLS) | RLS erzwingt den Datenzugriff für Anfragen aus dem Browser |
Dazu kommen Authentifizierung über Supabase Auth und Dateiablage in Storage-Buckets. Das Backend gibt es in zwei Varianten (Lovable: Supabase-Integration):
| Lovable Cloud (in der Doku: built-in backend) | Eigenes Supabase-Projekt | |
|---|---|---|
| Grundlage | Nutzt laut Lovable die Open-Source-Grundlage von Supabase (Lovable: Built-in backend) | Supabase-Konto und -Projekt des Betreibers |
| Verwaltung | Ansichten Database, Users und Storage in Lovable | Supabase-Dashboard |
| Backups, Instanzgröße, Pausieren | Infrastruktur von Lovable betrieben, Wiederherstellung von Backups, Instanzgröße und Pausieren steuert der Betreiber in Lovable | Vom Betreiber im Supabase-Dashboard verwaltet |
| Wechsel | Zu einem eigenen Supabase-Projekt nur manuell per Export und Wiederherstellung | Zurück zum eingebauten Backend derzeit nicht unterstützt (Lovable: Built-in backend) |
Zum Zugriffsmodell: Die Seiten der App sprechen die Datenbank mit einem publishable Key an. Den Schlüssel kann jeder Nutzer der App sehen, das ist laut Lovable beabsichtigt, weil er keine privilegierten Rechte gibt. Welche Daten eine Anfrage erreicht, bestimmt die Postgres-Rolle (Supabase: API keys):
| Schlüssel | Nutzer angemeldet | Postgres-Rolle | RLS gilt |
|---|---|---|---|
| Publishable Key | Nein | anon |
Ja |
| Publishable Key | Ja | authenticated |
Ja |
Secret Key (löst den Legacy-Key service_role ab), Anfrage ohne Benutzer-Token |
Nein | service_role |
Nein, die Rolle umgeht die Policies |
| Secret Key, Anfrage mit Benutzer-Token | Ja | Rolle des angemeldeten Nutzers | Ja, es gelten die Policies dieses Nutzers (Supabase: RLS) |
Publishable und Secret Key sind neue Schlüsseltypen. Die Legacy-Keys anon und service_role bleiben parallel gültig, bis sie im Dashboard deaktiviert werden (Supabase: API keys).
Eine Policy, die nur authenticated prüft, gibt laut Lovable jedem angemeldeten Nutzer denselben Zugriff auf alle Zeilen, die sie abdeckt. Um Nutzerdaten zu trennen, muss die Policy den Anfragenden mit einer Angabe in der Zeile vergleichen, etwa dem Eigentümer.
Die häufigsten Lücken in Lovable-Apps
Die Tabelle nennt Lücken, die die Dokumentation von Lovable und Supabase selbst als Risiko beschreiben. Die Reihenfolge ist keine Häufigkeitsrangfolge. Die Prüfung "von außen" meint Anfragen mit dem publishable Key, wie sie jeder Besucher der App stellen kann.
| Lücke | Woran man sie erkennt | Behebung |
|---|---|---|
| RLS fehlt oder ist zu weit | Eine Tabelle ohne RLS ist für jede Rolle mit Grant les- und schreibbar (Supabase: RLS). Der Security Advisor meldet "Table publicly accessible" (Lint 0013, ERROR) und "Security policy allows unrestricted access" für USING (true) (Lint 0024, WARN) (Supabase: Advisors). Lovables Quick Scan meldet Tabellen ohne Zeilenschutz und Regeln, die jeden durchlassen (Lovable). Von außen: Abfrage ohne Anmeldung liefert Daten |
RLS auf jeder Tabelle in exponierten Schemas aktivieren, Grants für anon und authenticated auf das Nötige begrenzen, je Operation eine Policy schreiben und mit supabase test db Positiv- und Negativfälle testen (Supabase: RLS) |
| Policy prüft nur die Anmeldung, nicht den Eigentümer | Ein zweites Konto kann Daten des ersten lesen oder ändern. Policies, die user_metadata auswerten, meldet der Advisor (Lint 0015, ERROR): Nutzer können diese Angabe selbst ändern (Supabase: Advisors) |
Policy vergleicht die Nutzer-ID aus dem Token mit der Eigentümerspalte, zum Beispiel (select auth.uid()) = user_id (Supabase: RLS). Rollen und Mandanten nicht aus user_metadata ableiten |
| Secret- oder service_role-Key im Browser oder Repository | Bundle, Repository und Git-Historie enthalten service_role, sb_secret_ oder lange JWT-Strings. Der Key umgeht RLS, solange die Anfrage kein Benutzer-Token mitsendet, mit Token gelten die Policies des Nutzers (Supabase: RLS). Ein geleakter Key bleibt in beiden Fällen kritisch. Im Browser weist Supabase ihn mit HTTP 401 ab, "an attacker can still use the key from other tools" (Supabase: API keys) |
Key rotieren und nur in serverseitigem Code verwenden. Lovable: den Service-Role-Key nie in Browser-Code einsetzen (Lovable: Database access). Legacy-Keys nach der Umstellung im Dashboard deaktivieren |
| Geheimnisse im Frontend-Bundle | Variablen mit dem Präfix VITE_ werden zur Build-Zeit in das Browser-Bundle eingebettet (Lovable: Secrets). Der Deep Scan meldet Geheimnisse im Quellcode und Repository (Lovable) |
Private Werte (Zahlungs-, KI- und Dienstschlüssel) als Secrets im Backend ablegen und über serverseitigen Code verwenden. Offengelegte Schlüssel beim Anbieter erneuern |
| Zugriff auf fremde Datensätze über die API | Objekt-ID in der Anfrage austauschen: Liefert die API Daten eines anderen Kontos? OWASP führt das als API1:2023 Broken Object Level Authorization. Lovables Deep Scan sucht Nutzer, die fremde Daten sehen oder ändern können, auch in Servercode, der die Datenbankregeln umgeht (Lovable) | Eigentumsprüfung je Objekt in Policy oder Servercode. Servercode soll als der Nutzer handeln statt mit privilegiertem Zugriff (Lovable: Database access). Ein Admin-Client ohne Filter nach der Nutzer-ID liefert die Zeilen aller Nutzer (Supabase: Securing Edge Functions) |
| Views und Datenbankfunktionen umgehen RLS | Views umgehen RLS standardmäßig (Supabase: RLS). Der Advisor meldet "View bypasses row-level security" (Lint 0010) und ohne Anmeldung aufrufbare SECURITY-DEFINER-Funktionen (Lint 0028) (Supabase: Advisors) | Views mit security_invoker=on anlegen. Bei Funktionen EXECUTE entziehen, auf SECURITY INVOKER umstellen oder aus dem exponierten Schema verschieben |
| Ungeschützte Edge Functions und Serverfunktionen | Wer die Adresse einer Server- oder Edge-Funktion kennt, kann sie aufrufen. Jede Funktion muss den Absender prüfen (Lovable: Edge functions). Der Deep Scan meldet Funktionen und Routen, die jeder auslösen kann (Lovable) | Auth-Modus je Funktion festlegen. Bei Funktionen für angemeldete Nutzer verify_jwt aktiv lassen: Abschalten entfernt die Plattformprüfung. Für Webhooks, Aufrufe mit Secret Key und öffentliche Funktionen wie Health-Checks nennt Supabase verify_jwt = false. Die Funktion muss den Aufrufer dann selbst prüfen, etwa über die Signaturprüfung des Anbieters (Supabase: Securing Edge Functions). Aufrufe nur mit API-Key im Code autorisieren, denn verify_jwt allein authentifiziert sie nicht (Supabase: API keys) |
| Offene Storage-Buckets | Dateien in öffentlichen Buckets kann jeder mit der URL öffnen (Lovable: Storage). Der Advisor meldet "Public bucket allows listing" (Lint 0025, WARN), wenn ein öffentlicher Bucket zusätzlich eine zu breite SELECT- oder ALL-Policy auf storage.objects hat: Clients können dann die Dateien auflisten. Ein öffentlicher Bucket allein löst die Warnung nicht aus (Supabase: Advisors) |
Buckets privat halten, sofern die Dateien nicht öffentlich sein sollen, und Zugriff über Policies auf storage.objects steuern (Supabase: Storage Access Control). Bei öffentlichen Buckets die breite SELECT-Policy entfernen: Die Datei-URLs funktionieren weiter. Öffentliche Buckets sind in Lovable standardmäßig gesperrt, Workspace-Admins können die Sperre aufheben |
| Fehlende Rate Limits, missbrauchbare Endpunkte | OWASP führt fehlende Limits als API4:2023 Unrestricted Resource Consumption. Lovables Deep Scan sucht Funktionen und Routen, mit denen jeder hochladen oder Nachrichten senden kann (Lovable) | Supabase Auth begrenzt Endpunkte standardmäßig: Registrierung, Passwort-Zurücksetzen, Magic-Link- und OTP-Anfragen auf 30 Anfragen je 5 Minuten und IP, den Token-Endpunkt (Anmeldung mit Passwort, Token-Erneuerung) auf 150 Anfragen je 5 Minuten und IP, jeweils mit kurzen Spitzen bis 30 Anfragen, und mit dem eingebauten Mailanbieter auf 2 E-Mails pro Stunde. Zusätzlich gilt je Nutzer standardmäßig eine Wartezeit von 60 Sekunden, bevor eine neue OTP-, Magic-Link-, Registrierungsbestätigungs- oder Passwort-Reset-Anfrage zulässig ist (Supabase: Rate limits). Eigene Limits für die Data API laufen über Pre-Request-Funktionen (Supabase: Securing your API). CAPTCHA für Registrierung, Anmeldung und Passwort-Reset ist verfügbar (Supabase: Production checklist) |
| Auth-Einstellungen aus der Testphase | Lovable rät, die E-Mail-Bestätigung zum Testen abzuschalten und vor dem Start wieder zu aktivieren (Lovable: Supabase-Integration). Die Supabase-Checkliste führt aktivierte E-Mail-Bestätigungen als Punkt auf. Der Quick Scan meldet ausgeschalteten Leaked-Password-Schutz (Lovable) | Einstellungen nach der Supabase-Checkliste setzen: E-Mail-Bestätigung an, Test-Rufnummern entfernt, OTP-Gültigkeit höchstens 3600 Sekunden, Custom SMTP für Auth-E-Mails |
| Abhängigkeiten mit bekannten Schwachstellen | Lovables Dependency Audit macht nur kritische Schwachstellen zu Befunden. Kritische mit niedrigem EPSS-Wert oder bestätigter Nichtbetroffenheit bleiben nur als Markierung in der Liste (Lovable) | Abhängigkeitsliste aus der Security-Ansicht als JSON-Bericht oder SBOM prüfen (Lovable: Security view), Pakete aktualisieren und das Audit erneut auslösen |
Dokumentierte Berichte und Vorfälle
Die folgenden Fälle sind in Primär- oder Fachquellen belegt. Die Tabelle gibt Gegenstand, Stand laut Lovable und Quelle wieder. Das Datum nennt den Tag des Ereignisses oder der zentralen Quelle der Zeile, weitere Quellen derselben Zeile können abweichend datiert sein. Die Angaben zu den Fällen vom Februar und April stammen aus The Register und den dort wiedergegebenen Stellungnahmen und wurden nicht unabhängig reproduziert. Zahlen sind Angaben der jeweiligen Autoren und wurden nicht unabhängig überprüft. Sie sagen nichts über die Lage in Ihrer App.
| Datum | Gegenstand | Stand laut Lovable | Quelle |
|---|---|---|---|
| 30.05.2025 | CVE-2025-48757: Eintrag im NVD zu unzureichenden Row-Level-Security-Regeln in Lovable bis 15.04.2025, durch die Angreifer ohne Anmeldung beliebige Tabellen generierter Seiten lesen oder schreiben konnten. Als disputed markiert. Die Entdecker nennen für den 21.03.2025 verwundbare Endpunkte in 170 von 1.645 geprüften Projekten (rund 10 %). Die Autoren nennen Replit als ihre Organisation | Der NVD-Vermerk gibt die Position des Lieferanten wieder: Jeder Kunde sei selbst für den Schutz der Daten seiner App verantwortlich. Der Changelog nennt am 25.04.2025 einen Security Scan beim Veröffentlichen für Apps mit Supabase-Anbindung. Der Eintrag nennt keine korrigierte Version | NVD, Bericht der Entdecker, Lovable-Changelog |
| 27.02.2026 | Laut The Register eine auf Lovables Discover-Seite gezeigte App mit 16 gemeldeten Schwachstellen, laut dem Forscher 18.697 Nutzerdatensätze abrufbar. Eine Datenbankfunktion sperrte angemeldete Nutzer und ließ nicht angemeldete durch. Der Forscher sieht auch Lovable in der Verantwortung | Lovables CISO laut The Register: Der Eigentümer sei kontaktiert worden. Der kostenlose Scan vor dem Veröffentlichen gebe Empfehlungen, ihre Umsetzung liege beim Nutzer. Das Projekt enthalte nicht von Lovable erzeugten Code, die Datenbank werde nicht von Lovable gehostet | The Register |
| 21.04.2026 | Laut The Register meldete ein Forscher am 20.04.2026, dass kostenlose Konten Chatverläufe und Quellcode öffentlicher Projekte anderer Nutzer lesen konnten, laut Forscher einschließlich Zugangsdaten im Quellcode | Lovable (Beiträge auf X, zitiert von The Register): Es habe keinen Datenabfluss gegeben, die eigene Dokumentation zu "public" sei unklar gewesen. "public" habe Chat und Code eines Projekts öffentlich gemacht. Der Chat-Zugriff auf öffentliche Projekte sei im Februar 2026 beim Vereinheitlichen der Berechtigungen versehentlich wieder aktiviert und nun zurückgenommen worden. Laut Lovable-Dokumentation gilt für neue Projekte seit dem 06.11.2025 Workspace-Sichtbarkeit als Standard, für alle Workspaces seit Dezember 2025. Seit dem 22.04.2026 ist die öffentliche Sichtbarkeit entfernt, bestehende öffentliche Projekte wurden auf Workspace-Sichtbarkeit gestellt | The Register, Lovable: Project access |
| 14.11.2026 | Lovables Head of Security äußert sich in einer Hacker-News-Diskussion zu einem veröffentlichten Bericht, der Lovable-Apps mit offen abrufbaren Daten beschreibt. Der Bericht und seine Zahlen sind hier nicht ausgewertet (siehe Stand und Methodik) | Lovables Head of Security (Selbstangabe im Kommentar, Hacker News, 14.11.2026 UTC): Ursache in diesen Apps sei unzureichende Row-Level Security, wofür die Scans gebaut seien. Genannt werden Scan vor dem Veröffentlichen, Fix-Funktion, Auto-Fix und die Sperre für Veröffentlichungen mit kritischen Befunden. Ein Blogbeitrag vom 10.11.2026 nennt zu offene Datenzugriffsregeln als häufigstes Problem in Lovable-Apps und kündigt eine überarbeitete Sicherheitsansicht und geplante Scans für alle bezahlten Pläne an | Hacker News: Kommentar, Hacker News: Diskussion, Lovable-Blog |
Einschätzung: Die Fälle vom 30.05.2025, 27.02.2026 und 14.11.2026 betreffen nach den Quellen und nach Lovables Angaben Zugriffsregeln einzelner Apps und damit vor allem den Teil, den der Betreiber verantwortet. Die Zuordnung ist nicht unstrittig: Der Eintrag zu CVE-2025-48757 ist als disputed markiert, und der Forscher im Februar-Fall sieht auch Lovable in der Verantwortung. Der Fall vom 21.04.2026 betrifft laut Bericht die Plattform und ist ein anderes Risiko. Betreiber können dort vorsorgen, etwa indem sie keine Geheimnisse in Quellcode und Chat ablegen und den Projektzugriff restriktiv halten. Ob das genügt, lässt sich aus den Quellen nicht ableiten.
Prüfliste vor dem Go-live
Diese Liste richtet sich an Betreiber, die die Grundprüfungen selbst durchführen. Sie ersetzt keine Prüfung durch Dritte. Quellen zu den einzelnen Punkten stehen in den Abschnitten oben.
- Backend und Region feststellen. Lovable Cloud oder eigenes Supabase-Projekt? Bei Lovable Cloud steht die Region unter More, Database, Manage, Settings (Lovable: Database).
- Alle erreichbaren Objekte auflisten. Tabellen, Views, Funktionen und Buckets. Neue Objekte im Schema
publicerhalten je nach Alter des Projekts und Einstellung der Data API automatisch Rechte für alle drei Rollen und sind damit über die Data API erreichbar, auch wenn das nicht beabsichtigt ist (Supabase: Securing your API). - RLS auf jeder Tabelle aktivieren und die Grants für
anonundauthenticatedauf das Nötige begrenzen. - Policies lesen. In Lovable unter More, Database, Manage, Policies (Lovable: Database access). Kein
USING (true)auf nicht öffentlichen Daten, keinuser_metadata, bei Nutzerdaten ein Vergleich mit dem Eigentümer oder Mandanten. Öffentliche Daten sind eine bewusste Ausnahme. - Test ohne Anmeldung. Jede Tabelle mit dem publishable Key abfragen, Beispiel unter der Liste.
- Zwei-Konten-Test. Mit Konto A anmelden und versuchen, Daten von Konto B zu lesen, zu ändern und zu löschen. Dasselbe mit einem normalen Nutzer gegen Admin-Funktionen.
- Schlüssel suchen. Build-Ordner, Repository und Git-Historie nach
service_role,sb_secret_und langen JWT-Strings durchsuchen. Nach einer Umstellung auf neue Schlüssel die Legacy-Keys im Supabase-Dashboard deaktivieren, sie bleiben sonst gültig (Supabase: API keys). - Geheimnisse prüfen. Private Werte nur als Secrets im Backend, keine
VITE_-Variablen für Privates, keine Schlüssel in Tabellen oder im Chat (Lovable: Secrets). - Funktionen prüfen. Prüft jede Edge Function und Serverfunktion, wer sie aufruft? Bei Funktionen für angemeldete Nutzer
verify_jwtaktiv? Bei abgeschaltetemverify_jwt(Webhooks, Aufrufe mit Secret Key, Health-Checks) prüft die Funktion den Aufrufer selbst, etwa per Signaturprüfung? Admin-Client nur dort, wo Zugriff über die Nutzerrechte hinaus nötig ist, und dann mit Filter nach der Nutzer-ID? - Views und SECURITY-DEFINER-Funktionen prüfen. Views mit
security_invoker=on, keine ohne Anmeldung aufrufbaren Funktionen mit erhöhten Rechten. - Storage prüfen. Buckets privat, außer die Dateien sollen öffentlich sein. Policies nach Eigentümer oder Pfad, keine zu breite SELECT-Policy auf öffentlichen Buckets.
- Auth-Einstellungen prüfen. E-Mail-Bestätigung an, Test-Rufnummern entfernt, OTP-Gültigkeit höchstens 3600 Sekunden, Custom SMTP für Auth-E-Mails, Leaked-Password-Schutz an, Rate Limits und CAPTCHA geprüft (Supabase: Production security checklist).
- Abhängigkeiten prüfen. Dependency Audit in der Security-Ansicht, Liste exportieren, Pakete aktualisieren.
- Scans ausführen. Quick Scan und Deep Scan in Lovable, bei eigenem Supabase-Projekt zusätzlich den Security Advisor. Jeden Befund einzeln bewerten, ignorierte Befunde mit Begründung festhalten.
- Zugänge sichern. Mehrfaktor-Anmeldung für das Supabase-Konto: Bei Anmeldung über GitHub ist es die Zwei-Faktor-Anmeldung auf GitHub, bei Anmeldung mit E-Mail und Passwort die MFA im Supabase-Konto. Dazu mehr als ein Owner in der Supabase-Organisation (Supabase: Production security checklist). Auch das Lovable-Konto kennt eine Zwei-Faktor-Anmeldung (Lovable: Account settings). Projektzugriff im Lovable-Editor restriktiv halten: Er umfasst Quellcode und Chatverlauf (Lovable: Project access).
- Nach Änderungen wiederholen, etwa wenn Funktionen hinzukommen, sich die Anmeldung oder der Datenzugriff ändern oder externe Anbindungen eingeführt werden. Lovable rät, die Sicherheitspraktiken in diesen Fällen erneut zu prüfen (Lovable: Security best practices). Bei Änderungen am Datenmodell ist das nach unserer Einschätzung ebenfalls sinnvoll.
Beispiel zu Punkt 5: Abfrage ohne Anmeldung
Nur gegen die eigene App ausführen. Projekt-URL und publishable Key stehen in der .env des Projekts als VITE_SUPABASE_URL und VITE_SUPABASE_PUBLISHABLE_KEY (Lovable: Secrets). Der Key gehört in den Header apikey (Supabase: API keys).
curl -s "$SUPABASE_URL/rest/v1/<tabelle>?select=*&limit=5" \
-H "apikey: $PUBLISHABLE_KEY"
Für nicht öffentliche Tabellen sollte die Antwort eine leere Liste oder ein Berechtigungsfehler sein: Eine Policy ohne Treffer liefert ein leeres Ergebnis, ein fehlender Grant einen Berechtigungsfehler (Supabase: API keys). Jede Antwort mit echten Datensätzen ist ein Befund.
Was Lovables eigene Sicherheitsprüfung abdeckt und was nicht
Alle Angaben stammen aus der Security-Dokumentation von Lovable und der Seite zur Security-Ansicht.
| Prüfung | Wann sie läuft | Was sie abdeckt | Was sie nicht abdeckt |
|---|---|---|---|
| Quick Scan | Automatisch bei jedem Veröffentlichen, kostenlos | Datenbankregeln (Tabellen ohne Zeilenschutz, Regeln, die jeden durchlassen, Leaked-Password-Schutz, Storage-Regeln), bekannte Schwachstellen in npm-Abhängigkeiten, MCP-Server ohne Anmeldung | Anwendungscode. Als Befund erscheinen nur kritische Schwachstellen in Abhängigkeiten, manche davon nur als Markierung in der Liste |
| Deep Scan | Auf Anforderung in der Security-Ansicht oder im Chat, kostenlos. Geplante Deep Scans laut Dokumentation nur im Enterprise-Plan | Gesamter Anwendungscode: Zugriffskontrolle, Endpunkte ohne Anmeldung, unsichere Eingaben und Injection, Geheimnisse, Zahlung, Authentifizierung, personenbezogene Daten in Fehlermeldungen und Logs | Läuft nicht automatisch während der Arbeit |
| Konversationelle Prüfung ("Review my app's security") | Auf Anforderung im Chat, verbraucht Credits | Startet Quick Scan und Deep Scan und erklärt die Ergebnisse im Chat | Umfang und Tiefe hängen vom Projekt ab |
| Auto-Fix | Optional je Workspace und Projekt | Behebt geeignete Quick-Scan-Befunde beim Bauen, etwa gängige RLS-Fehlkonfigurationen und Abhängigkeiten | Befunde des Deep Scans |
| Optionale Anbindungen externer Sicherheitsdienste | Von Workspace-Admins verbunden | Lovable dokumentiert optionale Anbindungen an externe Sicherheitsdienste, etwa für statische Analyse von Code und Abhängigkeiten und für dynamische Tests gegen die laufende App (Lovable: Security overview) | Nicht im Standardumfang |
Die Grenzen nennt Lovable selbst:
- Die Werkzeuge "cannot guarantee complete security" und ersetzen keine gründliche Sicherheitsprüfung. Für Apps mit sensiblen Daten oder kritischen Funktionen empfiehlt Lovable eine zusätzliche professionelle Prüfung.
- "No issues found" bedeutet, dass der letzte Scan nichts gefunden hat. Der Scanner könne nicht jedes Risiko erkennen (Lovable: Security view).
- Scan-Ergebnisse gelten für eine bestimmte Version des Codes. Nach Änderungen sind sie veraltet.
Einschätzung: Ob eine Regel zu Ihrem Geschäftsmodell passt, etwa wer in Ihrer Mandantenstruktur was sehen darf, lässt sich aus dem Code nur teilweise ableiten. Das prüft ein Test mit mehreren Konten und Rollen.
DSGVO: was technisch zu klären ist
Dieser Abschnitt ist keine Rechtsberatung. Er nennt die technischen Punkte, die Ihr Datenschutzbeauftragter oder Ihre Kanzlei als Eingabe braucht. Eine pauschale Aussage für Lovable oder für eine damit gebaute App gibt es nicht.
| Thema | Was die Herstellerdokumentation sagt | Was zu klären ist |
|---|---|---|
| Standort des Backends | Lovable Cloud: Region Americas, Europe oder Asia Pacific, gewählt beim Aktivieren des Backends, danach nicht änderbar. Innerhalb der Region verteilt Lovable neue Projekte auf verfügbare Rechenzentren. Länderspezifische Regionen nur im Enterprise-Plan auf Anfrage (Lovable: Built-in backend, Lovable: Privacy & security settings). Eigenes Supabase-Projekt: Sammelregion Europe umfasst auch London und Zürich, eine bestimmte EU-Region legt den Standort genau fest. Die Regionswahl sei "a data-location control, not proof of regulatory compliance" (Supabase: Regions) | Welche Region hat die bestehende App? Reicht Europe oder muss es eine bestimmte EU-Region sein? Ein späterer Wechsel erfordert Export und Migration |
| Weitere Verarbeitung | Das Frontend wird immer weltweit ausgeliefert, die Regionseinstellung betrifft nur Backend-Daten (Lovable: Hosting). Die Region gilt nicht für KI-Anfragen, dafür gibt es im Enterprise-Plan EU inference (Lovable: Built-in backend). Backups, Logs, Exporte, Edge-Function-Ausführung und Unterauftragsverarbeiter können Datenresidenz und Drittlandübermittlung beeinflussen (Supabase: GDPR) | Datenflüsse in einer Übersicht erfassen, auch KI-Funktionen, E-Mail-Versand und Zahlungsanbieter |
| Auftragsverarbeitung | Lovable: DPA in Business und Enterprise enthalten, Unterauftragsverarbeiter auf einer eigenen Seite, EU-Standardvertragsklauseln für Übermittlungen außerhalb des EWR, die nicht durch einen Angemessenheitsbeschluss abgedeckt sind. Der Kunde bleibt für seine Konfigurations- und Designentscheidungen verantwortlich und darf nach der DPA (Section 3.8) keine als sensibel eingestuften Daten bereitstellen, etwa geschützte Gesundheitsinformationen nach HIPAA, Finanzkontonummern, amtliche Kennungen oder biometrische Daten (Lovable: DPA, Unterauftragsverarbeiter). Supabase stellt eine DPA bereit (Supabase: DPA) | Welcher Plan und welcher Vertrag gilt für Ihre App? Für andere Pläne als Business und Enterprise ist das vertraglich zu klären. Verarbeitet die App die oben genannten sensiblen Datenarten, ist die vertragliche Zulässigkeit vor dem Einsatz zu klären |
| Zugriffskonzept | RLS, Rollen und Schlüssel (siehe oben). Supabase-Konto: Mehrfaktor-Anmeldung laut Checkliste, bei Anmeldung über GitHub per GitHub-Zwei-Faktor-Anmeldung (Supabase: Production security checklist). Lovable-Konto: Zwei-Faktor-Anmeldung (Lovable: Account settings) | Wer darf Produktivdaten sehen? Wie wird das protokolliert? |
| Löschung | Das Löschen einer Datei wird an den Storage-Dienst gesendet, ein sofortiges Löschen vom Datenträger sichert Lovable nicht zu (Lovable: Storage). Das Entfernen der Datenbank löscht auch Backups, Nutzerkonten und Dateien (Lovable: Built-in backend) | Aufbewahrungs- und Löschfristen festlegen und technisch abbilden |
| Training | Seit 9. September 2026 dürfen Kundendaten (Prompts, Code, Projektdateien) aus Free und Pro zum Training verwendet werden, ein Opt-out ist im Konto möglich. Endnutzerdaten der Apps nicht. Business und Enterprise sind standardmäßig ausgenommen (Lovable: Training data) | Unsere Empfehlung: keine personenbezogenen Daten in Prompts und Testdaten verwenden, Opt-out prüfen |
Rechtsgrundlage, Informationspflichten, Verzeichnis der Verarbeitungstätigkeiten und eine mögliche Datenschutz-Folgenabschätzung sind rechtlich zu bewerten und nicht Gegenstand dieses Beitrags.
Verbreitete Irrtümer
| Irrtum | Richtig | Quelle |
|---|---|---|
| Der Supabase-Schlüssel im Browser-Code ist ein Leck | Publishable Key und URL sind für den Browser gedacht, den Schutz liefert RLS. Ein Secret- oder service_role-Key im Browser wäre ein Leck | Lovable, Supabase |
| Lovable sichert meine App ab | Die Plattform bietet Scans. Für die App ist der Betreiber verantwortlich | Lovable |
| Kein Befund im Scan heißt, die App ist sicher | "No issues found" heißt nur, dass der letzte Scan nichts gefunden hat. Der Quick Scan prüft keinen Anwendungscode | Lovable |
| RLS ist aktiviert, also sind die Daten geschützt | Grants und Policies müssen passen. USING (true) öffnet die Tabelle, Views und der Secret-Key (bei Anfragen ohne Benutzer-Token) umgehen RLS, eine Policy nur auf authenticated gibt allen Angemeldeten alles |
Supabase, Lovable |
| Serverseitiger Code ist automatisch geschützt | Auch Serverfunktionen sind von außen aufrufbar und müssen den Aufrufer prüfen | Lovable |
| Ein öffentlicher Bucket ist unproblematisch, die URL kennt niemand | Jeder mit der URL kann die Datei öffnen, bei breiten Policies lassen sich Dateien sogar auflisten | Lovable, Supabase |
| Liegen die Daten in der EU, ist alles geklärt | Die Regionswahl ist eine Kontrolle des Datenstandorts und kein Konformitätsnachweis | Supabase |
| CVE-2025-48757 ist ein Fehler, den ein Lovable-Update geschlossen hat | Der NVD-Eintrag ist als disputed markiert und nennt keine korrigierte Version. Maßgeblich ist die RLS-Konfiguration der eigenen App | NVD |
Stand und Methodik
Stand: 19. November 2026. Grundlage sind die Dokumentation von Lovable und Supabase (abgerufen am 19. November 2026, die datierten Supabase-Seiten tragen Änderungsdaten vom 1. Oktober bis 18. November 2026), der NVD-Eintrag zu CVE-2025-48757, Berichte von The Register, der Blogbeitrag von Lovable vom 10. November 2026 und ein Kommentar von Lovables Head of Security auf Hacker News. Berichte von Anbietern von Sicherheitsprüfungen verwenden wir nicht als Quelle, ein im November 2026 veröffentlichter Bericht über Lovable-Apps ist deshalb nicht ausgewertet. Bezeichnungen sind nicht einheitlich: Lovable Cloud heißt in der Dokumentation built-in backend, im Produkt kommen auch Cloud und Lovable backend services vor. Supabase führt die Schlüsseltypen publishable und secret ein, die Legacy-Schlüssel anon und service_role bleiben gültig, bis sie deaktiviert werden. Prüfen Sie Bezeichnungen und Menüpfade vor der Umsetzung gegen die aktuelle Dokumentation. Aussagen von Lovable sind als Angaben des Unternehmens wiedergegeben. Die ursprünglichen Beiträge auf X zum April-Fall wurden nicht eingesehen, die Angaben stammen aus The Register. Die Fälle vom Februar und April sind nicht unabhängig reproduziert. Wir haben für diesen Beitrag keine Lovable-Apps Dritter getestet, Zahlen aus Berichten sind Angaben der jeweiligen Autoren und nicht unabhängig überprüft. Einschätzungen sind als solche gekennzeichnet.
Unser Vorgehen bei WZ-IT
- Übergabe: Sie übergeben Quellcode, eine Testinstanz und Testkonten je Rolle und Mandant. Wir prüfen, dass die Anwendung Ihnen gehört.
- Audit: Das Production Readiness Audit prüft Code, Konfiguration, Datenzugriff und Betriebsreife und trennt, was vor dem Go-live zu beheben ist und was später. Ab 1.490 € netto.
- Pentest: Wir erstellen ein vollständiges Inventar aller Routen und greifen die Testinstanz an, nie das Produktivsystem. Bestätigte Befunde kommen mit Beleg. Jeder Befund trägt einen von vier Zuständen: bestätigt, widerlegt, Verdacht ohne Bestätigung oder nicht geprüft. Schwere bestätigte Befunde prüft das Team von Hand. Der Bericht enthält eine Abdeckungstabelle. Der Pentest liegt einmalig bei 1.000 bis 2.000 € netto, je nach Größe der Anwendung.
- Kombipaket: Audit plus Pentest ab 1.990 € netto für eine kleine Anwendung.
- Beheben und betreiben: Auf Wunsch beheben wir die Befunde und übernehmen Hosting und Betrieb (Übernahme einer Lovable-App, Betrieb KI-entwickelter Apps). Wer mit KI-Werkzeugen weiterentwickelt, kann Änderungen laufend prüfen lassen: AI Code Review ab 990 € netto im Monat.
Alle Preise: Stand November 2026, netto.
Weiterführende Guides
- Lovable-App prüfen lassen: Audit und Pentest
- KI-generierte App prüfen lassen
- Lovable-App übernehmen und betreiben
- Pentest für Webanwendungen und APIs
- Lovable, Bolt und v0 im Vergleich 2026
- Lovable Cloud zu Supabase migrieren
- Supabase RLS prüfen: Policies, Rollen und Mandantentrennung
Lovable-App vor dem Go-live prüfen lassen: Wir prüfen Zugriffsregeln, Funktionen, Geheimnisse und Betrieb, belegen bestätigte Befunde und beheben auf Wunsch. Lovable-App prüfen lassen · Erstgespräch buchen
Quellen
- Lovable: Security overview
- Lovable: Project security view
- Lovable: Security best practices for Lovable apps
- Lovable: Control who can access your app's data
- Lovable: Built-in backend
- Lovable: Database
- Lovable: Storage
- Lovable: Edge functions
- Lovable: Secrets
- Lovable: Connect to Supabase
- Lovable: Privacy & security settings
- Lovable: How Lovable hosts your app
- Lovable: Control project access
- Lovable: Account settings
- Lovable: Manage training data and privacy
- Lovable: Changelog (Eintrag vom 25. April 2025)
- Lovable: Data Processing Agreement
- Lovable: Unterauftragsverarbeiter (Trust-Portal)
- Lovable-Blog: Find it, fix it, ship it (10. November 2026)
- Supabase: Row Level Security
- Supabase: API keys
- Supabase: Securing your API
- Supabase: Advisors
- Supabase: Storage Access Control
- Supabase: Securing Edge Functions
- Supabase: Auth rate limits
- Supabase: Production Checklist
- Supabase: Production security checklist
- Supabase: Shared Responsibility Model
- Supabase: GDPR compliance and Supabase
- Supabase: Available regions
- Supabase: Data Processing Agreement
- NVD: CVE-2025-48757
- Bericht der Entdecker zu CVE-2025-48757
- The Register: Lovable-hosted app littered with basic flaws exposed 18K users (27. Februar 2026)
- The Register: Lovable denies data leak, cites intentional behavior (21. April 2026)
- Hacker News: Kommentar von Lovables Head of Security (14. November 2026, UTC)
- Hacker News: Diskussion zu einem Bericht über Lovable-Apps (14. November 2026)
- OWASP API Security Top 10 2023: API1 Broken Object Level Authorization
- OWASP API Security Top 10 2023: API4 Unrestricted Resource Consumption











