---
title: "Supabase vs Firebase säkerhet: samma attacker på båda"
description: "Jag skickade samma åtkomstattacker mot en lokal Supabase och Firebase-emulatorer. Båda startar stängda; de skiljer sig i hur en felaktig regel felar."
url: "https://madsalt.tech/sv/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/sv/about/"
language: "sv"
published: 2026-11-06
---

# Supabase vs Firebase säkerhet: samma attacker på båda

TL;DR

Båda startar stängda: en ny Supabase-tabell svarade `401` till en gäst tills jag gav den grants, och en ny Firebase-databas med deny-all-regler svarade `403`. Skillnaden är hur ett misstag felar. När användare A uppdaterade eller raderade användare Bs data under en policy bara för ägaren, svarade Supabase `200` med noll rader och inget fel; Firebase nekade med `403`. Firebase lät däremot A lämna över en order till B med `200` när update-regeln bara kontrollerade den gamla ägaren, medan Supabase nekade samma drag med `403`. Öppnade (en grant till `anon` med RLS av, eller `if true`) gav båda en gäst alla tre raderna och lät hen radera en. Den publika nyckeln ensam öppnar ingenting i någon av dem; reglerna avgör.

Jag heter Denys och är Forward Deployed Engineer. De flesta appar jag reparerar körs på Supabase eller Firebase, och de som väljer mellan dem frågar vilken som är säkrast. Jämförelser av funktioner och priser svarar inte på det, så jag skickade båda samma förfrågningar.

**Så testade jag.** Supabase via en lokal stack (CLI 2.109.1, Postgres 17.6) och Firebase via Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore och Storage), båda den 6 november 2026. Rena REST-anrop som gäst och som två inloggade användare A och B, med påhittade data: ordrarna `a1` och `a2` ägs av A, `b1` av B. Ingenting rörde ett riktigt projekt.

## Hur skyddar Supabase och Firebase data?

Supabase lägger data i Postgres. En grant avgör om API-rollerna alls får röra en tabell, och row level security-policyer (RLS), skrivna i SQL, avgör vilka rader varje förfrågan ser och skriver. Firebase lägger data i Firestore och Cloud Storage, och säkerhetsregler, ett eget språk, avgör per sökväg och förfrågan om en läsning eller skrivning är tillåten.

Båda har alltså åtkomstkontroll, och frågan är vad var och en låter dig göra fel. Firebases regler behandlas ingående i [exempel på Firebase-säkerhetsregler](https://madsalt.tech/sv/blog/firebase-security-rules-examples/), Supabases i [exempel på Supabase RLS-policyer](https://madsalt.tech/sv/blog/supabase-rls-policy-examples/).

## Vad gör var och en med ett nytt projekt?

| Förfrågan                       | Supabase, ny tabell, inget givet | Firebase, deny-all-regler |
| ------------------------------- | -------------------------------- | ------------------------- |
| Gäst listar datan               | `401`, permission denied (42501) | `403`                     |
| Inloggad användare listar datan | `403`, permission denied (42501) | `403`                     |
| Samling utan regel för den      | ej tillämpligt                   | `403`                     |

En ny uppsättning är stängd på båda. På Supabase är det nytt: tabeller som skapas efter den 30 oktober 2026 får inte längre Data API-grants automatiskt, och min CLI betedde sig redan så, så den första förfrågan föll på den saknade granten, inte på en policy. Ändringen beskrev jag i [grant-ändringen den 30 oktober](https://madsalt.tech/sv/blog/supabase-october-30-grant-change/). En Firebase-databas skapad i produktionsläge startar med deny-all-regler.

## Vad händer när det lämnas öppet?

| Förfrågan från en gäst | Supabase, grant till `anon`, RLS av | Firebase, `allow read, write: if true` |
| ---------------------- | ----------------------------------- | -------------------------------------- |
| Lista datan            | `200`, alla 3 rader                 | `200`, alla 3 dokument                 |
| Lägga till en post     | `201`                               | `200`                                  |
| Radera en post         | `200`, raden raderad                | `200`, dokumentet raderat              |

De öppna lägena är inte detsamma. På Supabase krävs en medveten grant till `anon` och RLS av, ett mönster som vissa guider och AI-verktyg skriver för att få ett fel att försvinna. På Firebase är det testläget, som många guider utgår från. Resultatet är identiskt: alla med appens publika identifierare kan läsa och radera datan. Att slå på RLS utan policy stängde Supabase-tabellen igen (`200` med 0 rader för en gäst och för A, och `403` vid insert).

## Vad händer när en användare rör någon annans data?

Här beter de sig olika. Båda hade en regel bara för ägaren: Supabase-policyer på `owner_id = auth.uid()`, Firebase-regler på `resource.data.ownerId == request.auth.uid`.

| Förfrågan från A             | Supabase                      | Firebase                               |
| ---------------------------- | ----------------------------- | -------------------------------------- |
| Listar allt                  | `200`, bara As 2 rader        | `403`, frågan mot hela samlingen nekad |
| Listar med filter på eget id | `200`, As 2 rader             | `200`, As 2 dokument                   |
| Filtrerar på Bs id           | `200`, 0 rader                | `403`                                  |
| Läser Bs post                | `200`, 0 rader                | `403`                                  |
| Uppdaterar Bs post           | `200`, 0 rader, inget fel     | `403`                                  |
| Raderar Bs post              | `200`, 0 rader, inget fel     | `403`                                  |
| Skapar en post som ägs av B  | `403`, brott mot row security | `403`                                  |

![Samma förfrågan, två backends. Användare A ändrar data som ägs av användare B, via respektive REST-API. Supabase, ägar-policy: Användare A → uppdaterar B:s data → 200 \[\] → 0 rader, inget fel; Firebase, ägar-regel: Användare A → uppdaterar B:s data → 403 → fel returneras.](https://madsalt.tech/charts/sv/supabase-vs-firebase-security.svg)

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

Ingen av dem läckte Bs data. Det som skiljer är svaret. Supabase filtrerar de rader en policy döljer, så en skrivning som inte träffade något är en framgång med noll rader, och en app som läser "inget fel" som "sparat" säger till användaren att ändringen lyckades. Firebase kontrollerar själva förfrågan: en fråga som kunde ge tillbaka dokument som regeln nekar avvisas i sin helhet, och en skrivning till någon annans dokument är ett fel som appen inte kan missa. Priset är att varje listfråga i Firebase måste bära det filter regeln förväntar sig.

## Kan en användare ge bort sina data eller göra sig själv till admin?

| Förfrågan från A                                                  | Supabase                                                             | Firebase                                                     |
| ----------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------ |
| Ändrar egen posts ägare till B, utan kontroll av nya värdet       | `403` (en update-policy utan kontroll återanvänder sitt eget filter) | `200`, och B läste den därefter med `200`                    |
| Samma, med uttrycklig kontroll av nya ägaren                      | `403`                                                                | `403`                                                        |
| Sätter egen `role` till `admin`, redigering av sig själv tillåten | `200`, rollen är nu `admin`                                          | `200`, och As läsning av Bs order gick från `403` till `200` |
| Samma, efter rättningen                                           | `403` med kolumn-grant bara på `display_name`; namn `200`            | `403` med en regel som jämför rollen                         |

Ägarbytet visar de olika standardvärdena: i Postgres tillämpar en policy med bara en `using`-klausul den även på den nya raden, medan en Firebase-update-regel bara kontrollerar det du skriver i den. Jag skrev den som många exempel gör, med kontroll av gamla ägaren, och Firebase godtog den nya.

Rollfallet felar lika på båda, och det är det jag oftast ser i genererad kod: en regel om att "användare kan redigera sin egen profil" som inkluderar rollkolumnen. Supabase stänger det med en kolumn-grant eller en trigger, Firebase med en regel som jämför `request.resource.data.role` med det lagrade värdet.

## Vad tillåter den publika nyckeln ensam?

Båda produkterna lägger en publik identifierare i varje klient. På Supabase nådde publishable-nyckeln (anon) API:ets schemalista med `200`, som nämnde de två tabeller jag gett `anon`, och datan följde grants och RLS: 3 rader med RLS av, 0 med RLS på. Secret-nyckeln gav alla 3 rader med RLS på, eftersom `service_role` hoppar över policyer, och den måste stanna på servern; detaljerna står i [anon key vs service role key](https://madsalt.tech/sv/blog/supabase-anon-key-vs-service-role-key/).

På Firebase lät den publika API-nyckeln mig skapa en anonym användare i Auth-emulatorn (`200` och en ID-token). Det är inget hål i sig, eftersom reglerna fortfarande avgör vad användaren ser, men det betyder att "inloggad" inte är en förtroendesignal när registrering är öppen. Regler som bara kontrollerar `request.auth != null` är öppna för vem som helst.

## Och fillagringen?

| Förfrågan                                       | Supabase Storage, privat bucket                      | Firebase Storage                                                       |
| ----------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------- |
| Inget uppsatt, A läser Bs fil                   | `400` not_found                                      | `403` (deny-all-regler)                                                |
| Ägarregel, A listar Bs mapp                     | `200`, 0 filer                                       | `403`                                                                  |
| Ägarregel, A läser Bs fil                       | `400` not_found                                      | `403`                                                                  |
| Ägarregel, A laddar upp till B                  | `400`, brott mot row security                        | `403`                                                                  |
| Ägarregel, A i egen mapp                        | lista `200`, 1 fil; läsning `200`; uppladdning `200` | lista `200`, 1 fil; läsning `200`; skrivning `200`                     |
| Regeln är "vilken inloggad användare som helst" | ej testat                                            | A läste Bs fil, listade alla 3 filer och skrev över Bs fil, allt `200` |

Samma mönster igen: Supabase döljer det du inte får se, så någon annans fil verkar saknas, och Firebase nekar rakt av. Regeln "vilken inloggad användare som helst" är lagringsversionen av felet med bara inloggning och lät en främling skriva över någons passkanning. Firebase-detaljerna, inklusive nedladdningstokens, finns i [Firebase Storage-regler](https://madsalt.tech/sv/blog/firebase-storage-rules/).

## Vilket är säkrast?

Ingen av dem är säker eller osäker som standard; båda startade stängda. De skiljer sig i var ett misstag gömmer sig:

| Fråga                                  | Supabase                                   | Firebase                              |
| -------------------------------------- | ------------------------------------------ | ------------------------------------- |
| Var åtkomstreglerna bor                | SQL-grants och -policyer                   | Regelspråk per sökväg                 |
| En nekad skrivning mot annan användare | `200` med noll rader vid update och delete | `403`                                 |
| En lista som inkluderar andras data    | Filtreras tyst                             | Avvisas om inte frågan matchar regeln |
| Ny ägare vid en update                 | Kontrolleras som standard                  | Bara om du skriver kontrollen         |
| Vad öppnar allt av misstag             | En grant till `anon` med RLS av            | Testläge eller `if true`              |
| Servernyckel                           | Secret-nyckeln hoppar över alla policyer   | Admin SDK hoppar över regler          |

Firebases nekanden är högljuddare och dess fel har regelform: en saknad kontroll av det nya värdet, ett rollfält användaren kan redigera. Supabases tystnad vid nekade skrivningar är det man måste designa kring, och dess fel har policyform: RLS av, en policy som alltid är sann. Om ditt team inte kommer att läsa någon av dem räddar ingen av dem dig. Om det gör det är Firebases `403` lättare att upptäcka vid test, och Supabases SQL kan uttrycka regler som beror på data, som MFA-nivå eller företagsmedlemskap. Vilken du än väljer, testa som två användare; metoden jag använder finns i [hur du testar Supabase RLS](https://madsalt.tech/sv/blog/how-to-test-supabase-rls/). Samma jämförelse mot en annan backend gjorde jag i [Appwrite vs Supabase säkerhet](https://madsalt.tech/sv/blog/appwrite-vs-supabase/).

## Hur kontrollerar du var och en?

Den kostnadsfria [Supabase-säkerhetskontrollen](https://madsalt.tech/sv/tools/supabase-security-check/) läser ditt projekt skrivskyddat och flaggar tabeller med RLS av, policyer som alltid är sanna, skrivpolicyer för gäster och grants som ger mer än policyerna antyder. Den kostnadsfria [Firebase-regelkontrollen](https://madsalt.tech/sv/tools/firebase-rules-checker/) läser inklistrade regler utan att röra ditt projekt och flaggar testläge, åtkomst bara med inloggning och roller användaren skriver själv. Ingen av dem ersätter att köra förfrågningarna ovan som gäst och som en andra användare.

**Begränsningar.** En lokal Supabase-stack och en körning av Firebase-emulatorn, över REST, på påhittade data. Firebase-emulatorn är inte produktion, och jag testade inte Realtime Database, Firebase App Check (Emulator Suite innehåller det inte), Supabase Realtime, funktioner eller priser. Dina egna regler och policyer avgör resultatet.

## Mitt liknande fall

Jag körde migreringarna från 1 170 publika Supabase-projekt på nya databaser: av de 568 som gick igenom utan fel hade 134 (23,6 %) en tabell med RLS avstängt som den publika nyckeln kunde läsa och ändra. Metoden och frågorna finns i [studien av öppen källkod-projekt på Supabase](https://madsalt.tech/sv/blog/open-source-supabase-projects-security-study/).

Väljer du backend till en app med privata data? Skriv till mig, så tar vi reda på vilken som passar och hur den låses ned.

Väljer du backend för privata data?

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)
