Einstieg
HTTP-Request & Response
HTTP ist ein Request-Response-Protokoll. Clients senden Anfragen (Methode, Pfad, Header, optionaler Body), Server antworten mit Status, Header und Body. HTTP/1.1 ist textbasiert, HTTP/2 und HTTP/3 nutzen binäres Framing.
# HTTP Request
GET /api/users HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Accept: application/json
# HTTP Response
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 45
{"id": 1, "name": "Alice", "email": "[email protected]"}URL-Struktur
URLs identifizieren Ressourcen. Das Scheme wählt das Protokoll. Der Host wird über DNS aufgelöst. Der Default-Port ist implizit, wenn er fehlt. Das Fragment (#) ist nur clientseitig und wird vor dem Senden an den Server entfernt. Query-Strings dienen üblicherweise Filterung/Pagination.
# Generic URL format
scheme://userinfo@host:port/path?query#fragment
# Example
https://user:[email protected]:8443/api/v1/users?page=2#section
# Components
# scheme - https (protocol)
# userinfo - user:pass (rare, deprecated)
# host - example.com (domain or IP)
# port - 8443 (default: 80 for http, 443 for https)
# path - /api/v1/users (resource location)
# query - page=2 (key=value pairs, & separated)
# fragment - section (client-only, never sent to server)HTTP-Versionen im Überblick
HTTP/0.9 war ein minimalistischer Prototyp. HTTP/1.0 ergänzte Header und Content-Typen, öffnete aber pro Anfrage eine neue Verbindung. HTTP/1.1 brachte persistente Verbindungen, den verpflichtenden Host-Header (ermöglicht Virtual Hosts) und Pipelining. HTTP/2 ergänzte binäres Multiplexing. HTTP/3 läuft über QUIC und eliminiert Head-of-Line-Blocking auf Transport-Ebene.
# HTTP/0.9 (1991) - single GET, no headers
GET /page.html
# HTTP/1.0 (1996) - headers, status codes, multiple types
GET /page.html HTTP/1.0
# HTTP/1.1 (1997) - persistent connections, Host header, pipelining
GET /page.html HTTP/1.1
Host: example.com
# HTTP/2 (2015) - binary, multiplexing, header compression
# (negotiated via ALPN or h2c upgrade)
# HTTP/3 (2022) - over QUIC (UDP-based)
# (negotiated via Alt-Svc header)Verbindungs-Lebenszyklus
HTTP/1.1 hält TCP-Verbindungen standardmäßig offen (keep-alive) und vermeidet so den Aufwand wiederholter Handshakes. Mehrere Anfragen laufen über eine Verbindung. Der Connection: close-Header signalisiert die letzte Anfrage. HTTP/2 multiplext viele Streams über eine einzige Verbindung. Keep-Alive timeout und max sind serverseitig konfigurierbar.
# HTTP/1.1 persistent connection (keep-alive)
GET /page1 HTTP/1.1
Host: example.com
Connection: keep-alive
# (server responds, connection stays open)
HTTP/1.1 200 OK
Content-Length: 128
Connection: keep-alive
# Client reuses same TCP connection for next request
GET /page2 HTTP/1.1
Host: example.com
# Closing the connection
GET /final HTTP/1.1
Host: example.com
Connection: closeNachrichtenformat
HTTP-Nachrichten beginnen mit einer start-line (request-line oder status-line), gefolgt von Headern, einer Leerzeile und einem optionalen Body. Zeilen nutzen CRLF-Endungen. Header-Namen sind case-insensitiv. Die Leerzeile ist Pflicht und markiert den Body-Beginn. Bodies können beliebiger Länge (chunked) oder fester Länge (Content-Length) sein.
# Request format
<METHOD> <PATH> <VERSION>
<Header-Name>: <value>
...
<optional body>
# Response format
<VERSION> <STATUS> <REASON>
<Header-Name>: <value>
...
<optional body>
# Lines end with CRLF (
). Headers are case-insensitive.
# A blank line (
) separates headers from body.Telnet / Rohe HTTP-Debugging
HTTP lässt sich roh über TCP sprechen mit nc oder telnet (Port 80) oder openssl s_client (HTTPS). Unbezahlbar zum Debuggen. Der Host-Header ist ab HTTP/1.1 Pflicht. Zwei Leerzeilen beenden die Anfrage. curl -v zeigt die Konversation im Drahtformat inklusive Header.
# Manual HTTP request via netcat/nc
nc example.com 80
GET / HTTP/1.1
Host: example.com
# (press Enter twice to send blank line)
# Using openssl for HTTPS
openssl s_client -connect example.com:443
GET / HTTP/1.1
Host: example.com
# curl with --http1.1 to force version
curl -v --http1.1 https://example.com
curl -v --http2 https://example.com
curl -v --http3 https://example.comHTTP-Methoden
GET — Ressource abrufen
GET holt eine Repräsentation einer Ressource. Es muss safe (keine Seiteneffekte) und idempotent (wiederholbar) sein. GET-Anfragen sind cachefähig und verlinkbar. Auch wenn der Spec einen Body erlaubt, ist davon abzuraten — Proxies und CDNs streichen ihn ggf. Für Filterung lieber Query-Parameter.
# Basic GET
GET /api/users/42 HTTP/1.1
Host: api.example.com
Accept: application/json
# GET with query parameters
GET /api/users?role=admin&active=true HTTP/1.1
Host: api.example.com
# GET should be safe & idempotent
# - safe: no server state change
# - idempotent: repeating yields same result
# - cacheable: yes
# - body allowed but discouraged (some clients/servers reject)POST — Ressource erzeugen
POST übermittelt zu verarbeitende Daten. Genutzt zum Anlegen neuer Ressourcen, bei denen der Server die URI vergibt (z. B. /api/users → /api/users/43). POST ist weder safe noch idempotent — zweimal Senden kann zwei Ressourcen erzeugen. Die 201-Created-Antwort sollte einen Location-Header enthalten, der auf die neue Ressource zeigt.
# POST creating a new resource
POST /api/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 52
{"name": "Bob", "email": "[email protected]", "age": 30}
# Response typically 201 Created with Location header
HTTP/1.1 201 Created
Location: /api/users/43
Content-Type: application/json
{"id": 43, "name": "Bob"}
# POST is neither safe nor idempotent.
# Repeating may create duplicate resources.PUT — Ressource ersetzen
PUT ersetzt die gesamte Ressource an der Ziel-URI durch den Request-Body. Es ist idempotent — dieselbe PUT-Anfrage führt immer zum selben Endzustand. PUT zielt auf eine konkrete URI (z. B. /users/43), anders als POST, das auf eine Collection zielt. Fehlt ein Feld in PUT, wird es typischerweise entfernt (vollständige Ersetzung).
# PUT replaces the entire resource at the given URI
PUT /api/users/43 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 60
{"id": 43, "name": "Robert", "email": "[email protected]", "age": 31}
# Idempotent: sending the same PUT again yields the same state.
# If the resource doesn't exist, PUT may create it (server-dependent).
# Response
HTTP/1.1 200 OK
# or 204 No Content if no body returnedPATCH — Teilupdate
PATCH wendet Teilupdates auf eine Ressource an, anders als PUT, das sie vollständig ersetzt. Die einfachste Form ist JSON Merge Patch (RFC 7396): nur die zu ändernden Felder senden. JSON Patch (RFC 6902) nutzt ein Array von Operationen (add, remove, replace, move, copy, test). PATCH ist standardmäßig NICHT idempotent, merge-patch schon.
# PATCH applies partial modifications
PATCH /api/users/43 HTTP/1.1
Host: api.example.com
Content-Type: application/merge-patch+json
Content-Length: 22
{"email": "[email protected]"}
# Only the email field is updated; other fields remain.
# JSON Patch (RFC 6902) - structured operations
PATCH /api/users/43 HTTP/1.1
Content-Type: application/json-patch+json
[
{"op": "replace", "path": "/email", "value": "[email protected]"},
{"op": "remove", "path": "/age"}
]DELETE — Ressource entfernen
DELETE entfernt die Ziel-Ressource. Es ist idempotent — dieselbe Ressource zweimal zu löschen sollte den Server in denselben Zustand versetzen. Übliche Erfolgscodes: 204 (ohne Body), 200 (mit bestätigendem Body) oder 202 (asynchrones Löschen). Die meisten APIs verlangen Authentifizierung. Ob bei fehlender Ressource 404 zurückgegeben wird, ist umstritten — 204 ist für Idempotenz sicherer.
# Delete a resource
DELETE /api/users/43 HTTP/1.1
Host: api.example.com
Authorization: Bearer <token>
# Successful responses:
HTTP/1.1 204 No Content # most common
HTTP/1.1 200 OK # if body returned
HTTP/1.1 202 Accepted # async deletion queued
# Idempotent: deleting an already-deleted resource
# should still return 204 (or 404 — debatable).HEAD & OPTIONS
HEAD entspricht GET, aber der Server liefert nur Header (kein Body) — nützlich, um Content-Length, Content-Type oder Last-Modified ohne Download zu prüfen. OPTIONS fragt erlaubte Methoden ab (der Allow-Header) und wird von Browsern für CORS-Preflight genutzt. Beide sind safe und idempotent.
# HEAD: like GET but returns headers only (no body)
HEAD /api/users/42 HTTP/1.1
Host: api.example.com
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 128
# (no body)
# OPTIONS: describe communication options
OPTIONS /api/users HTTP/1.1
Host: api.example.com
HTTP/1.1 200 OK
Allow: GET, POST, HEAD, OPTIONS
Access-Control-Allow-Methods: GET, POSTStatuscodes
1xx Informational
1xx-Codes sind informativ und zeigen an, dass die Anfrage empfangen wurde und die Verarbeitung weiterläuft. 100 Continue lässt einen Client pr üfen, ob ein großer Body gesendet werden soll (gepaart mit dem Expect: 100-continue-Header). 101 Switching Protocols ermöglicht WebSocket. 103 Early Hints lässt den Server dem Browser vorladen nahelegen, bevor die finale Antwort bereit ist.
# 100 Continue - server received headers, client may send body
POST /upload HTTP/1.1
Host: example.com
Expect: 100-continue
Content-Length: 1048576
# Server replies:
HTTP/1.1 100 Continue
# (client now sends the request body)
# 101 Switching Protocols - used for WebSocket upgrade
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
# 103 Early Hints - preload resources before final response
HTTP/1.1 103 Early Hints
Link: </style.css>; rel=preload; as=style2xx Erfolg
2xx-Codes bedeuten Erfolg. 200 OK ist der generische Erfolg. 201 Created zeigt eine neue Ressource (mit Location-Header). 202 Accepted bedeutet, die Anfrage ist für asynchrone Verarbeitung eingereiht (z. B. ein Langlauf-Job). 204 No Content signalisiert Erfolg ohne Body — üblich für DELETE/PUT. 206 Partial Content liefert einen Teil einer Ressource (Range-Anfrage).
# 200 OK - standard success
HTTP/1.1 200 OK
# 201 Created - new resource created (POST/PUT)
HTTP/1.1 201 Created
Location: /api/users/43
# 202 Accepted - request queued for async processing
HTTP/1.1 202 Accepted
# 204 No Content - success, no body (DELETE, PUT)
HTTP/1.1 204 No Content
# 206 Partial Content - Range request result
HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/20483xx Umleitung
3xx-Codes bedeuten Umleitung. 301/308 sind dauerhaft (cachefähig, SEO-Link-Juice wandert mit); 302/307 sind temporär. Der entscheidende Unterschied: 301 und 302 erlaubten historisch die POST→GET-Umwandlung (mit Datenverlust), während 307 und 308 strikt die Methode erhalten. 304 Not Modified kommt bei bedingten Anfragen, wenn der Cache gültig ist — ohne Body.
# 301 Moved Permanently - cacheable, change bookmarks
HTTP/1.1 301 Moved Permanently
Location: https://newsite.com/page
# 302 Found - temporary redirect (don't update bookmarks)
HTTP/1.1 302 Found
Location: /login
# 304 Not Modified - cache is still valid (conditional GET)
HTTP/1.1 304 Not Modified
ETag: "abc123"
# 307 Temporary Redirect - preserves method (POST stays POST)
HTTP/1.1 307 Temporary Redirect
Location: /new-endpoint
# 308 Permanent Redirect - permanent, preserves method
HTTP/1.1 308 Permanent Redirect
Location: https://newsite.com/api4xx Client-Fehler
4xx-Codes bedeuten einen Client-Fehler. 400 Bad Request ist malformed Input. 401 bedeutet fehlende/ungültige Authentifizierung (WWW-Authenticate mitschicken). 403 bedeutet authentifiziert, aber ohne Berechtigung. 404 ist eine fehlende Ressource. 429 zeigt Rate Limiting (Retry-After mitgeben). Weitere Häufige: 405 Method Not Allowed, 409 Conflict, 422 Unprocessable Entity.
# 400 Bad Request - malformed syntax
HTTP/1.1 400 Bad Request
Content-Type: application/json
{"error": "Invalid JSON in request body"}
# 401 Unauthorized - authentication required
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer realm="api"
# 403 Forbidden - authenticated but not allowed
HTTP/1.1 403 Forbidden
# 404 Not Found - resource doesn't exist
HTTP/1.1 404 Not Found
# 429 Too Many Requests - rate limit hit
HTTP/1.1 429 Too Many Requests
Retry-After: 605xx Server-Fehler
5xx-Codes bedeuten ein Server-Versagen. 500 ist der Sammelcode für unbehandelte Fehler (Server-Logs prüfen). 501 bedeutet, der Server implementiert die Methode nicht. 502 bedeutet, ein Proxy/Gateway bekam eine schlechte Antwort vom Upstream. 503 bedeutet temporäre Überlast (Retry-After setzen). 504 bedeutet ein Upstream-Timeout. Clients dürfen 502/503/504 mit Backoff wiederholen.
# 500 Internal Server Error - generic server failure
HTTP/1.1 500 Internal Server Error
# 501 Not Implemented - server doesn't support the method
HTTP/1.1 501 Not Implemented
# 502 Bad Gateway - upstream server returned invalid response
HTTP/1.1 502 Bad Gateway
# 503 Service Unavailable - temporary overload or maintenance
HTTP/1.1 503 Service Unavailable
Retry-After: 300
# 504 Gateway Timeout - upstream didn't respond in time
HTTP/1.1 504 Gateway TimeoutStatuscode-Muster
Eine konsistente Statuscode-Zuordnung macht APIs vorhersagbar. 2xx für Erfolg mit semantischer Präzision (201 beim Anlegen, 204 ohne Body). 4xx für Client-Fehler mit dem spezifischsten Code (409 für Konflikte, 422 für Validierung). 401 vs. 403 ist die häufigste Verwirrung: 401 = 'Wer bist du?', 403 = 'Ich weiß, wer du bist, aber das darfst du nicht'.
# REST API common mapping
GET /users -> 200
POST /users -> 201 (Created)
GET /users/42 -> 200 | 404
PUT /users/42 -> 200 | 201 (if created) | 404
PATCH /users/42 -> 200 | 404
DELETE /users/42 -> 204 | 404
# Validation errors
400 -> malformed JSON, missing required field
409 -> duplicate resource / version conflict
422 -> semantic validation failure (some APIs)
# Auth flow
401 -> no/invalid token (login required)
403 -> logged in but lacking permission
404 -> hide existence from unauthorized users
# Use 418 I'm a teapot for fun (RFC 2324 joke).Request-Header
Häufige Request-Header
Häufige Request-Header transportieren Client-Identität (User-Agent), gewünschtes Antwortformat (Accept-Familie), Verbindungssteuerung (Connection), Authentifizierung (Authorization), Zustand (Cookie) und Herkunft (Referer/Origin). Host ist ab HTTP/1.1 Pflicht für Virtual Hosting. Content-Type und Content-Length beschreiben einen Request-Body.
GET /api/data HTTP/1.1
Host: api.example.com # target host (mandatory in HTTP/1.1)
User-Agent: Mozilla/5.0 # client identity
Accept: application/json # desired response format
Accept-Language: en-US,en;q=0.9
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Authorization: Bearer <token>
Cookie: session=abc123; theme=dark
Referer: https://example.com/
Origin: https://example.com
Content-Type: application/json
Content-Length: 42Accept-Header (Content Negotiation)
Die Accept-Familie treibt die Content Negotiation an. Quality-Werte (q, 0-1) drücken Präferenz aus — höher ist bevorzugter. */* ist ein Wildcard-Catch-all. Der Server wählt das beste Match aus dem, was er unterstützt; ohne Match gibt er 406 Not Acceptable (die meisten Server fallen aber auf einen Default zurück statt 406). Brotli (br) und zstd komprimieren besser als gzip.
# Accept: desired media types with quality (q) values
Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8
# Accept-Language: preferred languages
Accept-Language: en-US,en;q=0.9, zh-CN;q=0.8, fr;q=0.7
# Accept-Encoding: accepted compression algorithms
Accept-Encoding: gzip, deflate, br, zstd;q=0.9
# q=1.0 is default. Higher q = more preferred.
# */* matches any type.
# Server responds with 406 Not Acceptable if it can't satisfy.Authorization- & Auth-Header
Authorization trägt Credentials. Basic-Auth sendet base64-kodiertes username:password bei jeder Anfrage (immer HTTPS). Bearer-Tokens sind opake Strings (oft JWTs) aus OAuth 2.0. Eigene Auth-Schemata (X-API-Key) sind bei API-Gateways üblich. Basic-Auths base64 ist Encoding, keine Verschlüsselung — ohne TLS keine Sicherheit.
# Basic Authentication (base64 of user:pass)
Authorization: Basic dXNlcjpwYXNz
# dXNlcjpwYXNz = base64("user:pass")
# Bearer Token (OAuth 2.0 / JWT)
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
# API Key in header (custom)
X-API-Key: abc123def456
# Proxy authentication
Proxy-Authorization: Basic dXNlcjpwYXNz
# WARNING: Basic auth sends credentials on every request.
# Always use HTTPS to prevent eavesdropping.User-Agent & Referer
User-Agent identifiziert den Client, aber die meisten Browser fälschen Mozilla/5.0 aus Abwärtskompatibilität (historisches Sniffing). Referer (im Spec falsch geschrieben, nie korrigiert) sagt dem Server, welche Seite auf die Anfrage verlinkt hat — genutzt für Analytics und Hotlink-Schutz. Origin ist scheme+host+port, gesendet von Browsern bei CORS-Anfragen und POSTs.
# User-Agent identifies the client software
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
# Common browsers prepend "Mozilla/5.0" for historical compatibility
# (servers used to serve different content to different browsers)
# Referer: page that linked to this request
Referer: https://example.com/search?q=hello
# Origin: scheme + host + port (used by CORS)
Origin: https://example.com
# Note: "Referer" is the official spelling (misspelled in the original spec)Bedingte Request-Header
Bedingte Header ermöglichen effizientes Caching und Nebenläufigkeitskontrolle. If-None-Match (mit ETag) und If-Modified-Since (mit Last-Modified) machen GET bedingt — der Server antwortet 304, wenn der Cache gültig ist. If-Match und If-Unmodified-Since schützen PUT/PATCH vor verlorenen Updates (optimistische Nebenläufigkeit). If-Range ermöglicht atomare Range-Anfragen.
# Conditional GET - only fetch if changed
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT
If-None-Match: "abc123"
# If-Match / If-Unmodified-Since - for safe PUT/PATCH
If-Match: "abc123"
If-Unmodified-Since: Wed, 21 Oct 2023 07:28:00 GMT
# If-Range - for range requests (all-or-nothing)
If-Range: "abc123"
Range: bytes=0-1023
# Typical flow:
# 1. Server sends ETag/Last-Modified with response
# 2. Client sends If-None-Match/If-Modified-Since on next request
# 3. Server replies 304 if unchanged, 200 if changedEigene & X-Header
Eigene Header nutzten historisch das X--Präfix, aber RFC 6648 deprecate diese Konvention 2012. Neue Header sollten X- weglassen (z. B. Request-ID statt X-Request-ID). X-Forwarded-For und X-Forwarded-Proto tragen Client-Infos durch Proxies (Hinweis: fälschbar). Die standardisierte Alternative ist Forwarded (RFC 7239). Traceparent/Tracestate ermöglichen Distributed Tracing (W3C).
# X- prefixed headers (deprecated convention, but widely used)
X-Request-ID: 550e8400-e29b-41d4-a716-446655440000
X-Correlation-ID: abc-123
X-Forwarded-For: 203.0.113.1, 70.41.3.18
X-Forwarded-Proto: https
X-Real-IP: 203.0.113.1
X-RateLimit-Remaining: 42
# Modern recommendation: avoid X- prefix (RFC 6648)
# Use a namespace instead:
Request-ID: 550e8400-e29b-41d4-a716-446655440000
Traceparent: 00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01
# Forwarded (RFC 7239) - standardized proxy info
Forwarded: for=203.0.113.1; proto=https; host=example.comResponse-Header
Häufige Response-Header
Häufige Response-Header beschreiben den Server (Server), den Antwort-Body (Content-Type, Content-Length), Verbindungssteuerung (Connection), Caching (Cache-Control, ETag, Last-Modified), Content Negotiation (Vary), Zustand (Set-Cookie) und CORS (Access-Control-*). Date ist Pflicht und nutzt das RFC-1123-Format in GMT.
HTTP/1.1 200 OK
Server: nginx/1.25.0
Date: Wed, 21 Oct 2023 07:28:00 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 128
Connection: keep-alive
Cache-Control: public, max-age=3600
ETag: "abc123"
Last-Modified: Mon, 20 Oct 2023 10:00:00 GMT
Vary: Accept-Encoding
Set-Cookie: session=xyz; HttpOnly; Secure
Access-Control-Allow-Origin: https://example.comContent-Header
Content-*-Header beschreiben den Body. Content-Type ist der MIME-Typ und entscheidend. Content-Length gibt die exakte Byte-Zahl (Pflicht, außer bei chunked encoding). Content-Encoding zeigt Kompression (gzip, br). Content-Disposition erzwingt Download mit Dateinamen. Content-Range begleitet 206-Partial-Content-Antworten.
# Body metadata
Content-Type: application/json; charset=utf-8
Content-Length: 128 # exact byte count
Content-Encoding: gzip # applied encoding
Content-Language: en-US
Content-Location: /api/users/42.json
Content-Disposition: attachment; filename="report.pdf"
Content-Range: bytes 0-1023/2048 # for partial content
# For chunked transfer (no Content-Length known upfront)
Transfer-Encoding: chunked
# MIME type format: type/subtype; parameter=value
# e.g., text/html; charset=UTF-8Security-Header
Security-Header härten Browser gegen häufige Angriffe. HSTS erzwingt HTTPS und verhindert SSL-Stripping. X-Content-Type-Options: nosniff verhindert MIME-Sniffing. X-Frame-Options (oder CSP frame-ancestors) blockiert Clickjacking. CSP ist das mächtigste — er steuert, welche Ressourcen geladen und ausgeführt werden dürfen. Referrer-Policy begrenzt geleakete Referrer-Infos. Auf jeder Antwort setzen.
# Force HTTPS for 6 months (incl. subdomains)
Strict-Transport-Security: max-age=15768000; includeSubDomains; preload
# Prevent MIME-type sniffing
X-Content-Type-Options: nosniff
# Prevent clickjacking
X-Frame-Options: DENY
# Or modern CSP frame-ancestors:
Content-Security-Policy: frame-ancestors 'none'
# Referrer policy
Referrer-Policy: strict-origin-when-cross-origin
# Permissions policy (feature lockdown)
Permissions-Policy: geolocation=(), camera=()
# Full Content-Security-Policy
Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.example.comCORS-Response-Header
CORS-Header (Cross-Origin Resource Sharing) lassen einen Server Cross-Origin-Anfragen freischalten. Access-Control-Allow-Origin ist Pflicht für jeden Cross-Origin-Read; ein konkreter Origin oder *. Bei Credentials: Allow-Credentials: true UND ein konkreter Origin (kein Wildcard). Preflight-(OPTIONS-)Antworten enthalten Allow-Methods/Headers. Expose-Headers lässt JS nicht-default Response-Header lesen.
# Allow a specific origin
Access-Control-Allow-Origin: https://example.com
# Or wildcard (but credentials won't work with *)
Access-Control-Allow-Origin: *
# Allow credentials (cookies, Authorization)
Access-Control-Allow-Credentials: true
# Allowed methods (preflight response)
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
# Allowed headers (preflight response)
Access-Control-Allow-Headers: Content-Type, Authorization
# How long browser can cache preflight (seconds)
Access-Control-Max-Age: 86400
# Headers the JS can read from the response
Access-Control-Expose-Headers: X-Request-ID, X-Total-CountCache-Header
Cache-Control ist der moderne (HTTP/1.1) Caching-Header mit Direktiven: public/private (wer darf cachen), max-age (Frische in Sekunden), no-cache (muss revalidieren), no-store (niemals cachen), immutable (URL ändert sich nie). ETag und Last-Modified sind Validatoren für bedingte Anfragen. Expires (HTTP/1.0) ist ein Fallback. Age verrät, wie lange eine Antwort schon gecacht ist.
# Cache-Control directives (HTTP/1.1 - preferred)
Cache-Control: public, max-age=3600
Cache-Control: private, max-age=600
Cache-Control: no-cache # revalidate before use
Cache-Control: no-store # never cache
Cache-Control: must-revalidate
Cache-Control: immutable
# Validators
ETag: "abc123" # opaque version tag
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT
# HTTP/1.0 fallbacks (deprecated)
Expires: Wed, 21 Oct 2023 08:28:00 GMT
Pragma: no-cache
# Age: time a response has been in a cache (seconds)
Age: 120Authentifizierung
Basic Authentication
Basic-Auth sendet base64-kodierte Credentials bei jeder Anfrage. Einfach und überall unterstützt, aber ohne HTTPS null Sicherheit — base64 ist trivial dekodierbar. Der WWW-Authenticate-Header fordert den Client auf (Browser zeigen einen nativen Login-Dialog). Basic-Auth ist in modernen Web-Apps selten, aber üblich für API-Tokens und interne Tools.
# Basic auth: base64(user:pass) sent on every request
GET /api/data HTTP/1.1
Host: example.com
Authorization: Basic dXNlcjpwYXNz
# dXNlcjpwYXNz = base64("user:pass")
# In curl: curl -u user:pass https://example.com/api/data
# Server challenge (401 with WWW-Authenticate)
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic realm="Restricted Area", charset="UTF-8"
# WARNING: base64 is encoding, NOT encryption.
# Always pair Basic auth with HTTPS.Bearer-Token (OAuth 2.0)
Bearer-Tokens sind opake Strings als Nachweis der Autorisierung. Der Server muss sie nur validieren — sie sind stateless, wenn selbst-tragend (JWT) oder in einem Store nachgeschlagen. OAuth 2.0 definiert Flows zum Beschaffen von Tokens (authorization code, client credentials, refresh token). Bearer-Tokens immer über HTTPS. Tokens haben begrenzte Lebensdauer; mit Refresh-Tokens neue holen.
# Bearer token: opaque string proving authorization
GET /api/profile HTTP/1.1
Host: api.example.com
Authorization: Bearer SlAV32hkKG...
# Token obtained from OAuth 2.0 flow:
POST /oauth/token HTTP/1.1
Content-Type: application/x-www-form-urlencoded
grant_type=password&username=alice&password=secret&client_id=...
# Response
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token": "SlAV32hkKG...",
"token_type": "Bearer",
"expires_in": 3600,
"refresh_token": "GmR..."
}JWT-Struktur
Ein JWT hat drei base64url-kodierte Teile, getrennt durch Punkte: header (Algorithmus), payload (Claims) und Signatur. Die Signatur belegt, dass der Token nicht manipuliert wurde. Häufige Claims: sub (subject), iat (issued at), exp (expiration), iss (issuer), aud (audience). Die Payload ist NICHT verschlüsselt — niemals Secrets dort ablegen. Signaturalgorithmen: HS256 (HMAC), RS256 (RSA), ES256 (ECDSA).
# JWT = header.payload.signature (base64url-encoded)
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFsaWNlIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
# Decoded:
# Header
{"alg": "HS256", "typ": "JWT"}
# Payload (claims)
{
"sub": "1234567890", # subject (user id)
"name": "Alice",
"iat": 1516239022, # issued at
"exp": 1516242622, # expiration
"iss": "example.com", # issuer
"aud": "api.example.com" # audience
}
# Signature (HMAC-SHA256 of header.payload with secret)
HMAC-SHA256(secret, "eyJhbGc...")JWT-Validierung
JWT-Validierung: Signatur prüfen (erkennt Manipulation), dann Claims prüfen (exp, iss, aud). exp ist das wichtigste — abgelaufene Tokens mit 401 ablehnen. JWTs sind stateless: einmal ausgestellt, sind sie bis zum Ablauf nicht widerrufbar. Für Widerruf kurzlebige Access-Tokens (5-15 min) + serverseitig gespeicherte Refresh-Tokens, oder eine Blacklist pflegen (widerlegt die Statelessness).
# Server-side JWT validation steps:
# 1. Parse three parts (header.payload.signature)
# 2. Verify signature using secret (HS256) or public key (RS256)
# 3. Check claims:
# - exp (must be in future)
# - iat (must be in past, optional)
# - iss (must match expected issuer)
# - aud (must match expected audience)
# 4. Check revocation list (if using short-lived + refresh)
# Common errors:
# 401 - invalid signature, expired, wrong issuer
# 401 - "Bearer" prefix missing
# 403 - valid token but lacking permission (scope)
# Token expired response
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer error="invalid_token", error_description="The token has expired"OAuth 2.0 Authorization-Code-Flow
Der Authorization-Code-Flow ist der Standard für serverseitige Web-Apps. Schritt 1 leitet den Nutzer zum Auth-Server um. Schritt 2 gibt einen kurzlebigen Code an die Redirect-URI zurück. Schritt 3 tauscht den Code (plus client_secret) Server-zu-Server gegen Tokens. PKCE (Proof Key for Code Exchange) ersetzt das Secret durch ein code challenge/verifier-Paar — essenziell für SPAs und Mobile-Apps, wo das Secret nicht sicher lagerbar ist.
# Step 1: Redirect user to authorization endpoint
GET /authorize?response_type=code&client_id=CLIENT_ID&redirect_uri=https://app.com/callback&scope=read&state=random123 HTTP/1.1
Host: auth.example.com
# Step 2: User logs in & grants consent, redirected back with code
HTTP/1.1 302 Found
Location: https://app.com/callback?code=AUTH_CODE&state=random123
# Step 3: Server exchanges code for token (server-to-server)
POST /oauth/token HTTP/1.1
Host: auth.example.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic base64(client_id:client_secret)
grant_type=authorization_code&code=AUTH_CODE&redirect_uri=https://app.com/callback
# Step 4: Token response
{"access_token": "...", "refresh_token": "...", "expires_in": 3600}
# Use PKCE for SPAs/mobile (no client_secret)
# code_challenge = base64url(SHA256(code_verifier))API-Keys
API-Keys sind einfache opake Secrets, die einen Client identifizieren. Sie gehen in Headern (bevorzugt) oder Query-Strings (vermeiden — landen in URLs und Proxy-Logs). API-Keys sind stateful (der Server schlägt nach) und widerrufbar. Anders als JWTs tragen sie keine Claims — der Server speichert die Rechte. Best-Practices: Keys im Ruhezustand hashen, eng begrenzen, rotieren und eine Self-Service-Rotation-UI bieten.
# API key in header (most common)
GET /api/data HTTP/1.1
X-API-Key: abc123def456
# API key as Bearer token
Authorization: Bearer abc123def456
# API key in query string (less secure - logged in URLs)
GET /api/data?api_key=abc123def456 HTTP/1.1
# API key in custom header with prefix
Authorization: ApiKey abc123def456
# Best practices:
# - Rotate keys periodically
# - Scope keys to specific permissions
# - Store keys hashed at rest (like passwords)
# - Never commit keys to source controlContent Negotiation
Accept-Header
Der Accept-Header listet Medientypen, die der Client verarbeiten kann, mit Quality-Werten (q) für die Präferenz. Wildcards (text/*, */*) weiten das Match aus. Der Server wählt das beste Match und antwortet mit dem gewählten Content-Type. Ohne passenden Medientyp sollte der Server 406 geben, aber in der Praxis fallen viele APIs auf ein Default-Format zurück.
# Single type
Accept: application/json
# Multiple types with preferences (q values, 0-1)
Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8
# Wildcard media types
Accept: text/* # any text/* subtype
Accept: */* # anything
Accept: image/png, image/*;q=0.8
# Parameters
Accept: text/html;charset=utf-8
# Server picks best match and returns it in Content-Type.
# If no match, server returns 406 Not Acceptable (or a default).Accept-Language
Accept-Language teilt dem Server die bevorzugten Sprachen des Nutzers mit, mit Quality-Werten für das Ranking. RFC 5646 definiert Sprach-Tags (language[-script][-region]). Der Server antwortet mit Content-Language. Browser setzen es aus den OS-/Locale-Einstellungen. Für i18n graceful ausweichen: ist die gewünschte Sprache nicht verfügbar, den Default zurückgeben. CDNs variieren Caches manchmal nach Accept-Language — den Vary-Header setzen.
# Single language
Accept-Language: en-US
# Multiple languages with preferences
Accept-Language: en-US,en;q=0.9, zh-CN;q=0.8, fr;q=0.7, de;q=0.5
# Wildcard
Accept-Language: *
# Server responds with the selected language:
Content-Language: en-US
# RFC 5646 language tags:
# en - language
# en-US - language + region
# zh-Hans - language + script (Simplified Chinese)
# es-419 - language + region (Latin America)Accept-Encoding
Accept-Encoding listet Kompressionsalgorithmen, die der Client dekodieren kann. Der Server wählt einen und wendet ihn an, mit Content-Encoding als Antwort. Brotli (br) komprimiert Text besser als gzip und wird von allen modernen Browsern unterstützt. zstd kommt mit besserer Geschwindigkeit/Ratio. identity bedeutet keine Kompression. Für Text-Antworten (HTML, CSS, JS, JSON) immer Kompression aktivieren — große Bandbreiteneinsparung, aber bereits komprimierte Formate (Bilder, Video) überspringen.
# Accepted compression algorithms
Accept-Encoding: gzip, deflate, br, zstd
# With preferences
Accept-Encoding: br;q=1.0, gzip;q=0.8, identity;q=0.5, *;q=0
# identity = no encoding (raw)
# * = any encoding not listed
# Server response
Content-Encoding: br
# Common algorithms:
# gzip - widespread, RFC 1952
# deflate - zlib, RFC 1950
# br - Brotli, better for text (modern browsers)
# zstd - Zstandard, fast + good ratio (newer)
# identity - no compressionVary-Header
Der Vary-Header sagt Caches (Browser, CDN, Proxy), welche Request-Header die Antwort beeinflussen. Gibt ein Server je nach Accept-Encoding unterschiedliche Inhalte, muss er Vary: Accept-Encoding setzen, damit der Cache keine gzip-Antwort an einen Client ausliefert, der nur br akzeptiert. Zu viel Vary senkt die Cache-Trefferquote; zu wenig verursacht Cache-Poisoning (falsche Inhalte). Vary: * deaktiviert Caching effektiv.
# Server response telling caches to vary by Accept-Encoding
HTTP/1.1 200 OK
Content-Type: text/html
Content-Encoding: gzip
Vary: Accept-Encoding
# Vary on multiple headers
Vary: Accept-Encoding, Accept-Language
# Vary on Accept (full content negotiation)
Vary: Accept
# Vary: * means "varies on everything" (effectively no-cache)
Vary: *
# CDN/cache key includes the Vary header values.
# A gzip+en response is cached separately from a br+fr response.Quality-Werte (q)
Quality-Werte (q, 0-1) drücken in Accept-Familie-Headern die Präferenzstärke aus. q=1.0 ist der Default (am meisten bevorzugt); q=0 bedeutet 'nicht akzeptabel'. Der Server listet, was er liefern kann, matcht gegen die Client-Liste und wählt das höchste q. Bei Gleichstand zählt die Spezifität: application/json schlägt */* selbst bei gleichem q. Drei Nachkommastellen sind erlaubt, aber selten nötig.
# q values appear in Accept, Accept-Language, Accept-Encoding, Accept-Charset
# Format: ;q=0.000 to ;q=1.000 (default is 1.0)
Accept: text/html;q=1.0, application/json;q=0.9, */*;q=0.1
# Meaning:
# q=1.0 - strongly preferred
# q=0.5 - acceptable
# q=0 - NOT acceptable (refuse)
# Server algorithm (RFC 7231):
# 1. List media types the server can produce
# 2. Match each against the client's Accept
# 3. Pick the match with the highest q value
# 4. Ties broken by specificity (concrete > wildcard)
# Example: client prefers JSON over XML
Accept: application/json, application/xml;q=0.5Caching
Cache-Control-Direktiven
Cache-Control ist der moderne Caching-Header mit Direktiven. public/private steuert, wer cachen darf; max-age setzt die Frische in Sekunden; no-cache erzwingt Revalidierung; no-store verbietet Caching; must-revalidate verbietet veraltete Auslieferung; s-maxage setzt eine separate TTL für geteilte Caches (CDNs). immutable sagt Browsern, dass sich die Ressource nie ändert — Revalidierung beim Reload überspringen. Stale-while-revalidate und stale-if-error erlauben graceful degradation.
# Response directives (server -> cache)
Cache-Control: public, max-age=3600 # cacheable by all, fresh 1h
Cache-Control: private, max-age=600 # browser only, fresh 10min
Cache-Control: no-cache # revalidate before use
Cache-Control: no-store # never cache (sensitive data)
Cache-Control: must-revalidate # never serve stale
Cache-Control: proxy-revalidate # proxies must revalidate
Cache-Control: immutable # URL never changes
Cache-Control: max-age=0, must-revalidate # always revalidate
Cache-Control: s-maxage=3600, max-age=600 # CDN caches 1h, browser 10min
# Request directives (client -> cache)
Cache-Control: no-cache # send request to origin
Cache-Control: no-store # don't store the response
Cache-Control: only-if-cached # only from cacheETag & If-None-Match
ETag ist ein opakes Versionstag (oft ein Hash des Inhalts) an einer Antwort. Bei der nächsten Anfrage sendet der Client If-None-Match mit dem gespeicherten ETag. Ist die Ressource unverändert, antwortet der Server mit 304 Not Modified ohne Body — spart Bandbreite. Starke ETags garantieren byteidentische Inhalte; schwache ETags (W/) erlauben semantisch äquivalente Antworten (z. B. Whitespace-Unterschiede).
# Server tags a response with an ETag
HTTP/1.1 200 OK
ETag: "abc123"
Content-Type: application/json
{"data": "..."}
# Client sends conditional request on next fetch
GET /api/data HTTP/1.1
If-None-Match: "abc123"
# Server compares:
# - If matches: 304 Not Modified (no body)
HTTP/1.1 304 Not Modified
ETag: "abc123"
# - If changed: 200 OK with new body + new ETag
HTTP/1.1 200 OK
ETag: "def456"
# Strong vs weak ETags:
# "abc123" - strong (byte-identical)
# W/"abc123" - weak (semantically equivalent)Last-Modified & If-Modified-Since
Last-Modified ist ein zeitbasierter Validator. Er hat 1-Sekunden-Präzision — subsekündige Änderungen können verloren gehen. If-Modified-Since triggert 304 bei Unverändertheit. If-Unmodified-Since schützt vor verlorenen Updates: hat ein anderer Client die Ressource geändert, antwortet der Server mit 412 Precondition Failed. ETag ist, wenn verfügbar, vorzuziehen (präziser), aber Last-Modified ist ein nützlicher Fallback.
# Server includes Last-Modified
HTTP/1.1 200 OK
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT
# Client sends conditional request
GET /api/data HTTP/1.1
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT
# Server: if not modified since that time -> 304
HTTP/1.1 304 Not Modified
# Server: if modified since -> 200 with new content
HTTP/1.1 200 OK
Last-Modified: Thu, 22 Oct 2023 09:00:00 GMT
# If-Unmodified-Since (for safe updates - optimistic locking)
PUT /api/users/42 HTTP/1.1
If-Unmodified-Since: Wed, 21 Oct 2023 07:28:00 GMT
# 412 Precondition Failed if modified elsewhereCache-Validierungs-Fluss
Cache-Fluss: frisch (innerhalb max-age) → aus dem Cache ausgeliefert, kein Netzwerk. Veraltet (nach max-age) → bedingte Anfrage mit Validatoren. 304 aktualisiert den Cache-Timer, ohne den Body neu zu laden. 200 ersetzt den Cache-Eintrag. Das drastisch reduziert Bandbreite und Origin-Last. Für Daten, die oft ändern, aber leichte Veraltung tolerieren lassen: stale-while-revalidate.
# 1. First request - server sends validators
GET /api/users HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: max-age=60
ETag: "v1"
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT
# 2. Within max-age (60s): cache serves directly, no network
GET /api/users (served from cache)
# 3. After max-age: stale - revalidate (conditional GET)
GET /api/users HTTP/1.1
If-None-Match: "v1"
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT
# 4a. Unchanged -> 304 (revalidate resets the cache timer)
HTTP/1.1 304 Not Modified
Cache-Control: max-age=60
ETag: "v1"
# 4b. Changed -> 200 with new body
HTTP/1.1 200 OK
Cache-Control: max-age=60
ETag: "v2"Cache-Busting & Invalidierung
Cache-Busting: unveränderliche Assets (JS, CSS, Bilder) mit versionierten URLs versehen (app.v1a2b3c.js) und ein Jahr lang mit immutable cachen. Beim Deployment die URL ändern — Browser laden die neue Datei. Der HTML-Einstiegspunkt nutzt no-cache, sodass Nutzer immer revalidieren und neue Asset-URLs aufnehmen. So entstehen sofortige Updates und langlebige Caches zugleich. Query-String-Versionierung vermeiden (?v=123) — manche Proxies cachen sie nicht.
# Immutable assets with long cache + versioned URLs
GET /assets/app.v1a2b3c.js HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: public, max-age=31536000, immutable
# When deploying a new version, the URL changes:
GET /assets/app.v4d5e6f.js HTTP/1.1
# (browser fetches new file; old one stays cached but unused)
# HTML entry point: short cache, must revalidate
GET /index.html HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: no-cache
# (revalidate every time, but 304 if unchanged)
# Anti-pattern: caching HTML forever (users see stale entry)
# Anti-pattern: querying JS with ?ts=123 (defeats CDN caching)
# Manual cache purge via CDN API (vendor-specific)CORS (Cross-Origin)
Same-Origin-Policy & CORS
Die Same-Origin-Policy (SOP) ist ein Browser-Sicherheitsmodell, das Web-Seiten standardmäßig am Lesen von Cross-Origin-Antworten hindert. CORS (Cross-Origin Resource Sharing) ist die Opt-out-Möglichkeit: der Server erklärt, welche Ursprünge seine Antworten lesen dürfen. Origin ist scheme+host+port — Abweichen eines davon bedeutet cross-origin. CORS zählt nur für Browser-basierte Anfragen; Server-zu-Server-Aufrufe sind unbeschränkt.
# Same-Origin Policy (SOP): browsers block cross-origin reads by default
# Origin = scheme + host + port
# https://app.com vs https://api.com -> DIFFERENT origins
# http://app.com vs https://app.com -> DIFFERENT (scheme)
# https://app.com vs https://app.com:8443 -> DIFFERENT (port)
# CORS lets a server OPT IN to cross-origin requests
# via Access-Control-Allow-Origin response header.
# Simple cross-origin GET (no preflight)
GET /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
# Server allows the origin
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.comEinfache Anfragen (kein Preflight)
Einfache Anfragen überspringen den Preflight und gehen direkt an den Server. Die Einschränkungen sind konservativ: nur GET/HEAD/POST, nur safelisted Header und nur einfache Content-Types. Jede Abweichung (z. B. Content-Type: application/json, eigene Header, PUT/DELETE) macht die Anfrage 'non-simple' und triggert einen Preflight. Der Server muss trotzdem CORS-Header auf der Antwort setzen, sonst blockiert der Browser das Lesen.
# A "simple" request is sent directly (no preflight):
# - Method: GET, HEAD, or POST
# - Only CORS-safelisted headers:
# Accept, Accept-Language, Content-Language, Content-Type
# - Content-Type limited to:
# application/x-www-form-urlencoded
# multipart/form-data
# text/plain
# - No event listeners on upload
# - No ReadableStream
# Example: simple cross-origin POST form submit
POST /api/login HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Content-Type: application/x-www-form-urlencoded
user=alice&pass=secret
# Server must respond with Allow-Origin for browser to expose responsePreflight-Anfragen (OPTIONS)
Ein Preflight ist eine OPTIONS-Anfrage, die der Browser vor einer non-simple Cross-Origin-Anfrage sendet. Er prüft, ob Methode und Header erlaubt sind. Der Server antwortet mit Allow-Methods und Allow-Headers. Access-Control-Max-Age cachet das Preflight-Ergebnis (Default 5s, Browser begrenzen auf 24h). Preflights kosten Latenz — für heiße Pfade nach Möglichkeit einfache Anfragen verwenden.
# Browser sends preflight OPTIONS before non-simple requests
OPTIONS /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: Content-Type, Authorization
# Server preflight response
HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400 # cache preflight for 24h
# Only then does the browser send the actual request
PUT /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Content-Type: application/json
Authorization: Bearer ...
{"key": "value"}CORS mit Credentials
Standardmäßig senden Cross-Origin-Fetches keine Cookies. Um sie einzuschließen, setzt der Client credentials: 'include'. Der Server muss mit Access-Control-Allow-Credentials: true antworten UND den konkreten Origin spiegeln (nicht den Wildcard *). Immer Vary: Origin mitgeben, damit Caches nicht eine für einen Origin ausgehandelte Antwort an einen anderen ausliefern. Fehlkonfiguriertes CORS+Credentials ist ein Sicherheitsloch — Ursprünge auf eine bekannte Allowlist beschränken.
# Client: opt in to sending cookies/auth
fetch('https://api.example.com/data', {
credentials: 'include' # send cookies cross-origin
});
# Browser sends:
GET /data HTTP/1.1
Origin: https://app.example.com
Cookie: session=abc123
# Server response MUST:
# 1. Echo the SPECIFIC origin (NOT *)
# 2. Set Allow-Credentials: true
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Credentials: true
Vary: Origin # important: caches must vary by Origin
# Wildcard origin + credentials = browser blocks response
# (Access-Control-Allow-Origin: * with credentials fails)Häufige CORS-Fehler
CORS-Fehler zeigen sich in der Browser-Konsole. Die häufigsten: fehlendes Allow-Origin (der Server hat nicht freigeschaltet), Wildcard-mit-Credentials (verbotene Kombination) und fehlendes Allow-Headers/Methods auf Preflight-Antworten. CORS erzwingt der Browser, nicht der Server — die Anfrage erreicht den Server trotzdem, aber der Browser verbirgt die Antwort vor JS. Im Network-Tab prüfen: scheitert der OPTIONS-Preflight, wird die echte Anfrage nie gesendet.
# Error: No 'Access-Control-Allow-Origin' header
# Cause: server didn't send CORS header, or origin not allowed
# Fix: add Access-Control-Allow-Origin on the server
# Error: Credentials flag is true, but Allow-Origin is *
# Cause: wildcard not allowed with credentials
# Fix: echo the specific request Origin instead of *
# Error: preflight missing Allow-Methods / Allow-Headers
# Cause: server didn't allow the method/header
# Fix: add them to Access-Control-Allow-Methods/Headers
# Error: Allow-Origin doesn't match Origin
# Cause: server echoed a different origin (or scheme mismatch)
# Fix: dynamically echo req.headers.origin if allowlisted
# Debug:
# - Check browser DevTools Console for exact error
# - Check Network tab -> see the OPTIONS preflight response
# - Verify headers in the responseHTTPS & SSL/TLS
TLS-Handshake (HTTPS)
HTTPS umwickelt HTTP mit TLS-Verschlüsselung. Der TLS-Handshake authentifiziert den Server (Zertifikat), verhandelt Verschlüsselung und tauscht Schlüssel. TLS 1.2 braucht 2 Round-Trips; TLS 1.3 nur 1 (oder 0 mit Resumption). SNI (Server Name Indication) sendet den Ziel-Hostnamen im Klartext, damit der Server das richtige Zertifikat wählen kann — das leakt den Hostnamen an Lauscher; ECH (Encrypted Client Hello) verschlüsselt ihn.
# HTTPS = HTTP over TLS
# 1. TCP connection (port 443)
# 2. TLS handshake:
ClientHello -> server
- supported TLS versions, cipher suites, extensions
- SNI: hostname (example.com)
ServerHello + Certificate + ServerHelloDone <- server
- selected cipher, certificate (public key)
ClientKeyExchange + ChangeCipherSpec -> server
- encrypted pre-master secret (RSA) or ECDHE params
ChangeCipherSpec + Finished <- server
# 3. Encrypted HTTP exchange begins
GET /page HTTP/1.1
Host: example.com
# TLS 1.3 collapses this to 1 round trip (1-RTT)
# 0-RTT resumption for returning connectionsHTTPS-Verbindung
HTTPS ist HTTP über TLS, typischerweise auf Port 443. Die HTTP-Nachrichten selbst sind unverändert — TLS verschlüsselt nur den zugrunde liegenden TCP-Traffic. HTTPS erzwingen: HTTP→HTTPS umleiten (301) und den HSTS-Header setzen, damit Browser sich die HTTPS-Nutzung für die Dauer merken. HSTS-Preload-Listen (von Browsern gepflegt) hardcoden das Verhalten, sodass sogar die erste Anfrage HTTPS geht.
# HTTP on port 80 (plaintext)
GET /page HTTP/1.1
Host: example.com
# HTTPS on port 443 (TLS-encrypted)
# Same HTTP messages, but the wire traffic is encrypted.
GET /page HTTP/1.1
Host: example.com
# Force HTTPS via redirect
HTTP/1.1 301 Moved Permanently
Location: https://example.com/page
# Force HTTPS via HSTS (browser remembers)
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
# Modern browsers default to https:// for bare domains
# (some even refuse plain HTTP for sensitive endpoints)Zertifikate
X.509-Zertifikate binden einen öffentlichen Schlüssel an eine Domain, signiert von einer Certificate Authority (CA). Die Vertrauenskette führt vom Server-Zertifikat über Zwischenzertifikate zu einer Root-CA, die im Browser vorinstalliert ist. Browser prüfen die Kette, das Ablaufdatum und, dass der SAN (Subject Alternative Name) zum angefragten Hostnamen passt. Wildcard-Zertifikate (*.example.com) und Multi-Domain-Zertifikate (mehrere SANs) decken mehrere Hostnamen ab.
# X.509 certificate contains:
# - Subject: example.com (CN is deprecated; use SAN)
# - Subject Alternative Name (SAN): example.com, www.example.com
# - Issuer: Let's Encrypt / DigiCert (CA)
# - Validity: Not Before / Not After
# - Public key (RSA or ECDSA)
# - Signature by CA
# Chain of trust:
# Root CA (self-signed, in browser trust store)
# -> Intermediate CA
# -> Server cert (your domain)
# Server sends leaf + intermediate during handshake.
# Browser verifies: signature chain back to a trusted root.
# Inspect a cert:
openssl s_client -connect example.com:443 -showcerts
openssl x509 -in cert.pem -text -nooutHSTS (HTTP Strict Transport Security)
HSTS sagt Browsern, für eine Domain immer HTTPS zu nutzen, und verhindert SSL-Stripping-Angriffe. max-age in Sekunden (1 Jahr = 31536000). includeSubDomains erstreckt es auf alle Subdomains. preload meldet die Domain einer hardcodierten Browser-Liste an, sodass schon der erste Besuch HTTPS ist — starker Schutz, aber schwer rückgängig (Entfernung dauert Monate). Immer erst HTTP→HTTPS umleiten, dann HSTS ergänzen, dann optional preload.
# Tell browser to use HTTPS for 6 months
Strict-Transport-Security: max-age=15768000
# Include subdomains
Strict-Transport-Security: max-age=15768000; includeSubDomains
# Submit to preload list (browsers hardcode the domain)
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
# Effects:
# - http://example.com -> browser rewrites to https://
# - Self-signed cert -> browser blocks (no override)
# - prevents SSL stripping attacks (downgrade to HTTP)
# Preload list: https://hstspreload.org
# Once preloaded, removal is slow and difficult.TLS-Versionen & Ciphers
SSLv2/v3 und TLS 1.0/1.1 deaktivieren — sie haben bekannte Schwachstellen (POODLE, BEAST). TLS 1.3 (2018) ist der moderne Standard: schnellerer Handshake, schwache Ciphers entfernt, Forward Secrecy Pflicht. TLS 1.2 mit ECDHE + AES-GCM ist akzeptabel. Mit Tools wie SSL Labs die Konfiguration bewerten. Forward Secrecy (ECDHE) hält frühere Traffic verschlüsselt, selbst wenn der private Schlüssel später leakt.
# TLS versions (deprecate old ones!)
# SSLv2, SSLv3 - BROKEN (POODLE), disable
# TLS 1.0, 1.1 - deprecated (2020), disable
# TLS 1.2 - widely supported, OK
# TLS 1.3 - fastest, most secure (preferred)
# Modern cipher suites (TLS 1.3):
# TLS_AES_256_GCM_SHA384
# TLS_CHACHA20_POLY1305_SHA256
# TLS_AES_128_GCM_SHA256
# TLS 1.2 recommended:
# ECDHE-ECDSA-AES256-GCM-SHA384 (forward secrecy + AEAD)
# ECDHE-RSA-AES256-GCM-SHA384
# Server config (nginx example)
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_ciphers ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
# Test: https://www.ssllabs.com/ssltest/HTTP/2
HTTP/2-Features
HTTP/2 erhält die HTTP-Semantik (Methoden, Statuscodes, Header), ändert aber das Drahtformat auf binäre Frames. Hauptgewinne: Multiplexing vieler Anfragen über eine TCP-Verbindung (kein Head-of-Line-Blocking auf HTTP-Ebene), HPACK-Header-Kompression und Stream-Priorisierung. Verhandelt über ALPN via TLS (am häufigsten) oder h2c-Upgrade über Klartext. Server Push wurde 2022 wegen mangelhafter Real-Performance deprecated.
# HTTP/2 (RFC 9113, 2015) - binary, multiplexed
# - Binary framing (not text)
# - Multiplexing: many streams over 1 TCP connection
# - Header compression (HPACK)
# - Server Push (deprecated in 2022)
# - Stream prioritization
# - Single connection per origin
# Negotiation:
# - Over TLS: ALPN extension advertises "h2"
# - Over plaintext: h2c upgrade (rare in practice)
#curl with HTTP/2:
curl -v --http2 https://example.com
# (Connection header shows HTTP/2)
# Backward compatible: same methods, status codes, headers, semantics
# Only the wire format changes.Multiplexing
Multiplexing ist HTTP/2s Aushängeschild. Viele Streams teilen eine TCP-Verbindung, mit ineinander verschachtelten Frames — kein 6-Verbindungen-pro-Origin-Limit mehr, kein Head-of-Line-Blocking auf HTTP-Ebene. Das eliminiert HTTP/1.1-Tricks wie Domain Sharding, Datei-Verkettung und Bild-Inlining. Hinweis: TCP-Ebene Head-of-Line-Blocking bleibt (ein verlorenes Paket blockiert alle Streams bis zur Neuübertragung) — das behebt HTTP/3 mit QUIC.
# HTTP/1.1: 6 parallel connections per origin, each request blocks its connection
# (head-of-line blocking at the HTTP level)
# HTTP/2: 1 connection, many parallel streams
# Each request/response is a stream with a unique ID.
# Frames carry data for multiple streams interleaved:
# Stream 1: HEADERS, DATA (request 1)
# Stream 3: HEADERS, DATA (request 2)
# Stream 5: HEADERS, DATA (request 3)
# Server responds with interleaved frames on each stream.
# Browser opens one TCP+TLS connection per origin,
# then sends all requests as concurrent streams.
# Eliminates: domain sharding, concatenation, inlining
# (those were HTTP/1.1 optimization hacks)Server Push (deprecated)
Server Push ließ den Server Ressourcen senden, bevor der Client fragte. Theoretisch spart das einen Round-Trip für kritische Assets. Praktisch wurde es 2022 deprecated: der Server kennt den Cache-Zustand des Clients nicht, pusht also zu viel und verschwendet oft Bandbreite. Browser ignorieren PUSH_PROMISE-Frames inzwischen. Moderne Alternativen: <link rel=preload> im HTML oder 103 Early Hints (der Server sendet Preload-Hinweise vor der finalen Antwort).
# Server proactively sends resources the client will need
GET /index.html HTTP/2
Host: example.com
HTTP/2 200 OK
Content-Type: text/html
Link: </style.css>; rel=preload; as=style
# Server then pushes style.css on a new stream
PUSH_PROMISE (stream 2, /style.css)
<headers + body of /style.css>
# Then the actual /index.html body follows.
# DEPRECATED (2022): browsers ignore it because:
# - Client cache might already have the asset
# - Server can't know what client has cached
# - Net performance negative in real deployments
# Modern alternative: <link rel="preload" href="...">
# or 103 Early HintsStream-Priorisierung
HTTP/2 ließ Clients Stream-Prioritäten über einen Abhängigkeitsbaum mit Gewichten ausdrücken. Der Server nutzte das zur Bandbreitenverteilung: z. B. CSS vor Bildern. RFC 9113 (2022) entfernte den expliziten PRIORITY-Frame und überließ das Scheduling dem Server — viele implementierten eigenes. Das Extensible Prioritization Scheme (RFC 9218) ist eine optionale moderne Alternative. Priorisierung zählt am meisten bei langsamen Verbindungen.
# HTTP/2 streams have priority (weight + dependency tree)
# Originally: client sends PRIORITY frames
# Client says: "CSS (stream 3) is more important than image (stream 5)"
# PRIORITY frame (original model):
# - stream dependency (parent)
# - weight (1-256)
# RFC 9113 (2022) removed explicit prioritization
# - Leaves it to the server
# - Many servers implement their own scheduler
# Practical effect: server allocates bandwidth
# - HTML, CSS, JS -> high priority
# - Images, fonts -> lower priority
# - Critical render path optimized
# Clients can still signal via Extensible Prioritization Scheme
# (RFC 9218) - optional.HPACK-Header-Kompression
HPACK komprimiert HTTP-Header über eine statische Tabelle häufiger Header, eine pro Verbindung lernende dynamische Tabelle kürzlich gesendeter Werte und Huffman-Kodierung. Das senkt den Overhead drastisch — ein 1-KB-Cookie bei jeder Anfrage wird zu einem winzigen Indexverweis. HPACK ist so gestaltet, dass es die CRIME/BREACH-Kompressions-Oracle-Angriffe früherer TLS-Kompression vermeidet. HTTP/3 nutzt ein ähnliches Schema namens QPACK.
# HTTP/1.1: headers sent as plaintext on every request (redundant)
# Cookies alone can exceed 1KB per request.
# HTTP/2: HPACK compresses headers
# - Static table: 61 common headers (e.g., :method GET)
# - Dynamic table: per-connection, learns recently sent headers
# - Huffman coding for strings
# Example: first request sends full User-Agent (200 bytes)
# Subsequent requests reference the dynamic table entry (2 bytes)
# Indexed header representation:
# 1 bit set + index -> "use entry N"
# Literal with incremental indexing:
# "add this to the dynamic table for future reuse"
# Security: CRIME attack exploited compression oracles.
# HPACK mitigates by never compressing sensitive + attacker-controlled
# data together.HTTP/3 & QUIC
QUIC-Protokoll
QUIC ist ein Transportprotokoll über UDP, das TLS 1.3 integriert und zuverlässige, gemultiplexte Streams liefert. Der Wechsel zu UDP lässt QUIC schneller weiterentwickeln als Kernel-TCP. Kernvorteile: kein TCP-Ebene Head-of-Line-Blocking (ein verlorenes Paket blockiert nur einen Stream), 0-RTT-Resumption für wiederkehrende Verbindungen und Connection Migration (ein Handy, das von WLAN auf Mobilfunk wechselt, behält die Verbindung). HTTP/3 läuft über QUIC.
# QUIC = Quick UDP Internet Connections (Google, then IETF)
# - Transport protocol over UDP (not TCP)
# - Built-in TLS 1.3 encryption
# - Multiple streams, independent per-stream delivery
# - 0-RTT connection resumption
# - Connection migration (survives IP changes)
# - Better loss recovery than TCP
# Why UDP? TCP is in the kernel and hard to evolve.
# QUIC moves reliability + congestion control to user space.
# Wire format: UDP packets containing QUIC packets
# - Initial, Handshake, 1-RTT, 0-RTT packets
# - Frames carry stream data, acks, flow control
# Negotiation:
# Server advertises HTTP/3 via Alt-Svc header on HTTP/2 response:
Alt-Svc: h3=":443"; ma=86400
# Browser caches this and uses HTTP/3 next time.HTTP/3-Features
HTTP/3 erhält die HTTP-Semantik, läuft aber über QUIC statt TCP. Der große Gewinn: kein Head-of-Line-Blocking. In HTTP/2 blockiert ein verlorenes TCP-Paket alle gemultiplexten Streams bis zur Neuübertragung; in HTTP/3 wartet nur der betroffene Stream. Dazu 0-RTT-Resumption und Connection Migration. Der Preis: mehr CPU (QUIC im Userspace) und UDP ist in manchen Netzen blockiert/gedrosselt. Die Verbreitung wächst — die meisten großen Sites unterstützen es.
# HTTP/3 (RFC 9114, 2022) - HTTP semantics over QUIC
# Same methods, status codes, headers as HTTP/2
# - Binary framing (similar to HTTP/2)
# - Multiplexing over QUIC streams (no HoL blocking!)
# - QPACK header compression (HPACK variant)
# - 0-RTT for returning clients
# - Connection migration
# Loss recovery: per-stream, not per-connection
# A lost packet stalls only that stream, others continue.
# Head-of-line blocking eliminated at the transport layer:
# HTTP/2: lost TCP packet blocks ALL streams (kernel retransmit)
# HTTP/3: lost QUIC packet blocks only that stream
# curl with HTTP/3 (requires special build):
curl -v --http3 https://example.com0-RTT-Resumption
0-RTT lässt wiederkehrende Clients Daten im ersten Flug senden (kein Round-Trip vor der Anfrage). Das spart bei Wiederholungsbesuchen Dutzende bis Hunderte Millisekunden. Der Haken: die frühen Daten können von einem Angreifer wiederholt werden, also nur für idempotente Operationen erlauben (GET, HEAD, PUT/DELETE wenn idempotent). Server sollten 0-RTT für POST und andere zustandsändernde Methoden ablehnen. Anti-Replay-Mechanismen kosten Komplexität.
# TLS 1.3 + QUIC: 0-RTT resumption for returning clients
# First visit: full handshake (1-RTT in TLS 1.3)
Client -> Server: ClientHello + key share
Server -> Client: ServerHello + key share + Finished
Client -> Server: Finished + first HTTP request
# Returning visit (0-RTT):
Client -> Server: ClientHello + early data (HTTP request)
# Server can respond immediately, no round trip!
# Trade-offs:
# + Saves 1 RTT on subsequent visits (faster page loads)
# - Vulnerable to replay attacks on early data
# - Only safe for idempotent methods (GET, HEAD)
# - Server should reject 0-RTT for non-idempotent requests
# Configure carefully:
# - Limit early data to safe methods
# - Use anti-replay mechanismsConnection Migration
QUIC-Verbindungen sind über eine connection ID identifiziert statt über das IP/Port-4-Tupel. Das heißt, eine Verbindung übersteht IP-Wechsel — ein Handy, das von WLAN auf Mobilfunk wechselt, oder ein Laptop zwischen Netzen behält die Verbindung. Der Server validiert den neuen Pfad mit PATH_CHALLENGE/PATH_RESPONSE. TCP kann das nicht, weil der Kernel Verbindungen über das 4-Tupel identifiziert. Großer Gewinn für Mobile.
# TCP connection identified by 4-tuple:
# (src IP, src port, dst IP, dst port)
# If your phone switches Wi-Fi -> cellular, IP changes ->
# the TCP connection dies. Browser must reconnect.
# QUIC uses a connection ID (random, in every packet).
# The 4-tuple can change mid-connection; the connection ID
# identifies the connection.
# Scenario:
# 1. Phone on Wi-Fi, downloading a large file over HTTP/3
# 2. Phone walks out, switches to cellular
# 3. Packets now arrive from a new IP, same connection ID
# 4. Server continues serving the same connection!
# 5. No reconnect, no re-handshake, no failed download.
# Validation: server sends PATH_CHALLENGE, client replies PATH_RESPONSE.HTTP/1.1 vs. HTTP/2 vs. HTTP/3
HTTP/1.1 ist Text über TCP mit 6 parallelen Verbindungen. HTTP/2 ist Binär über TCP mit Multiplexing (aber TCP-Ebene HoL-Blocking). HTTP/3 ist Binär über QUIC ohne HoL-Blocking, mit Pflicht-Verschlüsselung, 0-RTT und Connection Migration. Die Verbreitung ist schrittweise: Server kündigen HTTP/3 über den Alt-Svc-Header auf HTTP/2-Antworten an, und Browser wechseln beim nächsten Besuch. Alle drei teilen die HTTP-Semantik.
# Feature comparison
# Property | HTTP/1.1 | HTTP/2 | HTTP/3
# -----------------+--------------+--------------+--------------
# Transport | TCP | TCP | QUIC (UDP)
# Format | Text | Binary | Binary
# Multiplexing | No (6 conns) | Yes | Yes
# HoL blocking | HTTP-level | TCP-level | None
# Header compress | No | HPACK | QPACK
# Server Push | No | Yes (deprecated) | No
# Encryption | Optional | Optional | Mandatory (TLS 1.3)
# 0-RTT | No | No | Yes
# Connection migration | No | No | Yes
# Handshake RTT | 1+ | 1+ | 0-1 (with resumption)
# Most sites today: HTTP/2 over TLS, with HTTP/3 available via Alt-SvcUmleitungen (3xx)
301 vs. 302
301 bedeutet dauerhaft: Browser cachen die Umleitung, Lesezeichen aktualisieren sich, und SEO-Link-Äquität wandert auf die neue URL. 302 bedeutet temporär: nichts wird gecacht, SEO bleibt beim Original. Historisch wandelten beide POST→GET (eine Spec-Verletzung, die zum De-facto wurde). Um die Methode strikt zu erhalten, 307 (temporär) oder 308 (dauerhaft) nutzen. Für SEO-Migrationen 301; für Login-Umleitungen 302 oder 307.
# 301 Moved Permanently
HTTP/1.1 301 Moved Permanently
Location: https://newsite.com/page
# - Permanent; browser & SEO caches it
# - Link juice transfers to new URL (SEO)
# - Bookmark updates
# - HTTP/1.1 spec: should preserve method, but historically
# POST -> GET (causing data loss)
# 302 Found
HTTP/1.1 302 Found
Location: /login
# - Temporary
# - Don't update bookmarks
# - SEO link juice stays with original URL
# - HTTP/1.1 spec: should preserve method, but historically
# POST -> GET
# Use 301 for permanent moves (site migrations).
# Use 302 for temporary redirects (login flows, A/B tests).307 vs. 308
307 und 308 sind die methodenerhaltenden Gegenstücke zu 302 und 301. Sie beheben den historischen POST→GET-Umwandlungsbug. 307 ist temporär, 308 dauerhaft — beide erhalten die ursprüngliche Methode und den Body. Bei Umleitungen von Non-GET-Anfragen nutzen, besonders bei APIs, wo eine POST→GET-Umwandlung stillschweigend den Body fallen lässt. 308 ist die moderne Wahl für dauerhafte API-Endpunkt-Moves.
# 307 Temporary Redirect (HTTP/1.1, method-preserving)
HTTP/1.1 307 Temporary Redirect
Location: /new-endpoint
# - Temporary
# - Method PRESERVED: POST stays POST, body stays intact
# - Browser prompts before re-issuing POST to different host
# 308 Permanent Redirect (RFC 7538)
HTTP/1.1 308 Permanent Redirect
Location: https://newsite.com/api
# - Permanent
# - Method PRESERVED
# - Like 301 but without the POST->GET conversion
# When to use:
# - 307: temporary redirect that must preserve method
# - 308: permanent redirect that must preserve method
# (e.g., API endpoint moved, clients still POSTing)
# Most browsers support both since ~2015.303 See Other (PRG-Muster)
303 See Other weist den Browser explizit an, mit einem GET zu folgen — das richtige Werkzeug für das Post/Redirect/Get-Muster (PRG). Nach der Verarbeitung eines POST mit 303 auf eine GET-Seite umleiten. Beim Refresh des Nutzers läuft nur das sichere GET (nicht das POST), und doppelte Formular-Einreichungen werden vermieden. 303 für PRG, 307/308, wenn die Original-Methode erhalten bleiben soll, 301/302 für normale Navigation.
# 303 See Other - explicitly converts to GET
HTTP/1.1 303 See Other
Location: /success
# - Always converts to GET (no body)
# - Used in Post/Redirect/Get (PRG) pattern
# PRG pattern: avoid double-submit on refresh
# 1. User submits form
POST /checkout HTTP/1.1
Host: shop.com
Content-Type: application/x-www-form-urlencoded
item=book&qty=1
# 2. Server processes, redirects to a GET page
HTTP/1.1 303 See Other
Location: /order/123/confirmation
# 3. Browser issues GET (safe to refresh)
GET /order/123/confirmation HTTP/1.1
Host: shop.com
HTTP/1.1 200 OK
# "Order confirmed!"Umleitungsketten & Loops
Umleitungsketten kosten Latenz (jeder Hop = Round-Trip) und sollten geglättet werden — die Original-URL direkt auf das Endziel zeigen lassen. Umleitungs-Loops sind fatal: Browser entdecken sie nach wenigen Hop und zeigen eine Fehlerseite. Häufige Ursachen: HTTPS↔HTTP-Fehlkonfiguration hinter einem Load Balancer (X-Forwarded-Proto nutzen) oder Trailing-Slash-Konflikte. HSTS vermeidet HTTP→HTTPS-Umleitungs-Loops, weil der Browser intern umschreibt.
# Redirect chain: A -> B -> C
GET /a -> 301 -> /b
GET /b -> 301 -> /c
GET /c -> 200 OK
# Each hop adds a round trip; chains hurt performance.
# Browsers cap redirects (typically 20), then error.
# Redirect loop (fatal):
GET /a -> 302 -> /b
GET /b -> 302 -> /a
GET /a -> 302 -> /b (browser detects loop, shows error)
# Common cause: HTTPS <-> HTTP loop
# Server A redirects HTTP -> HTTPS
# Server B (behind TLS terminator) sees HTTP internally,
# redirects to HTTPS again -> loop
# Fix: trust X-Forwarded-Proto, or use HSTS instead of redirects
# Common cause: trailing slash mismatch
# /api/users -> 301 -> /api/users/ -> 301 -> /api/users/
# (server config bug)Häufige Umleitungsfälle
Häufige Umleitungsfälle: HTTP→HTTPS (301), apex↔www (301), old→new-URL-Migrationen (301), Login-Umleitungen (302/303), PRG-Muster (303), API-Endpunkt-Moves (308) und CDN-Origin-Fallbacks. Für dauerhafte Moves immer 301/308 bevorzugen, damit Caches und SEO aktualisieren. Wo möglich HSTS statt HTTP→HTTPS-Umleitungen — es vermeidet den Umleitungs-Round-Trip bei Folgeberuchen.
# 1. HTTP -> HTTPS upgrade
HTTP/1.1 301 Moved Permanently
Location: https://example.com/
# 2. www -> apex (or vice versa)
HTTP/1.1 301 Moved Permanently
Location: https://example.com/
# 3. Old URL -> new URL (site migration)
HTTP/1.1 301 Moved Permanently
Location: https://example.com/new-page
# 4. Login required (temporary)
HTTP/1.1 302 Found
Location: /login?return=/dashboard
# 5. POST form -> confirmation (PRG)
HTTP/1.1 303 See Other
Location: /success
# 6. API endpoint moved (preserve method)
HTTP/1.1 308 Permanent Redirect
Location: /v2/users
# 7. CDN origin fallback (when content not cached)
HTTP/1.1 302 Found
Location: https://origin.example.com/assetContent-Typen (MIME)
Häufige MIME-Typen
MIME-Typen (media types) beschreiben das Format eines Bodys. Sie bestehen aus type/subtype und optionalen Parametern (charset, boundary). Häufige Typen: text/html für Seiten, application/json für APIs, image/* und video/* für Medien. application/octet-stream ist der Fallback für unbekannte Binärdaten — Browser laden sie herunter, statt sie zu rendern. IANA pflegt die offizielle Registry.
# Text
text/html # HTML pages
text/plain # plain text
text/css # stylesheets
text/csv # comma-separated values
text/javascript # JavaScript (legacy, was application/javascript)
# Application
application/json # JSON
application/xml # XML
application/javascript # JavaScript (modern, text/javascript also OK)
application/pdf # PDF
application/zip # ZIP archive
application/octet-stream # binary (unknown type, forces download)
application/x-www-form-urlencoded # form data
application/ld+json # JSON-LD (linked data)
# Image
image/jpeg, image/png, image/gif, image/webp, image/svg+xml, image/avif
# Audio/Video
audio/mpeg, audio/ogg, video/mp4, video/webm
# Multipart
multipart/form-data # file uploads
multipart/byteranges # partial contentContent-Type-Header
Der Content-Type-Header deklariert den MIME-Typ des Bodys. Für Text-Typen gibt charset das Encoding an (Default für text/* ist ISO-8859-1; UTF-8 immer explizit setzen). Bei multipart-Bodies trennt boundary die Teile. Browser 'sniffen' den Typ, wenn er fehlt oder vage ist — mit X-Content-Type-Options: nosniff verhindern, das zwingt sie zum Einhalten des deklarierten Typs (Härtung gegen XSS über File-Uploads).
# Response Content-Type
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
# Request Content-Type (for bodies)
POST /api/users HTTP/1.1
Content-Type: application/json
{"name": "Alice"}
# charset parameter (text types)
Content-Type: text/html; charset=UTF-8
# boundary parameter (multipart)
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary
# X-Content-Type-Options: nosniff
# tells browser not to sniff/override the declared typemultipart/form-data
multipart/form-data kodiert mehrere Teile (Felder und Dateien) in einem Body, getrennt durch eine boundary. Jeder Teil hat sein eigenes Content-Disposition (mit optionalem filename) und Content-Type. Das Format nutzen Browser beim Einreichen von Formularen mit File-Inputs. Die einzige praktische Art, Dateien via HTML-Formulare hochzuladen; bei APIs ist base64-in-JSON oder direktes PUT zu einer Storage-URL oft einfacher.
# File upload form
POST /upload HTTP/1.1
Content-Type: multipart/form-data; boundary=----boundary123
------boundary123
Content-Disposition: form-data; name="title"
My Photo
------boundary123
Content-Disposition: form-data; name="file"; filename="photo.jpg"
Content-Type: image/jpeg
<binary JPEG bytes>
------boundary123--
# Each part has its own headers (Content-Disposition, Content-Type).
# Final boundary has trailing --.
# Used for file uploads (browsers' <input type="file">).
# Less efficient than JSON for plain fields - overhead per part.application/json
application/json ist das dominante API-Format — leichtgewichtig, menschenlesbar und nativ in jeder Sprache unterstützt. JSON ist UTF-8 per Default (der charset-Parameter ist redundant, aber harmlos). Vendor-spezifische Medientypen (application/vnd.api+json, application/vnd.github.v3+json) ermöglichen Versionierung und Profil-Negotiation. RFC 7807 (application/problem+json) standardisiert Fehlerantworten.
# Most common API Content-Type
POST /api/users HTTP/1.1
Content-Type: application/json
Accept: application/json
{
"name": "Alice",
"age": 30,
"tags": ["admin", "user"],
"metadata": null
}
# Variants:
# application/json - standard
# application/json; charset=utf-8 - JSON is UTF-8 by default, charset is redundant
# application/ld+json - JSON-LD (linked data with @context)
# application/vnd.api+json - JSON:API spec
# application/problem+json - RFC 7807 problem details for errors
# Vendor types: application/vnd.company.v1+json
# (custom versioned JSON)charset-Parameter
Der charset-Parameter deklariert das Text-Encoding. Für text/*-Typen immer setzen — der Default ISO-8859-1 verursacht mojibake bei Nicht-ASCII-Zeichen. UTF-8 ist die universelle Best-Wahl. Bei JSON ist charset redundant (JSON ist per Spec UTF-8). Bei XML ist der Spec-Default UTF-8, aber explizit zu deklarieren vermeidet den BOM-Sniffing-Overhead. Falsch gepaarte Charsets erzeugen Müllzeichen.
# charset specifies the text encoding
Content-Type: text/html; charset=UTF-8 # preferred
Content-Type: text/html; charset=iso-8859-1 # legacy
# For JSON, charset is redundant (JSON spec mandates UTF-8)
Content-Type: application/json # correct
Content-Type: application/json; charset=utf-8 # harmless but redundant
# Default charsets (when omitted):
# text/* -> ISO-8859-1 (legacy, problematic)
# application/json -> UTF-8 (mandatory per spec)
# application/xml -> UTF-8 (per XML spec)
# Always declare charset for text types to avoid mojibake.
# Mismatched charset = broken characters.
# In HTML, also declare in the document:
<meta charset="UTF-8">Chunked Transfer
Transfer-Encoding: chunked
Chunked transfer encoding lässt den Server einen Body streamen, ohne seine Gesamtlänge vorab zu kennen. Jeder Chunk trägt seine Länge hex-kodiert, gefolgt von CRLF, den Daten und CRLF. Ein Chunk der Länge null signalisiert das Ende. Essenziell für dynamisch erzeugte Antworten (Template-Rendering, DB-Queries), deren Größe erst beim Erzeugen bekannt wird. HTTP/2 und HTTP/3 nutzen kein chunked encoding — sie haben eigenes Framing.
# When the server doesn't know the final Content-Length
# (e.g., streaming, dynamically generated content),
# it sends the body in chunks.
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked
4
Wiki
6
pedia
E
in chunks.
0
# Each chunk: <hex-length>
<data>
# Final chunk: 0
(zero length)
# Then optional trailer headers + final
Streaming-Antworten
Streaming-Antworten nutzen chunked encoding, um Daten schrittweise zu pushen. Server-Sent Events (SSE) ist das kanonische Muster: der Server hält die Verbindung offen und schreibt Ereignisse als 'data: <payload>\n\n'. Die EventSource-API des Browsers empfängt sie beim Ankommen. Weitere Anwendungen: progressives HTML-Rendering (fortlaufend flushen), große JSON-Arrays, Log-Tailing. Sicherstellen, dass kein Zwischen-Proxy puffert — für nginx X-Accel-Buffering: no setzen.
# Server-Sent Events (SSE): one-way streaming over HTTP
HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive
Transfer-Encoding: chunked
data: {"msg": "hello"}
data: {"msg": "world"}
data: {"msg": "done"}
# Each event: "data: <payload>
"
# Browser keeps the connection open via EventSource API.
# Other streaming patterns:
# - Server-side rendering: flush HTML as it's generated
# - Large JSON: stream array elements
# - Logs tailing: continuous chunk stream
# Don't buffer: set X-Accel-Buffering: no (nginx)Trailer-Header
Trailer-Header gehen nach dem Body bei chunked encoding raus. Nützlich für Summary-Stats, die beim Streaming berechnet werden — etwa eine Zeilenzahl, eine Checksumme oder eine Verarbeitungsdauer. Der Trailer-Header kündigt an, welche Trailer erscheinen. Manche Header sind als Trailer verboten (Host, Content-Length, Transfer-Encoding, Auth-Header), weil sie das Verbindungsfroaming betreffen. Client-Unterstützung ist lückenhaft — viele Clients ignorieren Trailer.
# Trailer headers are sent AFTER the body (with chunked encoding)
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Trailer: X-Total-Count, X-Duration
5
{"a":1
5
,"b":2
0
X-Total-Count: 2
X-Duration: 0.045s
# Use case: compute summary stats during streaming
# (e.g., total count, checksum) and send at the end.
# The "Trailer" header declares which trailers to expect.
# Some headers are forbidden as trailers:
# - Transfer-Encoding, Content-Length, Host
# - Authentication-related headersContent-Length vs. Chunked
Content-Length sagt dem Client vorab die exakte Body-Größe — simpel, ermöglicht Fortschrittsbalken und erlaubt saubere Wiederverwendung der Verbindung. Chunked encoding erlaubt Streaming ohne bekannte Größe. Man muss eines von beiden nutzen (oder die Verbindung am Ende schließen). Beide zu senden ist mehrdeutig; per Spec gewinnt chunked, aber alte Clients können sich daneben benehmen. Für statische Dateien immer Content-Length; für dynamisches/Streaming chunked.
# Content-Length: known body size up front
HTTP/1.1 200 OK
Content-Type: text/plain
Content-Length: 11
Hello World
# Pros: simple, allows progress bars, enables persistent conn reuse
# Cons: requires knowing the size before sending
# Transfer-Encoding: chunked: stream without knowing size
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked
5
Hello
6
World
0
# Pros: can stream as data is produced
# Cons: no progress bar, slightly more overhead per chunk
# Rule: you must use ONE of these (or close the connection).
# Using both is ambiguous - chunked wins per spec but is buggy in old clients.HTTP/2-Streaming (ohne Chunked)
HTTP/2 und HTTP/3 nutzen kein chunked encoding — sie haben eigenes binäres Framing. DATA-Frames tragen Body-Bytes; das END_STREAM-Flag signalisiert das Ende. Das liefert dieselbe Streaming-Fähigkeit ohne den Chunk-für-Chunk-Overhead des Hex-Längen-Framings. Der Transfer-Encoding-Header ist in HTTP/2 illegal (RFC 9113). Content-Length bleibt erlaubt, ist aber optional. Die Streaming-Semantik bleibt; nur der Drahtmechanismus ändert sich.
# HTTP/2 and HTTP/3 don't use Transfer-Encoding: chunked.
# They have their own framing: DATA frames carry body bytes,
# END_STREAM flag marks the end.
# In HTTP/2, "streaming" means sending multiple DATA frames
# on a single stream, with the END_STREAM flag on the last.
# Server push of partial response:
# HEADERS frame (status, headers)
# DATA frame (chunk 1)
# DATA frame (chunk 2)
# DATA frame + END_STREAM (chunk 3, final)
# Effect: same streaming behavior as chunked,
# but at the framing layer, not the encoding layer.
# Transfer-Encoding header is illegal in HTTP/2.
# Content-Length is allowed but optional.Range-Anfragen
Range-Header
Range-Anfragen lassen einen Client einen Teil einer Ressource holen — essenziell für fortsetzbare Downloads, Videosuche und parallele chunk-basierte Downloads. Der Range-Header spezifiziert Byte-Bereiche. Der Server antwortet mit 206 Partial Content und einem Content-Range-Header, der zeigt, was zurückgegeben wurde. Unterstützt der Server keine Bereiche, ignoriert er den Header und gibt 200 mit vollem Body. Immer zuerst Accept-Ranges prüfen.
# Request a portion of a resource (e.g., resume downloads, video seeking)
GET /video.mp4 HTTP/1.1
Host: example.com
Range: bytes=0-1023 # first 1024 bytes
# Server response: 206 Partial Content
HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/1048576
Content-Length: 1024
Content-Type: video/mp4
<1024 bytes of video>
# Range formats:
Range: bytes=0-1023 # bytes 0 through 1023
Range: bytes=1024- # from byte 1024 to end
Range: bytes=-1024 # last 1024 bytes
Range: bytes=0-1023,2048-3071 # multiple ranges (multipart response)Accept-Ranges-Header
Der Accept-Ranges-Header zeigt an, ob der Server Range-Anfragen unterstützt. bytes bedeutet ja; none (oder Fehlen) nein. Clients sollten das prüfen, bevor sie auf Range vertrauen — ein Server, der Range ignoriert, gibt den vollen Body mit 200. Browser nutzen das automatisch für <video>-Suche (Sprung zu einem Zeitstempel = Range-Anfrage) und fortsetzbare Downloads. Die meisten CDNs und statischen Server unterstützen Bereiche; dynamische Endpunkte oft nicht.
# Server advertises range support
HTTP/1.1 200 OK
Accept-Ranges: bytes # supports byte-range requests
Content-Length: 1048576
# Server doesn't support ranges
HTTP/1.1 200 OK
Accept-Ranges: none
# (or omit the header entirely - same as "none")
# Client checks before sending Range:
# 1. HEAD or GET request to inspect Accept-Ranges
# 2. If "bytes", send Range: bytes=...
# 3. If "none" or missing, expect 200 with full body
# Browsers handle this transparently for video/audio,
# resumable downloads, and PDF preview.Partial-Content-Antwort (206)
206 Partial Content ist die Antwort auf eine erfolgreiche Range-Anfrage. Content-Range zeigt die Einheit (bytes), den zurückgegebenen Bereich und die Gesamtgröße. Überschreitet der angefragte Bereich die Ressource, antwortet der Server mit 416 Range Not Satisfiable. If-Range macht die Range-Anfrage bedingt: passt der Validator (ETag oder Datum), 206; hat sich die Ressource geändert, 200 mit vollem Body — verhindert Teilkorruption.
# Single range request
GET /file.bin HTTP/1.1
Range: bytes=100-199
# 206 Partial Content
HTTP/1.1 206 Partial Content
Content-Range: bytes 100-199/1024
Content-Length: 100
Content-Type: application/octet-stream
<100 bytes>
# Content-Range format: <unit> <start>-<end>/<total>
# total can be "*" if unknown (streaming)
# If range is out of bounds:
# Range: bytes=1000-2000 on a 500-byte file ->
HTTP/1.1 416 Range Not Satisfiable
Content-Range: bytes */500
# If-Range: only return range if validator still matches
GET /file.bin HTTP/1.1
Range: bytes=0-1023
If-Range: "etag123"
# If etag matches: 206 (partial)
# If etag differs: 200 (full body, resource changed)Multi-Range-Anfragen
Multi-Range-Anfragen fordern mehrere Byte-Bereiche in einer Anfrage an. Der Server antwortet mit multipart/byteranges — jeder Teil hat sein eigenes Content-Type und Content-Range. In der Praxis selten genutzt: Clients stellen stattdessen typischerweise parallele Ein-Bereich-Anfragen (einfacher, cachefreundlicher, leichter zu erholen). Manche Server begrenzen die Bereichszahl oder verschmelzen überlappende. Für kritische Pfade nicht auf multi-range verlassen.
# Request multiple ranges in one request
GET /file.bin HTTP/1.1
Range: bytes=0-99,200-299,400-499
# Server responds with multipart/byteranges
HTTP/1.1 206 Partial Content
Content-Type: multipart/byteranges; boundary=THIS_STRING_SEPARATES
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 0-99/1024
<100 bytes>
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 200-299/1024
<100 bytes>
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 400-499/1024
<100 bytes>
--THIS_STRING_SEPARATES--
# Most clients use single-range; multi-range is rare in practice.Range-Anwendungsfälle
Range-Anfragen treiben Videosuche (Sprung zu einem Zeitstempel), fortsetzbare Downloads (Fortsetzen nach Pause), parallele Downloads (Download-Manager teilen Dateien in Chunks), PDF-Seitenvorschau und das Lesen von am Dateienden gespeicherten Metadaten (ID3-Tags) an. Dafür muss der Server Bereiche unterstützen und per Accept-Ranges: bytes anzeigen. Ohne Range-Support degradiert Videosuche zum vollen Download, und fortsetzbare Downloads sind unmöglich.
# 1. Video seeking (HTML5 <video>)
# Browser sends Range when user jumps to a timestamp
GET /video.mp4 HTTP/1.1
Range: bytes=5242880- # seek to ~5MB offset
# 2. Resumable downloads
# Pause at 50%, resume later
GET /bigfile.zip HTTP/1.1
Range: bytes=524288000- # continue from 500MB
# 3. Parallel downloads (download managers)
# Split file into N chunks, fetch concurrently
GET /bigfile.zip HTTP/1.1
Range: bytes=0-10485759 # chunk 1 (first 10MB)
# (parallel connection)
GET /bigfile.zip HTTP/1.1
Range: bytes=10485760-20971519 # chunk 2
# 4. PDF preview (load only visible pages)
GET /doc.pdf HTTP/1.1
Range: bytes=102400-204800 # specific page region
# 5. Streaming audio with metadata at the end
# Fetch ID3 tag without downloading the whole fileSession-Management
Cookie-basierte Sessions
Cookie-basierte Sessions speichern eine serverseitige Session (im Speicher, Redis oder einer DB), verschlüsselt über eine zufällige session ID. Das Cookie hält nur die ID. Vorteile: widerrufbar (Session löschen), kleines Cookie, ausgereift. Nachteile: stateful (der Server muss Sessions speichern), horizontale Skalierung braucht geteilten Session-Speicher (Redis), CSRF-anfällig (mit SameSite dämpfen). Am besten für traditionelle Web-Apps mit servergerenderten Seiten.
# 1. User logs in
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json
{"username": "alice", "password": "secret"}
# 2. Server validates, creates session, stores in DB/Redis,
# returns session ID in a cookie
HTTP/1.1 200 OK
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax
# 3. Subsequent requests carry the cookie
GET /dashboard HTTP/1.1
Cookie: session=abc123
# 4. Server looks up session ID, finds user, serves request
# 5. Logout: delete session server-side, expire cookie
POST /logout HTTP/1.1
Cookie: session=abc123
HTTP/1.1 200 OK
Set-Cookie: session=; Max-Age=0; Path=/Token-basierte Sessions (JWT)
Token-basierte Sessions (meist JWT) speichern den Session-Zustand IM Token. Der Server validiert die Signatur ohne DB-Lookup — stateless. Vorteile: skalierbar (kein Session-Store), funktioniert über Services hinweg, mobile-freundlich. Nachteile: bis zum Ablauf nicht widerrufbar (gedämpft durch kurze Access-Tokens + serverseitig gespeicherte Refresh-Tokens), größer als eine session ID, XSS-anfällig, wenn in localStorage gespeichert. Am besten für APIs und SPAs.
# 1. Login returns a JWT (no server-side state)
POST /login HTTP/1.1
HTTP/1.1 200 OK
Content-Type: application/json
{"token": "eyJhbGciOiJIUzI1NiJ9..."}
# 2. Client stores token (memory, sessionStorage)
# 3. Each request includes the token in a header
GET /api/profile HTTP/1.1
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...
# 4. Server validates signature + claims, no DB lookup needed
# 5. Logout: client discards token (no server-side invalidation
# until exp - this is the stateless tradeoff)
# Refresh token flow:
# - Short-lived access token (5-15 min)
# - Long-lived refresh token (days), stored server-side, revocable
# - When access token expires, exchange refresh token for new oneSessions in Headern
Sessions über Header (Authorization, X-API-Key) sind stateless und funktionieren für jeden Client (Browser, Mobile, CLI, Server-zu-Server). Der Refresh-Token-Flow behandelt den Ablauf: kurzlebige Access-Tokens begrenzen den Schaden eines gestohlenen Tokens, während das Refresh-Token (sicher gespeichert, idealerweise im HttpOnly-Cookie) dem Client neue Access-Tokens ohne Re-Authentifizierung gibt. Gestohlene Refresh-Tokens über Rotation erkennen.
# Bearer token in Authorization header
GET /api/data HTTP/1.1
Authorization: Bearer eyJhbGc...
# Custom header (e.g., API gateway)
GET /api/data HTTP/1.1
X-API-Key: abc123def456
# Basic auth (per-request credentials)
GET /api/data HTTP/1.1
Authorization: Basic dXNlcjpwYXNz
# Bearer + refresh flow:
# 1. Access token expires -> API returns 401
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer error="invalid_token"
# 2. Client uses refresh token to get a new access token
POST /token HTTP/1.1
Content-Type: application/x-www-form-urlencoded
grant_type=refresh_token&refresh_token=GmR...
# 3. New access token returned
{"access_token": "...", "expires_in": 900}Session-Ablauf & Sliding
Session-Ablauf-Policies: absolut (feste Lebensdauer ab Login), sliding (setzt sich bei Aktivität zurück) oder kombiniert (was zuerst kommt). Kombiniert ist am sichersten — begrenzt die Gesamtdauer, erlaubt aber vernünftige Inaktivität. Cookies nutzen Max-Age; serverseitige Sessions haben eine separate TTL. JWTs können nicht slidens — der exp-Claim steht bei Ausstellung fest. Ein JWT 'verlängern' heißt: ein neues ausstellen (Refresh-Token-Flow), nicht das alte verändern.
# Absolute expiration: session dies after fixed time from login
# e.g., 8 hours after login, regardless of activity
session.expires_at = session.created_at + 8h
# Sliding/Idle expiration: resets on each activity
# e.g., session dies after 30 min of inactivity
session.expires_at = NOW() + 30min # updated on each request
# Combined (most secure):
# - Absolute cap (e.g., 24h max from login)
# - Idle timeout (e.g., 30min inactivity)
# Whichever comes first.
# Set-Cookie with Max-Age sets cookie lifetime,
# but server-side session may expire earlier (DB cleanup).
Set-Cookie: session=abc; Max-Age=1800 # 30 min
# JWT exp claim (absolute):
# {"exp": 1516242622} # hardcoded, can't slideCSRF-Schutz
CSRF-Angriffe nutzen, dass Browser Cookies automatisch senden. SameSite-Cookies (Lax als Default in modernen Browsern) blockieren das meiste CSRF, indem sie Cookies bei Cross-Site-POSTs verweigern. Das CSRF-Token-Muster ergänzt ein servergeneriertes Token zu Formularen und validiert es beim Einreichen — Angreifer können es wegen der SOP nicht lesen. Double-submit und eigene Header ergänzen Defense-in-Depth. APIs mit Bearer-Tokens (keine Cookies) sind von Natur aus CSRF-immun.
# CSRF (Cross-Site Request Forgery): attacker tricks the user's
# browser into sending a state-changing request using their cookies.
# Defense 1: SameSite cookies (modern default)
Set-Cookie: session=abc; SameSite=Lax # blocks most CSRF
Set-Cookie: session=abc; SameSite=Strict # blocks all cross-site
# Defense 2: CSRF token (synchronizer pattern)
# Server embeds a random token in the form
<form action="/transfer" method="POST">
<input type="hidden" name="csrf" value="randomtoken123">
...
</form>
# Server validates the token on POST
# Defense 3: Double-submit cookie
Set-Cookie: csrf=xyz
# JS reads cookie, includes value in a custom header
X-CSRF-Token: xyz
# (custom headers can't be sent cross-site without preflight)
# Defense 4: Require custom header on state-changing requests
# (browsers block cross-site custom headers without CORS preflight)WebSocket
WebSocket-Upgrade
WebSocket startet als HTTP-Anfrage mit dem Upgrade-Header. Stimmt der Server zu, antwortet er mit 101 Switching Protocols. Danach spricht dieselbe TCP-Verbindung das binäre WebSocket-Protokoll — Vollduplex, geringer Overhead, kein HTTP-Overhead pro Nachricht. Der Sec-WebSocket-Accept-Wert (SHA-1 des Client-Keys plus eine feste GUID) belegt, dass der Server bewusst hochgestuft hat. Origin lässt den Server die Upgrade-Quelle autorisieren.
# Client initiates HTTP upgrade
GET /ws HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: https://example.com
# Server accepts upgrade
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
# After 101, the TCP connection is "upgraded" - HTTP is done.
# Both sides send WebSocket frames (binary protocol).
# Sec-WebSocket-Accept = base64(SHA1(key + magic GUID))
# Server must compute this to prove it understood the upgrade.WebSocket-Handshake (JS-Client)
Die Browser-WebSocket-API ist event-getrieben: onopen feuert nach dem erfolgreichen Upgrade, onmessage bei jedem eingehenden Frame, onclose bei Trennung, onerror bei Fehlern. Strings oder Binärdaten senden (ArrayBuffer, Blob). Mit einem Code schließen (1000 = normal) und einer Begründung. Die Verbindung ist Vollduplex — beide Seiten können jederzeit senden. WSS (WebSocket Secure) nutzt TLS, gleich HTTPS.
# Browser client
const ws = new WebSocket('wss://example.com/ws');
ws.onopen = () => {
console.log('connected');
ws.send('Hello Server');
};
ws.onmessage = (event) => {
console.log('received:', event.data);
};
ws.onclose = (event) => {
console.log('closed:', event.code, event.reason);
};
ws.onerror = (error) => {
console.error('error:', error);
};
# Send binary
ws.send(new ArrayBuffer(8));
# Close
ws.close(1000, 'normal closure');WebSocket-Frames
WebSocket-Frames sind binär: ein FIN-Bit (Nachricht komplett), opcode (text/binary/close/ping/pong), mask bit (Client-Frames müssen maskiert sein, um Cache-Poisoning durch Vermittler zu verhindern), payload length und Daten. Close-Codes verraten, warum die Verbindung endete — 1000 ist normal, 1006 abnormal (kein close frame, oft ein Netzabfall). Ping/pong-Frames halten die Verbindung am Leben und entdecken tote Partner. Frames können über mehrere Frames fragmentiert werden.
# After the handshake, communication is via binary frames:
# - FIN bit (1 = final fragment of a message)
# - Opcode (4 bits): 0x1 text, 0x2 binary, 0x8 close,
# 0x9 ping, 0xA pong
# - Mask bit (client->server frames are masked)
# - Payload length (7, 7+16, or 7+64 bits)
# - Masking key (4 bytes, client->server only)
# - Payload data
# Close codes:
# 1000 Normal closure
# 1001 Endpoint going away
# 1006 Abnormal closure (no close frame)
# 1008 Policy violation
# 1011 Internal server error
# 4000-4999 Application-defined
# Ping/Pong: keep-alive and liveness check
# Server: ping -> Client: pong (within timeout)
# Frames can be fragmented (FIN=0) and reassembled.WebSocket vs. HTTP
WebSocket ist Vollduplex und bidirektional, ideal für Echtzeit-Apps (Chat, Gaming, Live-Dashboards, kollaboratives Editieren). HTTP ist Anfrage-Antwort — der Client fragt, der Server antwortet. Für einseitige Server-zu-Client-Updates ist SSE einfacher (baut auf HTTP, reconnected automatisch, mag Proxies). Für stateless CRUD ist HTTP/REST richtig. WebSocket hat den geringsten Nachricht-Overhead, aber die höchsten Setup-Kosten (Upgrade, Framing).
# HTTP: request-response, half-duplex (client initiates)
# WebSocket: full-duplex, either side can send anytime
# Use HTTP when:
# - Client asks, server answers (CRUD APIs)
# - Stateless, cacheable resources
# - Occasional data fetches
# Use WebSocket when:
# - Real-time updates (chat, live sports, dashboards)
# - Bidirectional streaming (collaborative editing, gaming)
# - High-frequency, low-latency messaging
# - Server pushes events without client polling
# Alternatives:
# - SSE (Server-Sent Events): one-way server->client over HTTP
# - HTTP/2 streaming: server can push via DATA frames
# - Long polling: HTTP hack (client polls, server holds open)
# WebSocket has lower per-message overhead than HTTP.WebSocket-Anwendungsfälle
WebSocket glänzt bei Echtzeit-bidirektionalen Apps: Chat, Live-Dashboards, Multiplayer-Spiele, kollaboratives Editieren, Benachrichtigungen und WebRTC-Signaling. Die Herausforderung ist Skalierung: ein Client verbindet sich mit einem konkreten Server, also braucht Broadcast an alle Clients ein Pub/Sub-Backend (Redis, Kafka), um über Server-Instanzen hinweg zu verteilen. Sticky Sessions am Load Balancer nutzen, oder stateless Server entwerfen, die Nachrichten über die Pub/Sub-Schicht routen.
# 1. Chat application
# Client sends: {"type": "message", "text": "hi"}
# Server broadcasts to all connected clients
# 2. Live dashboard (stock prices, sports scores)
# Server pushes updates every second
# Client just listens
# 3. Multiplayer game
# Low-latency bidirectional: position, actions, events
# 4. Collaborative editing (Google Docs style)
# Operational Transform / CRDT messages both ways
# 5. Live notifications
# Server pushes: "you have a new message"
# 6. Voice/video signaling (WebRTC)
# WS carries SDP offers/answers before media flows over UDP
# Scaling WebSockets: sticky sessions or a pub/sub backend
# (Redis Pub/Sub, Kafka) so any server can reach any client.REST-API-Design
Ressourcen-Namensgebung
REST-Ressourcen sind Nomen (Plural: /users nicht /user), HTTP-Methoden drücken die Aktion aus. Keine Verben in URLs (/createUser ist falsch — POST /users ist richtig). Sub-Ressourcen drücken Beziehungen aus (/users/42/orders). Query-Parameter behandeln Filterung, Sortierung, Pagination — nie in den Pfad backen. Für mehrwortige Pfadsegmente kebab-case (/password-resets, nicht /passwordResets). Konsistenz ist die wichtigste Regel.
# Resources are nouns, pluralized
GET /api/users # list users
POST /api/users # create user
GET /api/users/42 # get user 42
PUT /api/users/42 # replace user 42
PATCH /api/users/42 # update user 42
DELETE /api/users/42 # delete user 42
# Sub-resources for relationships
GET /api/users/42/orders # user 42's orders
GET /api/users/42/orders/1001 # specific order
# Use query params for filtering/sorting/pagination
GET /api/users?role=admin&sort=-created_at&page=2&limit=20
# Bad (verbs in URL):
POST /api/createUser # should be POST /api/users
GET /api/getUser/42 # should be GET /api/users/42
# Good: nouns + HTTP methods express the action.HTTP-Methoden in REST
Die Standard-REST-CRUD-Zuordnung: POST=erzeugen, GET=lesen, PUT=ersetzen, PATCH=aktualisieren, DELETE=löschen. GET/HEAD/OPTIONS sind safe (keine Seiteneffekte). PUT und DELETE sind idempotent. POST nicht (Wiederholung erzeugt Duplikate). Für Aktionen, die nicht in CRUD passen (lock, archive, send-email), ein Sub-Ressource mit POST nutzen: /users/42/lock. Diese 'RPC-Notluke' ist pragmatisch — pure REST modelliert nicht jede Operation sauber.
# Standard CRUD mapping:
POST /users # Create (server assigns ID)
GET /users # List (with filtering/pagination)
GET /users/:id # Read one
PUT /users/:id # Replace (full update)
PATCH /users/:id # Update (partial)
DELETE /users/:id # Delete
# Safe (no side effects): GET, HEAD, OPTIONS
# Idempotent (repeatable): GET, HEAD, OPTIONS, PUT, DELETE
# Neither: POST (creates new resource each time)
# PATCH: idempotency depends on the patch format
# Custom "actions" on a resource (RPC-style escape hatch):
POST /users/42/lock # lock the user (not pure REST)
POST /users/42/unlock
POST /users/42:lock # Google AIP style
POST /users/42/actions/lock # explicit escape hatchStatuscodes in REST
Statuscodes semantisch nutzen. 200 ist generischer Erfolg; 201 zeigt eine Erzeugung (mit Location); 204 bedeutet Erfolg ohne Body. 400 ist malformed Input; 422 (WebDAV) ist wohlgeformt, aber semantisch ungültig (Validierung). 401 vs. 403 ist das am häufigsten verwechselte Paar: 401 = 'Wer bist du?', 403 = 'Ich weiß, wer du bist, aber das darfst du nicht'. 5xx bedeutet ein Server-Versagen — Clients dürfen mit Backoff wiederholen. Über die API hinweg konsistent sein.
# Success (2xx)
200 OK # generic success, returns data
201 Created # POST/PUT created a resource (Location header)
202 Accepted # async job queued (return job URL)
204 No Content # success, no body (DELETE, PUT)
# Client errors (4xx)
400 Bad Request # malformed input, validation failure
401 Unauthorized # not authenticated (needs login)
403 Forbidden # authenticated but lacks permission
404 Not Found # resource doesn't exist
409 Conflict # version conflict, duplicate
422 Unprocessable # semantic error (well-formed but invalid)
429 Too Many Requests # rate limited (Retry-After)
# Server errors (5xx)
500 Internal Server Error # unexpected failure
503 Service Unavailable # maintenance, overload
# Idempotency: 204 for DELETE/PUT is conventional.
# 201 vs 200 for POST: 201 if a resource was created.Pagination
Seiten-basierte Pagination (offset/limit) ist simpel, aber ineffizient bei großen Datensätzen (OFFSET scannt vergangene Zeilen) und instabil (neue Inserts verschieben Zeilen). Cursor-basierte Pagination nutzt ein opakes Token, das auf das letzte Element zeigt — stabil bei gleichzeitigen Inserts und schnell (indizierter Lookup auf der Cursor-Spalte). Cursor für Infinite Scrolls und große Feeds; Seiten-basiert für Admin-UIs mit 'Sprung zu Seite N'. Der Link-Header (RFC 5988) ist ein HATEOAS-artiger Weg, Pagination-URLs zu exponieren.
# Page-based (offset/limit)
GET /api/users?page=2&limit=20
# Response:
{
"data": [...],
"page": 2,
"limit": 20,
"total": 1000,
"total_pages": 50
}
# Cursor-based (token, better for large/realtime datasets)
GET /api/users?cursor=abc123&limit=20
# Response:
{
"data": [...],
"next_cursor": "def456",
"has_more": true
}
# Link header (RFC 5988):
Link: <https://api.example.com/users?page=3>; rel="next",
<https://api.example.com/users?page=50>; rel="last"
# Pros of cursor: stable under inserts/deletes,
# faster on large datasets (no OFFSET scan).
# Cons: can't jump to arbitrary page.API-Versionierung
API-Versionierung verhindert, dass Breaking Changes bestehende Clients verletzen. URI-Versionierung (/v1/, /v2/) ist der häufigste, expliziteste Ansatz — leicht zu debuggen, zu routen und zu cachen. Header-Versionierung hält URLs sauber, ist aber im Browser schwerer zu testen. Beim Deprecaten die Sunset- und Deprecation-Header (RFC 8594) nutzen, um das End-of-Life-Datum zu ankündigen, Clients reichlich Zeit geben (6-24 Monate) und den Migrationspfad dokumentieren. Non-breaking Changes (optionale Felder ergänzen) brauchen keine Versions-Erhöhung.
# 1. URI versioning (most common, explicit)
GET /api/v1/users
GET /api/v2/users
# 2. Header versioning (cleaner URLs)
GET /api/users
Accept: application/vnd.example.v2+json
# 3. Custom header
X-API-Version: 2
# 4. Query parameter
GET /api/users?version=2
# Deprecation flow:
# - Mark old version as deprecated (Sunset header)
Sunset: Sat, 31 Dec 2025 23:59:59 GMT
Deprecation: true
# - Document migration guide
# - Maintain old version for a transition period (6-24 months)
# - Notify clients via email, response headers, logs
# - Eventually shut down the old version
# Breaking changes require a new major version.
# Non-breaking changes (adding fields) don't.REST-Best-Practices
REST-Best-Practices: Plural-Nomen, Methoden drücken Aktionen aus, semantische Statuscodes, Pagination per Default, Filterung über Query-Strings, konsistentes Fehlerformat (RFC 7807 problem+json ist der Standard) und Hypermedia-Links für Entdeckbarkeit (HATEOAS). Für POST-Endpunkte, die nicht natürlich idempotent sind (Zahlungen, Bestell-Erzeugung), einen Idempotency-Key-Header akzeptieren, damit Clients sicher wiederholen können ohne Effekte zu duplizieren — der Server speichert die Antwort zum UUID-Key und spielt sie bei Retries ab.
# 1. Use plural nouns: /users not /user
# 2. HTTP methods express actions (no verbs in URLs)
# 3. Status codes are semantic (201 for create, 404 for missing)
# 4. Pagination on list endpoints (default limit, max cap)
# 5. Filtering via query params: ?role=admin&active=true
# 6. Consistent error format (RFC 7807 problem+json):
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/problem+json
{
"type": "https://example.com/errors/validation",
"title": "Validation failed",
"status": 422,
"detail": "Email is required",
"instance": "/api/users",
"errors": [{"field": "email", "message": "required"}]
}
# 7. Hypermedia (HATEOAS) links in responses (optional):
{"data": {...}, "_links": {"self": "/users/42", "orders": "/users/42/orders"}}
# 8. Idempotency keys for safe POST retries (Stripe pattern)
Idempotency-Key: client-generated-uuidVerwandte HTTP-Snippets
Copy-paste ready code for common tasks.
Methods
Core HTTP request methods.
Status Codes
Five classes of response codes.
Headers
Common request and response headers.
Caching
Cache-Control, ETag, and conditional requests.
Cookies
Set, send, and expire cookies.
Authentication
Basic, Bearer, and challenge responses.
Content Negotiation
Negotiate representation with Accept headers.
CORS
Cross-origin preflight and responses.
Was this helpful?