Autorize um cliente com PKCE

Implementar o fluxo de código de autorização da ShareAI com S256 PKCE, verificar o estado e trocar o código no backend da sua aplicação.

Ver como Markdown

Nesta página

Este fluxo conecta uma conta de cliente à sua aplicação. O cliente inicia sessão, escolhe uma conta pessoal ou de organização e aprova as permissões solicitadas. O seu backend então troca o código de curta duração por tokens.

Antes de começar#

Concluir registo da aplicação. Necessita de um callback registado exato, credenciais do cliente armazenadas no servidor e uma sessão no lado do servidor para o navegador que completa a autorização.

1. Criar o pedido de autorização#

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

Peça ao cliente para autorizar a aplicação.

URL Base: https://auth.shareai.now
Autenticação: Redirecionamento do navegador; aplicação registada

Gere um novo verificador, estado e nonce para cada tentativa. Armazene-os na sessão do lado do servidor do utilizador que iniciou. Envie o desafio SHA-256, nunca o verificador, no redirecionamento do navegador. Solicite apenas os escopos necessários para a sua aplicação.

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. Validar o callback#

Se a autorização for recusada, trate o erro OAuth como um cancelamento normal. Caso contrário, compare o state valor retornado com o valor guardado antes de usar o código. Rejeite um estado ausente ou incompatível. Consuma o estado guardado uma vez; não aceite URLs de callback submetidos por outra sessão do navegador.

3. Trocar o código#

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

Troque um código de uso único e o verificador PKCE correspondente.

URL Base: https://auth.shareai.now
Autenticação: Autenticação 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"

Use o método de autenticação de cliente configurado para o cliente. O exemplo utiliza autenticação de cliente baseada em formulário. Não envie o mesmo código duas vezes; inicie a autorização novamente após um código consumido ou expirado.

4. Armazenar o resultado e estabelecer a sessão da sua aplicação#

Armazene tokens de acesso e de atualização no seu backend. Use o expires_in retornado em vez de assumir um token permanente. Se usar um token de ID, valide a sua assinatura com o JWKS do emissor, o emissor esperado, o público do cliente, a validade e o nonce original antes de confiar nas declarações.

Continuar o ciclo de vida#

Atualização e rotação · Escopos e identidade da conta · Pedidos de chat OAuth

Última atualização em 15 de setembro de 2026