---
title: "Supabase vs Firebase turvalisus: samad rünnakud mõlemale"
description: "Samad ligipääsurünnakud kohaliku Supabase'i ja Firebase'i emulaatorite vastu. Mõlemad algavad suletuna; erinevad selles, kuidas vale reegel ebaõnnestub."
url: "https://madsalt.tech/et/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/et/about/"
language: "et"
published: 2026-11-06
---

# Supabase vs Firebase turvalisus: samad rünnakud mõlemale

TL;DR

Mõlemad algavad suletuna: uus Supabase'i tabel vastas külalisele `401`, kuni ma selle välja andsin, ja uus Firebase'i andmebaas deny-all-reeglitega vastas `403`. Erinevus on selles, kuidas viga ebaõnnestub. Kui kasutaja A muutis või kustutas kasutaja B andmeid ainult omaniku poliitika all, vastas Supabase `200`, null rida ja viga puudus; Firebase keeldus `403`-ga. Teisalt lasi Firebase A-l anda tellimuse B-le üle vastusega `200`, kui update-reegel kontrollis ainult vana omanikku, samas kui Supabase keeldus samast sammust `403`-ga. Avatuna (grant `anon`-ile ja RLS väljas või `if true`) andsid mõlemad külalisele kõik kolm rida ja lasid ühe kustutada. Avalik võti üksi ei ava kummaski midagi; otsustavad reeglid.

Olen Denys, Forward Deployed Engineer. Enamik rakendusi, mida ma parandan, töötab Supabase'is või Firebase'is, ja need, kes nende vahel valivad, küsivad, kumb on turvalisem. Funktsiooni- ja hinnavõrdlused sellele ei vasta, nii et saatsin mõlemale samad päringud.

**Kuidas testisin.** Supabase'i kohaliku stacki kaudu (CLI 2.109.1, Postgres 17.6) ja Firebase'i Local Emulator Suite'i kaudu (firebase-tools 15.35.0, Auth, Firestore ja Storage), mõlemat 6. novembril 2026. Lihtsad REST-kutsed külalisena ja kahe sisselogitud kasutajana A ja B, väljamõeldud andmetega: tellimused `a1` ja `a2` kuuluvad A-le, `b1` B-le. Midagi ei puudutanud päris projekti.

## Kuidas Supabase ja Firebase andmeid kaitsevad?

Supabase hoiab andmeid Postgresis. Grant otsustab, kas API rollid saavad tabelit üldse puudutada, ja row level security (RLS) poliitikad, kirjutatud SQL-is, otsustavad, milliseid ridu iga päring näeb ja kirjutab. Firebase hoiab andmeid Firestore'is ja Cloud Storage'is, ja turvareeglid, eraldi keel, otsustavad tee ja päringu kaupa, kas lugemine või kirjutamine on lubatud.

Seega on mõlemal ligipääsukontroll ja küsimus on, mida kumbki lubab sul valesti teha. Firebase'i reegleid käsitleb põhjalikult [Firebase'i turvareeglite näited](https://madsalt.tech/et/blog/firebase-security-rules-examples/), Supabase'i omi [Supabase'i RLS-poliitikate näited](https://madsalt.tech/et/blog/supabase-rls-policy-examples/).

## Mida kumbki uue projektiga teeb?

| Päring                               | Supabase, uus tabel, midagi pole antud | Firebase, deny-all-reeglid |
| ------------------------------------ | -------------------------------------- | -------------------------- |
| Külaline loetleb andmed              | `401`, permission denied (42501)       | `403`                      |
| Sisselogitud kasutaja loetleb andmed | `403`, permission denied (42501)       | `403`                      |
| Kollektsioon, millele pole reeglit   | ei kehti                               | `403`                      |

Värske seadistus on mõlemal suletud. Supabase'is on see uus: pärast 30. oktoobrit 2026 loodud tabelid ei saa enam Data API grante automaatselt ja minu CLI käitus juba nii, nii et esimene päring ebaõnnestus puuduva granti, mitte poliitika tõttu. Muudatust kirjeldasin artiklis [30. oktoobri grantide muudatus](https://madsalt.tech/et/blog/supabase-october-30-grant-change/). Tootmisrežiimis loodud Firebase'i andmebaas algab deny-all-reeglitega.

## Mis juhtub, kui see jääb lahti?

| Külalise päring    | Supabase, grant `anon`-ile, RLS väljas | Firebase, `allow read, write: if true` |
| ------------------ | -------------------------------------- | -------------------------------------- |
| Andmete loetlemine | `200`, kõik 3 rida                     | `200`, kõik 3 dokumenti                |
| Kirje lisamine     | `201`                                  | `200`                                  |
| Kirje kustutamine  | `200`, rida kustutatud                 | `200`, dokument kustutatud             |

Avatud olekud ei ole üks ja sama. Supabase'is on vaja tahtlikku granti `anon`-ile ja RLS-i väljalülitamist, mida mõned õpetused ja tehisintellekti tööriistad kirjutavad, et viga kaoks. Firebase'is on see testrežiim, millest paljud õpetused alustavad. Tulemus on sama: igaüks, kellel on rakenduse avalikud identifikaatorid, saab andmeid lugeda ja kustutada. RLS-i sisselülitamine ilma poliitikata sulges Supabase'i tabeli uuesti (`200` ja 0 rida külalisele ning A-le, `403` sisestamisel).

## Mis juhtub, kui kasutaja puudutab teise andmeid?

Siin käituvad nad erinevalt. Mõlemal oli ainult omaniku reegel: Supabase'i poliitikad `owner_id = auth.uid()` peal, Firebase'i reeglid `resource.data.ownerId == request.auth.uid` peal.

| A päring                     | Supabase                      | Firebase                                        |
| ---------------------------- | ----------------------------- | ----------------------------------------------- |
| Loetleb kõik                 | `200`, ainult A 2 rida        | `403`, kogu kollektsiooni päring tagasi lükatud |
| Loetleb filtriga oma id peal | `200`, A 2 rida               | `200`, A 2 dokumenti                            |
| Filtreerib B id järgi        | `200`, 0 rida                 | `403`                                           |
| Loeb B kirjet                | `200`, 0 rida                 | `403`                                           |
| Uuendab B kirjet             | `200`, 0 rida, viga puudub    | `403`                                           |
| Kustutab B kirje             | `200`, 0 rida, viga puudub    | `403`                                           |
| Loob B-le kuuluva kirje      | `403`, row security rikkumine | `403`                                           |

![Sama päring, kaks backendi. Kasutaja A muudab kasutaja B andmeid kummagi REST API kaudu. Supabase, ainult omaniku poliitika: Kasutaja A → muudab B andmeid → 200 \[\] → 0 rida, viga puudub; Firebase, ainult omaniku reegel: Kasutaja A → muudab B andmeid → 403 → tagastati viga.](https://madsalt.tech/charts/et/supabase-vs-firebase-security.svg)

*Joonis 1. Minu testid, 6. november 2026: kohalik Supabase'i stack (CLI 2.109.1) ja Firebase'i emulaatorid (CLI 15.35.0).*

Kumbki ei lekitanud B andmeid. Erineb vastus. Supabase filtreerib read, mida poliitika peidab, nii et kirjutamine, mis midagi ei leidnud, on edu nulli reaga, ja rakendus, mis loeb "viga puudub" kui "salvestatud", ütleb kasutajale, et muudatus õnnestus. Firebase kontrollib päringut ennast: päring, mis võiks tagastada reegli keelatud dokumente, lükatakse tervikuna tagasi, ja kirjutamine võõrasse dokumenti on viga, mida rakendus ei saa märkamata jätta. Hind on see, et iga Firebase'i loetelupäring peab kandma filtrit, mida reegel ootab.

## Kas kasutaja saab oma andmed ära anda või end adminiks teha?

| A päring                                                   | Supabase                                                             | Firebase                                                 |
| ---------------------------------------------------------- | -------------------------------------------------------------------- | -------------------------------------------------------- |
| Muudab oma kirje omaniku B-ks, uut väärtust ei kontrollita | `403` (update-poliitika ilma kontrollita kasutab oma filtrit uuesti) | `200` ja B luges selle seejärel `200`-ga                 |
| Sama, uue omaniku selge kontrolliga                        | `403`                                                                | `403`                                                    |
| Seab oma `role` väärtuseks `admin`, enda muutmine lubatud  | `200`, roll on nüüd `admin`                                          | `200` ja A lugemine B tellimusest läks `403`-lt `200`-le |
| Sama, pärast parandust                                     | `403` veerugrantiga ainult `display_name` peal; nimi `200`           | `403` reegliga, mis võrdleb rolli                        |

Omaniku üleandmine näitab erinevaid vaikeväärtusi: Postgresis rakendab poliitika, millel on ainult `using`-klausel, selle ka uuele reale, samas kui Firebase'i update-reegel kontrollib ainult seda, mille sa kirjutad. Kirjutasin selle nii, nagu paljud näited, vana omaniku kontrolliga, ja Firebase võttis uue vastu.

Rolli juhtum ebaõnnestub mõlemal samamoodi ja see on see, mida genereeritud koodis näen kõige sagedamini: reegel "kasutajad võivad oma profiili muuta", mis hõlmab rolli veergu. Supabase sulgeb selle veerugrandi või triggeriga, Firebase reegliga, mis võrdleb `request.resource.data.role` salvestatud väärtusega.

## Mida lubab avalik võti üksi?

Mõlemad tooted panevad igasse kliendisse avaliku identifikaatori. Supabase'is jõudis publishable (anon) võti API skeemiloendini vastusega `200`, mis nimetas kaht tabelit, mille olin `anon`-ile andnud, ja tagastatud andmed järgisid grante ja RLS-i: 3 rida RLS-iga väljas, 0 RLS-iga sees. Secret-võti tagastas kõik 3 rida ka RLS-iga sees, sest `service_role` jätab poliitikad vahele, ja see peab jääma serverisse; üksikasjad on artiklis [anon key vs service role key](https://madsalt.tech/et/blog/supabase-anon-key-vs-service-role-key/).

Firebase'is lasi avalik API võti mul Auth'i emulaatoris luua anonüümse kasutaja (`200` ja ID token). See ei ole iseenesest auk, sest reeglid otsustavad ikka, mida see kasutaja näeb, kuid see tähendab, et "sisse logitud" ei ole usaldussignaal, kui registreerimine on avatud. Reeglid, mis kontrollivad ainult `request.auth != null`, on igaühele lahti.

## Aga failide salvestus?

| Päring                                    | Supabase Storage, privaatne bucket                       | Firebase Storage                                                          |
| ----------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------- |
| Midagi pole seadistatud, A loeb B faili   | `400` not_found                                          | `403` (deny-all-reeglid)                                                  |
| Ainult omaniku reegel, A loetleb B kausta | `200`, 0 faili                                           | `403`                                                                     |
| Ainult omaniku reegel, A loeb B faili     | `400` not_found                                          | `403`                                                                     |
| Ainult omaniku reegel, A laeb B-le üles   | `400`, row security rikkumine                            | `403`                                                                     |
| Ainult omaniku reegel, A oma kaustas      | loend `200`, 1 fail; lugemine `200`; üleslaadimine `200` | loend `200`, 1 fail; lugemine `200`; kirjutamine `200`                    |
| Reegel on "iga sisselogitud kasutaja"     | ei testitud                                              | A luges B faili, loetles kõik 3 faili ja kirjutas B faili üle, kõik `200` |

Sama muster: Supabase peidab selle, mida sa näha ei tohi, nii et võõras fail paistab puuduvat, ja Firebase keeldub otse. Reegel "iga sisselogitud kasutaja" on salvestuse versioon ainult-sisselogimise veast ja lasi võõral kellegi passiskaneeringu üle kirjutada. Firebase'i üksikasjad, sealhulgas allalaadimistokenid, on artiklis [Firebase Storage'i reeglid](https://madsalt.tech/et/blog/firebase-storage-rules/).

## Kumb on turvalisem?

Kumbki pole vaikimisi turvaline ega ebaturvaline; mõlemad algasid suletuna. Nad erinevad selles, kus viga peidus on:

| Küsimus                             | Supabase                                 | Firebase                                      |
| ----------------------------------- | ---------------------------------------- | --------------------------------------------- |
| Kus ligipääsureeglid elavad         | SQL-i grandid ja poliitikad              | Reegliskeel tee kaupa                         |
| Keelatud võõra kasutaja kirjutamine | `200` nulli reaga update'il ja delete'il | `403`                                         |
| Loend, mis sisaldab teiste andmeid  | Filtreeritakse vaikselt                  | Lükatakse tagasi, kui päring reegliga ei sobi |
| Uus omanik update'il                | Kontrollitakse vaikimisi                 | Ainult kui sa kontrolli kirjutad              |
| Mis avab kõik kogemata              | Grant `anon`-ile ja RLS väljas           | Testrežiim või `if true`                      |
| Serveri võti                        | Secret-võti jätab kõik poliitikad vahele | Admin SDK jätab reeglid vahele                |

Firebase'i keeldumised on valjemad ja selle vead on reegli kujulised: puuduv uue väärtuse kontroll, rolliväli, mida kasutaja saab muuta. Supabase'i vaikus keelatud kirjutamistel on see, mille ümber tuleb kavandada, ja selle vead on poliitika kujulised: RLS väljas, poliitika, mis on alati tõene. Kui su meeskond ei hakka kumbagi lugema, ei päästa sind kumbki. Kui hakkab, on Firebase'i `403` testimisel lihtsamini märgatav ja Supabase'i SQL oskab väljendada reegleid, mis sõltuvad andmetest, näiteks MFA tase või ettevõtte liikmelisus. Kumba iganes valid, testi kahe kasutajana; meetod, mida kasutan, on artiklis [kuidas testida Supabase'i RLS-i](https://madsalt.tech/et/blog/how-to-test-supabase-rls/). Sama võrdluse tegin teise backendiga artiklis [Appwrite vs Supabase turvalisus](https://madsalt.tech/et/blog/appwrite-vs-supabase/).

## Kuidas kumbagi kontrollida?

Tasuta [Supabase'i turvakontroll](https://madsalt.tech/et/tools/supabase-security-check/) loeb sinu projekti ainult lugemisrežiimis ja märgib tabelid RLS-iga väljas, alati tõesed poliitikad, kirjutamispoliitikad külalistele ja grandid, mis annavad rohkem, kui poliitikad vihjavad. Tasuta [Firebase'i reeglikontroll](https://madsalt.tech/et/tools/firebase-rules-checker/) loeb kleebitud reegleid sinu projekti puudutamata ja märgib testrežiimi, ainult sisselogimisega ligipääsu ja kasutaja enda kirjutatud rollid. Kumbki ei asenda ülaltoodud päringute käivitamist külalisena ja teise kasutajana.

**Piirangud.** Üks kohalik Supabase'i stack ja üks Firebase'i emulaatori käivitus, REST-i kaudu, väljamõeldud andmetel. Firebase'i emulaator ei ole toodang ja ma ei testinud Realtime Database'i, Firebase App Checki (Emulator Suite seda ei sisalda), Supabase Realtime'i, funktsioone ega hindu. Tulemuse otsustavad sinu enda reeglid ja poliitikad.

## Minu sarnane juhtum

Rakendasin 1 170 avaliku Supabase'i projekti migratsioonid värsketele andmebaasidele: 568-st, mis jooksid puhtalt läbi, oli 134-l (23,6 %) tabel, mille RLS oli välja lülitatud ja mida avalik võti sai lugeda ja muuta. Meetod ja päringud on [avatud lähtekoodiga Supabase'i uuringus](https://madsalt.tech/et/blog/open-source-supabase-projects-security-study/).

Valite taustasüsteemi privaatseid andmeid sisaldavale rakendusele? Kirjutage mulle, siis selgitame välja, milline sobib ja kuidas see lukku panna.

Valite taustasüsteemi privaatsetele andmetele?

Öelge mulle, mis teil praegu on ja mida vajate. Vastan valikuga, mille ise teeksin.

[Kirjutage mulle](https://madsalt.tech/et/#contact)
