---
title: "Supabase vs Firebase drošība: vienādi uzbrukumi abiem"
description: "Tos pašus piekļuves uzbrukumus palaidu uz lokālu Supabase un Firebase emulatoriem. Abi sākas slēgti; atšķiras tas, kā neizdodas nepareizs noteikums."
url: "https://madsalt.tech/lv/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/lv/about/"
language: "lv"
published: 2026-11-06
---

# Supabase vs Firebase drošība: vienādi uzbrukumi abiem

TL;DR

Abi sākas slēgti: jauna Supabase tabula viesim atbildēja `401`, kamēr to nebiju piešķīris, un jauna Firebase datubāze ar deny-all noteikumiem atbildēja `403`. Atšķirība ir tajā, kā kļūda izpaužas. Kad lietotājs A atjaunināja vai izdzēsa lietotāja B datus ar tikai īpašnieka politiku, Supabase atbildēja `200`, nulle rindu un bez kļūdas; Firebase atteica ar `403`. Savukārt Firebase ļāva A nodot pasūtījumu B ar `200`, kad update noteikums pārbaudīja tikai veco īpašnieku, kamēr Supabase to pašu gājienu atteica ar `403`. Atverot (grant `anon` ar izslēgtu RLS vai `if true`), abi viesim iedeva visas trīs rindas un ļāva vienu izdzēst. Publiska atslēga vien nevienā neatver neko; lemj noteikumi.

Esmu Denys, Forward Deployed Engineer. Lielākā daļa lietotņu, ko labāju, darbojas uz Supabase vai Firebase, un tie, kas izvēlas starp tām, jautā, kura ir drošāka. Funkciju un cenu salīdzinājumi uz to neatbild, tāpēc abiem nosūtīju tos pašus pieprasījumus.

**Kā testēju.** Supabase caur lokālu steku (CLI 2.109.1, Postgres 17.6) un Firebase caur Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore un Storage), abus 2026. gada 6. novembrī. Vienkārši REST izsaukumi kā viesis un kā divi pieteikušies lietotāji A un B, ar izdomātiem datiem: pasūtījumi `a1` un `a2` pieder A, `b1` pieder B. Nekas neskāra īstu projektu.

## Kā Supabase un Firebase aizsargā datus?

Supabase glabā datus Postgres. Grant nosaka, vai API lomas vispār drīkst pieskarties tabulai, un row level security (RLS) politikas, rakstītas SQL, nosaka, kuras rindas katrs pieprasījums redz un raksta. Firebase glabā datus Firestore un Cloud Storage, un drošības noteikumi, atsevišķa valoda, pēc ceļa un pieprasījuma nosaka, vai lasīšana vai rakstīšana ir atļauta.

Tātad abiem ir piekļuves kontrole, un jautājums ir, ko katrs ļauj izdarīt nepareizi. Firebase noteikumus detalizēti aplūko [Firebase drošības noteikumu piemēri](https://madsalt.tech/lv/blog/firebase-security-rules-examples/), Supabase – [Supabase RLS politiku piemēri](https://madsalt.tech/lv/blog/supabase-rls-policy-examples/).

## Ko katrs dara ar jaunu projektu?

| Pieprasījums                      | Supabase, jauna tabula, nekas nav piešķirts | Firebase, deny-all noteikumi |
| --------------------------------- | ------------------------------------------- | ---------------------------- |
| Viesis izvada datus               | `401`, permission denied (42501)            | `403`                        |
| Pieteicies lietotājs izvada datus | `403`, permission denied (42501)            | `403`                        |
| Kolekcija bez tai noteikuma       | nav attiecināms                             | `403`                        |

Svaiga iestatīšana abiem ir slēgta. Supabase tā ir jaunumā: tabulas, kas izveidotas pēc 2026. gada 30. oktobra, vairs automātiski nesaņem Data API grantus, un mans CLI jau tā uzvedās, tāpēc pirmais pieprasījums neizdevās trūkstoša granta dēļ, nevis politikas dēļ. Izmaiņu aprakstīju rakstā [30. oktobra grantu izmaiņas](https://madsalt.tech/lv/blog/supabase-october-30-grant-change/). Ražošanas režīmā izveidota Firebase datubāze sākas ar deny-all noteikumiem.

## Kas notiek, ja to atstāj vaļā?

| Viesa pieprasījums | Supabase, grant `anon`, RLS izslēgts | Firebase, `allow read, write: if true` |
| ------------------ | ------------------------------------ | -------------------------------------- |
| Izvadīt datus      | `200`, visas 3 rindas                | `200`, visi 3 dokumenti                |
| Pievienot ierakstu | `201`                                | `200`                                  |
| Dzēst ierakstu     | `200`, rinda izdzēsta                | `200`, dokuments izdzēsts              |

Atvērtie stāvokļi nav viens un tas pats. Supabase vajag apzinātu grantu `anon` un izslēgtu RLS – paraugu, ko daži pamācību autori un mākslīgā intelekta rīki raksta, lai kļūda pazustu. Firebase tas ir testa režīms, no kura sākas daudzas pamācības. Rezultāts ir identisks: ikviens ar lietotnes publiskajiem identifikatoriem var lasīt un dzēst datus. RLS ieslēgšana bez politikas Supabase tabulu atkal aizvēra (`200` ar 0 rindām viesim un A, `403` ievietojot).

## Kas notiek, ja lietotājs pieskaras cita datiem?

Šeit tie uzvedas atšķirīgi. Abiem bija tikai īpašnieka noteikums: Supabase politikas uz `owner_id = auth.uid()`, Firebase noteikumi uz `resource.data.ownerId == request.auth.uid`.

| A pieprasījums                 | Supabase                      | Firebase                                    |
| ------------------------------ | ----------------------------- | ------------------------------------------- |
| Izvada visu                    | `200`, tikai A 2 rindas       | `403`, visas kolekcijas vaicājums noraidīts |
| Izvada ar filtru pēc sava id   | `200`, A 2 rindas             | `200`, A 2 dokumenti                        |
| Filtrē pēc B id                | `200`, 0 rindu                | `403`                                       |
| Lasa B ierakstu                | `200`, 0 rindu                | `403`                                       |
| Atjaunina B ierakstu           | `200`, 0 rindu, bez kļūdas    | `403`                                       |
| Dzēš B ierakstu                | `200`, 0 rindu, bez kļūdas    | `403`                                       |
| Izveido ierakstu, kas pieder B | `403`, row security pārkāpums | `403`                                       |

![Viens pieprasījums, divi backend. Lietotājs A maina lietotāja B datus caur katra REST API. Supabase, tikai īpašnieka politika: Lietotājs A → maina B datus → 200 \[\] → 0 rindu, bez kļūdas; Firebase, tikai īpašnieka noteikums: Lietotājs A → maina B datus → 403 → atgriezta kļūda.](https://madsalt.tech/charts/lv/supabase-vs-firebase-security.svg)

*1. att. Mani testi, 2026. gada 6. novembris: lokāls Supabase steks (CLI 2.109.1) un Firebase emulatori (CLI 15.35.0).*

Neviens neizplūdināja B datus. Atšķiras atbilde. Supabase filtrē rindas, ko politika slēpj, tāpēc rakstīšana, kas neatrada neko, ir veiksme ar nulle rindu, un lietotne, kas "bez kļūdas" saprot kā "saglabāts", pasaka lietotājam, ka labojums izdevās. Firebase pārbauda pašu pieprasījumu: vaicājums, kas varētu atgriezt noteikuma aizliegtus dokumentus, tiek noraidīts pilnībā, un rakstīšana cita dokumentā ir kļūda, ko lietotne nevar nepamanīt. Cena ir tā, ka katram Firebase saraksta vaicājumam jānes filtrs, ko noteikums gaida.

## Vai lietotājs var atdot savus datus vai sevi padarīt par adminu?

| A pieprasījums                                                      | Supabase                                                            | Firebase                                                            |
| ------------------------------------------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------- |
| Maina sava ieraksta īpašnieku uz B, jaunā vērtība netiek pārbaudīta | `403` (update politika bez pārbaudes atkārtoti izmanto savu filtru) | `200`, un B to pēc tam nolasīja ar `200`                            |
| Tas pats, ar skaidru jaunā īpašnieka pārbaudi                       | `403`                                                               | `403`                                                               |
| Iestata savu `role` uz `admin`, sevis rediģēšana atļauta            | `200`, loma tagad ir `admin`                                        | `200`, un A veiktā B pasūtījuma lasīšana mainījās no `403` uz `200` |
| Tas pats, pēc labojuma                                              | `403` ar kolonnas grantu tikai uz `display_name`; vārds `200`       | `403` ar noteikumu, kas salīdzina lomu                              |

Īpašnieka nodošana parāda atšķirīgos noklusējumus: Postgres politika tikai ar `using` klauzulu piemēro to arī jaunajai rindai, kamēr Firebase update noteikums pārbauda tikai to, ko tajā ierakstāt. Es to uzrakstīju tā, kā daudzi piemēri, pārbaudot veco īpašnieku, un Firebase pieņēma jauno.

Lomas gadījums abiem neizdodas vienādi, un tas ir tas, ko ģenerētā kodā redzu visbiežāk: noteikums "lietotāji var rediģēt savu profilu", kas ietver lomas kolonnu. Supabase to aizver ar kolonnas grantu vai trigeri, Firebase ar noteikumu, kas salīdzina `request.resource.data.role` ar saglabāto vērtību.

## Ko atļauj publiskā atslēga vien?

Abi produkti ievieto publisku identifikatoru katrā klientā. Supabase publishable (anon) atslēga sasniedza API shēmas sarakstu ar `200`, kurā bija abas tabulas, ko biju piešķīris `anon`, un atgrieztie dati sekoja grantiem un RLS: 3 rindas ar izslēgtu RLS, 0 ar ieslēgtu. Secret atslēga atgrieza visas 3 rindas arī ar ieslēgtu RLS, jo `service_role` izlaiž politikas, un tai jāpaliek serverī; sīkāk – rakstā [anon key vs service role key](https://madsalt.tech/lv/blog/supabase-anon-key-vs-service-role-key/).

Firebase publiskā API atslēga ļāva man Auth emulatorā izveidot anonīmu lietotāju (`200` un ID token). Tas pats par sevi nav caurums, jo noteikumi joprojām lemj, ko šis lietotājs redz, bet tas nozīmē, ka "pieteicies" nav uzticības signāls, kad reģistrācija ir atvērta. Noteikumi, kas pārbauda tikai `request.auth != null`, ir atvērti ikvienam.

## Un failu krātuve?

| Pieprasījums                                    | Supabase Storage, privāts bucket                            | Firebase Storage                                                               |
| ----------------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Nekas nav konfigurēts, A lasa B failu           | `400` not_found                                             | `403` (deny-all noteikumi)                                                     |
| Tikai īpašnieka noteikums, A izvada B mapi      | `200`, 0 faili                                              | `403`                                                                          |
| Tikai īpašnieka noteikums, A lasa B failu       | `400` not_found                                             | `403`                                                                          |
| Tikai īpašnieka noteikums, A augšupielādē pie B | `400`, row security pārkāpums                               | `403`                                                                          |
| Tikai īpašnieka noteikums, A savā mapē          | saraksts `200`, 1 fails; lasīšana `200`; augšupielāde `200` | saraksts `200`, 1 fails; lasīšana `200`; rakstīšana `200`                      |
| Noteikums ir "jebkurš pieteicies lietotājs"     | netestēts                                                   | A nolasīja B failu, izvadīja visus 3 failus un pārrakstīja B failu, viss `200` |

Atkārtojas tas pats paraugs: Supabase paslēpj to, ko nedrīkst redzēt, tāpēc cita fails šķiet neesošs, un Firebase atsaka tieši. Noteikums "jebkurš pieteicies lietotājs" ir krātuves versija kļūdai tikai ar pieteikšanos, un tas ļāva svešiniekam pārrakstīt kāda pases skenējumu. Firebase detaļas, ieskaitot lejupielādes žetonus, ir rakstā [Firebase Storage noteikumi](https://madsalt.tech/lv/blog/firebase-storage-rules/).

## Kurš ir drošāks?

Neviens nav drošs vai nedrošs pēc noklusējuma; abi sākās slēgti. Tie atšķiras ar to, kur slēpjas kļūda:

| Jautājums                           | Supabase                                       | Firebase                                     |
| ----------------------------------- | ---------------------------------------------- | -------------------------------------------- |
| Kur mīt piekļuves noteikumi         | SQL granti un politikas                        | Noteikumu valoda pēc ceļa                    |
| Noraidīta cita lietotāja rakstīšana | `200` ar nulle rindu update un delete gadījumā | `403`                                        |
| Saraksts, kas ietver citu datus     | Filtrēts klusi                                 | Noraidīts, ja vaicājums neatbilst noteikumam |
| Jaunais īpašnieks update gadījumā   | Pārbaudīts pēc noklusējuma                     | Tikai ja uzrakstāt pārbaudi                  |
| Kas kļūdas dēļ atver visu           | Grant `anon` ar izslēgtu RLS                   | Testa režīms vai `if true`                   |
| Servera atslēga                     | Secret atslēga izlaiž visas politikas          | Admin SDK izlaiž noteikumus                  |

Firebase atteikumi ir skaļāki, un tā kļūdas ir noteikuma formā: trūkstoša jaunās vērtības pārbaude, lomas lauks, ko lietotājs var rediģēt. Supabase klusēšana pie noraidītām rakstīšanām ir tas, ap ko jāprojektē, un tās kļūdas ir politikas formā: RLS izslēgts, politika, kas vienmēr ir patiesa. Ja jūsu komanda nelasīs nevienu, nevienu neglābs. Ja lasīs, Firebase `403` testēšanā ir vieglāk pamanāms, un Supabase SQL var izteikt no datiem atkarīgus noteikumus, piemēram, MFA līmeni vai piederību uzņēmumam. Ko izvēlēsieties, testējiet kā divi lietotāji; mana metode ir rakstā [kā testēt Supabase RLS](https://madsalt.tech/lv/blog/how-to-test-supabase-rls/). Tādu pašu salīdzinājumu ar citu backend izdarīju rakstā [Appwrite vs Supabase drošība](https://madsalt.tech/lv/blog/appwrite-vs-supabase/).

## Kā pārbaudīt katru?

Bezmaksas [Supabase drošības pārbaude](https://madsalt.tech/lv/tools/supabase-security-check/) lasa jūsu projektu tikai lasīšanas režīmā un atzīmē tabulas ar izslēgtu RLS, vienmēr patiesas politikas, rakstīšanas politikas viesiem un grantus, kas dod vairāk, nekā liecina politikas. Bezmaksas [Firebase noteikumu pārbaudītājs](https://madsalt.tech/lv/tools/firebase-rules-checker/) lasa ielīmētus noteikumus, neskarot jūsu projektu, un atzīmē testa režīmu, piekļuvi tikai ar pieteikšanos un lietotāja pašu rakstītas lomas. Neviens neaizstāj iepriekš minēto pieprasījumu izpildi kā viesis un kā otrs lietotājs.

**Ierobežojumi.** Viens lokāls Supabase steks un viens Firebase emulatora palaišanas reize, caur REST, uz izdomātiem datiem. Firebase emulators nav ražošana, un netestēju Realtime Database, Firebase App Check (Emulator Suite to neietver), Supabase Realtime, funkcijas vai cenas. Rezultātu nosaka jūsu pašu noteikumi un politikas.

## Mans līdzīgais gadījums

Pielietoju 1 170 publisku Supabase projektu migrācijas svaigām datubāzēm: no 568, kas darbojās bez kļūdām, 134 (23,6 %) bija tabula ar izslēgtu RLS, ko publiskā atslēga varēja lasīt un mainīt. Metode un vaicājumi ir [atvērtā koda Supabase pētījumā](https://madsalt.tech/lv/blog/open-source-supabase-projects-security-study/).

Izvēlaties backend lietotnei ar privātiem datiem? Uzrakstiet man, kopā izlemsim, kurš der un kā to nodrošināt.

Izvēlaties backend privātiem datiem?

Uzrakstiet man, kas jums ir tagad un kas jums vajadzīgs. Atbildēšu ar variantu, ko izvēlētos pats.

[Rakstiet man](https://madsalt.tech/lv/#contact)
