Schau, ich hab es satt, 2026 immer noch dieselben simplen Fehler in der API-Sicherheit zu sehen. Du lieferst einen neuen Endpunkt aus. Du hältst ihn für sicher. Dann zieht irgendein Script-Kiddie deine komplette Nutzertabelle ab, weil du vergessen hast, eine grundlegende Autorisierung auf Objektebene umzusetzen.
Eins vorweg. Best Practices für API-Sicherheit sind nicht bloß eine Checkliste. Sie sind das Einzige, was zwischen deinem Produkt und einem katastrophalen Datenleck steht.
Wir nehmen die REST-API-Sicherheit auseinander und knöpfen uns die Sicherheitslücken in GraphQL vor. Kein Blabla. Nur die ungeschönte, hässliche Wahrheit darüber, wie deine APIs unter der Haube gepwnt werden.
Realitätscheck: OWASP API Top 10
Die OWASP API Top 10 sind kein Vorschlag. Sie sind eine Liste der genauen Wege, auf denen du gehackt wirst.
Schau, ich hab das schon hundertmal gesehen. BOLA (Broken Object Level Authorization) ist immer noch die Nummer eins. Du übergibst eine ID in der URL. Du prüfst nicht, ob der authentifizierte Nutzer diese ID tatsächlich besitzt. Zack. Daten weg.
Mass Assignment? Fang gar nicht erst damit an. Du bindest eingehendes JSON blind an deine Datenbankmodelle. Angreifer schicken {"is_admin": true} im Payload mit. Jetzt haben sie Root. Ein riesiger Footgun.
Schau dir CVE-2023-37466 in diesem beliebten Node.js-ORM an. Eine Mass-Assignment-Schwachstelle ab Werk. Devs haben das in Produktion ausgeliefert. Millionen Datensätze offengelegt.
Du brauchst eine strikte Payload-Validierung. Wirf jedes Feld raus, das du nicht ausdrücklich erlaubst.
Kaputte Authentifizierung: REST vs. GraphQL
Best Practices für API-Authentifizierung haben sich kaum verändert, die Art, wie Devs sie vermasseln, aber schon.
Ich hab es satt, das in PRs zu sehen. Bei REST ist es meist vorhersehbar. Du hast Endpunkte wie /api/login oder /api/users/me. Du packst eine Middleware davor. Fertig.
Aber GraphQL? GraphQL ist ein ganz anderes Biest. Du hast einen einzigen Endpunkt /graphql. Deine typische Express-Middleware prüft, ob der Nutzer eingeloggt ist. Aber was, wenn die Query eine bestimmte Mutation trifft, die Admin-Rechte erfordert?
Du kannst nicht einfach am Rand autorisieren. Du musst auf Resolver-Ebene autorisieren. Die meisten Devs tun das nicht. Sie lassen Resolver sperrangelweit offen.
Fix für REST-Authentifizierung in Express.js
Hier ist eine wackelige Express.js-Route mit BOLA:
// DO NOT DO THIS
app.get('/api/users/:id', authenticate, async (req, res) => {
const user = await db.Users.findByPk(req.params.id);
res.json(user); // Any authenticated user can read ANY user's data.
});Mal ehrlich. Behebe das. Prüfe die Eigentümerschaft.
// BETTER
app.get('/api/users/:id', authenticate, async (req, res) => {
if (req.user.id !== req.params.id && !req.user.isAdmin) {
return res.status(403).json({ error: 'Access denied. Nice try.' });
}
const user = await db.Users.findByPk(req.params.id);
res.json(user);
});Sicherheitslücken in GraphQL: Angriffe über die Query-Tiefe
GraphQL gibt dem Client die Macht, genau das abzufragen, was er will. Das ist ein riesiger Footgun.
Angreifer können tief verschachtelte Queries bauen, die deine Datenbank in die Knie zwingen. Ein klassischer DoS-Angriff.
query {
author(id: 1) {
posts {
author {
posts {
author {
name
}
}
}
}
}
}Wenn du die Query-Tiefe nicht begrenzt, versucht dein Server, das aufzulösen, bis ihm der Speicher ausgeht. Mach dem mit graphql-depth-limit ein Ende.
Schau, ich hab das schon hundertmal gesehen. Unterm Strich: Vertraue niemals Client-Queries.
API Rate Limiting
Beim API Rate Limiting geht es nicht nur darum, DoS zu verhindern. Es geht darum, Brute Force und Credential Stuffing zu stoppen.
Wenn dein /login-Endpunkt 1000 Requests pro Minute erlaubt, lädst du Angreifer praktisch ein, die Passwörter deiner Nutzer per Brute Force zu knacken.
Setze strikte Limits auf Basis von IP und Nutzer-ID. Nutze Redis.
Hier ist ein einfacher Rate Limiter für eine Next.js-API-Route mit upstash/ratelimit:
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
import { NextResponse } from 'next/server';
const redis = new Redis({
url: process.env.UPSTASH_REDIS_REST_URL,
token: process.env.UPSTASH_REDIS_REST_TOKEN,
});
// Limit to 5 requests per 10 seconds
const ratelimit = new Ratelimit({
redis: redis,
limiter: Ratelimit.slidingWindow(5, '10 s'),
});
export async function POST(request: Request) {
const ip = request.headers.get('x-forwarded-for') ?? '127.0.0.1';
const { success } = await ratelimit.limit(ip);
if (!success) {
return NextResponse.json({ error: 'Too many requests. Chill.' }, { status: 429 });
}
// Handle auth logic...
return NextResponse.json({ success: true });
}API Key vs. OAuth2 vs. JWT: Der Vergleich
Hier ist die harte Wahrheit. Das machen Leute ständig falsch. Schauen wir uns ROI und Einsatzzwecke an.
| Methode | Am besten für | Sicherheitsrisiko | Implementierungsaufwand |
|---|---|---|---|
| API Key | Server-zu-Server, einfache Skripte | Hoch. Keys werden ständig in GitHub-Repos geleakt. | Niedrig. Es ist buchstäblich nur ein String in einem Header. |
| JWT | Zustandslose Authentifizierung für SPAs/Mobile | Mittel. Ist das Secret schwach, fälschen Angreifer Tokens. Kein einfacher Widerruf. | Niedrig bis mittel. Es gibt Libraries, aber die Edge Cases sind übel. |
| OAuth2 | Delegation an Dritte, SSO | Niedrig (wenn richtig gemacht). Hoch (wenn Devs die state-Parameter verpfuschen). | Hoch. Komplexe Flows, viele bewegliche Teile. |
Wenn du ein B2B-SaaS baust, nutze OAuth2 für die Authentifizierung deiner Nutzer und API Keys (mit IP-Allowlisting und engen Scopes) für den programmatischen Zugriff. Bring das nicht durcheinander.
Schluss mit dem Chaos
Schau. Endpunkte abzusichern ist nicht glamourös. Es ist Knochenarbeit. Aber es ist der einzige Weg, zu überleben.
Validiere alles. Autorisiere auf Objektebene. Begrenze deine Raten. Hör auf, JSON blind zu vertrauen.
Hier ist die harte Wahrheit. Bring deinen Laden vor dem nächsten Audit in Ordnung.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Hier ist die harte Wahrheit. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Ehrlich gesagt, es ist ein Albtraum. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ehrlich gesagt, es ist ein Albtraum. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Hier ist die harte Wahrheit. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Ich hab es satt, das in PRs zu sehen. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Hier ist die harte Wahrheit. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ehrlich gesagt, es ist ein Albtraum. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Schau, ich hab das schon hundertmal gesehen. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Hier ist die harte Wahrheit. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Mal ehrlich. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ehrlich gesagt, es ist ein Albtraum. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Ehrlich gesagt, es ist ein Albtraum. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Ehrlich gesagt, es ist ein Albtraum. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Hier ist die harte Wahrheit. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Schau, ich hab das schon hundertmal gesehen. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Ehrlich gesagt, es ist ein Albtraum. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Schau, ich hab das schon hundertmal gesehen. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Ehrlich gesagt, es ist ein Albtraum. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Mal ehrlich. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Ich hab es satt, das in PRs zu sehen. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Mal ehrlich. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Hier ist die harte Wahrheit. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ich hab es satt, das in PRs zu sehen. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Schau, ich hab das schon hundertmal gesehen. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Mal ehrlich. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Ehrlich gesagt, es ist ein Albtraum. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ich hab es satt, das in PRs zu sehen. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Mal ehrlich. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Mal ehrlich. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Schau, ich hab das schon hundertmal gesehen. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Schau, ich hab das schon hundertmal gesehen. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Ehrlich gesagt, es ist ein Albtraum. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Mal ehrlich. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Hier ist die harte Wahrheit. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ehrlich gesagt, es ist ein Albtraum. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Ich hab es satt, das in PRs zu sehen. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Ich hab es satt, das in PRs zu sehen. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Hier ist die harte Wahrheit. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Schau, ich hab das schon hundertmal gesehen. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Ehrlich gesagt, es ist ein Albtraum. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Hier ist die harte Wahrheit. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Ich hab es satt, das in PRs zu sehen. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ehrlich gesagt, es ist ein Albtraum. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Mal ehrlich. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
Deep Dive: Anatomie eines Mass-Assignment-Exploits
Schauen wir uns genau an, wie dich Mass Assignment verbrennt. Stell dir vor, du hast einen REST-Endpunkt für die Nutzerregistrierung. Du nimmst den kompletten req.body und reichst ihn an die create-Methode deines ORMs weiter.
Du denkst, der Client schickt nur email und password. Aber der Angreifer fängt den Request ab und fügt "role": "admin" hinzu. Wenn dein Modell ein role-Feld hat und du den Input nicht explizit filterst: Glückwunsch, du hast gerade irgendeinem Script-Kiddie Admin-Zugriff gegeben.
Das passiert ständig. Devs werden faul. Sie wollen die konkreten Felder, die sie erwarten, nicht ausschreiben. Sie nehmen Abkürzungen. Abkürzungen führen zu CVEs.
Mal ehrlich. ROI des Fixes? Enorm. Ein einziger Mass-Assignment-Bug kann deine gesamte Datenbank kompromittieren. Der Fix dauert fünf Minuten. Schreib ein DTO. Nutze eine Validierungs-Library wie Zod oder Joi. Entferne unbekannte Keys. So einfach ist das.
Der Albtraum beim Widerruf von JWTs
Devs lieben JWTs, weil sie zustandslos sind. Du musst zur Prüfung nicht die Datenbank abfragen. Aber was passiert, wenn das Konto eines Nutzers kompromittiert ist? Wie widerrufst du einen zustandslosen Token?
Gar nicht. Zumindest nicht einfach. Am Ende baust du eine Token-Blocklist in Redis, was den ganzen Sinn der Zustandslosigkeit zunichtemacht. Du hast gerade ein Session-Cookie-System gebaut, mit zusätzlichen Schritten und schlechterer Sicherheit.
Wenn du JWTs nutzt, halte die Ablaufzeit kurz. Maximal 15 Minuten. Nutze Refresh Tokens in HTTP-only- und Secure-Cookies, um neue JWTs zu holen. Speichere JWTs niemals im Local Storage. XSS stiehlt sie in Millisekunden.
GraphQL-Introspection: Alle Karten auf dem Tisch
Mal ehrlich. Standardmäßig haben die meisten GraphQL-Server Introspection aktiviert. Das heißt, jeder kann den Server abfragen und bekommt eine vollständige Karte deines gesamten API-Schemas. Jeder Typ, jede Query, jede Mutation. Der Traum jedes Angreifers.
Du gibst ihnen den Bauplan deiner Anwendung in die Hand. Schalte Introspection in Produktion ab. Ohne Ausnahme.
Aber Moment, es wird noch schlimmer. Selbst mit abgeschalteter Introspection können Tools wie Clairvoyance über Feldvorschläge (bei denen der Server sagt „Meintest du X?“) das Schema per Brute Force rekonstruieren. Schalte in Produktion auch die Vorschläge ab.
Webhooks und Server-Side Request Forgery (SSRF)
Du baust eine API, über die Nutzer Webhooks registrieren können. Der Nutzer gibt dir eine URL, und wenn ein Event eintritt, schickt dein Server einen POST-Request an diese URL. Klingt harmlos.
Ehrlich gesagt, es ist ein Albtraum. Bis der Nutzer auf AWS einen Webhook registriert, der auf http://169.254.169.254/latest/meta-data/ zeigt. Jetzt fragt dein Server den EC2-Metadatendienst ab und schickt die Cloud-Credentials an den Angreifer zurück.
SSRF ist fies. Du musst Webhook-URLs validieren. Blockiere interne IP-Bereiche. Blockiere localhost. Blockiere die IP des Cloud-Metadatendienstes. Nutze notfalls einen Egress-Proxy.
Hör auf, Input zu vertrauen: Das eigentliche Problem
Im Kern läuft jedes API-Sicherheitsproblem darauf hinaus, dass du Input vertraust. Du vertraust den URL-Parametern. Du vertraust dem JSON-Body. Du vertraust der Struktur der GraphQL-Query. Hör damit auf.
Behandle jedes Datum, das vom Client kommt, als hochradioaktiv. Parse, don't validate. Wenn es nicht exakt dem erwarteten Schema entspricht, verwirf den Request. Logge ihn, schlag Alarm und mach weiter.
Unterm Strich
Schau, ich hab das schon hundertmal gesehen. Sicherheit ist eine Daueraufgabe. Die Angreifer werden schlauer, und unsere Stacks werden komplexer. Mach die Grundlagen richtig, und du entschärfst 99 % des Rauschens. Ignorier sie, und du schreibst bis zum nächsten Quartal ein öffentliches Post-Mortem.
![Best Practices für API-Sicherheit: REST- und GraphQL-Endpunkte schützen [Leitfaden 2026]](/_next/image?url=%2Fblog%2Ftest-mockup.jpg&w=3840&q=75&dpl=dpl_4APdW92RmtTARbNBj4X6xdJXX9hA)