Autorisez un client avec PKCE

Implémentez le flux d'autorisation par code ShareAI avec S256 PKCE, vérifiez l'état et échangez le code sur le backend de votre application.

Voir en Markdown

Sur cette page

Ce flux connecte un compte client à votre application. Le client se connecte, choisit un compte personnel ou organisationnel et approuve les autorisations demandées. Votre backend échange ensuite le code à durée limitée contre des jetons.

Avant de commencer#

Terminé enregistrement de l'application. Vous avez besoin d'un callback enregistré exact, des identifiants client détenus par le serveur et d'une session côté serveur pour le navigateur complétant l'autorisation.

1. Créez la requête d'autorisation#

GET https://auth.shareai.now/oauth/authorize

Demandez au client d'autoriser l'application.

URL de base: https://auth.shareai.now
Authentification: Redirection du navigateur ; application enregistrée

Générez un vérificateur, un état et un nonce uniques pour chaque tentative. Stockez-les dans la session côté serveur de l'utilisateur initiateur. Envoyez le défi SHA-256, jamais le vérificateur, dans la redirection du navigateur. Demandez uniquement les scopes nécessaires à votre application.

Python

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))

TypeScript

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. Validez le callback#

Si l'autorisation est refusée, gérez l'erreur OAuth comme une annulation normale. Sinon, comparez la valeur retournée state avec la valeur enregistrée avant d'utiliser le code. Rejetez un état manquant ou non correspondant. Consommez l'état enregistré une seule fois ; n'acceptez pas les URLs de callback soumises par une autre session de navigateur.

3. Échangez le code#

POST https://auth.shareai.now/oauth/token

Échangez un code à usage unique et le vérificateur PKCE correspondant.

URL de base: https://auth.shareai.now
Authentification: Authentification client confidentielle

cURL

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"

Utilisez la méthode d'authentification client configurée pour le client. L'exemple utilise l'authentification client basée sur formulaire. Ne renvoyez pas le même code deux fois ; recommencez l'autorisation après un code consommé ou expiré.

4. Stockez le résultat et établissez la session de votre application#

Stockez les jetons d'accès et de rafraîchissement dans votre backend. Utilisez la valeur retournée expires_in plutôt que de supposer un jeton permanent. Si vous utilisez un ID token, validez sa signature avec le JWKS de l'émetteur, l'émetteur attendu, l'audience client, l'expiration et votre nonce original avant de faire confiance aux revendications.

Continuez le cycle de vie#

Rafraîchissement et rotation · Scopes et identité du compte · Requêtes OAuth pour chat

Dernière mise à jour le 15 septembre 2026