---
title: "Supabase vs Firebase: bezpečnost, stejné útoky na oba"
description: "Stejné přístupové útoky jsem pustil na lokální Supabase a emulátory Firebase. Oba startují zavřené; liší se tím, jak selže špatné pravidlo."
url: "https://madsalt.tech/cs/blog/supabase-vs-firebase-security/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/cs/about/"
language: "cs"
published: 2026-11-06
---

# Supabase vs Firebase: bezpečnost, stejné útoky na oba

TL;DR

Oba startují zavřené: nová tabulka Supabase odpovídala hostovi `401`, dokud jsem ji nepřidělil, a nová databáze Firebase s pravidly deny-all odpověděla `403`. Rozdíl je v tom, jak selže chyba. Když uživatel A upravil nebo smazal data uživatele B pod politikou jen pro vlastníka, Supabase odpověděla `200` s nulou řádků a bez chyby; Firebase odmítla s `403`. Firebase naopak nechala A předat objednávku uživateli B s `200`, když pravidlo update kontrolovalo jen starého vlastníka, kdežto Supabase stejný krok odmítla s `403`. Po otevření (grant pro `anon` s vypnutým RLS, nebo `if true`) dostal host na obou všechny tři řádky a mohl jeden smazat. Veřejný klíč sám neotevře na žádné z nich nic; rozhodují pravidla.

Jsem Denys, Forward Deployed Engineer. Většina aplikací, které opravuji, běží na Supabase nebo Firebase, a lidé, kteří mezi nimi vybírají, se ptají, která je bezpečnější. Srovnání funkcí a cen na to neodpoví, tak jsem oběma poslal stejné požadavky.

**Jak jsem testoval.** Supabase přes lokální stack (CLI 2.109.1, Postgres 17.6) a Firebase přes Local Emulator Suite (firebase-tools 15.35.0, Auth, Firestore a Storage), obojí 6. listopadu 2026. Čisté REST volání jako host a jako dva přihlášení uživatelé A a B, s vymyšlenými daty: objednávky `a1` a `a2` patří A, `b1` patří B. Nic se nedotklo skutečného projektu.

## Jak Supabase a Firebase chrání data?

Supabase ukládá data do Postgresu. Grant rozhoduje, zda role API vůbec sáhnou na tabulku, a politiky row level security (RLS), psané v SQL, rozhodují, které řádky každý požadavek vidí a zapisuje. Firebase ukládá data do Firestore a Cloud Storage a bezpečnostní pravidla, samostatný jazyk, rozhodují podle cesty a požadavku, zda je čtení nebo zápis povolen.

Řízení přístupu mají tedy oba a otázka zní, co vám každý dovolí pokazit. Pravidla Firebase podrobně popisuje článek [příklady bezpečnostních pravidel Firebase](https://madsalt.tech/cs/blog/firebase-security-rules-examples/), Supabase článek [příklady politik Supabase RLS](https://madsalt.tech/cs/blog/supabase-rls-policy-examples/).

## Co dělá každý s novým projektem?

| Požadavek                       | Supabase, nová tabulka, nic nepřidělené | Firebase, pravidla deny-all |
| ------------------------------- | --------------------------------------- | --------------------------- |
| Host vypíše data                | `401`, permission denied (42501)        | `403`                       |
| Přihlášený uživatel vypíše data | `403`, permission denied (42501)        | `403`                       |
| Kolekce bez pravidla pro ni     | nelze použít                            | `403`                       |

Čerstvé nastavení je na obou zavřené. Na Supabase je to novinka: tabulky vytvořené po 30. říjnu 2026 už automaticky nedostávají granty Data API a moje CLI se tak už chovalo, takže první požadavek selhal na chybějícím grantu, ne na politice. Změnu jsem popsal v článku [změna grantů 30. října](https://madsalt.tech/cs/blog/supabase-october-30-grant-change/). Databáze Firebase vytvořená v produkčním režimu startuje s pravidly deny-all.

## Co se stane, když zůstane otevřené?

| Požadavek hosta | Supabase, grant pro `anon`, RLS vypnuté | Firebase, `allow read, write: if true` |
| --------------- | --------------------------------------- | -------------------------------------- |
| Výpis dat       | `200`, všechny 3 řádky                  | `200`, všechny 3 dokumenty             |
| Přidání záznamu | `201`                                   | `200`                                  |
| Smazání záznamu | `200`, řádek smazán                     | `200`, dokument smazán                 |

Otevřené stavy nejsou totéž. Na Supabase to chce záměrný grant pro `anon` a vypnuté RLS, což je vzor, který píšou některé návody a nástroje AI, aby zmizela chyba. Na Firebase je to testovací režim, od kterého začíná spousta návodů. Výsledek je stejný: kdokoli s veřejnými identifikátory aplikace může data číst i smazat. Zapnutí RLS bez politiky tabulku Supabase znovu zavřelo (`200` s 0 řádky pro hosta i pro A a `403` při vložení).

## Co se stane, když uživatel sáhne na cizí data?

Tady se chovají jinak. Oba měli pravidlo jen pro vlastníka: politiky Supabase na `owner_id = auth.uid()`, pravidla Firebase na `resource.data.ownerId == request.auth.uid`.

| Požadavek uživatele A          | Supabase                     | Firebase                               |
| ------------------------------ | ---------------------------- | -------------------------------------- |
| Vypíše všechno                 | `200`, jen 2 řádky A         | `403`, dotaz na celou kolekci odmítnut |
| Vypíše s filtrem na vlastní id | `200`, 2 řádky A             | `200`, 2 dokumenty A                   |
| Filtruje podle id uživatele B  | `200`, 0 řádků               | `403`                                  |
| Čte záznam uživatele B         | `200`, 0 řádků               | `403`                                  |
| Upraví záznam uživatele B      | `200`, 0 řádků, bez chyby    | `403`                                  |
| Smaže záznam uživatele B       | `200`, 0 řádků, bez chyby    | `403`                                  |
| Vytvoří záznam patřící B       | `403`, porušení row security | `403`                                  |

![Stejný požadavek, dva backendy. Uživatel A upravuje data uživatele B přes REST API obou. Supabase, politika jen pro vlastníka: Uživatel A → úprava dat B → 200 \[\] → 0 řádků, bez chyby; Firebase, pravidlo jen pro vlastníka: Uživatel A → úprava dat B → 403 → vrácena chyba.](https://madsalt.tech/charts/cs/supabase-vs-firebase-security.svg)

*Obrázek 1. Moje testy, 6. listopadu 2026: lokální stack Supabase (CLI 2.109.1) a emulátory Firebase (CLI 15.35.0).*

Ani jedna neprozradila data uživatele B. Liší se odpověď. Supabase filtruje řádky, které politika skrývá, takže zápis, který nic nenašel, je úspěch s nulou řádků, a aplikace, která bere „žádná chyba“ jako „uloženo“, řekne uživateli, že úprava proběhla. Firebase kontroluje samotný požadavek: dotaz, který by mohl vrátit zakázané dokumenty, odmítne celý, a zápis do cizího dokumentu je chyba, kterou aplikace nepřehlédne. Cenou je, že každý výpis ve Firebase musí nést filtr, který pravidlo očekává.

## Může uživatel svá data předat nebo se udělat adminem?

| Požadavek uživatele A                                             | Supabase                                                   | Firebase                                                            |
| ----------------------------------------------------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------- |
| Změní vlastníka vlastního záznamu na B, bez kontroly nové hodnoty | `403` (politika update bez kontroly použije vlastní filtr) | `200` a B ho pak přečetl s `200`                                    |
| Totéž s explicitní kontrolou nového vlastníka                     | `403`                                                      | `403`                                                               |
| Nastaví si vlastní `role` na `admin`, úprava sebe je povolena     | `200`, role je nyní `admin`                                | `200` a čtení objednávky B uživatelem A se změnilo z `403` na `200` |
| Totéž po opravě                                                   | `403` s grantem sloupce jen na `display_name`; jméno `200` | `403` s pravidlem, které porovná roli                               |

Přesun vlastníka ukazuje odlišné výchozí chování: v Postgresu politika jen s klauzulí `using` ji použije i na nový řádek, kdežto pravidlo update ve Firebase kontroluje jen to, co do něj napíšete. Napsal jsem ho jako spousta příkladů, s kontrolou starého vlastníka, a Firebase přijala nového.

Případ s rolí selže na obou stejně a je to ten, který v generovaném kódu vidím nejčastěji: pravidlo „uživatelé mohou upravovat svůj profil“ zahrnující sloupec role. Supabase ho zavře grantem na sloupec nebo triggerem, Firebase pravidlem, které porovná `request.resource.data.role` s uloženou hodnotou.

## Co dovolí samotný veřejný klíč?

Oba produkty dávají do každého klienta veřejný identifikátor. Na Supabase se publishable (anon) klíč dostal k výpisu schématu API s `200`, který jmenoval dvě tabulky, které jsem přidělil `anon`, a vrácená data se řídila granty a RLS: 3 řádky s vypnutým RLS, 0 se zapnutým. Secret klíč vrátil všechny 3 řádky i se zapnutým RLS, protože `service_role` politiky obchází, a musí zůstat na serveru; podrobnosti jsou v článku [anon key vs service role key](https://madsalt.tech/cs/blog/supabase-anon-key-vs-service-role-key/).

Na Firebase mi veřejný API klíč v emulátoru Auth umožnil vytvořit anonymního uživatele (`200` a ID token). To samo o sobě není díra, protože pravidla stále rozhodují, co tento uživatel vidí, ale znamená to, že „přihlášen“ není signál důvěry, když je registrace otevřená. Pravidla, která kontrolují jen `request.auth != null`, jsou otevřená komukoli.

## A úložiště souborů?

| Požadavek                                     | Supabase Storage, soukromý bucket                 | Firebase Storage                                                           |
| --------------------------------------------- | ------------------------------------------------- | -------------------------------------------------------------------------- |
| Nic nenastaveno, A čte soubor uživatele B     | `400` not_found                                   | `403` (pravidla deny-all)                                                  |
| Pravidlo jen pro vlastníka, A vypíše složku B | `200`, 0 souborů                                  | `403`                                                                      |
| Pravidlo jen pro vlastníka, A čte soubor B    | `400` not_found                                   | `403`                                                                      |
| Pravidlo jen pro vlastníka, A nahraje k B     | `400`, porušení row security                      | `403`                                                                      |
| Pravidlo jen pro vlastníka, A ve své složce   | výpis `200`, 1 soubor; čtení `200`; nahrání `200` | výpis `200`, 1 soubor; čtení `200`; zápis `200`                            |
| Pravidlo „každý přihlášený uživatel“          | netestováno                                       | A přečetl soubor B, vypsal všechny 3 soubory a přepsal soubor B, vše `200` |

Opakuje se stejný vzor: Supabase skryje, co vidět nesmíte, takže cizí soubor vypadá, že neexistuje, a Firebase odmítne rovnou. Pravidlo „každý přihlášený uživatel“ je úložištní verze chyby s pravidlem jen na přihlášení a nechalo cizího uživatele přepsat něčí sken pasu. Podrobnosti o Firebase, včetně download tokenů, jsou v článku [pravidla Firebase Storage](https://madsalt.tech/cs/blog/firebase-storage-rules/).

## Který je bezpečnější?

Ani jeden není ve výchozím stavu bezpečný nebo nebezpečný; oba startovaly zavřené. Liší se tím, kde se chyba skrývá:

| Otázka                           | Supabase                              | Firebase                                  |
| -------------------------------- | ------------------------------------- | ----------------------------------------- |
| Kde žijí pravidla přístupu       | granty a politiky v SQL               | jazyk pravidel podle cesty                |
| Zamítnutý zápis cizího uživatele | `200` s nulou řádků u update a delete | `403`                                     |
| Výpis, který zahrnuje cizí data  | potichu vyfiltrován                   | odmítnut, pokud dotaz neodpovídá pravidlu |
| Nový vlastník při update         | ve výchozím stavu kontrolován         | jen pokud kontrolu napíšete               |
| Co omylem otevře všechno         | grant pro `anon` s vypnutým RLS       | testovací režim nebo `if true`            |
| Serverový klíč                   | secret klíč obchází všechny politiky  | Admin SDK obchází pravidla                |

Odmítnutí ve Firebase jsou hlasitější a její chyby mají tvar pravidla: chybějící kontrola nové hodnoty, pole role, které uživatel smí upravit. Ticho Supabase u zamítnutých zápisů je to, kolem čeho se musí navrhovat, a její chyby mají tvar politiky: vypnuté RLS, politika, která vždy platí. Pokud váš tým nebude číst ani jedno, nezachrání vás ani jedno. Pokud ano, `403` z Firebase je při testování snáze vidět a SQL v Supabase umí vyjádřit pravidla závislá na datech, třeba úroveň MFA nebo členství ve firmě. Ať zvolíte cokoli, testujte jako dva uživatelé; metoda, kterou používám, je v článku [jak testovat Supabase RLS](https://madsalt.tech/cs/blog/how-to-test-supabase-rls/). Stejné srovnání s jiným backendem jsem udělal v článku [Appwrite vs Supabase: bezpečnost](https://madsalt.tech/cs/blog/appwrite-vs-supabase/).

## Jak každý z nich zkontrolovat?

Bezplatná [kontrola zabezpečení Supabase](https://madsalt.tech/cs/tools/supabase-security-check/) čte váš projekt jen pro čtení a označí tabulky s vypnutým RLS, politiky, které vždy platí, zápisové politiky pro hosty a granty, které dávají víc, než politiky naznačují. Bezplatný [kontrolor pravidel Firebase](https://madsalt.tech/cs/tools/firebase-rules-checker/) čte vložená pravidla bez dotyku vašeho projektu a označí testovací režim, přístup jen na přihlášení a role, které si uživatel píše sám. Ani jeden nenahradí spuštění výše uvedených požadavků jako host a jako druhý uživatel.

**Limity.** Jeden lokální stack Supabase a jeden běh emulátoru Firebase, přes REST, na vymyšlených datech. Emulátor Firebase není produkce a netestoval jsem Realtime Database, Firebase App Check (Emulator Suite ho neobsahuje), Supabase Realtime, funkce ani ceny. Výsledek rozhodují vaše vlastní pravidla a politiky.

## Můj podobný případ

Aplikoval jsem migrace 1 170 veřejných projektů Supabase na čerstvé databáze: z 568, které proběhly bez chyby, mělo 134 (23,6 %) tabulku s vypnutým RLS, kterou veřejný klíč uměl číst a měnit. Metoda a dotazy jsou v [open-source studii Supabase](https://madsalt.tech/cs/blog/open-source-supabase-projects-security-study/).

Vybíráte backend pro aplikaci s privátními daty? Napište mi a společně určíme, který se hodí a jak ho zabezpečit.

Vybíráte backend pro privátní data?

Napište mi, co máte teď a co potřebujete. Odpovím variantou, kterou bych zvolil já.

[Napište mi](https://madsalt.tech/cs/#contact)
