Autoriza a un cliente con PKCE

Implementa el flujo de código de autorización de ShareAI con S256 PKCE, verifica el estado e intercambia el código en el backend de tu aplicación.

Ver como Markdown

En esta página

Este flujo conecta una cuenta de cliente con tu aplicación. El cliente inicia sesión, elige una cuenta personal u organizacional y aprueba los permisos solicitados. Luego, tu backend intercambia el código de corta duración por tokens.

Antes de comenzar#

Completar registro de la aplicación. Necesitas un callback registrado exacto, credenciales del cliente almacenadas en el servidor y una sesión del lado del servidor para el navegador que completa la autorización.

1. Crea la solicitud de autorización#

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

Pide al cliente que autorice la aplicación.

URL base: https://auth.shareai.now
Autenticación: Redirección del navegador; aplicación registrada

Genera un nuevo verificador, estado y nonce para cada intento. Almacénalos en la sesión del lado del servidor del usuario que inicia. Envía el desafío SHA-256, nunca el verificador, en la redirección del navegador. Solicita solo los alcances que tu aplicación necesite.

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. Valida el callback#

Si se rechaza la autorización, maneja el error de OAuth como una cancelación normal. De lo contrario, compara el state devuelto con el valor guardado antes de usar el código. Rechaza un estado faltante o que no coincida. Consume el estado guardado una vez; no aceptes URLs de callback enviadas por otra sesión del navegador.

3. Intercambia el código#

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

Intercambia un código de un solo uso y el verificador PKCE correspondiente.

URL base: https://auth.shareai.now
Autenticación: Autenticación de cliente confidencial

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"

Usa el método de autenticación de cliente configurado para el cliente. El ejemplo utiliza autenticación de cliente basada en formularios. No envíes el mismo código dos veces; inicia la autorización nuevamente después de un código consumido o expirado.

4. Almacena el resultado y establece la sesión de tu aplicación#

Almacena los tokens de acceso y actualización en tu backend. Usa el expires_in devuelto en lugar de asumir un token permanente. Si usas un token de ID, valida su firma con el JWKS del emisor, el emisor esperado, la audiencia del cliente, la expiración y tu nonce original antes de confiar en las afirmaciones.

Continúa el ciclo de vida#

Actualización y rotación · Alcances e identidad de la cuenta · Solicitudes de chat OAuth

Última actualización septiembre 15, 2026