Hoppa till innehållet

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

Visa som MarkdownÖppna i ClaudeÖppna i ChatGPTÖppna i Perplexity

Frågan kopieras också. Om chatten öppnas tom, klistra in den.

På den här sidan
  1. Hur skyddar Supabase och Firebase data?
  2. Vad gör var och en med ett nytt projekt?
  3. Vad händer när det lämnas öppet?
  4. Vad händer när en användare rör någon annans data?
  5. Kan en användare ge bort sina data eller göra sig själv till admin?
  6. Vad tillåter den publika nyckeln ensam?
  7. Och fillagringen?
  8. Vilket är säkrast?
  9. Hur kontrollerar du var och en?
  10. Mitt liknande fall

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, Supabases i exempel på Supabase RLS-policyer.

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. 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.
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.

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.

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. Samma jämförelse mot en annan backend gjorde jag i Appwrite vs Supabase säkerhet.

Hur kontrollerar du var och en?

Den kostnadsfria Supabase-säkerhetskontrollen 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 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.

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

© 2026 Denys Zaichenko. Originalartikel: https://madsalt.tech/sv/blog/supabase-vs-firebase-security/