Autorisieren Sie einen Kunden mit PKCE

Dieser Flow verbindet ein Kundenkonto mit Ihrer Anwendung. Der Kunde meldet sich an, wählt ein persönliches oder Organisationskonto aus und genehmigt die angeforderten Berechtigungen. Ihr Backend tauscht dann den kurzlebigen Code gegen Tokens aus.

Bevor Sie beginnen#

Abschließen Anwendungsregistrierung. Sie benötigen einen exakt registrierten Callback, serverseitige Client-Anmeldedaten und eine serverseitige Sitzung für den Browser, der die Autorisierung abschließt.

1. Erstellen Sie die Autorisierungsanfrage#

Generieren Sie für jeden Versuch einen neuen Verifier, Status und Nonce. Speichern Sie diese in der serverseitigen Sitzung des initiierenden Benutzers. Senden Sie die SHA-256-Challenge, niemals den Verifier, in der Browser-Weiterleitung. Fordern Sie nur die Berechtigungen an, die Ihre Anwendung benötigt.

import base64
import hashlib
import secrets
import urllib.parse

verifier = secrets.token_urlsafe(48)
challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).rstrip(b"=").decode()
state = secrets.token_urlsafe(32)
nonce = secrets.token_urlsafe(32)
# Store verifier, state and nonce in the user's server-side session.
params = {
    "response_type": "code",
    "client_id": "YOUR_CLIENT_ID",
    "redirect_uri": "https://app.example.com/auth/shareai/callback",
    "scope": "openid profile surcharge",
    "state": state,
    "nonce": nonce,
    "code_challenge": challenge,
    "code_challenge_method": "S256",
}
print("https://auth.shareai.now/oauth/authorize?" + urllib.parse.urlencode(params))

import { randomBytes, createHash } from "node:crypto";
const verifier = randomBytes(48).toString("base64url");
const state = randomBytes(32).toString("base64url");
const nonce = randomBytes(32).toString("base64url");
const challenge = createHash("sha256").update(verifier).digest("base64url");
// Save verifier, state and nonce in the initiating server-side session.
const params = new URLSearchParams({ response_type: "code", client_id: "YOUR_CLIENT_ID",
  redirect_uri: "https://app.example.com/auth/shareai/callback",
  scope: "openid profile surcharge", state, nonce,
  code_challenge: challenge, code_challenge_method: "S256" });
const authorizationUrl = `https://auth.shareai.now/oauth/authorize?${params}`;
// Redirect the browser to authorizationUrl.

2. Validieren Sie den Callback#

Wenn die Autorisierung abgelehnt wird, behandeln Sie den OAuth-Fehler wie eine normale Stornierung. Vergleichen Sie andernfalls den zurückgegebenen state mit dem gespeicherten Wert, bevor Sie den Code verwenden. Lehnen Sie einen fehlenden oder nicht übereinstimmenden Status ab. Verwenden Sie den gespeicherten Status nur einmal; akzeptieren Sie keine Callback-URLs, die von einer anderen Browsersitzung eingereicht wurden.

3. Tauschen Sie den Code aus#

curl --fail-with-body "https://auth.shareai.now/oauth/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "grant_type=authorization_code" \
  --data-urlencode "client_id=$SHAREAI_CLIENT_ID" \
  --data-urlencode "client_secret=$SHAREAI_CLIENT_SECRET" \
  --data-urlencode "code=$AUTHORIZATION_CODE" \
  --data-urlencode "redirect_uri=https://app.example.com/auth/shareai/callback" \
  --data-urlencode "code_verifier=$PKCE_VERIFIER"

Verwenden Sie die für den Client konfigurierte Authentifizierungsmethode. Das Beispiel verwendet formularbasierte Client-Authentifizierung. Senden Sie denselben Code nicht zweimal; starten Sie die Autorisierung erneut nach einem verbrauchten oder abgelaufenen Code.

4. Speichern Sie das Ergebnis und richten Sie Ihre App-Sitzung ein#

Speichern Sie Zugriffs- und Aktualisierungstokens in Ihrem Backend. Verwenden Sie den zurückgegebenen expires_in anstelle der Annahme eines permanenten Tokens. Wenn Sie ein ID-Token verwenden, validieren Sie dessen Signatur mit den JWKS des Herausgebers, dem erwarteten Herausgeber, der Client-Zielgruppe, dem Ablaufdatum und Ihrem ursprünglichen Nonce, bevor Sie Ansprüche vertrauen.

Fahren Sie mit dem Lebenszyklus fort#

Aktualisierung und Rotation · Scopes und Kontenidentität · OAuth-Chat-Anfragen