PKCE-Code-Challenge-Generator
Erstelle mit der Web Crypto API einen kryptografisch zufälligen PKCE-code_verifier und die zugehörige S256-code_challenge, genau wie in RFC 7636 festgelegt. Baue eine fertige Autorisierungs-URL und eine Token-Anfrage zum Testen oder prüfe, ob ein vorhandener Verifier und eine Challenge zusammengehören.
Zuletzt aktualisiert:
Builder für Autorisierungs-URL & Token-Anfrage
Paar prüfen
Anleitung: PKCE-Code-Challenge-Generator
- Klicke auf „Neues Paar erzeugen“ (beim Laden der Seite ist bereits ein Paar bereit). Passe bei Bedarf die Länge des Verifiers an.
- Kopiere die code_challenge und sende sie mit
code_challenge_method=S256in der Autorisierungsanfrage, oder nutze den URL-Builder. - Speichere den code_verifier sicher in deiner App (im Arbeitsspeicher oder Session Storage), bis der Nutzer mit einem Autorisierungscode zurückkehrt.
- Tausche den Code ein: Sende den code_verifier in der Token-Anfrage (siehe das curl-Beispiel).
- Fehlersuche? Füge unter „Paar prüfen“ einen Verifier und eine Challenge ein, um zu sehen, ob sie zusammenpassen.
So funktioniert der PKCE-Ablauf
- Verifier erstellen. Der Client erzeugt einen zufälligen
code_verifiermit hoher Entropie (43-128 Zeichen ausA-Z a-z 0-9 - . _ ~) und hält ihn geheim. - Challenge ableiten.
code_challenge = BASE64URL(SHA256(code_verifier)), Base64URL ohne=-Padding. - Autorisierungsanfrage. Der Client leitet den Nutzer mit
code_challengeundcode_challenge_method=S256zum Autorisierungsserver weiter. Der Server speichert die Challenge zusammen mit dem ausgestellten Autorisierungscode. - Token-Anfrage. Der Client sendet den Autorisierungscode zusammen mit dem ursprünglichen
code_verifier. - Prüfung. Der Server hasht den Verifier und vergleicht ihn mit der gespeicherten Challenge. Nur der Client, der den Ablauf gestartet hat, kann ihn abschließen.
Testvektor aus RFC 7636 (Anhang B)
| code_verifier | dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk |
|---|---|
| code_challenge (S256) | E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM |
Klicke auf RFC-7636-Beispiel laden, um es mit diesem Tool nachzuvollziehen. Wenn dein eigener Code ein anderes Ergebnis liefert, sind die üblichen Ursachen Standard-Base64 statt Base64URL, übrig gebliebenes =-Padding, das Hashen des Hex-Strings des Digests oder das Hashen eines Strings mit abschließendem Zeilenumbruch.
PKCE im Code erzeugen
JavaScript (Browser oder Node 18+):
const b64url = b => btoa(String.fromCharCode(...new Uint8Array(b)))
.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
const verifier = b64url(crypto.getRandomValues(new Uint8Array(32)));
const challenge = b64url(await crypto.subtle.digest('SHA-256',
new TextEncoder().encode(verifier)));
Python:
import base64, hashlib, secrets
verifier = secrets.token_urlsafe(32) # 43 characters
challenge = base64.urlsafe_b64encode(
hashlib.sha256(verifier.encode('ascii')).digest()).rstrip(b'=').decode()
Häufige Fragen
Was ist PKCE?
PKCE (Proof Key for Code Exchange, ausgesprochen „pixy“) ist eine OAuth-2.0-Erweiterung, die in RFC 7636 definiert ist. Der Client erstellt einen geheimen code_verifier, sendet mit der Autorisierungsanfrage nur dessen Hash (die code_challenge) und beweist später, dass er den Ablauf gestartet hat, indem er den Verifier mit der Token-Anfrage sendet. Ein Angreifer, der den Autorisierungscode abfängt, kann ihn ohne den Verifier nicht verwenden.
Wie wird die S256-Code-Challenge berechnet?
code_challenge = BASE64URL-ENCODE(SHA256(ASCII(code_verifier))). Der SHA-256-Digest der ASCII-Bytes des Verifiers wird Base64URL-kodiert: + wird zu -, / wird zu _, und das abschließende =-Padding wird entfernt. Eine SHA-256-Challenge ist daher immer 43 Zeichen lang.
Welche Regeln gelten für einen code_verifier?
Er muss 43 bis 128 Zeichen lang sein und darf nur die nicht reservierten Zeichen A-Z, a-z, 0-9, Bindestrich, Punkt, Unterstrich und Tilde enthalten. RFC 7636 empfiehlt, 32 zufällige Bytes zu erzeugen und sie mit Base64URL zu kodieren, was einen Verifier mit 43 Zeichen und 256 Bit Entropie ergibt.
Soll ich S256 oder plain verwenden?
Verwende immer S256, wenn der Client SHA-256 berechnen kann, was jede moderne Plattform kann. Bei plain ist die Challenge gleich dem Verifier, sodass jeder, der die Autorisierungsanfrage sieht, auch den Verifier kennt. OAuth 2.1 und viele Anbieter verlangen S256.
Brauche ich mit PKCE trotzdem einen state-Parameter?
PKCE schützt vor dem Abfangen des Autorisierungscodes und verhindert auch CSRF, wenn der Server es erzwingt, aber viele Anbieter und Bibliotheken erwarten trotzdem einen state-Wert, und er ist nützlich, um App-Kontext mitzuführen. Beides zu verwenden ist die übliche Empfehlung.
Ist PKCE nur für Mobil- und Single-Page-Apps?
Nein. PKCE wurde für öffentliche Clients wie Mobil- und Browser-Apps entwickelt, die kein Client-Secret geheim halten können, aber die OAuth 2.0 Security Best Current Practice (RFC 9700) empfiehlt es auch für vertrauliche serverseitige Clients, und OAuth 2.1 schreibt es für den Authorization-Code-Flow vor.
Ist es sicher, einen code_verifier auf einer Website zu erzeugen?
Diese Seite erzeugt die Werte lokal mit dem kryptografischen Zufallsgenerator des Browsers und überträgt sie nie. Im Produktivbetrieb sollte deine Anwendung jedoch für jede Anmeldung einen neuen Verifier erzeugen; nutze dieses Tool zum Lernen, Testen und zur Fehlersuche.
Werden alle Tools auf FreeToolCabin auf Qualität und Genauigkeit getestet?
Ja. Jedes Tool auf der Website durchläuft automatische Tests in echten Browsern, die prüfen, ob das Ergebnis stimmt und keine Fehler auftreten. Wenn du einen Fehler findest oder einen Vorschlag hast, schreib uns an [email protected] – wir sehen es uns an.