---
title: "Supabase service role key läckt: vad du gör, i ordning"
description: "Vad en läckt Supabase service role key öppnade i mitt lokala test, och i vilken ordning du byter den, drar in den gamla och kollar skadan utan driftstopp."
url: "https://madsalt.tech/sv/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/sv/about/"
language: "sv"
published: 2026-11-14
---

# Supabase service role key läckt: vad du gör, i ordning

Kort sagt

En läckt service role key hoppar över RLS och kan använda Auth admin API. I mitt lokala test läste den 3 av 3 rader under policyer bara för ägaren, ändrade en annan användares rad och listade alla användare. Åtgärda orsaken till läckan, skapa en ny secret key, flytta över varje komponent till den, dra in den gamla nyckeln och kontrollera sedan vad som ändrats medan den var ute. Om någon använder nyckeln just nu, dra in den först och acceptera driftstoppet.

Min gratis [secret scanner](https://madsalt.tech/sv/tools/secret-scanner/) läser HTML-koden på en publik sida och skriptfilerna den länkar till efter API-nycklar, tokens och databas-URL:er som en besökare kan kopiera, bland dem Supabase-nyckeln `service_role`; värdena visas maskerade. Den här anteckningen handlar om vad du gör om nyckeln har läckt.

När jag tar över en Supabase-app är den här nyckeln det första jag söker efter i den byggda JavaScript-filen. Skillnaden mellan de två nycklarna finns i [anon key vs service role key](https://madsalt.tech/sv/blog/supabase-anon-key-vs-service-role-key/). Den här noten är till för den dåliga dagen, när den hemliga dök upp i en bundle, ett publikt repo eller en logg.

## Vad kan någon göra med den läckta nyckeln?

Jag kontrollerade på en lokal Supabase-stack (CLI 2.109.1, Postgres 17.6), på en tabell med RLS på, policyer bara för ägaren och 3 falska beställningar, plus en lista med testanvändare.

![Vad den läckta nyckeln öppnade. Lokal Supabase, RLS på, policyer bara för ägaren. Läs tabellen: Secret key → orders, RLS på → 3 av 3 rader; Lista användare: Secret key → Auth admin API → 200, alla användare; Samma anrop, publik nyckel: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/sv/supabase-service-role-key-leaked.svg)

*Mitt test på en lokal Supabase-stack, 2 november 2026.*

| Förfrågan                  | Publishable key | Secret- eller `service_role`-nyckel |
| -------------------------- | --------------- | ----------------------------------- |
| Läs `orders`               | 0 rader         | 3 av 3 rader                        |
| Uppdatera någon annans rad | Inte provat     | 1 rad ändrad                        |
| `GET /auth/v1/admin/users` | `403`           | `200`, alla användare listade       |

Den äldre `service_role`-nyckeln och den nya `sb_secret_` betedde sig likadant i alla tre.

Två resultat kan ge falsk trygghet:

- En ny tabell på den här stacken gav API-rollerna bara `TRUNCATE`, `REFERENCES` och `TRIGGER`. Därför fick secret key `403` med koden `42501` på den tills jag körde en `GRANT`. Det gör inte en läcka ofarlig: Auth admin-anropet svarade `200` just då. Ändringen bakom detta finns i [Supabase 42501 permission denied](https://madsalt.tech/sv/notes/supabase-42501-permission-denied/).
- Supabases [guide om API-nycklar](https://supabase.com/docs/guides/getting-started/api-keys) säger att en secret key som används från en webbläsare får `401`, och tillägger att en angripare ändå kan använda den från andra verktyg. Min lokala stack svarade `200` på en förfrågan med webbläsar-headers, så jag kunde inte återskapa den spärren här.

## Vilken är rätt ordning för att byta nyckeln?

De här stegen följer Supabases [guide för att rotera en läckt nyckel](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Jag körde dem inte på ett hostat projekt för den här noten.

1. **Åtgärda orsaken.** Ta bort nyckeln ur bundlen, repot eller loggen, annars läcker den nya på samma sätt. Att radera den i Gits senaste commit räcker inte, eftersom historiken fortfarande innehåller den.
2. **Skapa en ny secret key** i Settings → API Keys.
3. **Byt ut den gamla nyckeln överallt**: servrar, cron-jobb, Edge Functions, Database Webhooks och `pg_net`-anrop. En webhook som skickade den äldre nyckeln i `Authorization: Bearer` skickar nu den nya i headern `apikey`.
4. **Om det var den äldre `service_role`-nyckeln som läckte, flytta även dina klienter till en publishable key.** När de äldre nycklarna inaktiveras stängs `anon` och `service_role` av tillsammans, så en klient som fortfarande kör `anon` slutar fungera.
5. **Bekräfta att inget använder den gamla nyckeln.** Sidan API Keys har indikatorer för senaste användning för detta.
6. **Dra in den.** Radera en secret key, vilket inte går att ångra, eller inaktivera de äldre nycklarna.
7. **För en äldre nyckel, återkalla även den äldre JWT-hemligheten**, via [guiden om JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). Äldre nycklar är tokens signerade med den hemligheten, så allt som fortfarande litar på den kan acceptera den läckta nyckeln.

Undantaget är ett pågående angrepp. Då säger guiden att du ska dra in nyckeln direkt, även om komponenterna som använder den slutar fungera tills du har bytt ut den.

Om du missade en klient efter att ha inaktiverat de äldre nycklarna, flytta den klienten till en ny nyckel. Att slå på de äldre nycklarna igen ger tillbaka även den läckta nyckeln.

## Hur kontrollerar du vad som hände medan den var ute?

Supabase kan inte säga utifrån nyckeln ensam vem som höll i den, så leta efter resultaten. Börja med nya eller ändrade konton:

```sql
select email, created_at, last_sign_in_at, raw_app_meta_data
from auth.users
order by created_at desc
limit 50;
```

Leta efter konton du inte känner igen och roller som ingen har tilldelat. Jämför sedan dina viktiga tabeller med den senaste säkerhetskopian från före läckan. Om den meningen fick dig att tvivla på att det finns någon, läs [Supabase backups](https://madsalt.tech/sv/notes/supabase-backups/). Dina användares personuppgifter kan ha varit läsbara, så kontrollera om dina dataskyddsregler kräver att du anmäler det.

## Hur håller du nästa läcka liten?

Använd en separat secret key per komponent, vilket guiden om API-nycklar rekommenderar, så att en läcka betyder en rotation. Håll nyckeln borta från allt med prefixet `NEXT_PUBLIC_` eller `VITE_`, eftersom det går till webbläsaren. Och sök i varje produktionsbygge efter `sb_secret_` och `service_role` innan det skickas ut. På en livesajt gör den kostnadsfria [secret scanner](https://madsalt.tech/sv/tools/secret-scanner/) samma sökning på en offentlig sida och skripten den länkar till.

Om en person ska gå igenom hela appen i stället för en enda inställning, gör jag en [granskning av appen med fast omfattning](https://madsalt.tech/sv/services/vibe-coded-app-audit/) med beskedet behålla, laga eller skriva om för varje del.

## Mitt liknande fall

Jag körde migreringarna från 1 170 publika Supabase-projekt på nya databaser: av de 568 som gick igenom utan fel hade 134 (23,6 %) en tabell med RLS avstängt som den publika nyckeln kunde läsa och ändra. Metoden och frågorna finns i [studien av öppen källkod-projekt på Supabase](https://madsalt.tech/sv/blog/open-source-supabase-projects-security-study/).

Orolig att en nyckel har läckt? Skriv till mig, så roterar vi den och kontrollerar vad den exponerade.

Orolig att en nyckel har läckt?

Berätta vad du har nu och vad du behöver. Jag svarar med det alternativ jag själv skulle välja.

[Skriv till mig](https://madsalt.tech/sv/#contact)
