---
title: "Supabase service role key lekket: hva du gjør, i rekkefølge"
description: "Hva en lekket Supabase service role key åpnet i min lokale test, og rekkefølgen for å bytte den, ta den gamle ut av drift og sjekke skaden uten nedetid."
url: "https://madsalt.tech/no/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/no/about/"
language: "no"
published: 2026-11-14
---

# Supabase service role key lekket: hva du gjør, i rekkefølge

TL;DR

En lekket service role key omgår RLS og kan bruke Auth admin API. I min lokale test leste den 3 av 3 rader under policyer som bare ga eieren tilgang, endret en annen brukers rad og listet alle brukere. Fjern årsaken til lekkasjen, lag en ny secret key, flytt hver komponent over til den, ta den gamle nøkkelen ut av drift, og sjekk så hva som endret seg mens den var ute. Hvis noen bruker nøkkelen akkurat nå, ta den ut av drift først og godta nedetiden.

Min gratis [secret scanner](https://madsalt.tech/no/tools/secret-scanner/) leser HTML-en til én offentlig side og skriptfilene den lenker til, på jakt etter API-nøkler, tokens og database-URL-er som en besøkende kan kopiere, blant dem Supabase-nøkkelen `service_role`; verdiene vises maskert. Dette notatet handler om hva du gjør hvis nøkkelen har lekket.

Når jeg overtar en Supabase-app, er denne nøkkelen det første jeg søker etter i den bygde JavaScript-en. Forskjellen mellom de to nøklene står i [anon key vs service role key](https://madsalt.tech/no/blog/supabase-anon-key-vs-service-role-key/). Dette notatet er for den dårlige dagen, da den hemmelige nøkkelen dukket opp i en bundle, et offentlig repo eller en logg.

## Hva kan noen gjøre med den lekkede nøkkelen?

Jeg sjekket på en lokal Supabase-stack (CLI 2.109.1, Postgres 17.6), på en tabell med RLS på, policyer bare for eieren og 3 falske bestillinger, pluss en testliste over brukere.

![Hva den lekkede nøkkelen åpnet. Lokal Supabase, RLS på, policyer bare for eieren. Les tabellen: Secret key → orders, RLS på → 3 av 3 rader; List brukere: Secret key → Auth admin API → 200, alle brukere; Samme kall, offentlig nøkkel: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/no/supabase-service-role-key-leaked.svg)

*Testen min på en lokal Supabase-stack, 2. november 2026.*

| Forespørsel                | Publishable key | Secret eller `service_role` key |
| -------------------------- | --------------- | ------------------------------- |
| Les `orders`               | 0 rader         | 3 av 3 rader                    |
| Oppdater en annens rad     | Ikke prøvd      | 1 rad endret                    |
| `GET /auth/v1/admin/users` | `403`           | `200`, alle brukere listet      |

Den gamle `service_role`-nøkkelen og den nye `sb_secret_`-nøkkelen oppførte seg likt i alle tre.

To resultater kan gi falsk trygghet:

- En ny tabell på denne stacken ga API-rollene bare `TRUNCATE`, `REFERENCES` og `TRIGGER`. Derfor fikk secret key `403` med kode `42501` på den til jeg kjørte en `GRANT`. Det gjør ikke en lekkasje ufarlig: Auth admin-kallet svarte `200` i det samme øyeblikket. Endringen bak dette står i [Supabase 42501 permission denied](https://madsalt.tech/no/notes/supabase-42501-permission-denied/).
- Supabases [guide om API-nøkler](https://supabase.com/docs/guides/getting-started/api-keys) sier at en secret key brukt fra en nettleser får `401`, og legger til at en angriper fortsatt kan bruke den fra andre verktøy. Min lokale stack svarte `200` på en forespørsel med nettleser-headers, så jeg kunne ikke gjenskape den blokkeringen her.

## Hva er riktig rekkefølge for å bytte nøkkelen?

Disse trinnene følger Supabases [guide for å rotere en lekket nøkkel](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Jeg kjørte dem ikke på et hostet prosjekt for dette notatet.

1. **Fjern årsaken.** Ta nøkkelen ut av bundlen, repoet eller loggen, ellers lekker den nye på samme måte. Å slette den fra Gits siste commit er ikke nok, fordi historikken fortsatt har den.
2. **Lag en ny secret key** i Settings → API Keys.
3. **Bytt den gamle nøkkelen overalt**: servere, cron-jobber, Edge Functions, Database Webhooks og `pg_net`-kall. En webhook som sendte den gamle nøkkelen i `Authorization: Bearer`, sender nå den nye i headeren `apikey`.
4. **Hvis lekkasjen var den gamle `service_role`-nøkkelen, flytt også klientene til en publishable key.** Å deaktivere de gamle nøklene slår av `anon` og `service_role` sammen, så en klient som fortsatt bruker `anon`, slutter å virke.
5. **Bekreft at ingenting bruker den gamle nøkkelen.** Siden API Keys har indikatorer for sist brukt til dette.
6. **Ta den ut av drift.** Slett en secret key, noe som ikke kan angres, eller deaktiver de gamle nøklene.
7. **For en gammel nøkkel, tilbakekall også den gamle JWT-hemmeligheten**, via [guiden om JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). Gamle nøkler er tokens signert med den hemmeligheten, så alt som fortsatt stoler på den, kan godta den lekkede nøkkelen.

Unntaket er et angrep som pågår. Da sier guiden at du skal ta nøkkelen ut av drift med en gang, selv om komponentene som bruker den slutter å virke til du har byttet den.

Hvis du overså en klient etter å ha deaktivert de gamle nøklene, flytt den klienten til en ny nøkkel. Å slå de gamle nøklene på igjen bringer den lekkede nøkkelen tilbake også.

## Hvordan sjekker du hva som skjedde mens den var ute?

Supabase kan ikke si ut fra nøkkelen alene hvem som hadde den, så se etter resultatene. Start med nye eller endrede kontoer:

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

Se etter kontoer du ikke kjenner igjen og roller ingen har tildelt. Sammenlign så de viktige tabellene dine med den siste sikkerhetskopien fra før lekkasjen. Hvis den setningen fikk deg til å lure på om du har en, les [Supabase backups](https://madsalt.tech/no/notes/supabase-backups/). Brukernes personopplysninger kan ha vært lesbare, så sjekk om personvernreglene dine krever at du melder fra.

## Hvordan holder du neste lekkasje liten?

Bruk en egen secret key per komponent, slik guiden om API-nøkler anbefaler, så betyr én lekkasje én rotasjon. Hold nøkkelen unna alt med prefikset `NEXT_PUBLIC_` eller `VITE_`, siden det sendes til nettleseren. Og søk i hver produksjonsbuild etter `sb_secret_` og `service_role` før den går ut. På et live nettsted gjør den gratis [secret scanner](https://madsalt.tech/no/tools/secret-scanner/) det samme søket på én offentlig side og skriptene den lenker til.

Hvis en person skal gå gjennom hele appen i stedet for én innstilling, gjør jeg en [gjennomgang av appen med fast omfang](https://madsalt.tech/no/services/vibe-coded-app-audit/) med dommen behold, fiks eller skriv om for hver del.

## Mitt tilsvarende tilfelle

Jeg kjørte migrasjonene til 1 170 offentlige Supabase-prosjekter på nye databaser: av de 568 som gikk rent gjennom hadde 134 (23,6 %) en tabell med RLS av som den offentlige nøkkelen kunne lese og endre. Metoden og spørringene står i [studien av åpen kildekode-prosjekter på Supabase](https://madsalt.tech/no/blog/open-source-supabase-projects-security-study/).

Redd for at en nøkkel har lekket? Skriv til meg, så roterer vi den og sjekker hva den eksponerte.

Redd for at en nøkkel har lekket?

Fortell meg hva du har nå og hva du trenger. Jeg svarer med alternativet jeg selv ville valgt.

[Skriv til meg](https://madsalt.tech/no/#contact)
