Intégration Rapide (Tout Langage)

Intégrez SyAuth en utilisant des requêtes HTTP standard depuis n'importe quel langage de programmation.

Avant de commencer

info

Vous avez besoin de ces identifiants avant de commencer. Obtenez-les depuis le Tableau de bord SyAuth.

Ce dont vous avez besoin	Où le trouver	Exemple
Client ID	Tableau de bord → Clients OAuth → Votre App	`a1b2c3d4-5678-90ab-cdef-...`
URI de Redirection	Vous configurez ceci dans Tableau de bord → Clients OAuth → URIs de redirection	`http://localhost:3000/callback`

Nouveau sur SyAuth ? Suivez d'abord ces étapes :

Créez un compte Nexorix (SyAuth utilise Nexorix pour l'authentification)
Créez votre première Application pour obtenir votre Client ID

Comment Fonctionne l'Authentification OAuth

Avant de plonger dans le code, voici ce qui se passe quand un utilisateur se connecte :

Étape 1 : Générer les Codes PKCE

Qu'est-ce que PKCE ? C'est une fonctionnalité de sécurité qui empêche les attaquants d'intercepter le code d'autorisation. Vous générez deux valeurs liées :

code_verifier — Une chaîne secrète aléatoire (gardez-la en sécurité !)
code_challenge — Une version hachée du verifier (envoyée à SyAuth)

Python
Node.js
Browser JS
PHP

import secrets
import hashlib
import base64

# Générer une chaîne aléatoire de 32 octets, encodée en base64url
code_verifier = base64.urlsafe_b64encode(secrets.token_bytes(32)).decode('utf-8').rstrip('=')

# Créer le hash SHA256 du verifier, puis encoder en base64url
code_challenge = base64.urlsafe_b64encode(
    hashlib.sha256(code_verifier.encode('utf-8')).digest()
).decode('utf-8').rstrip('=')

# IMPORTANT : Stockez code_verifier en session - vous en aurez besoin à l'Étape 3 !
print(f"code_verifier: {code_verifier}")
print(f"code_challenge: {code_challenge}")

// Pour Node.js, utilisez le module crypto
const crypto = require('crypto');

function base64UrlEncode(buffer) {
  return buffer.toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=/g, '');
}

// Générer un verifier aléatoire
const codeVerifier = base64UrlEncode(crypto.randomBytes(32));

// Créer le hash SHA256 du verifier
const codeChallenge = base64UrlEncode(
  crypto.createHash('sha256').update(codeVerifier).digest()
);

// IMPORTANT : Stockez codeVerifier en session - vous en aurez besoin à l'Étape 3 !
console.log('code_verifier:', codeVerifier);
console.log('code_challenge:', codeChallenge);

async function generatePKCE() {
  // Générer des octets aléatoires
  const array = new Uint8Array(32);
  crypto.getRandomValues(array);
  
  // Encoder en Base64url
  const codeVerifier = btoa(String.fromCharCode(...array))
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=/g, '');
  
  // Créer le hash SHA256
  const encoder = new TextEncoder();
  const data = encoder.encode(codeVerifier);
  const hash = await crypto.subtle.digest('SHA-256', data);
  
  const codeChallenge = btoa(String.fromCharCode(...new Uint8Array(hash)))
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=/g, '');
  
  // IMPORTANT : Stockez codeVerifier - vous en aurez besoin à l'Étape 3 !
  // Dans un navigateur, utilisez sessionStorage :
  sessionStorage.setItem('pkce_code_verifier', codeVerifier);
  
  return { codeVerifier, codeChallenge };
}

<?php
// Générer un verifier aléatoire
$codeVerifier = rtrim(strtr(base64_encode(random_bytes(32)), '+/', '-_'), '=');

// Créer le hash SHA256 du verifier
$codeChallenge = rtrim(strtr(base64_encode(hash('sha256', $codeVerifier, true)), '+/', '-_'), '=');

// IMPORTANT : Stockez $codeVerifier en session - vous en aurez besoin à l'Étape 3 !
$_SESSION['pkce_code_verifier'] = $codeVerifier;

echo "code_verifier: $codeVerifier\n";
echo "code_challenge: $codeChallenge\n";
?>

ATTENTION

Stockez le code_verifier en sécurité ! Vous en aurez besoin à l'Étape 3 pour échanger le code d'autorisation contre des tokens. Si vous le perdez, vous devrez recommencer.

Étape 2 : Rediriger l'Utilisateur vers la Connexion

Construisez l'URL d'autorisation et redirigez le navigateur de l'utilisateur vers SyAuth :

GET https://api.syauth.com/e/v1/oauth/authorize
    ?response_type=code
    &client_id=VOTRE_CLIENT_ID
    &redirect_uri=VOTRE_REDIRECT_URI
    &scope=openid profile email
    &state=STATE_ALEATOIRE
    &code_challenge=VOTRE_CODE_CHALLENGE
    &code_challenge_method=S256

Référence des Paramètres

Paramètre	Requis	Valeur	Description
`response_type`	✅	`code`	Utilisez toujours `code` pour le flux de code d'autorisation
`client_id`	✅	Votre Client ID	Trouvez-le dans Tableau de bord → Clients OAuth → Votre App
`redirect_uri`	✅	Votre URL de callback	Doit correspondre exactement à ce que vous avez configuré dans le Tableau de bord
`scope`	✅	`openid profile email`	Permissions à demander (scopes OIDC standard)
`state`	✅	Chaîne aléatoire	Générez une valeur unique pour prévenir les attaques CSRF. Vérifiez qu'elle correspond à l'Étape 3
`code_challenge`	✅	De l'Étape 1	Le `code_challenge` que vous avez généré
`code_challenge_method`	✅	`S256`	Utilisez toujours `S256` (hachage SHA-256)

Exemple : Construire l'URL

Python
JavaScript

from urllib.parse import urlencode
import secrets

# Configuration de votre app
CLIENT_ID = "votre-client-id-du-tableau-de-bord"  # <-- Obtenez depuis le Tableau de bord
REDIRECT_URI = "http://localhost:3000/callback"  # <-- Doit correspondre à la config du Tableau de bord

# Générer l'état pour la protection CSRF
state = secrets.token_urlsafe(32)

# Construire l'URL d'autorisation
params = {
    'response_type': 'code',
    'client_id': CLIENT_ID,
    'redirect_uri': REDIRECT_URI,
    'scope': 'openid profile email',
    'state': state,
    'code_challenge': code_challenge,  # De l'Étape 1
    'code_challenge_method': 'S256'
}

auth_url = f"https://api.syauth.com/e/v1/oauth/authorize?{urlencode(params)}"

# Stocker l'état en session pour vérifier plus tard
session['oauth_state'] = state

# Rediriger l'utilisateur vers cette URL
print(f"Rediriger vers : {auth_url}")

// Configuration de votre app
const CLIENT_ID = 'votre-client-id-du-tableau-de-bord';  // <-- Obtenez depuis le Tableau de bord
const REDIRECT_URI = 'http://localhost:3000/callback';  // <-- Doit correspondre au Tableau de bord

// Générer l'état pour la protection CSRF
const state = crypto.randomUUID();

// Stocker l'état pour vérifier plus tard
sessionStorage.setItem('oauth_state', state);

// Construire l'URL d'autorisation
const params = new URLSearchParams({
    response_type: 'code',
    client_id: CLIENT_ID,
    redirect_uri: REDIRECT_URI,
    scope: 'openid profile email',
    state: state,
    code_challenge: codeChallenge,  // De l'Étape 1
    code_challenge_method: 'S256'
});

const authUrl = `https://api.syauth.com/e/v1/oauth/authorize?${params}`;

// Rediriger l'utilisateur
window.location.href = authUrl;

Après que l'utilisateur se soit connecté avec succès, SyAuth le redirige vers votre redirect_uri avec un code d'autorisation.

Étape 3 : Échanger le Code contre des Tokens

Quand l'utilisateur est redirigé vers votre app, l'URL ressemblera à :

https://votre-app.com/callback?code=CODE_AUTORISATION&state=MEME_STATE_QUE_VOUS_AVEZ_ENVOYE

Avant d'échanger le code :

✅ Vérifiez que state correspond à ce que vous avez stocké (empêche les attaques CSRF)
✅ Extrayez le paramètre code

Maintenant échangez le code contre des tokens d'accès :

curl
Python
JavaScript

curl -X POST https://api.syauth.com/e/v1/oauth/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=authorization_code" \
  -d "code=LE_CODE_DU_CALLBACK" \
  -d "client_id=VOTRE_CLIENT_ID" \
  -d "redirect_uri=VOTRE_REDIRECT_URI" \
  -d "code_verifier=VOTRE_CODE_VERIFIER_DE_L_ETAPE_1"

import requests

# Obtenez ceux-ci depuis l'URL de callback
authorization_code = request.args.get('code')
returned_state = request.args.get('state')

# SÉCURITÉ : Vérifiez que l'état correspond
if returned_state != session.get('oauth_state'):
    raise Exception("État invalide - attaque CSRF possible !")

# Échangez le code contre des tokens
response = requests.post('https://api.syauth.com/e/v1/oauth/token', data={
    'grant_type': 'authorization_code',
    'code': authorization_code,
    'client_id': CLIENT_ID,
    'redirect_uri': REDIRECT_URI,
    'code_verifier': session.get('pkce_code_verifier')  # De l'Étape 1 !
})

tokens = response.json()
access_token = tokens['access_token']
refresh_token = tokens['refresh_token']

print(f"Access Token : {access_token}")

// Analyser l'URL de callback
const urlParams = new URLSearchParams(window.location.search);
const code = urlParams.get('code');
const returnedState = urlParams.get('state');

// SÉCURITÉ : Vérifiez que l'état correspond
if (returnedState !== sessionStorage.getItem('oauth_state')) {
    throw new Error("État invalide - attaque CSRF possible !");
}

// Échangez le code contre des tokens
const response = await fetch('https://api.syauth.com/e/v1/oauth/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
        grant_type: 'authorization_code',
        code: code,
        client_id: CLIENT_ID,
        redirect_uri: REDIRECT_URI,
        code_verifier: sessionStorage.getItem('pkce_code_verifier')  // De l'Étape 1 !
    })
});

const tokens = await response.json();
console.log('Access Token :', tokens.access_token);

Réponse Token

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
}

Champ	Description
`access_token`	Utilisez ceci pour authentifier les requêtes API. Valide pour 1 heure.
`refresh_token`	Utilisez ceci pour obtenir un nouveau token d'accès quand l'actuel expire.
`expires_in`	Secondes avant que le token d'accès expire (3600 = 1 heure).

astuce

Stockez les tokens en sécurité ! Utilisez des cookies HTTP-only ou un stockage sécurisé côté serveur. N'exposez jamais les tokens dans le JavaScript côté client où ils peuvent être accédés par des scripts malveillants.

Étape 4 : Appeler les APIs avec le Token d'Accès

Utilisez l'access_token pour faire des requêtes authentifiées :

curl
Python
JavaScript

# Remplacez avec votre token d'accès réel de l'Étape 3
curl https://api.syauth.com/e/v1/user/profile \
  -H "Authorization: Bearer VOTRE_ACCESS_TOKEN"

response = requests.get(
    'https://api.syauth.com/e/v1/user/profile',
    headers={'Authorization': f'Bearer {access_token}'}
)

user = response.json()
print(f"Bienvenue, {user['first_name']} {user['last_name']}!")
print(f"Email : {user['email']}")

const response = await fetch('https://api.syauth.com/e/v1/user/profile', {
    headers: { 'Authorization': `Bearer ${accessToken}` }
});

const user = await response.json();
console.log(`Bienvenue, ${user.first_name} ${user.last_name}!`);

Exemple de Réponse

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "email": "[email protected]",
  "first_name": "Jean",
  "last_name": "Dupont",
  "email_verified": true
}

Étape 5 : Rafraîchir les Tokens Expirés

Les tokens d'accès expirent après 1 heure. Utilisez le refresh_token pour obtenir un nouveau token d'accès sans demander à l'utilisateur de se reconnecter :

Python
JavaScript

response = requests.post('https://api.syauth.com/e/v1/oauth/token', data={
    'grant_type': 'refresh_token',
    'refresh_token': refresh_token,
    'client_id': CLIENT_ID
})

new_tokens = response.json()
new_access_token = new_tokens['access_token']
# Mettez aussi à jour le refresh_token si un nouveau est fourni

const response = await fetch('https://api.syauth.com/e/v1/oauth/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
        grant_type: 'refresh_token',
        refresh_token: storedRefreshToken,
        client_id: CLIENT_ID
    })
});

const newTokens = await response.json();

Dépannage

Erreur "Invalid redirect_uri"

Cause : L'redirect_uri dans votre requête ne correspond pas exactement à ce qui est configuré dans le Tableau de bord.

Solution :

Allez dans Tableau de bord → Clients OAuth → Votre App → Modifier les paramètres → URIs de redirection
Assurez-vous que l'URI correspond exactement (y compris http vs https, slashes finaux, etc.)

Erreur "Invalid code_verifier"

Cause : Le code_verifier ne correspond pas au code_challenge envoyé durant l'autorisation.

Solution :

Assurez-vous d'utiliser le même code_verifier que vous avez généré à l'Étape 1
Vérifiez que vous l'avez stocké en session et récupéré correctement

Erreur "Invalid or expired code"

Cause : Les codes d'autorisation expirent après 10 minutes et ne peuvent être utilisés qu'une seule fois.

Solution :

Complétez l'échange de token immédiatement après avoir reçu le callback
Ne rafraîchissez pas la page de callback (cela essaie d'utiliser le code à nouveau)

Exemple Complet

Exemple Complet Python Flask

from flask import Flask, redirect, request, session
import requests
import secrets
import hashlib
import base64
from urllib.parse import urlencode

app = Flask(__name__)
# IMPORTANT : En production, utilisez une variable d'environnement aléatoire sécurisée
app.secret_key = 'your-secret-key'

# Configuration - obtenez ceux-ci depuis votre Tableau de bord SyAuth
CLIENT_ID = 'your-client-id'
REDIRECT_URI = 'http://localhost:5000/callback'

@app.route('/login')
def login():
    # Étape 1 : Générer PKCE
    code_verifier = base64.urlsafe_b64encode(secrets.token_bytes(32)).decode().rstrip('=')
    code_challenge = base64.urlsafe_b64encode(
        hashlib.sha256(code_verifier.encode()).digest()
    ).decode().rstrip('=')
    
    # Stocker le verifier pour plus tard
    session['pkce_verifier'] = code_verifier
    
    # Générer l'état
    state = secrets.token_urlsafe(32)
    session['oauth_state'] = state
    
    # Étape 2 : Rediriger vers SyAuth
    params = {
        'response_type': 'code',
        'client_id': CLIENT_ID,
        'redirect_uri': REDIRECT_URI,
        'scope': 'openid profile email',
        'state': state,
        'code_challenge': code_challenge,
        'code_challenge_method': 'S256'
    }
    
    return redirect(f"https://api.syauth.com/e/v1/oauth/authorize?{urlencode(params)}")

@app.route('/callback')
def callback():
    # Vérifier l'état
    if request.args.get('state') != session.get('oauth_state'):
        return "Invalid state!", 400
    
    # Étape 3 : Échanger le code contre des tokens
    response = requests.post('https://api.syauth.com/e/v1/oauth/token', data={
        'grant_type': 'authorization_code',
        'code': request.args.get('code'),
        'client_id': CLIENT_ID,
        'redirect_uri': REDIRECT_URI,
        'code_verifier': session.get('pkce_verifier')
    })
    
    tokens = response.json()
    session['access_token'] = tokens['access_token']
    
    return redirect('/profile')

@app.route('/profile')
def profile():
    # Étape 4 : Utiliser le token d'accès
    response = requests.get(
        'https://api.syauth.com/e/v1/user/profile',
        headers={'Authorization': f"Bearer {session.get('access_token')}"}
    )
    
    user = response.json()
    return f"Hello, {user['first_name']}!"

if __name__ == '__main__':
    app.run(port=5000)

Prochaines Étapes

Créez Votre Première Application — Configurez votre client OAuth
Guide d'Intégration Complet — Exemples plus détaillés et cas limites
Référence API — Documentation API complète
Bonnes Pratiques de Sécurité — Sécurisez votre intégration

Avant de commencer​

Comment Fonctionne l'Authentification OAuth​

Étape 1 : Générer les Codes PKCE​

Étape 2 : Rediriger l'Utilisateur vers la Connexion​

Référence des Paramètres​

Exemple : Construire l'URL​

Étape 3 : Échanger le Code contre des Tokens​

Réponse Token​

Étape 4 : Appeler les APIs avec le Token d'Accès​

Exemple de Réponse​

Étape 5 : Rafraîchir les Tokens Expirés​

Dépannage​

Erreur "Invalid redirect_uri"​

Erreur "Invalid code_verifier"​

Erreur "Invalid or expired code"​

Exemple Complet​

Prochaines Étapes​

Avant de commencer

Comment Fonctionne l'Authentification OAuth

Étape 1 : Générer les Codes PKCE

Étape 2 : Rediriger l'Utilisateur vers la Connexion

Référence des Paramètres

Exemple : Construire l'URL

Étape 3 : Échanger le Code contre des Tokens

Réponse Token

Étape 4 : Appeler les APIs avec le Token d'Accès

Exemple de Réponse

Étape 5 : Rafraîchir les Tokens Expirés

Dépannage

Erreur "Invalid redirect_uri"

Erreur "Invalid code_verifier"

Erreur "Invalid or expired code"

Exemple Complet

Prochaines Étapes