Startseite › Entwickler-Tools › PKCE-Code-Challenge-Generator

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
1. Autorisierungsanfrage (im Browser öffnen)

2. Token-Anfrage (AUTHORIZATION_CODE ersetzen)

Paar prüfen

Anzeige
Anzeige

Anleitung: PKCE-Code-Challenge-Generator

  1. Klicke auf „Neues Paar erzeugen“ (beim Laden der Seite ist bereits ein Paar bereit). Passe bei Bedarf die Länge des Verifiers an.
  2. Kopiere die code_challenge und sende sie mit code_challenge_method=S256 in der Autorisierungsanfrage, oder nutze den URL-Builder.
  3. Speichere den code_verifier sicher in deiner App (im Arbeitsspeicher oder Session Storage), bis der Nutzer mit einem Autorisierungscode zurückkehrt.
  4. Tausche den Code ein: Sende den code_verifier in der Token-Anfrage (siehe das curl-Beispiel).
  5. Fehlersuche? Füge unter „Paar prüfen“ einen Verifier und eine Challenge ein, um zu sehen, ob sie zusammenpassen.

So funktioniert der PKCE-Ablauf

  1. Verifier erstellen. Der Client erzeugt einen zufälligen code_verifier mit hoher Entropie (43-128 Zeichen aus A-Z a-z 0-9 - . _ ~) und hält ihn geheim.
  2. Challenge ableiten. code_challenge = BASE64URL(SHA256(code_verifier)), Base64URL ohne =-Padding.
  3. Autorisierungsanfrage. Der Client leitet den Nutzer mit code_challenge und code_challenge_method=S256 zum Autorisierungsserver weiter. Der Server speichert die Challenge zusammen mit dem ausgestellten Autorisierungscode.
  4. Token-Anfrage. Der Client sendet den Autorisierungscode zusammen mit dem ursprünglichen code_verifier.
  5. 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_verifierdBjftJeZ4CVP-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.

Ähnliche Tools

Alle Code-Generatoren & Builder ansehen →