---
title: "Supabase RLS: var 4:e open source-app lämnar en tabell öppen"
description: "Jag körde migrationerna från 568 open source-projekt på Supabase och kollade säkerhet och RLS med 15 regler. 24 % lämnar en tabell alla kan läsa och ändra."
url: "https://madsalt.tech/sv/blog/open-source-supabase-projects-security-study/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/sv/about/"
language: "sv"
published: 2026-11-08
---

# Supabase RLS: var 4:e open source-app lämnar en tabell öppen

Kort sagt

Jag tog 1 170 publika GitHub-repon som innehåller Supabase-migrations, körde var och en på en ny Supabase-databas i en offline-sandlåda och körde samma 15 databasregler som min gratis kontroll kör på live-projekt. 568 projekt gick igenom utan fel: 15 624 tabeller i `public`. **134 av dem (23,6 %) har minst en tabell med RLS avstängt som den publika nyckeln kan läsa och ändra.** 8,8 % har en policy som låter en utloggad besökare uppdatera eller ta bort vilken rad som helst, 10,9 % låter dem lägga in vad som helst och 12,0 % exponerar en vy som hoppar över RLS. Projekt gjorda i Lovable lämnar färre tabeller utan RLS (9,1 %) men skriver `true` i policyer två till tre gånger så ofta. I ett projekt som skapats efter Supabase ändring den 30 oktober lämnar samma migrations 3,6 % öppna i stället för 22,7 %. Tre SQL-frågor i slutet visar var ditt eget projekt står.

De flesta råd om Supabase-säkerhet säger samma sak: slå på RLS, skriv policyer, kolla Advisor. Jag ville veta hur ofta riktiga projekt faktiskt gör fel, mätt på samma sätt varje gång, inte utifrån de få appar som folk postar på Reddit. Publika GitHub har tusentals Supabase-projekt med hela sin migrationshistorik, så jag byggde så många jag kunde och tittade på databasen som migrationerna lämnar efter sig.

## Hur testade jag 568 projekt?

Jag sökte på GitHub efter SQL-filer under `supabase/migrations` som innehåller `create table`, uppdelade efter filstorlek för att ta mig förbi söktaket. Det gav 8 914 repon, forkar undantagna. Därifrån tog jag ett fast pseudoslumpmässigt urval, sorterat efter en hash av reponamnet, och laddade bara ner migrationsmappen och `package.json` från vart och ett.

| Steg                                                                     | Projekt |
| ------------------------------------------------------------------------ | ------- |
| Repon med Supabase-migrations (GitHubs kodsökning, 7 november 2026)      | 8 914   |
| Nedladdat urval                                                          | 1 170   |
| Mätta, efter att exakta dubbletter tagits bort                           | 1 168   |
| Mallar och Supabase egna repon borttagna                                 | 9       |
| Migrations som stoppar med fel på en ny databas                          | 567     |
| Inga tabeller i `public`                                                 | 8       |
| Använder Supabase automatiska RLS-trigger (undantagna, se begränsningar) | 16      |
| **Analyserade**                                                          | **568** |

Varje projekt kördes i sin egen nya databas i en Docker-container utan nätverksåtkomst, byggd från en dump av en lokal Supabase-stack (CLI 2.109.1, Postgres 17.6, med de riktiga schemana `auth` och `storage`). Migrations kördes i filnamnsordning som rollen `postgres`, som inte är superuser på Supabase och som även `supabase db push` använder. Ingenting från ett repo kördes någonsin utanför den containern.

På den resulterande databasen körde jag katalogfrågorna och de 15 databasreglerna i min [Supabase-säkerhetskontroll](https://madsalt.tech/sv/tools/supabase-security-check/), oförändrade. Inställningar som finns utanför databasen, som e-postbekräftelse eller skydd mot läckta lösenord, syns inte i migrations, så de reglerna är utelämnade.

Nästan hälften av projekten stoppar med fel innan den sista migrationen. Vanliga orsaker är seed-data som pekar på användare som bara finns i skaparens eget projekt, objekt som skapats för hand i dashboarden och refereras senare, och migrations som aldrig fungerat på en ren databas. Jag redovisar bara projekt som gick igenom utan fel.

## Vad hittade jag?

![568 open source-projekt på Supabase: andel per fynd. Procent av projekten. Migrations körda på en ny databas, november 2026. RLS av, öppet för publika nyckeln: 23,60; Vy som hoppar över RLS: 12; Vem som helst kan lägga in vad som helst: 10,90; Känslig kolumn nåbar: 10; Vem som helst kan ändra eller radera: 8,80; Storage öppet för utloggade: 5,30; Policy litar på user_metadata: 0,70.](https://madsalt.tech/charts/sv/open-source-supabase-projects-security-study.svg)

*Källa: min studie av 1 168 publika GitHub-repon med Supabase-migrations, 568 av dem gick igenom utan fel, 7-8 november 2026.*

| Fynd                                                                                             | Alla (568) | Gjorda i Lovable (66) | Övriga (502) |
| ------------------------------------------------------------------------------------------------ | ---------- | --------------------- | ------------ |
| Minst en tabell med RLS avstängt som den publika nyckeln kan läsa och ändra                      | **23,6 %** | 9,1 %                 | 25,5 %       |
| En policy låter utloggade besökare uppdatera eller ta bort vilken rad som helst (`using (true)`) | **8,8 %**  | 15,2 %                | 8,0 %        |
| En policy låter utloggade besökare lägga in vad som helst (`with check (true)`)                  | 10,9 %     | 28,8 %                | 8,6 %        |
| En vy i `public` som hoppar över RLS för sina tabeller                                           | 12,0 %     | 7,6 %                 | 12,5 %       |
| En storage-policy öppen för utloggade besökare                                                   | 5,3 %      | 12,1 %                | 4,4 %        |
| En kolumn med ett känsligt klingande namn som nås via API:et                                     | 10,0 %     | 16,7 %                | 9,2 %        |
| En policy som litar på `user_metadata`                                                           | 0,7 %      | 0 %                   | 0,8 %        |

Av alla 15 624 tabeller har 8,5 % RLS avstängt. Det låter lite tills man räknar per projekt: en app av fyra har minst en sådan tabell, och med de standardbehörigheter som Supabase använde fram till 30 oktober 2026 kan den publika nyckeln läsa och skriva varje rad i den.

### Tabeller som ingen slog på RLS för

I vart och ett av de fem projekt jag öppnade för hand körde ingen migration någonsin `alter table … enable row level security` på den öppna tabellen. Ett projekt hade 31 tabeller och RLS på ingen av dem. Vad tabellerna innehåller varierar: referenslistor som länder, men också räknare, händelser, försäljningar och profiler. Noten [RLS disabled in public](https://madsalt.tech/sv/notes/supabase-rls-disabled-in-public/) förklarar vad Advisor-varningen betyder och hur du stänger den utan att förstöra appen.

### Policyer som säger `true`

En policy med `using (true)` på `update` eller `delete` betyder att varje besökare med din publika nyckel kan ändra eller ta bort varje rad. 8,8 % av projekten har minst en. `with check (true)` på `insert` är vanligare, 10,9 %, och ibland avsiktligt, för en väntelista eller ett kontaktformulär. Jag räknade bara det bokstavliga `true`: en policy som anropar en hjälpfunktion som `is_member(team_id)` skyddas inuti funktionen och finns därför inte i dessa siffror. [Noten](https://madsalt.tech/sv/notes/supabase-rls-using-true/) om `using (true)` visar hur du skiljer det avsiktliga fallet från olyckan.

### Vyer som hoppar över RLS

En vy i `public` körs med ägarens rättigheter om den inte skapats med `security_invoker = true`, så den returnerar rader som tabellens egna policyer skulle dölja. 12,0 % av projekten har minst en.

## Är projekt gjorda i Lovable sämre?

Inte på det sätt jag väntade mig. Jag räknade ett projekt som gjort i Lovable när dess `package.json` listar `lovable-tagger` eller minst hälften av migrationsfilerna har Lovables namnform `<timestamp>_<uuid>.sql`. De projekten lämnar färre tabeller utan RLS, 9,1 % mot 25,5 %. De skriver `true` i policyer betydligt oftare: 15,2 % låter vem som helst uppdatera eller ta bort rader, 28,8 % låter vem som helst lägga in rader och 12,1 % öppnar en storage-policy för utloggade besökare. Bara 66 Lovable-projekt gick igenom utan fel, medan 152 stoppade med fel, ofta på seed-data för skaparens egna användare, så se Lovable-kolumnen som en riktning, med en marginal på ungefär åtta procentenheter åt vardera håll.

## Löser ändringen den 30 oktober det här?

Supabase [breaking change](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically) slutar ge nya tabeller i `public` automatiska behörigheter för API-rollerna; vad den går sönder på testade jag i [det här inlägget](https://madsalt.tech/sv/blog/supabase-october-30-grant-change/). Jag körde 433 av projekten en andra gång med de nya standardvärdena, så som ett projekt skapat efter omställningen börjar. 194 av dem gick igenom utan fel båda gångerna.

| Samma 194 projekt                                                           | Gamla standardvärden | Nya standardvärden |
| --------------------------------------------------------------------------- | -------------------- | ------------------ |
| Minst en tabell med RLS avstängt som den publika nyckeln kan läsa och ändra | 44 (22,7 %)          | 7 (3,6 %)          |

![Samma 194 projekt före och efter 30 oktober. Procent med en tabell som har RLS av och som den publika nyckeln kan läsa och ändra. Gamla standardbehörigheter: 22,70; Nya standardbehörigheter: 3,60.](https://madsalt.tech/charts/sv/open-source-supabase-projects-security-study-oct30.svg)

*Källa: min studie, november 2026: samma migrations körda med Supabase gamla och nya standardbehörigheter.*

Så ja, för nya tabeller stänger den större delen av gapet: en tabell som ingen gett behörighet är onåbar, med eller utan RLS. De sju projekt som förblir öppna ger API-rollerna åtkomst själva i sina migrations, vilket genast tar tillbaka den gamla exponeringen. Och omställningen ändrar bara vad nya tabeller får: ett projekt som redan har en öppen tabell behåller den öppen, så den första frågan nedan gäller fortfarande för varje befintligt projekt.

## Hur såg jag till att siffrorna stämmer?

Innan jag litade på något resultat byggde jag ett testprojekt med sex planterade problem (en tabell med RLS avstängt, `using (true)`-policyer, en vy utan `security_invoker`, en security definer-funktion som vem som helst kan anropa, en policy som läser `user_metadata`, en publik bucket med anonyma uppladdningar) och två korrekt säkrade tabeller. Pipelinen skulle hitta alla sex och ingen av de två. De första körningarna klarade inte det: reglerna behöver listan över API-scheman, som ett live-projekt ger och en sandlåda inte gör, och sandlådans admin-roll skrev ut `uid()` i stället för `auth.uid()` i policyer, vilket fick säkra policyer att se öppna ut. Båda är åtgärdade, jag mätte om varje projekt och öppnade stickprov av varje fynd för hand.

## Vad den här studien inte kan se

- Migrations är inte den levande databasen. Allt som ändrats i dashboarden och aldrig skrivits in i en migration syns inte här, i båda riktningarna.
- Projekt som publicerar sina migrations på GitHub är inte alla Supabase-projekt. Många är övnings- och sidoprojekt.
- Nästan hälften av urvalet gick inte igenom utan fel och finns inte med i siffrorna. De projekten kan vara säkrare eller mindre säkra.
- Projekt som slagit på Supabase [automatiska RLS-trigger](https://supabase.com/docs/guides/database/postgres/event-triggers) får RLS på nya tabeller utan att någon migration säger det. Jag undantog de 16 som refererar till den; andra kan använda den utan spår i sina filer.
- Reponamn publiceras inte. Datan kommer från publik, icke-personlig information enligt forskningsklausulen i [GitHubs Acceptable Use Policies](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).

## Hur kollar du ditt eget projekt?

Kör dessa i SQL Editor. Var och en returnerade exakt det planterade problemet i mitt testprojekt och inget annat.

Tabeller med RLS avstängt, och om den publika nyckeln når dem:

```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;
```

Policyer som låter utloggade besökare skriva utan något villkor:

```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;
```

Vyer som hoppar över RLS:

```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;
```

Ett tomt resultat på alla tre är en bra början, inget friskintyg. [Så slår du på RLS](https://madsalt.tech/sv/blog/how-to-enable-rls-in-supabase/) täcker den första frågan, [exempel på RLS-policyer](https://madsalt.tech/sv/blog/supabase-rls-policy-examples/) den andra, och [hur du testar RLS](https://madsalt.tech/sv/blog/how-to-test-supabase-rls/) visar hur du bevisar att en användare inte kan läsa en annans rader. För helhetsbilden, se [är Supabase säkert](https://madsalt.tech/sv/blog/is-supabase-secure/) och [säkerhetschecklistan för Lovable-appar](https://madsalt.tech/sv/blog/lovable-app-security-checklist/).

## Mitt liknande fall

När jag byggde en tidrapportering för en revisionsbyrå hittade jag 4 fel som ingen skärm visade, bland annat en konfidentiell klient som läckte via rapportsummor och etikettantal. Alla åtkomstregler ligger nu i databasen och testas före varje driftsättning; hela historien finns i [caset om revisionsbyrån](https://madsalt.tech/sv/work/audit-firm-time-tracking/).

Vill du veta var ditt eget projekt står? Skriv till mig, så kontrollerar vi det på samma sätt.

Var står ditt projekt?

Berätta vad du har nu och vad du behöver. Jag svarar med det alternativ jag själv skulle välja.

[Skriv till mig](https://madsalt.tech/sv/#contact)

## Källor

- GitHubs kodsökning och repodata, 7 november 2026; urval och pipeline beskrivs ovan.
- Supabase, [Securing your API: default privileges](https://supabase.com/docs/guides/api/securing-your-api), läst 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).
