---
title: "Supabase vs Firebase sauga: tos pačios atakos abiem"
description: "Tas pačias prieigos atakas paleidau ant vietinio Supabase ir Firebase emuliatorių. Abu prasideda uždari; skiriasi tai, kaip suklysta klaidinga taisyklė."
url: "https://madsalt.tech/lt/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/lt/about/"
language: "lt"
published: 2026-11-06
---

# Supabase vs Firebase sauga: tos pačios atakos abiem

TL;DR

Abu prasideda uždari: nauja Supabase lentelė svečiui atsakė `401`, kol jos neišdaviau, o nauja Firebase duomenų bazė su deny-all taisyklėmis atsakė `403`. Skirtumas yra tai, kaip nepavyksta klaida. Kai vartotojas A atnaujino ar ištrynė vartotojo B duomenis pagal tik savininko politiką, Supabase atsakė `200`, nulis eilučių ir be klaidos; Firebase atsisakė su `403`. Kita vertus, Firebase leido A perduoti užsakymą B su `200`, kai update taisyklė tikrino tik seną savininką, o Supabase tą patį žingsnį atmetė su `403`. Atvertus (grant `anon` su išjungtu RLS arba `if true`), abu davė svečiui visas tris eilutes ir leido vieną ištrinti. Vien viešas raktas nė viename nieko neatveria; sprendžia taisyklės.

Esu Denys, Forward Deployed Engineer. Dauguma programų, kurias taisau, veikia ant Supabase arba Firebase, o tie, kurie renkasi tarp jų, klausia, kuris saugesnis. Funkcijų ir kainų palyginimai į tai neatsako, todėl abiem išsiunčiau tas pačias užklausas.

**Kaip testavau.** Supabase per vietinį stack (CLI 2.109.1, Postgres 17.6), o Firebase per Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore ir Storage), abu 2026 m. lapkričio 6 d. Paprasti REST kvietimai kaip svečias ir kaip du prisijungę vartotojai A ir B, su išgalvotais duomenimis: užsakymai `a1` ir `a2` priklauso A, `b1` priklauso B. Nieko nelietė tikras projektas.

## Kaip Supabase ir Firebase saugo duomenis?

Supabase laiko duomenis Postgres. Grant nusprendžia, ar API rolės apskritai gali liesti lentelę, o row level security (RLS) politikos, parašytos SQL, nusprendžia, kurias eilutes kiekviena užklausa mato ir rašo. Firebase laiko duomenis Firestore ir Cloud Storage, o saugumo taisyklės, atskira kalba, pagal kelią ir užklausą nusprendžia, ar skaitymas ar rašymas leidžiamas.

Taigi abu turi prieigos kontrolę, o klausimas, ką kiekvienas leidžia padaryti klaidingai. Firebase taisykles išsamiai aptaria [Firebase saugumo taisyklių pavyzdžiai](https://madsalt.tech/lt/blog/firebase-security-rules-examples/), Supabase – [Supabase RLS politikų pavyzdžiai](https://madsalt.tech/lt/blog/supabase-rls-policy-examples/).

## Ką kiekvienas daro su nauju projektu?

| Užklausa                         | Supabase, nauja lentelė, nieko neišduota | Firebase, deny-all taisyklės |
| -------------------------------- | ---------------------------------------- | ---------------------------- |
| Svečias išvardija duomenis       | `401`, permission denied (42501)         | `403`                        |
| Prisijungęs vartotojas išvardija | `403`, permission denied (42501)         | `403`                        |
| Kolekcija be taisyklės jai       | netaikoma                                | `403`                        |

Šviežia sąranka abiejuose uždara. Supabase tai nauja: lentelės, sukurtos po 2026 m. spalio 30 d., nebegauna Data API grantų automatiškai, ir mano CLI jau taip elgėsi, todėl pirma užklausa nepavyko dėl trūkstamo granto, o ne dėl politikos. Pakeitimą aprašiau straipsnyje [spalio 30 d. grantų pakeitimas](https://madsalt.tech/lt/blog/supabase-october-30-grant-change/). Produkcijos režimu sukurta Firebase duomenų bazė prasideda su deny-all taisyklėmis.

## Kas nutinka, kai paliekama atvira?

| Svečio užklausa    | Supabase, grant `anon`, RLS išjungtas | Firebase, `allow read, write: if true` |
| ------------------ | ------------------------------------- | -------------------------------------- |
| Išvardyti duomenis | `200`, visos 3 eilutės                | `200`, visi 3 dokumentai               |
| Pridėti įrašą      | `201`                                 | `200`                                  |
| Ištrinti įrašą     | `200`, eilutė ištrinta                | `200`, dokumentas ištrintas            |

Atviros būsenos nėra tas pats. Supabase reikia sąmoningo granto `anon` ir išjungto RLS – šabloną kai kurios pamokos ir dirbtinio intelekto įrankiai rašo, kad klaida išnyktų. Firebase tai bandymo režimas, nuo kurio prasideda daug pamokų. Rezultatas vienodas: bet kas, turintis viešus programos identifikatorius, gali skaityti ir ištrinti duomenis. Įjungus RLS be politikos Supabase lentelė vėl užsidarė (`200` su 0 eilučių svečiui ir A, `403` įterpiant).

## Kas nutinka, kai vartotojas liečia svetimus duomenis?

Čia elgiasi skirtingai. Abu turėjo tik savininko taisyklę: Supabase politikos su `owner_id = auth.uid()`, Firebase taisyklės su `resource.data.ownerId == request.auth.uid`.

| A užklausa                        | Supabase                       | Firebase                                 |
| --------------------------------- | ------------------------------ | ---------------------------------------- |
| Išvardija viską                   | `200`, tik A 2 eilutės         | `403`, visos kolekcijos užklausa atmesta |
| Išvardija su filtru pagal savo id | `200`, A 2 eilutės             | `200`, A 2 dokumentai                    |
| Filtruoja pagal B id              | `200`, 0 eilučių               | `403`                                    |
| Skaito B įrašą                    | `200`, 0 eilučių               | `403`                                    |
| Atnaujina B įrašą                 | `200`, 0 eilučių, be klaidos   | `403`                                    |
| Ištrina B įrašą                   | `200`, 0 eilučių, be klaidos   | `403`                                    |
| Sukuria įrašą, priklausantį B     | `403`, row security pažeidimas | `403`                                    |

![Ta pati užklausa, du backend. Vartotojas A keičia vartotojo B duomenis per kiekvieno REST API. Supabase, tik savininko politika: Vartotojas A → keičia B duomenis → 200 \[\] → 0 eilučių, be klaidos; Firebase, tik savininko taisyklė: Vartotojas A → keičia B duomenis → 403 → grąžinta klaida.](https://madsalt.tech/charts/lt/supabase-vs-firebase-security.svg)

*1 pav. Mano testai, 2026 m. lapkričio 6 d.: vietinis Supabase stack (CLI 2.109.1) ir Firebase emuliatoriai (CLI 15.35.0).*

Nei vienas neprarado B duomenų. Skiriasi atsakymas. Supabase filtruoja eilutes, kurias politika slepia, todėl įrašymas, kuris nieko neradęs, yra sėkmė su nuliu eilučių, o programa, kuri "be klaidos" supranta kaip "išsaugota", pasako vartotojui, kad pakeitimas pavyko. Firebase tikrina pačią užklausą: užklausa, kuri galėtų grąžinti taisyklės draudžiamus dokumentus, atmetama visa, o rašymas į svetimą dokumentą yra klaida, kurios programa negali praleisti. Kaina ta, kad kiekviena Firebase sąrašo užklausa turi nešti filtrą, kurio taisyklė tikisi.

## Ar vartotojas gali atiduoti savo duomenis arba pasidaryti adminu?

| A užklausa                                                     | Supabase                                                             | Firebase                                                   |
| -------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------------------------------------- |
| Pakeičia savo įrašo savininką į B, naujos reikšmės netikrinama | `403` (update politika be patikros pakartotinai naudoja savo filtrą) | `200`, o B vėliau jį perskaitė su `200`                    |
| Tas pats, su aiškia naujo savininko patikra                    | `403`                                                                | `403`                                                      |
| Nustato savo `role` į `admin`, savęs redagavimas leidžiamas    | `200`, rolė dabar `admin`                                            | `200`, o A skaitymas B užsakymo pasikeitė iš `403` į `200` |
| Tas pats, po pataisymo                                         | `403` su stulpelio grantu tik `display_name`; vardas `200`           | `403` su taisykle, lyginančia rolę                         |

Savininko perdavimas rodo skirtingas numatytąsias reikšmes: Postgres politika tik su `using` sąlyga taiko ją ir naujai eilutei, o Firebase update taisyklė tikrina tik tai, ką į ją įrašai. Parašiau ją taip, kaip daug pavyzdžių, tikrindamas seną savininką, ir Firebase priėmė naują.

Rolės atvejis abiejuose nepavyksta vienodai ir tai dažniausia, ką matau sugeneruotame kode: taisyklė "vartotojai gali redaguoti savo profilį", apimanti rolės stulpelį. Supabase tai uždaro stulpelio grantu ar trigeriu, Firebase – taisykle, lyginančia `request.resource.data.role` su išsaugota reikšme.

## Ką leidžia vien viešas raktas?

Abu produktai į kiekvieną klientą deda viešą identifikatorių. Supabase publishable (anon) raktas pasiekė API schemos sąrašą su `200`, kuriame buvo dvi lentelės, kurias buvau davęs `anon`, o grąžinti duomenys sekė grantus ir RLS: 3 eilutės su išjungtu RLS, 0 su įjungtu. Secret raktas grąžino visas 3 eilutes ir su įjungtu RLS, nes `service_role` praleidžia politikas, ir jis turi likti serveryje; išsami informacija – straipsnyje [anon key vs service role key](https://madsalt.tech/lt/blog/supabase-anon-key-vs-service-role-key/).

Firebase viešas API raktas leido man Auth emuliatoriuje sukurti anoniminį vartotoją (`200` ir ID žetonas). Tai savaime ne skylė, nes taisyklės vis tiek nusprendžia, ką tas vartotojas mato, bet tai reiškia, kad "prisijungęs" nėra pasitikėjimo signalas, kai registracija atvira. Taisyklės, tikrinančios tik `request.auth != null`, atviros kiekvienam.

## O failų saugykla?

| Užklausa                                      | Supabase Storage, privatus bucket                        | Firebase Storage                                                               |
| --------------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Nieko nesukonfigūruota, A skaito B failą      | `400` not_found                                          | `403` (deny-all taisyklės)                                                     |
| Tik savininko taisyklė, A išvardija B aplanką | `200`, 0 failų                                           | `403`                                                                          |
| Tik savininko taisyklė, A skaito B failą      | `400` not_found                                          | `403`                                                                          |
| Tik savininko taisyklė, A įkelia pas B        | `400`, row security pažeidimas                           | `403`                                                                          |
| Tik savininko taisyklė, A savo aplanke        | sąrašas `200`, 1 failas; skaitymas `200`; įkėlimas `200` | sąrašas `200`, 1 failas; skaitymas `200`; rašymas `200`                        |
| Taisyklė "bet kuris prisijungęs vartotojas"   | netestuota                                               | A perskaitė B failą, išvardijo visus 3 failus ir perrašė B failą, viskas `200` |

Kartojasi tas pats šablonas: Supabase paslepia tai, ko negali matyti, todėl svetimas failas atrodo neegzistuojantis, o Firebase atsisako tiesiai. Taisyklė "bet kuris prisijungęs vartotojas" yra saugyklos versija klaidos tik su prisijungimu ir leido nepažįstamajam perrašyti kažkieno paso skenavimą. Firebase detalės, įskaitant atsisiuntimo žetonus, – straipsnyje [Firebase Storage taisyklės](https://madsalt.tech/lt/blog/firebase-storage-rules/).

## Kuris saugesnis?

Nė vienas nėra saugus ar nesaugus pagal numatytuosius nustatymus; abu prasidėjo uždari. Jie skiriasi tuo, kur slepiasi klaida:

| Klausimas                          | Supabase                                 | Firebase                                     |
| ---------------------------------- | ---------------------------------------- | -------------------------------------------- |
| Kur gyvena prieigos taisyklės      | SQL grantai ir politikos                 | Taisyklių kalba pagal kelią                  |
| Atmestas svetimo vartotojo rašymas | `200` su nuliu eilučių update ir delete  | `403`                                        |
| Sąrašas, apimantis kitų duomenis   | Filtruojamas tyliai                      | Atmetamas, jei užklausa neatitinka taisyklės |
| Naujas savininkas update metu      | Tikrinamas pagal numatymą                | Tik jei parašysi patikrą                     |
| Kas per klaidą atveria viską       | Grant `anon` su išjungtu RLS             | Bandymo režimas arba `if true`               |
| Serverio raktas                    | Secret raktas praleidžia visas politikas | Admin SDK praleidžia taisykles               |

Firebase atsisakymai garsesni, o jo klaidos turi taisyklės formą: trūkstama naujos reikšmės patikra, rolės laukas, kurį vartotojas gali keisti. Supabase tyla dėl atmestų rašymų yra tai, aplink ką reikia projektuoti, o jos klaidos turi politikos formą: RLS išjungtas, politika, kuri visada teisinga. Jei jūsų komanda neskaitys nei vieno, nei vienas jūsų neišgelbės. Jei skaitys, Firebase `403` lengviau pastebimas testuojant, o Supabase SQL gali išreikšti nuo duomenų priklausančias taisykles, pavyzdžiui MFA lygį ar narystę įmonėje. Kurį bepasirinktumėte, testuokite kaip du vartotojai; mano naudojamas metodas – straipsnyje [kaip testuoti Supabase RLS](https://madsalt.tech/lt/blog/how-to-test-supabase-rls/). Tą patį palyginimą su kitu backend padariau straipsnyje [Appwrite vs Supabase sauga](https://madsalt.tech/lt/blog/appwrite-vs-supabase/).

## Kaip patikrinti kiekvieną?

Nemokamas [Supabase saugumo patikrinimas](https://madsalt.tech/lt/tools/supabase-security-check/) skaito jūsų projektą tik skaitymo režimu ir pažymi lenteles su išjungtu RLS, visada teisingas politikas, rašymo politikas svečiams ir grantus, kurie duoda daugiau, nei leidžia suprasti politikos. Nemokamas [Firebase taisyklių tikrintuvas](https://madsalt.tech/lt/tools/firebase-rules-checker/) skaito įklijuotas taisykles nelies jūsų projekto ir pažymi bandymo režimą, prieigą tik su prisijungimu ir vartotojo pačių parašytas roles. Nė vienas nepakeičia aukščiau pateiktų užklausų vykdymo kaip svečias ir kaip antras vartotojas.

**Apribojimai.** Vienas vietinis Supabase stack ir vienas Firebase emuliatoriaus paleidimas, per REST, su išgalvotais duomenimis. Firebase emuliatorius nėra produkcija, ir netestavau Realtime Database, Firebase App Check (Emulator Suite jo neturi), Supabase Realtime, funkcijų ar kainų. Rezultatą nulemia jūsų pačių taisyklės ir politikos.

## Mano panašus atvejis

Pritaikiau 1 170 viešų Supabase projektų migracijas švarioms duomenų bazėms: iš 568, kurios veikė be klaidų, 134 (23,6 %) turėjo lentelę su išjungtu RLS, kurią viešasis raktas galėjo skaityti ir keisti. Metodas ir užklausos pateikti [atvirojo kodo Supabase tyrime](https://madsalt.tech/lt/blog/open-source-supabase-projects-security-study/).

Renkatės backend programai su privačiais duomenimis? Parašykite man, kartu nuspręsime, kuris tinka ir kaip jį apsaugoti.

Renkatės backend privatiems duomenims?

Parašykite man, ką turite dabar ir ko jums reikia. Atsakysiu variantu, kurį pasirinkčiau pats.

[Parašykite man](https://madsalt.tech/lt/#contact)
