Read this article in English →
security · · · Streatix

Next.js API-Route absichern: KI schützt nur die Seite

KI-Tools sichern die Next.js-Seite per Redirect ab und lassen die API-Route dahinter offen. Hier stehen Exploit, JWT-Mechanik und der Fix auf dem Server.

Bei unseren Audits von Apps, die mit Lovable, Bolt und Cursor gebaut wurden, stoßen wir fast immer auf dieselbe Form: ein Dashboard, das abgemeldete Nutzer auf /login umleitet, vor einer API-Route, die dieselben Daten an jeden ausliefert, der sie aufruft. Der Redirect läuft im Browser. Wer eine Next.js API-Route absichern will, muss das im Handler tun, und der authentifiziert hier niemanden. Im schlimmeren Fall fragt er auch noch mit einem Service-Role-Key ab, sodass nicht einmal Row Level Security abfängt, was der Handler nie prüft. Wir nennen die Prüfung im Browser den kosmetischen Wächter und die Trennung, die ihn dort stranden lässt, den Page-vs-API-Split. Dieselbe Fehlerklasse wie der unsignierte Webhook als Default, ausgelieferte Apps mit deaktivierter RLS und öffentliche S3-Buckets: eine Vertrauensgrenze, die eine HTTP-Schicht von der Stelle entfernt liegt, an der die Daten gelesen werden.

Der Page-Wächter ist eine Render-Entscheidung, keine Vertrauensgrenze

Bitten Sie ein KI-Tool um „ein Dashboard, das nur eingeloggte Nutzer sehen können“, landet der Schutz in der Komponente:

// app/dashboard/page.tsx
'use client'

import { useEffect } from 'react'
import { useRouter } from 'next/navigation'
import { useAuth } from '@/hooks/use-auth'

export default function DashboardPage() {
  const { user, loading } = useAuth()
  const router = useRouter()

  useEffect(() => {
    if (!loading && !user) {
      router.push('/login')
    }
  }, [user, loading, router])

  if (loading) return <Spinner />
  if (!user) return null

  return <Dashboard userId={user.id} />
}

Drei Eigenschaften:

  1. Der Code läuft in der Client-Laufzeit. Der Server wertet ihn nie aus. Die Prüfung hat keinen Einfluss darauf, was ein HTTP-Endpoint zurückgibt.
  2. Die Zeile if (!user) return null verhindert zwar, dass die geschützte Komponente rendert, es blitzt also kein Inhalt auf. Aber auch das ist eine Render-Entscheidung im Browser. Sie steuert das DOM, nicht die Antwort eines Endpoints.
  3. Sie schützt einen React-Teilbaum. Die Daten darunter kommen per HTTP von einem Handler, der seine eigene, unabhängige Autorisierungsentscheidung trifft. Dort liegt die einzige Entscheidung, die zählt.

Eine ungeschützte API-Route authentifiziert niemanden

Das ist der Endpoint, den das Dashboard aufruft, generiert in einem separaten Prompt:

// app/api/projects/[id]/route.ts

import { NextResponse } from 'next/server'
import { createAdminClient } from '@/lib/supabase/admin' // service_role key

export async function GET(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params
  const supabase = createAdminClient()

  const { data: project } = await supabase
    .from('projects')
    .select('*')
    .eq('id', id)
    .single()

  return NextResponse.json(project)
}

Kein getUser(), kein 401, kein Ownership-Prädikat. Dazu der Service-Role-Client, und genau das macht aus einer fehlenden Prüfung vollen Lesezugriff.

Ein Supabase-Access-Token ist ein JWT. PostgREST liest den role-Claim und führt vor Ihrer Query SET LOCAL ROLE auf diese Postgres-Rolle aus; auth.uid() löst sich innerhalb einer Policy zu current_setting('request.jwt.claims', true)::json ->> 'sub' auf. Ihre RLS-Policies sind für die Rollen authenticated und anon geschrieben, typischerweise USING (auth.uid() = owner_id). Die Postgres-Rolle service_role hat BYPASSRLS, und die neueren Secret Keys von Supabase laufen auf derselben Rolle. Eine Query mit dem Service-Key überspringt also jede Policy, auch das Ownership-Prädikat, auf das Sie sich verlassen haben. Für wirklich vertrauenswürdige Arbeit ist der Admin-Client das richtige Werkzeug (ein Cron-Job, ein Webhook, dessen Herkunft Sie schon verifiziert haben). Auf einer Route, die ein Browser erreicht, macht er aus „RLS schützt diese Tabelle“ ein „nichts schützt sie“.

Selbst mit aktiver RLS und korrekten Policies umgeht diese Route sie also by Design.

Der Exploit ist ein GET

Der Page-Wächter liegt nie im Pfad. Der Angreifer lädt die Seite nicht, er ruft auf, was die Seite aufgerufen hätte:

# No cookie, no Authorization header. Just the id.
curl https://yourapp.com/api/projects/8f2a1c7e-4b90-4f1e-9c2d-a1b2c3d4e5f6
# 200, full project row

Wie groß der Schaden ist, hängt von Ihrem ID-Typ ab. Eine UUIDv4 hat 122 Bit Entropie, die Tabelle lässt sich also nicht durchzählen. Geheim sind die IDs deshalb nicht. Sie leaken ständig: in Referer-Headern an Dritte, in geteilten Links, in Error-Payloads, auf einem Support-Screenshot, über einen anderen Endpoint, der IDs ungefiltert liefert. Jede geleakte ID ist ein unauthentifiziertes GET von der Zeile entfernt. Ist die Spalte ein bigserial, entfällt das alles, und man liest die Tabelle einfach aus:

for id in $(seq 1 100000); do curl -s "https://yourapp.com/api/projects/$id"; done

Wir haben das auf Referenz-Apps reproduziert, die mit Lovable, Bolt und Cursor gebaut wurden. Die Seite leitet um, der Handler liefert aus.

Warum das Modell den Wächter auf die Seite setzt

Dem Modell fehlt nicht das Wissen über Auth. Das Problem ist, wo die Anforderung in der Prompt-Abfolge steht. „Dashboard nur für eingeloggte Nutzer sichtbar machen“ hat die Seite als Subjekt, also landet der Redirect in der Komponente. Ein späterer, separater Prompt wie „Endpoint zum Abrufen eines Projekts hinzufügen“ enthält weder Akteur noch Regel, also schreibt das Modell genau ein Fetch-by-ID. Die beiden Anforderungen stehen nie im selben Prompt, und die Autorisierung, die an die Naht zwischen ihnen gehört, schreibt keiner von beiden.

Diese Naht ist der Page-vs-API-Split. Autorisierung ist ein Querschnittsthema, ein LLM gibt pro Prompt eine Datei aus. Der Wächter landet auf der Oberfläche, die Sie beschrieben haben, und nicht im Lesepfad, den Sie nicht beschrieben haben. Ein „und prüfen, ob der Nutzer der Eigentümer ist“ flickt manchmal die eine Route, die gerade im Blick ist, oft auf dem Admin-Client. Dort öffnet ein einziges vergessenes .eq('owner_id', user.id) sie wieder, und im Typsystem fällt das nicht auf.

Next.js API-Route absichern heißt: erst Identität auf dem Server, dann Ownership

// app/api/projects/[id]/route.ts

import { NextResponse } from 'next/server'
import { createClient } from '@/lib/supabase/server' // request-scoped, carries the caller's JWT

export async function GET(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params
  const supabase = await createClient()

  const { data: { user } } = await supabase.auth.getUser()
  if (!user) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  const { data: project, error } = await supabase
    .from('projects')
    .select('*')
    .eq('id', id)
    .eq('owner_id', user.id) // authorization, in the query
    .single()

  if (error || !project) {
    return NextResponse.json({ error: 'Not found' }, { status: 404 })
  }

  return NextResponse.json(project)
}

params ist seit Next.js 15 ein Promise, und Next.js 16 hat den synchronen Zugriff entfernt, deshalb warten beide Handler darauf. Sicherheitsrelevant sind vier Änderungen:

  1. Der Admin-Client fliegt raus. Der Request-scoped Client reicht das JWT des Aufrufers als Rolle authenticated weiter, RLS greift also, und der Service-Role-Bypass ist weg.
  2. getUser() klärt die Identität und gibt 401 zurück, wenn es keine gibt. Authentifizierung, das Wer.
  3. .eq('owner_id', user.id) klärt die Berechtigung. Autorisierung, das Was. Erzwingt RLS das zusätzlich auf Zeilenebene, ist das doppelt abgesichert; ohne RLS ist es das Einzige zwischen einem Aufrufer und der Zeile eines anderen Mandanten. So oder so steht es in der Query, dort, wo gelesen wird.
  4. 404, nicht 403, wenn die Ownership nicht passt. Bestätigen Sie niemandem, dass eine Zeile existiert, die ihm nicht gehört.

getUser versus getSession, auf Token-Ebene

Hier landet der Bug trotz „Auth eingebaut“ in Produktion.

getSession() lädt die Session aus dem Storage des Clients, erneuert sie bei Bedarf und gibt sie zurück. Bei einem nicht abgelaufenen Token fragt es den Auth-Server nie, ob das Token noch gilt. Ein Token von einem Nutzer, der sich überall abgemeldet hat, gelöscht oder gesperrt wurde, besteht getSession() weiterhin, denn der Widerruf liegt auf dem Server, den es nicht gefragt hat.

getUser() schickt GET /auth/v1/user mit dem Token. GoTrue, der Auth-Server von Supabase, prüft die Signatur gegen das JWT-Secret des Projekts (HS256, oder den aktiven asymmetrischen Key auf neueren Projekten) und bestätigt, dass der Nutzer noch existiert und zugelassen ist. Dieser Round-Trip ist die Revalidierung. Der Next.js-Guide von Supabase sagt, man solle getSession() in Server-Code nie vertrauen, weil es die Session aus dem Cookie liest, ohne sie zu revalidieren.

Derselbe Guide empfiehlt inzwischen, Seiten und Nutzerdaten mit getClaims() zu schützen. Es prüft das Token gegen das JWKS des Projekts, wenn das Projekt asymmetrische Signing Keys nutzt, und ruft sonst den Auth-Server auf. Ob es eine widerrufene Session erkennt, steht in dieser Referenz nicht, deshalb bleiben die Beispiele hier bei getUser(), zum Preis eines Requests an Ihren Auth-Host pro Aufruf. Wenn das in p99 auffällt und sofortiger Widerruf keine Anforderung ist, wechseln Sie zu getClaims() oder cachen Sie das Ergebnis kurz hinter einem eigenen Key. Gehen Sie nicht zurück zu getSession().

Ein fehlender Check soll beim Kompilieren scheitern, nicht still durchgehen

Eine reparierte Route behebt den Split nicht. Der Split ist pro Handler, und der echte Vorfall ist der dreißigste Endpoint, den jemand ohne die vier Zeilen ergänzt hat. Zentralisieren Sie die Identität, sodass eine Route keinen Nutzer lesen kann, ohne einen authentifiziert zu haben:

// lib/with-auth.ts
import { NextResponse } from 'next/server'
import { createClient } from '@/lib/supabase/server'
import type { User } from '@supabase/supabase-js'

type Ctx = { params: Promise<Record<string, string>> }
type AuthedHandler = (req: Request, ctx: Ctx & { user: User }) => Promise<Response>

export function withAuth(handler: AuthedHandler) {
  return async (req: Request, ctx: Ctx) => {
    const supabase = await createClient()
    const { data: { user } } = await supabase.auth.getUser()
    if (!user) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
    }
    return handler(req, { ...ctx, user })
  }
}
// app/api/projects/[id]/route.ts
export const GET = withAuth(async (_req, { params, user }) => {
  // `user` is only reachable through withAuth; there is no other way to get it here
  const { id } = await params
  ...
})

Vergessen wird dadurch nicht unmöglich. Der authentifizierte Pfad wird aber zur einzigen Quelle für user und zum Weg des geringsten Widerstands, und aus dreißig verstreuten getUser()-Aufrufen wird einer, den Sie wirklich reviewen können. Das Ownership-Prädikat müssen Sie weiterhin pro Query schreiben; zentralisiert wird die Identität.

Middleware macht den Route-Handler nicht sicher

Der naheliegende nächste Schritt ist eine globale Prüfung in middleware.ts, seit Next.js 16 proxy.ts. Das hilft und reicht nicht. Der Authentifizierungs-Guide von Next.js nennt Proxy-Prüfungen optimistisch, sagt, Proxy solle nicht Ihre einzige Verteidigungslinie sein, und rät, Route-Handler wie öffentliche API-Endpoints zu behandeln. Sein Beispiel-matcher überspringt außerdem api-Pfade: Kopieren Sie ihn unverändert, sehen Ihre API-Routen die Prüfung nie.

Auch das Framework selbst hatte diesen Fehler. CVE-2025-29927 erlaubte es, Autorisierungsprüfungen in der Middleware zu umgehen, behoben in 12.3.5, 13.5.9, 14.2.25 und 15.2.3. Der Redirect für die Seite kann gern in der Middleware bleiben. Die Prüfung, die zählt, gehört trotzdem in den Handler oder die Policy.

Die Negativtests sind die, die das Modell nicht schreibt

Den Happy-Path-Test (Eigentümer ruft eigenes Projekt ab, 200) schreibt das Modell. Der Bug steckt in den beiden anderen:

# 1. No session -> 401
curl -i https://yourapp.com/api/projects/SOME_ID
# Expect 401

# 2. Authenticated as A, fetching B's row -> 404 (not 200, not the row)
curl -i https://yourapp.com/api/projects/USER_B_PROJECT_ID \
  -H "Cookie: $USER_A_SESSION_COOKIE"
# Expect 404

Gibt der erste 200 zurück, ist der kosmetische Wächter immer noch Ihr einziger Wächter. Gibt der zweite die Zeile zurück, haben Sie den Aufrufer authentifiziert, den Zugriff aber nicht autorisiert.

Identität plus Ownership schließt nur den Lesezugriff

Über Schreibpfade sagt das nichts (POST und PATCH brauchen dasselbe Prädikat plus Regeln pro Feld, was ein Aufrufer setzen darf), nichts über select('*'), das Spalten liefert, die der Client nicht sehen soll, und nichts darüber, dass der getUser()-Round-Trip in einem Hot Path zur Abhängigkeit von der Verfügbarkeit Ihres Auth-Hosts wird. Außerdem setzt das owner_id-Modell einen einzigen Eigentümer pro Zeile voraus. Sobald Sie geteilte Projekte oder Org-Rollen haben, wird aus dem Prädikat ein Join gegen eine Membership-Tabelle, und RLS ist der vernünftigere Ort dafür. Das führen wir als eigene Befunde.

Ein Redirect ändert, was rendert, und nichts an der Server-Antwort

Eine Autorisierung, die nicht im Lesepfad steht, also in der Query oder der Policy, die für die Query läuft, wird nirgends erzwungen, wo ein Request hinkommt.

Derselbe Fehler reicht über generierten Code hinaus. Bei den Instagram-Konto-Übernahmen bei Meta beschreiben Presseberichte einen Wächter, an dem sich ein Angreifer vorbeireden konnte, und Metas eigene Meldung beschreibt einen E-Mail-Check, der nicht funktionierte.

Wenn Sie das für Ihre eigene App wollen

Dreißigminütiges Audit, kostenlos. Wir rufen dieselben Endpunkte per curl auf und lesen dieselben Dateien. Liste in Ihrem Postfach binnen achtundvierzig Stunden.

Kostenloses Audit buchen