---
title: "Supabase vs Firebase sikkerhed: samme angreb på begge"
description: "Jeg sendte samme adgangsangreb mod en lokal Supabase og Firebase-emulatorer. Begge starter lukkede; de adskiller sig i, hvordan en forkert regel fejler."
url: "https://madsalt.tech/da/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/da/about/"
language: "da"
published: 2026-11-06
---

# Supabase vs Firebase sikkerhed: samme angreb på begge

TL;DR

Begge starter lukkede: en ny Supabase-tabel svarede `401` til en gæst, indtil jeg gav den grants, og en ny Firebase-database med deny-all-regler svarede `403`. Forskellen er, hvordan en fejl viser sig. Da bruger A opdaterede eller slettede bruger B's data under en policy kun for ejer, svarede Supabase `200` med nul rækker og ingen fejl; Firebase afviste med `403`. Til gengæld lod Firebase A give en ordre videre til B med `200`, når update-reglen kun tjekkede den gamle ejer, hvor Supabase afviste samme træk med `403`. Åbnet op (en grant til `anon` med RLS slået fra, eller `if true`) gav begge en gæst alle tre rækker og lod vedkommende slette en. Den offentlige nøgle alene åbner intet på nogen af dem; reglerne bestemmer.

Jeg er Denys, Forward Deployed Engineer. De fleste apps, jeg retter, kører på Supabase eller Firebase, og folk, der vælger mellem dem, spørger, hvilken der er sikrest. Funktions- og prissammenligninger svarer ikke på det, så jeg sendte begge de samme forespørgsler.

**Sådan testede 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 den 6. november 2026. Rene REST-kald som gæst og som to loggede brugere A og B, med opfundne data: ordrerne `a1` og `a2` ejes af A, `b1` af B. Intet rørte et rigtigt projekt.

## Hvordan beskytter Supabase og Firebase data?

Supabase lægger data i Postgres. En grant afgør, om API-rollerne overhovedet kan røre en tabel, og row level security-policyer (RLS), skrevet i SQL, afgør, hvilke rækker hver forespørgsel ser og skriver. Firebase lægger data i Firestore og Cloud Storage, og sikkerhedsregler, et separat sprog, afgør pr. sti og pr. forespørgsel, om en læsning eller skrivning er tilladt.

Begge har altså adgangskontrol, og spørgsmålet er, hvad hver af dem lader dig komme til at gøre forkert. Reglerne i Firebase gennemgår [eksempler på Firebase-sikkerhedsregler](https://madsalt.tech/da/blog/firebase-security-rules-examples/) i dybden, og Supabase gør [eksempler på Supabase RLS-policyer](https://madsalt.tech/da/blog/supabase-rls-policy-examples/).

## Hvad gør hver af dem med et nyt projekt?

| Forespørgsel               | Supabase, ny tabel, intet givet  | Firebase, deny-all-regler |
| -------------------------- | -------------------------------- | ------------------------- |
| Gæst viser data            | `401`, permission denied (42501) | `403`                     |
| Logget bruger viser data   | `403`, permission denied (42501) | `403`                     |
| Samling uden regel for den | ikke relevant                    | `403`                     |

En ny opsætning er lukket på begge. På Supabase er det nyt: tabeller oprettet efter 30. oktober 2026 får ikke længere Data API-grants automatisk, og min CLI opførte sig allerede sådan, så den første forespørgsel fejlede på den manglende grant, ikke på en policy. Ændringen står i [grant-ændringen 30. oktober](https://madsalt.tech/da/blog/supabase-october-30-grant-change/). En Firebase-database oprettet i produktionstilstand starter med deny-all-regler.

## Hvad sker der, når det står åbent?

| Forespørgsel fra en gæst | Supabase, grant til `anon`, RLS slået fra | Firebase, `allow read, write: if true` |
| ------------------------ | ----------------------------------------- | -------------------------------------- |
| Vis data                 | `200`, alle 3 rækker                      | `200`, alle 3 dokumenter               |
| Tilføj en post           | `201`                                     | `200`                                  |
| Slet en post             | `200`, rækken slettet                     | `200`, dokumentet slettet              |

De åbne tilstande er ikke det samme. På Supabase kræver det en bevidst grant til `anon` og RLS slået fra, et mønster nogle vejledninger og AI-værktøjer skriver for at få en fejl til at forsvinde. På Firebase er det testtilstand, som mange vejledninger starter fra. Resultatet er det samme: enhver med appens offentlige identifikatorer kan læse og slette data. At slå RLS til uden policy lukkede Supabase-tabellen igen (`200` med 0 rækker for en gæst og for A, og `403` ved insert).

## Hvad sker der, når en bruger rører andres data?

Her opfører de sig forskelligt. Begge havde en regel kun for ejer: Supabase-policyer på `owner_id = auth.uid()`, Firebase-regler på `resource.data.ownerId == request.auth.uid`.

| Forespørgsel fra A          | Supabase                    | Firebase                                     |
| --------------------------- | --------------------------- | -------------------------------------------- |
| Viser alt                   | `200`, kun A's 2 rækker     | `403`, forespørgsel på hele samlingen afvist |
| Viser med filter på eget id | `200`, A's 2 rækker         | `200`, A's 2 dokumenter                      |
| Filtrerer på B's id         | `200`, 0 rækker             | `403`                                        |
| Læser B's post              | `200`, 0 rækker             | `403`                                        |
| Opdaterer B's post          | `200`, 0 rækker, ingen fejl | `403`                                        |
| Sletter B's post            | `200`, 0 rækker, ingen fejl | `403`                                        |
| Opretter en post ejet af B  | `403`, brud på row security | `403`                                        |

![Samme anmodning, to backends. Bruger A ændrer data, som bruger B ejer, via hvert REST API. Supabase, policy kun for ejer: Bruger A → opdater B's data → 200 \[\] → 0 rækker, ingen fejl; Firebase, regel kun for ejer: Bruger A → opdater B's data → 403 → fejl returneret.](https://madsalt.tech/charts/da/supabase-vs-firebase-security.svg)

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

Ingen af dem lækkede B's data. Det er svaret, der er forskelligt. Supabase filtrerer de rækker, en policy skjuler, så en skrivning, der ikke ramte noget, er en succes med nul rækker, og en app, der læser "ingen fejl" som "gemt", fortæller brugeren, at ændringen virkede. Firebase tjekker selve forespørgslen: en forespørgsel, der kunne returnere dokumenter, reglen afviser, afvises som helhed, og en skrivning til en andens dokument er en fejl, appen ikke kan overse. Prisen er, at hver listeforespørgsel i Firebase skal bære det filter, reglen forventer.

## Kan en bruger give sine data væk eller gøre sig selv til admin?

| Forespørgsel fra A                                             | Supabase                                                     | Firebase                                                   |
| -------------------------------------------------------------- | ------------------------------------------------------------ | ---------------------------------------------------------- |
| Skifter egen posts ejer til B, uden tjek af den nye værdi      | `403` (en update-policy uden tjek genbruger sit eget filter) | `200`, og B læste den derefter med `200`                   |
| Samme, med eksplicit tjek af den nye ejer                      | `403`                                                        | `403`                                                      |
| Sætter egen `role` til `admin`, redigering af sig selv tilladt | `200`, rollen er nu `admin`                                  | `200`, og A's læsning af B's ordre gik fra `403` til `200` |
| Samme, efter rettelsen                                         | `403` med en kolonne-grant kun på `display_name`; navn `200` | `403` med en regel, der sammenligner rollen                |

Ejerskiftet viser de forskellige standarder: i Postgres anvender en policy med kun en `using`-klausul den også på den nye række, mens en Firebase-update-regel kun tjekker det, du skriver i den. Jeg skrev den, som mange eksempler gør, med tjek af den gamle ejer, og Firebase accepterede den nye.

Rolletilfældet fejler ens på begge, og det er det, jeg oftest ser i genereret kode: en regel om, at "brugere kan redigere deres egen profil", der inkluderer rollekolonnen. Supabase lukker det med en kolonne-grant eller en trigger, Firebase med en regel, der sammenligner `request.resource.data.role` med den gemte værdi.

## Hvad tillader den offentlige nøgle alene?

Begge produkter lægger en offentlig identifikator i hver klient. På Supabase nåede publishable-nøglen (anon) til API'ets skemaliste med `200`, som navngav de to tabeller, jeg havde givet til `anon`, og dataene fulgte grants og RLS: 3 rækker med RLS slået fra, 0 med RLS slået til. Secret-nøglen returnerede alle 3 rækker med RLS slået til, fordi `service_role` springer policyer over, og den skal blive på serveren; detaljerne står i [anon key vs service role key](https://madsalt.tech/da/blog/supabase-anon-key-vs-service-role-key/).

På Firebase lod den offentlige API-nøgle mig oprette en anonym bruger i Auth-emulatoren (`200` og et ID-token). Det er ikke i sig selv et hul, for reglerne afgør stadig, hvad brugeren ser, men det betyder, at "logget ind" ikke er et tillidssignal, når tilmelding er åben. Regler, der kun tjekker `request.auth != null`, er åbne for alle.

## Hvad med fillagring?

| Forespørgsel                          | Supabase Storage, privat bucket                 | Firebase Storage                                                    |
| ------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------- |
| Intet sat op, A læser B's fil         | `400` not_found                                 | `403` (deny-all-regler)                                             |
| Regel kun for ejer, A viser B's mappe | `200`, 0 filer                                  | `403`                                                               |
| Regel kun for ejer, A læser B's fil   | `400` not_found                                 | `403`                                                               |
| Regel kun for ejer, A uploader til B  | `400`, brud på row security                     | `403`                                                               |
| Regel kun for ejer, A i egen mappe    | liste `200`, 1 fil; læsning `200`; upload `200` | liste `200`, 1 fil; læsning `200`; skrivning `200`                  |
| Reglen er "enhver logget bruger"      | ikke testet                                     | A læste B's fil, viste alle 3 filer og overskrev B's fil, alt `200` |

Samme mønster igen: Supabase skjuler det, du ikke må se, så en andens fil ser ud til at mangle, og Firebase afviser direkte. Reglen "enhver logget bruger" er lagringsversionen af fejlen med kun-login og lod en fremmed overskrive en andens passcan. Firebase-detaljerne, inklusive download-tokens, står i [Firebase Storage-regler](https://madsalt.tech/da/blog/firebase-storage-rules/).

## Hvilken er mest sikker?

Ingen af dem er sikker eller usikker som standard; begge startede lukkede. De adskiller sig i, hvor en fejl gemmer sig:

| Spørgsmål                               | Supabase                                  | Firebase                                        |
| --------------------------------------- | ----------------------------------------- | ----------------------------------------------- |
| Hvor adgangsreglerne bor                | SQL-grants og -policyer                   | Regelsprog pr. sti                              |
| En afvist skrivning på tværs af brugere | `200` med nul rækker ved update og delete | `403`                                           |
| En liste, der indeholder andres data    | Filtreres stille                          | Afvises, medmindre forespørgslen matcher reglen |
| Ny ejer ved en update                   | Tjekkes som standard                      | Kun hvis du skriver tjekket                     |
| Hvad åbner alt ved en fejl              | En grant til `anon` med RLS slået fra     | Testtilstand eller `if true`                    |
| Servernøgle                             | Secret-nøglen springer alle policyer over | Admin SDK springer regler over                  |

Firebase afviser højere, og dens fejl har regelform: et manglende tjek af den nye værdi, et rollefelt brugeren kan redigere. Supabases tavshed ved afviste skrivninger er det, man skal designe omkring, og dens fejl har policyform: RLS slået fra, en policy der altid er sand. Hvis dit team ikke vil læse nogen af dem, redder ingen af dem dig. Hvis det vil, er Firebases `403` lettere at opdage i test, og Supabases SQL kan udtrykke regler, der afhænger af data, som MFA-niveau eller virksomhedsmedlemskab. Uanset hvad du vælger, så test som to brugere; metoden, jeg bruger, står i [sådan tester du Supabase RLS](https://madsalt.tech/da/blog/how-to-test-supabase-rls/). Samme sammenligning mod en anden backend lavede jeg i [Appwrite vs Supabase: sikkerhed](https://madsalt.tech/da/blog/appwrite-vs-supabase/).

## Hvordan tjekker du hver af dem?

Det gratis [Supabase-sikkerhedstjek](https://madsalt.tech/da/tools/supabase-security-check/) læser dit projekt skrivebeskyttet og markerer tabeller med RLS slået fra, policyer der altid er sande, skrivepolicyer for gæster og grants, der giver mere, end policyerne antyder. Den gratis [Firebase-regelkontrol](https://madsalt.tech/da/tools/firebase-rules-checker/) læser indsatte regler uden at røre dit projekt og markerer testtilstand, adgang kun med login og roller, brugeren selv skriver. Ingen af dem erstatter at køre forespørgslerne ovenfor som gæst og som en anden bruger.

**Begrænsninger.** Én lokal Supabase-stack og ét kørsel af Firebase-emulatoren, over REST, på opfundne data. Firebase-emulatoren er ikke produktion, og jeg testede ikke Realtime Database, Firebase App Check (Emulator Suite indeholder det ikke), Supabase Realtime, funktioner eller priser. Dine egne regler og policyer afgør resultatet.

## Min lignende sag

Jeg kørte migreringerne fra 1.170 offentlige Supabase-projekter på nye databaser: af de 568, der kørte rent igennem, havde 134 (23,6 %) en tabel med RLS slået fra, som den offentlige nøgle kunne læse og ændre. Metoden og forespørgslerne står i [undersøgelsen af open source-projekter på Supabase](https://madsalt.tech/da/blog/open-source-supabase-projects-security-study/).

Vælger du backend til en app med private data? Skriv til mig, så finder vi ud af, hvilken der passer, og hvordan den låses ned.

Vælger du backend til private data?

Fortæl mig, hvad du har nu, og hvad du har brug for. Jeg svarer med den løsning, jeg selv ville vælge.

[Skriv til mig](https://madsalt.tech/da/#contact)
