---
title: "Supabase vs Firebase tietoturva: samat hyökkäykset"
description: "Samat pääsyhyökkäykset paikallista Supabasea ja Firebase-emulaattoreita vastaan. Molemmat alkavat suljettuina; ero on siinä, miten väärä sääntö kaatuu."
url: "https://madsalt.tech/fi/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fi/about/"
language: "fi"
published: 2026-11-06
---

# Supabase vs Firebase tietoturva: samat hyökkäykset

TL;DR

Molemmat alkavat suljettuina: uusi Supabase-taulu vastasi vieraalle `401`, kunnes annoin sille oikeudet, ja uusi Firebase-tietokanta deny-all-säännöillä vastasi `403`. Ero on siinä, miten virhe näkyy. Kun käyttäjä A päivitti tai poisti käyttäjän B dataa vain omistajalle tarkoitetulla policylla, Supabase vastasi `200`, nolla riviä eikä virhettä; Firebase kieltäytyi `403`:lla. Toisaalta Firebase antoi A:n siirtää tilauksen B:lle vastauksella `200`, kun update-sääntö tarkisti vain vanhan omistajan, kun taas Supabase kieltäytyi samasta siirrosta `403`:lla. Avattuna (grant `anon`-roolille ja RLS pois päältä, tai `if true`) molemmat antoivat vieraalle kaikki kolme riviä ja antoivat poistaa yhden. Julkinen avain yksin ei avaa kummassakaan mitään; säännöt ratkaisevat.

Olen Denys, Forward Deployed Engineer. Useimmat korjaamani sovellukset pyörivät Supabasella tai Firebasella, ja niiden välillä valitsevat kysyvät, kumpi on turvallisempi. Ominaisuus- ja hintavertailut eivät vastaa siihen, joten lähetin molemmille samat pyynnöt.

**Näin testasin.** Supabase paikallisella stackillä (CLI 2.109.1, Postgres 17.6) ja Firebase Local Emulator Suitella (firebase-tools 15.35.0, Auth, Firestore ja Storage), molemmat 6. marraskuuta 2026. Pelkkiä REST-kutsuja vieraana ja kahtena kirjautuneena käyttäjänä A ja B, keksityllä datalla: tilaukset `a1` ja `a2` kuuluvat A:lle, `b1` B:lle. Mikään ei koskenut oikeaa projektia.

## Miten Supabase ja Firebase suojaavat dataa?

Supabase pitää datan Postgresissa. Grant ratkaisee, pääsevätkö API-roolit tauluun lainkaan, ja SQL:llä kirjoitetut row level security (RLS) -policyt ratkaisevat, mitkä rivit kukin pyyntö näkee ja kirjoittaa. Firebase pitää datan Firestoressa ja Cloud Storagessa, ja tietoturvasäännöt, erillinen kieli, ratkaisevat polku- ja pyyntökohtaisesti, onko luku tai kirjoitus sallittu.

Molemmilla on siis pääsynhallinta, ja kysymys on, mitä kumpikin antaa sinun tehdä väärin. Firebasen sääntöjä käsittelee perusteellisesti [Firebasen tietoturvasääntöjen esimerkit](https://madsalt.tech/fi/blog/firebase-security-rules-examples/), Supabasea [Supabasen RLS-policyjen esimerkit](https://madsalt.tech/fi/blog/supabase-rls-policy-examples/).

## Mitä kumpikin tekee uudelle projektille?

| Pyyntö                            | Supabase, uusi taulu, mitään ei annettu | Firebase, deny-all-säännöt |
| --------------------------------- | --------------------------------------- | -------------------------- |
| Vieras listaa datan               | `401`, permission denied (42501)        | `403`                      |
| Kirjautunut käyttäjä listaa datan | `403`, permission denied (42501)        | `403`                      |
| Kokoelma, jolle ei ole sääntöä    | ei sovellu                              | `403`                      |

Tuore asennus on molemmilla suljettu. Supabasessa se on uutta: 30. lokakuuta 2026 jälkeen luodut taulut eivät enää saa Data API -granttejä automaattisesti, ja CLI:ni toimi jo niin, joten ensimmäinen pyyntö kaatui puuttuvaan granttiin, ei policyyn. Muutoksen kävin läpi artikkelissa [30. lokakuuta grant-muutos](https://madsalt.tech/fi/blog/supabase-october-30-grant-change/). Tuotantotilassa luotu Firebase-tietokanta alkaa deny-all-säännöillä.

## Mitä tapahtuu, kun se jätetään auki?

| Vieraan pyyntö | Supabase, grant `anon`-roolille, RLS pois | Firebase, `allow read, write: if true` |
| -------------- | ----------------------------------------- | -------------------------------------- |
| Listaa data    | `200`, kaikki 3 riviä                     | `200`, kaikki 3 dokumenttia            |
| Lisää tietue   | `201`                                     | `200`                                  |
| Poista tietue  | `200`, rivi poistettu                     | `200`, dokumentti poistettu            |

Avoimet tilat eivät ole sama asia. Supabasessa tarvitaan tietoinen grant `anon`-roolille ja RLS pois päältä, kuvio, jonka jotkin oppaat ja tekoälytyökalut kirjoittavat saadakseen virheen katoamaan. Firebasessa se on testitila, josta moni opas lähtee liikkeelle. Tulos on sama: kuka tahansa, jolla on sovelluksen julkiset tunnisteet, voi lukea ja poistaa datan. RLS:n päälle kytkeminen ilman policya sulki Supabase-taulun uudelleen (`200` ja 0 riviä vieraalle ja A:lle, `403` lisäyksessä).

## Mitä tapahtuu, kun käyttäjä koskee toisen dataan?

Tässä ne käyttäytyvät eri tavalla. Molemmilla oli vain omistajalle tarkoitettu sääntö: Supabasen policyt ehdolla `owner_id = auth.uid()`, Firebasen säännöt ehdolla `resource.data.ownerId == request.auth.uid`.

| A:n pyyntö                        | Supabase                      | Firebase                             |
| --------------------------------- | ----------------------------- | ------------------------------------ |
| Listaa kaiken                     | `200`, vain A:n 2 riviä       | `403`, koko kokoelman kysely hylätty |
| Listaa suodattimella omaan id:hen | `200`, A:n 2 riviä            | `200`, A:n 2 dokumenttia             |
| Suodattaa B:n id:llä              | `200`, 0 riviä                | `403`                                |
| Lukee B:n tietueen                | `200`, 0 riviä                | `403`                                |
| Päivittää B:n tietueen            | `200`, 0 riviä, ei virhettä   | `403`                                |
| Poistaa B:n tietueen              | `200`, 0 riviä, ei virhettä   | `403`                                |
| Luo tietueen, jonka omistaa B     | `403`, row security -rikkomus | `403`                                |

![Sama pyyntö, kaksi taustajärjestelmää. Käyttäjä A muokkaa käyttäjän B tietoja kummankin REST API:n kautta. Supabase, omistajapolitiikka: Käyttäjä A → päivittää B:n tiedot → 200 \[\] → 0 riviä, ei virhettä; Firebase, omistajasääntö: Käyttäjä A → päivittää B:n tiedot → 403 → virhe palautetaan.](https://madsalt.tech/charts/fi/supabase-vs-firebase-security.svg)

*Kuva 1. Omat testini, 6. marraskuuta 2026: paikallinen Supabase-stack (CLI 2.109.1) ja Firebase-emulaattorit (CLI 15.35.0).*

Kumpikaan ei vuotanut B:n dataa. Vastaus on se, mikä eroaa. Supabase suodattaa rivit, jotka policy piilottaa, joten kirjoitus, joka ei osunut mihinkään, onnistuu nollalla rivillä, ja sovellus, joka lukee "ei virhettä" tarkoittavan "tallennettu", kertoo käyttäjälle muokkauksen onnistuneen. Firebase tarkistaa itse pyynnön: kysely, joka voisi palauttaa säännön kieltämiä dokumentteja, hylätään kokonaan, ja kirjoitus toisen dokumenttiin on virhe, jota sovellus ei voi ohittaa. Hinta on se, että jokaisen Firebasen listauskyselyn on kannettava suodatin, jota sääntö odottaa.

## Voiko käyttäjä antaa datansa pois tai tehdä itsestään adminin?

| A:n pyyntö                                                         | Supabase                                                                    | Firebase                                                     |
| ------------------------------------------------------------------ | --------------------------------------------------------------------------- | ------------------------------------------------------------ |
| Vaihtaa oman tietueensa omistajaksi B:n, uutta arvoa ei tarkisteta | `403` (update-policy ilman tarkistusta käyttää omaa suodatintaan uudelleen) | `200`, ja B luki sen sen jälkeen `200`:lla                   |
| Sama, uuden omistajan selkeällä tarkistuksella                     | `403`                                                                       | `403`                                                        |
| Asettaa oman `role`-arvonsa `admin`, itsensä muokkaus sallittu     | `200`, rooli on nyt `admin`                                                 | `200`, ja A:n B:n tilauksen luku vaihtui `403`:sta `200`:ksi |
| Sama korjauksen jälkeen                                            | `403` sarakegrantilla vain `display_name`-sarakkeelle; nimi `200`           | `403` säännöllä, joka vertaa roolia                          |

Omistajan siirto näyttää erilaiset oletukset: Postgresissa policy, jossa on vain `using`-lauseke, soveltaa sitä myös uuteen riviin, kun taas Firebasen update-sääntö tarkistaa vain sen, minkä siihen kirjoitat. Kirjoitin sen kuten monet esimerkit, vanhan omistajan tarkistuksella, ja Firebase hyväksyi uuden.

Roolitapaus epäonnistuu molemmilla samoin, ja se on se, jonka näen useimmin generoidussa koodissa: sääntö "käyttäjät voivat muokata omaa profiiliaan", joka sisältää roolisarakkeen. Supabase sulkee sen sarakegrantilla tai triggerillä, Firebase säännöllä, joka vertaa `request.resource.data.role`-arvoa tallennettuun.

## Mitä julkinen avain yksin sallii?

Molemmat tuotteet laittavat julkisen tunnisteen jokaiseen clientiin. Supabasessa publishable (anon) -avain pääsi API:n skeemaluetteloon vastauksella `200`, joka nimesi kaksi taulua, jotka olin antanut `anon`-roolille, ja palautettu data noudatti granttejä ja RLS:ää: 3 riviä RLS pois päältä, 0 RLS päällä. Secret-avain palautti kaikki 3 riviä RLS päällä, koska `service_role` ohittaa policyt, ja sen on pysyttävä palvelimella; yksityiskohdat ovat artikkelissa [anon key vs service role key](https://madsalt.tech/fi/blog/supabase-anon-key-vs-service-role-key/).

Firebasessa julkinen API-avain antoi minun luoda anonyymin käyttäjän Auth-emulaattorissa (`200` ja ID-token). Se ei sellaisenaan ole aukko, koska säännöt ratkaisevat yhä, mitä käyttäjä näkee, mutta se tarkoittaa, ettei "kirjautunut" ole luottamussignaali, kun rekisteröityminen on auki. Säännöt, jotka tarkistavat vain `request.auth != null`, ovat auki kenelle tahansa.

## Entä tiedostojen tallennus?

| Pyyntö                                        | Supabase Storage, yksityinen bucket               | Firebase Storage                                                                             |
| --------------------------------------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Mitään ei asetettu, A lukee B:n tiedoston     | `400` not_found                                   | `403` (deny-all-säännöt)                                                                     |
| Vain omistajan sääntö, A listaa B:n kansion   | `200`, 0 tiedostoa                                | `403`                                                                                        |
| Vain omistajan sääntö, A lukee B:n tiedoston  | `400` not_found                                   | `403`                                                                                        |
| Vain omistajan sääntö, A lataa B:n kansioon   | `400`, row security -rikkomus                     | `403`                                                                                        |
| Vain omistajan sääntö, A omassa kansiossa     | lista `200`, 1 tiedosto; luku `200`; lataus `200` | lista `200`, 1 tiedosto; luku `200`; kirjoitus `200`                                         |
| Sääntö on "mikä tahansa kirjautunut käyttäjä" | ei testattu                                       | A luki B:n tiedoston, listasi kaikki 3 tiedostoa ja ylikirjoitti B:n tiedoston, kaikki `200` |

Sama kuvio toistuu: Supabase piilottaa sen, mitä et saa nähdä, joten toisen tiedosto näyttää puuttuvan, ja Firebase kieltäytyy suoraan. Sääntö "mikä tahansa kirjautunut käyttäjä" on tallennuksen versio vain kirjautumisen virheestä, ja se antoi ulkopuolisen ylikirjoittaa jonkun passiskannauksen. Firebasen yksityiskohdat, lataustokenit mukaan lukien, ovat artikkelissa [Firebase Storagen säännöt](https://madsalt.tech/fi/blog/firebase-storage-rules/).

## Kumpi on turvallisempi?

Kumpikaan ei ole oletuksena turvallinen tai turvaton; molemmat alkoivat suljettuina. Ne eroavat siinä, missä virhe piilee:

| Kysymys                            | Supabase                                    | Firebase                              |
| ---------------------------------- | ------------------------------------------- | ------------------------------------- |
| Missä pääsysäännöt elävät          | SQL-grantit ja -policyt                     | Sääntökieli polkua kohti              |
| Estetty toisen käyttäjän kirjoitus | `200` ja nolla riviä updatessa ja deletessä | `403`                                 |
| Lista, joka sisältää muiden dataa  | Suodatetaan hiljaa                          | Hylätään, ellei kysely vastaa sääntöä |
| Uusi omistaja updatessa            | Tarkistetaan oletuksena                     | Vain jos kirjoitat tarkistuksen       |
| Mikä avaa kaiken vahingossa        | Grant `anon`-roolille ja RLS pois           | Testitila tai `if true`               |
| Palvelinavain                      | Secret-avain ohittaa kaikki policyt         | Admin SDK ohittaa säännöt             |

Firebasen kieltäytymiset ovat äänekkäämpiä, ja sen virheet ovat sääntömuotoisia: puuttuva uuden arvon tarkistus, roolikenttä, jota käyttäjä voi muokata. Supabasen hiljaisuus estetyissä kirjoituksissa on se, minkä ympärille on suunniteltava, ja sen virheet ovat policymuotoisia: RLS pois, policy joka on aina tosi. Jos tiimisi ei lue kumpaakaan, kumpikaan ei pelasta. Jos lukee, Firebasen `403` huomataan testissä helpommin, ja Supabasen SQL voi ilmaista dataan sidottuja sääntöjä, kuten MFA-taso tai yrityksen jäsenyys. Kumman tahansa valitset, testaa kahtena käyttäjänä; käyttämäni menetelmä on artikkelissa [Supabase RLS:n testaus](https://madsalt.tech/fi/blog/how-to-test-supabase-rls/). Saman vertailun tein toista taustajärjestelmää vastaan artikkelissa [Appwrite vs Supabase tietoturva](https://madsalt.tech/fi/blog/appwrite-vs-supabase/).

## Miten kumpikin tarkistetaan?

Ilmainen [Supabasen tietoturvatarkistus](https://madsalt.tech/fi/tools/supabase-security-check/) lukee projektisi vain luku -tilassa ja merkitsee taulut, joissa RLS on pois, aina todet policyt, vieraiden kirjoituspolicyt ja grantit, jotka antavat enemmän kuin policyt antavat ymmärtää. Ilmainen [Firebasen sääntötarkistin](https://madsalt.tech/fi/tools/firebase-rules-checker/) lukee liitetyt säännöt koskematta projektiisi ja merkitsee testitilan, vain kirjautumiseen perustuvan pääsyn ja käyttäjän itse kirjoittamat roolit. Kumpikaan ei korvaa yllä olevien pyyntöjen ajamista vieraana ja toisena käyttäjänä.

**Rajoitukset.** Yksi paikallinen Supabase-stack ja yksi Firebase-emulaattorin ajo, REST:n yli, keksityllä datalla. Firebase-emulaattori ei ole tuotanto, enkä testannut Realtime Databasea, Firebase App Checkiä (Emulator Suite ei sisällä sitä), Supabase Realtimea, funktioita enkä hintoja. Oma sääntösi ja policysi ratkaisevat tuloksen.

## Vastaava tapaukseni

Ajoin 1 170 julkisen Supabase-projektin migraatiot uusiin tietokantoihin: niistä 568:sta, jotka menivät läpi puhtaasti, 134:ssä (23,6 %) oli taulu, jonka RLS oli pois päältä ja jota julkinen avain pystyi lukemaan ja muuttamaan. Menetelmä ja kyselyt ovat [avoimen lähdekoodin Supabase-tutkimuksessa](https://madsalt.tech/fi/blog/open-source-supabase-projects-security-study/).

Valitsetko taustajärjestelmää sovellukselle, jossa on yksityistä dataa? Kirjoita minulle, niin selvitämme, mikä sopii ja miten se lukitaan.

Valitsetko taustajärjestelmää yksityiselle datalle?

Kerro, mitä sinulla on nyt ja mitä tarvitset. Vastaan vaihtoehdolla, jonka itse valitsisin.

[Kirjoita minulle](https://madsalt.tech/fi/#contact)
