---
title: "Supabase vs Firebase sikkerhet: samme angrep på begge"
description: "Jeg sendte samme tilgangsangrep mot en lokal Supabase og Firebase-emulatorer. Begge starter lukket; de skiller seg i hvordan en feil regel slår ut."
url: "https://madsalt.tech/no/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/no/about/"
language: "no"
published: 2026-11-06
---

# Supabase vs Firebase sikkerhet: samme angrep på begge

TL;DR

Begge starter lukket: en ny Supabase-tabell svarte `401` til en gjest til jeg ga den grants, og en ny Firebase-database med deny-all-regler svarte `403`. Forskjellen er hvordan en feil slår ut. Da bruker A oppdaterte eller slettet bruker Bs data under en policy bare for eier, svarte Supabase `200` med null rader og ingen feil; Firebase avviste med `403`. Til gjengjeld lot Firebase A gi en ordre videre til B med `200` når update-regelen bare sjekket gammel eier, mens Supabase avviste det samme grepet med `403`. Åpnet opp (en grant til `anon` med RLS av, eller `if true`) ga begge en gjest alle tre radene og lot vedkommende slette én. Den offentlige nøkkelen alene åpner ingenting i noen av dem; reglene avgjør.

Jeg er Denys, Forward Deployed Engineer. De fleste appene jeg retter, kjører på Supabase eller Firebase, og de som velger mellom dem spør hvilken som er tryggest. Sammenligninger av funksjoner og priser svarer ikke på det, så jeg sendte begge de samme forespørslene.

**Slik testet jeg.** Supabase via en lokal stack (CLI 2.109.1, Postgres 17.6) og Firebase via Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore og Storage), begge 6. november 2026. Rene REST-kall som gjest og som to innloggede brukere A og B, med oppdiktede data: ordrene `a1` og `a2` eies av A, `b1` av B. Ingenting rørte et ekte prosjekt.

## Hvordan beskytter Supabase og Firebase data?

Supabase legger data i Postgres. En grant avgjør om API-rollene i det hele tatt kan røre en tabell, og row level security-policyer (RLS), skrevet i SQL, avgjør hvilke rader hver forespørsel ser og skriver. Firebase legger data i Firestore og Cloud Storage, og sikkerhetsregler, et eget språk, avgjør per sti og per forespørsel om en lesing eller skriving er tillatt.

Begge har altså tilgangskontroll, og spørsmålet er hva hver av dem lar deg gjøre feil. Reglene i Firebase dekkes grundig i [eksempler på Firebase-sikkerhetsregler](https://madsalt.tech/no/blog/firebase-security-rules-examples/), og Supabase i [eksempler på Supabase RLS-policyer](https://madsalt.tech/no/blog/supabase-rls-policy-examples/).

## Hva gjør hver av dem med et nytt prosjekt?

| Forespørsel                     | Supabase, ny tabell, ingenting gitt | Firebase, deny-all-regler |
| ------------------------------- | ----------------------------------- | ------------------------- |
| Gjest lister dataene            | `401`, permission denied (42501)    | `403`                     |
| Innlogget bruker lister dataene | `403`, permission denied (42501)    | `403`                     |
| Samling uten regel for den      | ikke aktuelt                        | `403`                     |

Et ferskt oppsett er lukket på begge. På Supabase er det nytt: tabeller opprettet etter 30. oktober 2026 får ikke lenger Data API-grants automatisk, og min CLI oppførte seg allerede slik, så den første forespørselen feilet på den manglende granten, ikke på en policy. Endringen står i [grant-endringen 30. oktober](https://madsalt.tech/no/blog/supabase-october-30-grant-change/). En Firebase-database opprettet i produksjonsmodus starter med deny-all-regler.

## Hva skjer når det står åpent?

| Forespørsel fra en gjest | Supabase, grant til `anon`, RLS av | Firebase, `allow read, write: if true` |
| ------------------------ | ---------------------------------- | -------------------------------------- |
| List dataene             | `200`, alle 3 rader                | `200`, alle 3 dokumenter               |
| Legg til en post         | `201`                              | `200`                                  |
| Slett en post            | `200`, raden slettet               | `200`, dokumentet slettet              |

De åpne tilstandene er ikke det samme. På Supabase krever det en bevisst grant til `anon` og RLS av, et mønster noen veiledninger og AI-verktøy skriver for å få en feil til å forsvinne. På Firebase er det testmodus, som mange veiledninger starter fra. Resultatet er identisk: alle med appens offentlige identifikatorer kan lese og slette dataene. Å slå på RLS uten policy lukket Supabase-tabellen igjen (`200` med 0 rader for en gjest og for A, og `403` ved insert).

## Hva skjer når en bruker rører andres data?

Her oppfører de seg forskjellig. Begge hadde en regel bare for eier: Supabase-policyer på `owner_id = auth.uid()`, Firebase-regler på `resource.data.ownerId == request.auth.uid`.

| Forespørsel fra A            | Supabase                     | Firebase                                  |
| ---------------------------- | ---------------------------- | ----------------------------------------- |
| Lister alt                   | `200`, bare As 2 rader       | `403`, spørring mot hele samlingen avvist |
| Lister med filter på egen id | `200`, As 2 rader            | `200`, As 2 dokumenter                    |
| Filtrerer på Bs id           | `200`, 0 rader               | `403`                                     |
| Leser Bs post                | `200`, 0 rader               | `403`                                     |
| Oppdaterer Bs post           | `200`, 0 rader, ingen feil   | `403`                                     |
| Sletter Bs post              | `200`, 0 rader, ingen feil   | `403`                                     |
| Oppretter en post eid av B   | `403`, brudd på row security | `403`                                     |

![Samme forespørsel, to backender. Bruker A endrer data som eies av bruker B, over hvert REST-API. Supabase, eier-policy: Bruker A → oppdaterer Bs data → 200 \[\] → 0 rader, ingen feil; Firebase, eier-regel: Bruker A → oppdaterer Bs data → 403 → feil returneres.](https://madsalt.tech/charts/no/supabase-vs-firebase-security.svg)

*Figur 1. Mine tester, 6. november 2026: lokal Supabase-stack (CLI 2.109.1) og Firebase-emulatorer (CLI 15.35.0).*

Ingen av dem lekket Bs data. Det er svaret som er forskjellig. Supabase filtrerer radene en policy skjuler, så en skriving som ikke traff noe er en suksess med null rader, og en app som leser «ingen feil» som «lagret» forteller brukeren at endringen virket. Firebase sjekker selve forespørselen: en spørring som kunne gitt tilbake dokumenter regelen nekter, avvises som helhet, og en skriving til andres dokument er en feil appen ikke kan overse. Prisen er at hver listespørring i Firebase må bære filteret regelen forventer.

## Kan en bruker gi bort dataene sine eller gjøre seg selv til admin?

| Forespørsel fra A                                              | Supabase                                                        | Firebase                                                 |
| -------------------------------------------------------------- | --------------------------------------------------------------- | -------------------------------------------------------- |
| Endrer egen posts eier til B, uten sjekk av ny verdi           | `403` (en update-policy uten sjekk gjenbruker sitt eget filter) | `200`, og B leste den deretter med `200`                 |
| Samme, med eksplisitt sjekk av ny eier                         | `403`                                                           | `403`                                                    |
| Setter egen `role` til `admin`, redigering av seg selv tillatt | `200`, rollen er nå `admin`                                     | `200`, og As lesing av Bs ordre gikk fra `403` til `200` |
| Samme, etter rettelsen                                         | `403` med kolonne-grant bare på `display_name`; navn `200`      | `403` med en regel som sammenligner rollen               |

Eierskiftet viser de ulike standardene: i Postgres bruker en policy med bare en `using`-klausul den også på den nye raden, mens en Firebase-update-regel bare sjekker det du skriver i den. Jeg skrev den som mange eksempler gjør, med sjekk av gammel eier, og Firebase godtok den nye.

Rolle-tilfellet feiler likt på begge, og det er det jeg oftest ser i generert kode: en regel om at «brukere kan redigere sin egen profil» som inkluderer rollekolonnen. Supabase lukker det med en kolonne-grant eller en trigger, Firebase med en regel som sammenligner `request.resource.data.role` med den lagrede verdien.

## Hva tillater den offentlige nøkkelen alene?

Begge produktene legger en offentlig identifikator i hver klient. På Supabase nådde publishable-nøkkelen (anon) API-ets skjemaliste med `200`, som navnga de to tabellene jeg hadde gitt til `anon`, og dataene fulgte grants og RLS: 3 rader med RLS av, 0 med RLS på. Secret-nøkkelen ga alle 3 rader med RLS på, fordi `service_role` hopper over policyer, og den må bli på serveren; detaljene står i [anon key vs service role key](https://madsalt.tech/no/blog/supabase-anon-key-vs-service-role-key/).

På Firebase lot den offentlige API-nøkkelen meg opprette en anonym bruker i Auth-emulatoren (`200` og et ID-token). Det er ikke et hull i seg selv, siden reglene fortsatt avgjør hva brukeren ser, men det betyr at «innlogget» ikke er et tillitssignal når registrering er åpen. Regler som bare sjekker `request.auth != null` er åpne for hvem som helst.

## Hva med fillagring?

| Forespørsel                          | Supabase Storage, privat bucket                    | Firebase Storage                                                    |
| ------------------------------------ | -------------------------------------------------- | ------------------------------------------------------------------- |
| Ingenting satt opp, A leser Bs fil   | `400` not_found                                    | `403` (deny-all-regler)                                             |
| Eier-regel, A lister Bs mappe        | `200`, 0 filer                                     | `403`                                                               |
| Eier-regel, A leser Bs fil           | `400` not_found                                    | `403`                                                               |
| Eier-regel, A laster opp til B       | `400`, brudd på row security                       | `403`                                                               |
| Eier-regel, A i egen mappe           | liste `200`, 1 fil; lesing `200`; opplasting `200` | liste `200`, 1 fil; lesing `200`; skriving `200`                    |
| Regelen er «enhver innlogget bruker» | ikke testet                                        | A leste Bs fil, listet alle 3 filene og overskrev Bs fil, alt `200` |

Samme mønster igjen: Supabase skjuler det du ikke får se, så en annens fil ser ut til å mangle, og Firebase avviser rett ut. Regelen «enhver innlogget bruker» er lagringsversjonen av feilen med bare innlogging, og den lot en fremmed overskrive noens passkanning. Firebase-detaljene, inkludert nedlastingstokens, står i [Firebase Storage-regler](https://madsalt.tech/no/blog/firebase-storage-rules/).

## Hvilken er tryggest?

Ingen av dem er trygg eller utrygg som standard; begge startet lukket. De skiller seg i hvor en feil gjemmer seg:

| Spørsmål                               | Supabase                                  | Firebase                                      |
| -------------------------------------- | ----------------------------------------- | --------------------------------------------- |
| Hvor tilgangsreglene bor               | SQL-grants og -policyer                   | Regelspråk per sti                            |
| En avvist skriving på tvers av brukere | `200` med null rader ved update og delete | `403`                                         |
| En liste som inkluderer andres data    | Filtreres stille                          | Avvises med mindre spørringen matcher regelen |
| Ny eier ved en update                  | Sjekkes som standard                      | Bare hvis du skriver sjekken                  |
| Hva åpner alt ved en feil              | En grant til `anon` med RLS av            | Testmodus eller `if true`                     |
| Servernøkkel                           | Secret-nøkkelen hopper over alle policyer | Admin SDK hopper over regler                  |

Firebases avvisninger er høyere, og feilene har regelform: en manglende sjekk av den nye verdien, et rollefelt brukeren kan redigere. Supabases stillhet ved avviste skrivinger er det man må designe rundt, og feilene har policyform: RLS av, en policy som alltid er sann. Hvis teamet ditt ikke vil lese noen av dem, redder ingen av dem deg. Hvis det vil, er Firebases `403` lettere å oppdage i testing, og Supabases SQL kan uttrykke regler som avhenger av data, som MFA-nivå eller selskapsmedlemskap. Uansett hva du velger, test som to brukere; metoden jeg bruker står i [slik tester du Supabase RLS](https://madsalt.tech/no/blog/how-to-test-supabase-rls/). Samme sammenligning mot en annen backend gjorde jeg i [Appwrite vs Supabase sikkerhet](https://madsalt.tech/no/blog/appwrite-vs-supabase/).

## Hvordan sjekker du hver av dem?

Den gratis [Supabase-sikkerhetssjekken](https://madsalt.tech/no/tools/supabase-security-check/) leser prosjektet ditt skrivebeskyttet og markerer tabeller med RLS av, policyer som alltid er sanne, skrivepolicyer for gjester og grants som gir mer enn policyene antyder. Den gratis [Firebase-regelkontrollen](https://madsalt.tech/no/tools/firebase-rules-checker/) leser innlimte regler uten å røre prosjektet ditt og markerer testmodus, tilgang bare med innlogging og roller brukeren skriver selv. Ingen av dem erstatter å kjøre forespørslene over som gjest og som en annen bruker.

**Begrensninger.** Én lokal Supabase-stack og én kjøring av Firebase-emulatoren, over REST, på oppdiktede data. Firebase-emulatoren er ikke produksjon, og jeg testet ikke Realtime Database, Firebase App Check (Emulator Suite har det ikke), Supabase Realtime, funksjoner eller priser. Dine egne regler og policyer avgjør resultatet.

## Mitt tilsvarende tilfelle

Jeg kjørte migrasjonene til 1 170 offentlige Supabase-prosjekter på nye databaser: av de 568 som gikk rent gjennom hadde 134 (23,6 %) en tabell med RLS av som den offentlige nøkkelen kunne lese og endre. Metoden og spørringene står i [studien av åpen kildekode-prosjekter på Supabase](https://madsalt.tech/no/blog/open-source-supabase-projects-security-study/).

Velger du backend for en app med private data? Skriv til meg, så finner vi ut hvilken som passer og hvordan den låses ned.

Velger du backend for private data?

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)
