---
title: "Lækket Supabase service role key: trin for trin"
description: "Hvad en lækket service role key åbnede i min lokale test, og i hvilken rækkefølge du udskifter den, lukker den gamle og tjekker skaden uden nedetid."
url: "https://madsalt.tech/da/notes/supabase-service-role-key-leaked/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/da/about/"
language: "da"
published: 2026-11-14
---

# Lækket Supabase service role key: trin for trin

TL;DR

En lækket service role key springer RLS over og kan bruge Auth admin API. I min lokale test læste den 3 af 3 rækker under policies kun for ejeren, ændrede en anden brugers række og listede alle brugere. Ret årsagen til lækagen, opret en ny secret key, flyt hver komponent over på den, luk den gamle nøgle, og tjek derefter, hvad der ændrede sig, mens den var ude. Hvis nogen bruger nøglen lige nu, så luk den først og accepter nedetiden.

Min gratis [secret scanner](https://madsalt.tech/da/tools/secret-scanner/) læser HTML’en på én offentlig side og de scriptfiler, den linker til, og leder efter API-nøgler, tokens og database-URL’er, som en besøgende kan kopiere, blandt andet Supabase-nøglen `service_role`; værdierne vises maskeret. Denne note handler om, hvad du gør, hvis nøglen er sluppet ud.

Når jeg overtager en Supabase-app, er denne nøgle det første, jeg leder efter i den byggede JavaScript. Forskellen på de to nøgler står i [anon key vs service role key](https://madsalt.tech/da/blog/supabase-anon-key-vs-service-role-key/). Denne note er til den dårlige dag, hvor den hemmelige dukkede op i et bundle, et offentligt repo eller en log.

## Hvad kan nogen gøre med den lækkede nøgle?

Jeg tjekkede det på en lokal Supabase (CLI 2.109.1, Postgres 17.6), på en tabel med RLS slået til, policies kun for ejeren og 3 falske ordrer, plus en testliste over brugere.

![Hvad den lækkede nøgle åbnede. Lokal Supabase, RLS slået til, policies kun for ejeren. Læs tabellen: Secret key → orders, RLS slået til → 3 af 3 rækker; List brugere: Secret key → Auth admin API → 200, alle brugere; Samme kald, offentlig nøgle: Publishable key → Auth admin API → 403.](https://madsalt.tech/charts/da/supabase-service-role-key-leaked.svg)

*Min test på en lokal Supabase, 2. november 2026.*

| Anmodning                  | Publishable key | Secret eller `service_role` key |
| -------------------------- | --------------- | ------------------------------- |
| Læs `orders`               | 0 rækker        | 3 af 3 rækker                   |
| Opdater en andens række    | Ikke prøvet     | 1 række ændret                  |
| `GET /auth/v1/admin/users` | `403`           | `200`, alle brugere listet      |

Den gamle `service_role`-nøgle og den nye `sb_secret_`-nøgle opførte sig ens i alle tre.

To resultater kunne give falsk tryghed:

- En ny tabel på denne stack gav API-rollerne kun `TRUNCATE`, `REFERENCES` og `TRIGGER`. Så secret key fik `403` med koden `42501` på den, indtil jeg kørte en `GRANT`. Det gør ikke en lækage harmløs: Auth admin-kaldet svarede `200` i det samme øjeblik. Ændringen bag dette står i [Supabase 42501 permission denied](https://madsalt.tech/da/notes/supabase-42501-permission-denied/).
- Supabases [guide til API keys](https://supabase.com/docs/guides/getting-started/api-keys) siger, at en secret key brugt fra en browser får `401`, og tilføjer, at en angriber stadig kan bruge den fra andre værktøjer. Min lokale stack svarede `200` på en forespørgsel med browser-headers, så jeg kunne ikke genskabe den blokering her.

## Hvad er den rigtige rækkefølge til at udskifte nøglen?

Disse trin følger Supabases [guide til rotation af en lækket nøgle](https://supabase.com/docs/guides/security/rotate-leaked-api-keys). Jeg kørte dem ikke på et hostet projekt til denne note.

1. **Ret årsagen.** Fjern nøglen fra bundlet, repoet eller loggen, ellers lækker den nye nøgle på samme måde. At slette den fra Gits seneste commit er ikke nok, fordi historikken stadig rummer den.
2. **Opret en ny secret key** under Settings → API Keys.
3. **Udskift den gamle nøgle overalt**: servere, cron jobs, Edge Functions, Database Webhooks og `pg_net`-kald. En webhook, der sendte den gamle nøgle i `Authorization: Bearer`, sender nu den nye nøgle i headeren `apikey`.
4. **Hvis lækagen var den gamle `service_role`-nøgle, så flyt også dine klienter til en publishable key.** At deaktivere de gamle nøgler slukker `anon` og `service_role` på én gang, så en klient, der stadig er på `anon`, holder op med at virke.
5. **Bekræft, at intet bruger den gamle nøgle.** Siden API Keys har indikatorer for sidste brug til det.
6. **Luk den.** Slet en secret key, hvilket ikke kan fortrydes, eller deaktivér de gamle nøgler.
7. **For en gammel nøgle skal du også tilbagekalde den gamle JWT-secret** via [guiden til JWT signing keys](https://supabase.com/docs/guides/auth/signing-keys). De gamle nøgler er tokens signeret med den secret, så alt, der stadig stoler på den, kan acceptere den lækkede nøgle.

Undtagelsen er et angreb, der er i gang. Så siger guiden, at du skal lukke nøglen med det samme, selv om de komponenter, der bruger den, holder op med at virke, indtil du udskifter den.

Hvis du overså en klient, efter du havde deaktiveret de gamle nøgler, så flyt den klient til en ny nøgle. At slå de gamle nøgler til igen bringer også den lækkede nøgle tilbage.

## Hvordan tjekker du, hvad der skete, mens den var ude?

Supabase kan ikke ud fra nøglen alene fortælle, hvem der havde den, så led efter resultaterne. Begynd med nye eller ændrede konti:

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

Led efter konti, du ikke kender, og roller, som ingen har tildelt. Sammenlign derefter dine vigtige tabeller med den seneste backup fra før lækagen. Hvis den sætning gjorde dig usikker på, om der er en, så læs [Supabase backups](https://madsalt.tech/da/notes/supabase-backups/). Dine brugeres personoplysninger kan have været læsbare, så tjek, om dine databeskyttelsesregler kræver, at du anmelder det.

## Hvordan holder du den næste lækage lille?

Brug en separat secret key pr. komponent, hvilket guiden til API keys anbefaler, så én lækage betyder én rotation. Hold nøglen ude af alt med præfikset `NEXT_PUBLIC_` eller `VITE_`, da det sendes til browseren. Og søg i hvert produktions-build efter `sb_secret_` og `service_role`, før det udgives. På et live site udfører den gratis [secret scanner](https://madsalt.tech/da/tools/secret-scanner/) samme søgning på én offentlig side og de scripts, den linker til.

Hvis en person skal gennemgå hele appen frem for én indstilling, laver jeg en [gennemgang af appen med fast omfang](https://madsalt.tech/da/services/vibe-coded-app-audit/) med dommen behold, reparér eller skriv om for hver del.

## Min lignende sag

Jeg kørte migreringerne fra 1.170 offentlige Supabase-projekter på nye databaser: af de 568, der kørte rent igennem, havde 134 (23,6 %) en tabel med RLS slået fra, som den offentlige nøgle kunne læse og ændre. Metoden og forespørgslerne står i [undersøgelsen af open source-projekter på Supabase](https://madsalt.tech/da/blog/open-source-supabase-projects-security-study/).

Bekymret for, at en nøgle er lækket? Skriv til mig, så roterer vi den og tjekker, hvad den eksponerede.

Bekymret for, at en nøgle er lækket?

Fortæl mig, hvad du har nu, og hvad du har brug for. Jeg svarer med den løsning, jeg selv ville vælge.

[Skriv til mig](https://madsalt.tech/da/#contact)
