---
title: "Supabase RLS: 1 av 4 åpen kildekode-apper har en åpen tabell"
description: "Supabase-sikkerhet: jeg kjørte migrasjonene fra 568 åpen kildekode-prosjekter gjennom 15 RLS-regler. 24 % lar en tabell stå åpen for lesing og skriving."
url: "https://madsalt.tech/no/blog/open-source-supabase-projects-security-study/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/no/about/"
language: "no"
published: 2026-11-08
---

# Supabase RLS: 1 av 4 åpen kildekode-apper har en åpen tabell

TL;DR

Jeg tok 1 170 offentlige GitHub-repoer med Supabase-migrasjoner, kjørte hvert av dem på en fersk Supabase-database i en offline sandkasse og brukte de samme 15 databasereglene som den gratis sjekken min bruker på live prosjekter. 568 prosjekter gikk gjennom uten feil: 15 624 tabeller i `public`. **134 av dem (23,6 %) har minst én tabell med RLS av som den offentlige nøkkelen kan lese og endre.** 8,8 % har en policy som lar en besøkende som ikke er innlogget oppdatere eller slette hvilken som helst rad, 10,9 % lar dem sette inn hva som helst, og 12,0 % eksponerer en view som hopper over RLS. Prosjekter laget i Lovable har færre tabeller uten RLS (9,1 %), men skriver `true` inn i policyer to til tre ganger så ofte. I et prosjekt opprettet etter Supabase sin endring 30. oktober lar de samme migrasjonene 3,6 % stå åpne i stedet for 22,7 %. Tre SQL-spørringer på slutten viser hvor ditt eget prosjekt står.

Det meste av Supabase-sikkerhetsrådene sier det samme: slå på RLS, skriv policyer, sjekk Advisor. Jeg ville vite hvor ofte ekte prosjekter faktisk gjør dette feil, målt på samme måte hver gang, ikke ut fra de få appene folk poster på Reddit. Offentlig GitHub har tusenvis av Supabase-prosjekter med hele migrasjonshistorikken, så jeg bygde så mange jeg kunne og så på databasen migrasjonene etterlater.

## Hvordan testet jeg 568 prosjekter?

Jeg søkte på GitHub etter SQL-filer under `supabase/migrations` som inneholder `create table`, delt opp etter filstørrelse for å komme forbi søkegrensen. Det ga 8 914 repoer, forks ikke regnet med. Derfra tok jeg et fast pseudotilfeldig utvalg, sortert etter en hash av repo-navnet, og lastet ned bare migrasjonsmappen og `package.json` fra hvert.

| Steg                                                                    | Prosjekter |
| ----------------------------------------------------------------------- | ---------- |
| Repoer med Supabase-migrasjoner (GitHub-kodesøk, 7. november 2026)      | 8 914      |
| Lastet ned utvalg                                                       | 1 170      |
| Målt, etter at eksakte duplikater er fjernet                            | 1 168      |
| Maler og Supabase sine egne repoer fjernet                              | 9          |
| Migrasjoner som stopper med feil på en fersk database                   | 567        |
| Ingen tabeller i `public`                                               | 8          |
| Bruker Supabase sin automatiske RLS-trigger (utelatt, se begrensninger) | 16         |
| **Analysert**                                                           | **568**    |

Hvert prosjekt kjørte i sin egen ferske database i en Docker-container uten nettverkstilgang, bygget fra en dump av en lokal Supabase-stack (CLI 2.109.1, Postgres 17.6, med de ekte `auth`- og `storage`-skjemaene). Migrasjonene kjørte i filnavnrekkefølge som rollen `postgres`, som ikke er superbruker på Supabase, rollen `supabase db push` også bruker. Ingenting fra et repo kjørte noen gang utenfor den containeren.

På den resulterende databasen kjørte jeg katalogspørringene og de 15 databasereglene fra [Supabase-sikkerhetssjekken](https://madsalt.tech/no/tools/supabase-security-check/) min, uendret. Innstillinger som ligger utenfor databasen, som e-postbekreftelse eller beskyttelse mot lekkede passord, kan ikke ses i migrasjoner, så de reglene er utelatt.

Nesten halvparten av prosjektene stopper med feil før siste migrasjon. De vanlige årsakene er seed-data som peker på brukere som bare finnes i forfatterens eget prosjekt, objekter opprettet for hånd i dashboardet og referert til senere, og migrasjoner som aldri har virket på en ren database. Jeg rapporterer bare prosjektene som gikk gjennom uten feil.

## Hva fant jeg?

![568 åpen kildekode-prosjekter med Supabase: andel per funn. Prosent av prosjektene. Migrasjoner kjørt på en fersk database, november 2026. RLS av, åpen for offentlig nøkkel: 23,60; View som hopper over RLS: 12; Alle kan sette inn hva som helst: 10,90; Sensitiv kolonne kan nås: 10; Alle kan endre eller slette rader: 8,80; Storage åpen uten innlogging: 5,30; Policy stoler på user_metadata: 0,70.](https://madsalt.tech/charts/no/open-source-supabase-projects-security-study.svg)

*Kilde: min undersøkelse av 1 168 offentlige GitHub-repoer med Supabase-migrasjoner, 568 av dem gikk gjennom uten feil, 7.-8. november 2026.*

| Funn                                                                                                        | Alle (568) | Laget i Lovable (66) | Andre (502) |
| ----------------------------------------------------------------------------------------------------------- | ---------- | -------------------- | ----------- |
| Minst én tabell med RLS av som den offentlige nøkkelen kan lese og endre                                    | **23,6 %** | 9,1 %                | 25,5 %      |
| En policy lar besøkende som ikke er innlogget oppdatere eller slette hvilken som helst rad (`using (true)`) | **8,8 %**  | 15,2 %               | 8,0 %       |
| En policy lar besøkende som ikke er innlogget sette inn hva som helst (`with check (true)`)                 | 10,9 %     | 28,8 %               | 8,6 %       |
| En view i `public` som hopper over RLS på tabellene sine                                                    | 12,0 %     | 7,6 %                | 12,5 %      |
| En storage-policy åpen for besøkende som ikke er innlogget                                                  | 5,3 %      | 12,1 %               | 4,4 %       |
| En kolonne med et sensitivt navn som kan nås via API-et                                                     | 10,0 %     | 16,7 %               | 9,2 %       |
| En policy som stoler på `user_metadata`                                                                     | 0,7 %      | 0 %                  | 0,8 %       |

På tvers av alle 15 624 tabellene har 8,5 % RLS av. Det høres lite ut helt til man teller per prosjekt: én av fire apper har minst én slik tabell, og med standardtilgangene Supabase brukte fram til 30. oktober 2026 kan den offentlige nøkkelen lese og skrive hver eneste rad i den.

### Tabeller ingen slo på RLS for

I hvert av de fem prosjektene jeg åpnet for hånd, kjørte ingen migrasjon noen gang `alter table … enable row level security` på den åpne tabellen. Ett prosjekt hadde 31 tabeller og RLS på ingen av dem. Hva tabellene inneholder, varierer: referanselister som land, men også tellere, hendelser, salg og profiler. Notatet [RLS disabled in public](https://madsalt.tech/no/notes/supabase-rls-disabled-in-public/) forklarer hva Advisor-varselet betyr og hvordan du lukker det uten å ødelegge appen.

### Policyer som sier `true`

En policy med `using (true)` på `update` eller `delete` betyr at hver besøkende med den offentlige nøkkelen din kan endre eller fjerne hver rad. 8,8 % av prosjektene har minst én. `with check (true)` på `insert` er vanligere, 10,9 %, og er noen ganger bevisst, for en venteliste eller et kontaktskjema. Jeg telte bare den bokstavelige `true`: en policy som kaller en hjelpefunksjon som `is_member(team_id)`, er beskyttet inne i funksjonen og er derfor ikke med i tallene. [Notatet](https://madsalt.tech/no/notes/supabase-rls-using-true/) om `using (true)` viser hvordan du kan skille det bevisste tilfellet fra uhellet.

### Views som hopper over RLS

En view i `public` kjører med eierens rettigheter med mindre den er opprettet med `security_invoker = true`, så den returnerer rader som tabellens egne policyer ville skjult. 12,0 % av prosjektene har minst én.

## Er prosjekter laget i Lovable verre?

Ikke på den måten jeg hadde ventet. Jeg regnet et prosjekt som laget i Lovable når `package.json` oppgir `lovable-tagger`, eller når minst halvparten av migrasjonsfilene har Lovable sine `<timestamp>_<uuid>.sql`-navn. Disse prosjektene etterlater færre tabeller uten RLS, 9,1 % mot 25,5 %. De skriver `true` inn i policyer mye oftere: 15,2 % lar hvem som helst oppdatere eller slette rader, 28,8 % lar hvem som helst sette inn, og 12,1 % åpner en storage-policy for besøkende som ikke er innlogget. Bare 66 Lovable-prosjekter gikk gjennom uten feil, mens 152 stoppet med feil, ofte på seed-data for forfatterens egne brukere, så les Lovable-kolonnen som en retning, med en margin på omtrent åtte prosentpoeng til hver side.

## Fikser endringen 30. oktober dette?

Supabase sin [breaking change](https://supabase.com/changelog/45329-breaking-change-tables-not-exposed-to-data-and-graphql-api-automatically) slutter å gi nye tabeller i `public` automatiske tilganger for API-rollene; hva den knekker, testet jeg i [dette innlegget](https://madsalt.tech/no/blog/supabase-october-30-grant-change/). Jeg kjørte 433 av prosjektene en gang til med de nye standardene, slik et prosjekt opprettet etter omleggingen starter. 194 av dem gikk gjennom uten feil begge gangene.

| De samme 194 prosjektene                                                 | Gamle standarder | Nye standarder |
| ------------------------------------------------------------------------ | ---------------- | -------------- |
| Minst én tabell med RLS av som den offentlige nøkkelen kan lese og endre | 44 (22,7 %)      | 7 (3,6 %)      |

![De samme 194 prosjektene før og etter 30. oktober. Prosent med en tabell som har RLS av og som den offentlige nøkkelen kan lese og endre. Gamle standardrettigheter: 22,70; Nye standardrettigheter: 3,60.](https://madsalt.tech/charts/no/open-source-supabase-projects-security-study-oct30.svg)

*Kilde: min undersøkelse, november 2026: de samme migrasjonene kjørt med Supabase sine gamle og nye standardrettigheter.*

Så ja, for nye tabeller lukker den det meste av gapet: en tabell ingen har gitt tilgang til, kan ikke nås, med eller uten RLS. De sju prosjektene som forblir åpne, gir selv API-rollene tilgang i migrasjonene sine, noe som bringer den gamle eksponeringen rett tilbake. Og omleggingen endrer bare hva nye tabeller får: et prosjekt som allerede har en åpen tabell, beholder den åpen, så den første spørringen under teller fortsatt i hvert eksisterende prosjekt.

## Hvordan sørget jeg for at tallene er riktige?

Før jeg stolte på noe resultat, bygde jeg et testprosjekt med seks plantede problemer (en tabell med RLS av, `using (true)`-policyer, en view uten `security_invoker`, en security definer-funksjon som hvem som helst kan kalle, en policy som leser `user_metadata`, en offentlig bucket med anonyme opplastinger) og to korrekt sikrede tabeller. Pipelinen måtte finne alle seks og ingen av de to. De første kjøringene gjorde ikke det: reglene trenger listen over API-skjemaer, som et live prosjekt gir og en sandkasse ikke gir, og sandkassens admin-rolle skrev `uid()` i stedet for `auth.uid()` i policyer, noe som fikk trygge policyer til å se åpne ut. Begge deler er rettet, hvert prosjekt er målt på nytt, og jeg åpnet utvalg av hvert funn for hånd.

## Hva undersøkelsen ikke kan se

- Migrasjoner er ikke den levende databasen. Alt som er endret i dashboardet og aldri skrevet i en migrasjon, er usynlig her, i begge retninger.
- Prosjekter som publiserer migrasjonene sine på GitHub, er ikke alle Supabase-prosjekter. Mange er læringsprosjekter og sideprosjekter.
- Nesten halvparten av utvalget gikk ikke gjennom uten feil og er ikke med i tallene. De prosjektene kan være tryggere eller mindre trygge.
- Prosjekter som har slått på Supabase sin [automatiske RLS-trigger](https://supabase.com/docs/guides/database/postgres/event-triggers), får RLS på nye tabeller uten at noen migrasjon sier det. Jeg utelot de 16 som refererer til den; andre kan bruke den uten spor i filene sine.
- Repo-navn publiseres ikke. Dataene kommer fra offentlig, ikke-personlig informasjon under forskningsklausulen i [GitHubs Acceptable Use Policies](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies).

## Hvordan sjekker du ditt eget prosjekt?

Kjør disse i SQL Editor. Hver av dem returnerte nøyaktig det plantede problemet i testprosjektet mitt og ingenting annet.

Tabeller med RLS av, og om den offentlige nøkkelen kan nå 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 lar besøkende som ikke er innlogget skrive uten noen betingelse:

```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 som hopper over 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;
```

Et tomt resultat på alle tre er en god start, ikke en friskmelding. [Slik slår du på RLS](https://madsalt.tech/no/blog/how-to-enable-rls-in-supabase/) dekker den første spørringen, [eksempler på RLS-policyer](https://madsalt.tech/no/blog/supabase-rls-policy-examples/) den andre, og [hvordan teste RLS](https://madsalt.tech/no/blog/how-to-test-supabase-rls/) viser hvordan du beviser at én bruker ikke kan lese en annens rader. For det bredere bildet, se [er Supabase trygt](https://madsalt.tech/no/blog/is-supabase-secure/) og [sikkerhetssjekklisten for Lovable-apper](https://madsalt.tech/no/blog/lovable-app-security-checklist/).

## Mitt tilsvarende tilfelle

Da jeg bygde en timeregistrering for et revisjonsselskap, fant jeg 4 feil ingen skjerm viste, blant annet en konfidensiell klient som lakk gjennom rapportsummer og tellere for merkelapper. Alle tilgangsregler ligger nå i databasen og testes før hver utrulling; hele historien står i [caset om revisjonsselskapet](https://madsalt.tech/no/work/audit-firm-time-tracking/).

Vil du vite hvor ditt eget prosjekt står? Skriv til meg, så sjekker vi det på samme måte.

Hvor står prosjektet ditt?

Fortell meg hva du har nå og hva du trenger. Jeg svarer med alternativet jeg selv ville valgt.

[Skriv til meg](https://madsalt.tech/no/#contact)

## Kilder

- GitHub-kodesøk og repodata, 7. november 2026; utvalg og pipeline beskrevet over.
- Supabase, [Securing your API: default privileges](https://supabase.com/docs/guides/api/securing-your-api), lest 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).
