SDK PHP (auris/sdk)

auris/sdk est le SDK PHP officiel d’Auris IAM. Il est entièrement autonome — aucune dépendance externe requise — et supporte PHP 7.4+.

Le SDK implémente le flux OAuth2 Authorization Code avec PKCE. Il gère automatiquement la génération du code verifier et du challenge, la vérification de l’état, l’échange de tokens et le rafraîchissement des tokens.

Prérequis

PHP 7.4+
Extensions : curl, openssl, session

Installation


composer require auris/sdk

AurisConfig

Toutes les options de configuration du client.


<?php
use Auris\AurisConfig;
 
$config = new AurisConfig([
    'domain'        => 'auth.votredomaine.com', // Obligatoire
    'clientId'      => 'app_xxxxx',             // Obligatoire
    'redirectUri'   => 'https://votresite.com/callback', // Obligatoire
    'clientSecret'  => 'cs_live_xxxxx',         // Optionnel — requis pour les applications web confidentielles
    'scope'         => 'openid profile email',  // Optionnel — défaut : 'openid profile email'
    'tenant'        => 'my-tenant',             // Optionnel — défaut : 'default'
    'tokenStore'    => new SessionTokenStore(), // Optionnel — voir section Stockage
]);

Options :

Option	Type	Obligatoire	Défaut	Description
`domain`	`string`	Oui	—	Le domaine du tenant Auris, sans `https://`
`clientId`	`string`	Oui	—	Client ID de l’application depuis la Console
`redirectUri`	`string`	Oui	—	URL de callback enregistrée dans la Console
`clientSecret`	`string`	Non	—	Client secret — requis pour les apps confidentielles
`scope`	`string`	Non	`'openid profile email'`	Scopes OAuth2 séparés par des espaces
`tenant`	`string`	Non	`'default'`	Identifiant tenant envoyé comme en-tête HTTP `x-tenant`
`tokenStore`	`TokenStore`	Non	`SessionTokenStore`	Implémentation de stockage des tokens

AurisClient

Le point d’entrée principal du SDK.


<?php
use Auris\AurisClient;
use Auris\AurisConfig;
 
$client = new AurisClient(new AurisConfig([
    'domain'      => $_ENV['AURIS_DOMAIN'],
    'clientId'    => $_ENV['AURIS_CLIENT_ID'],
    'redirectUri' => $_ENV['AURIS_REDIRECT_URI'],
    'tenant'      => $_ENV['AURIS_TENANT'],
]));

`getLoginUrl(options?)`

Génère l’URL de connexion OAuth2 avec un code PKCE verifier et un état aléatoire sécurisé. Mémorise le verifier et l’état dans la session.

Signature :


public function getLoginUrl(array $options = []): string

Options :

Option	Type	Description
`login_hint`	`string`	Pré-remplit le champ email
`screen_hint`	`'signup'`	Ouvre l’écran d’inscription au lieu de la connexion
`prompt`	`'login' \| 'none'`	Force la ré-authentification ou exige une session silencieuse
`locale`	`string`	Définit la langue de la page hébergée
`connection`	`string`	Force un alias de connexion SSO spécifique


<?php
$loginUrl = $client->getLoginUrl([
    'login_hint' => '[email protected]',
    'screen_hint' => 'signup',
]);
header('Location: ' . $loginUrl);
exit;

`handleCallback(code, state)`

Complète le flux OAuth2 en validant l’état, échangeant le code d’autorisation contre des tokens et stockant le résultat.

Signature :


public function handleCallback(string $code, string $state): TokenResult

Lève : AurisException si l’état ne correspond pas ou si l’échange de token échoue.


<?php
try {
    $result = $client->handleCallback(
        $_GET['code'],
        $_GET['state']
    );
    header('Location: /dashboard');
    exit;
} catch (\Auris\AurisException $e) {
    echo 'Erreur de connexion : ' . $e->getMessage();
}

`isAuthenticated()`

Retourne true si un token d’accès valide (non expiré) est présent dans le store.

Signature :


public function isAuthenticated(): bool


<?php
if (!$client->isAuthenticated()) {
    header('Location: /login');
    exit;
}

`getUser()`

Retourne les informations de l’utilisateur courant décodées depuis le token ID mémorisé.

Signature :


public function getUser(): ?AurisUser


<?php
$user = $client->getUser();
if ($user) {
    echo 'Bonjour, ' . $user->firstName;
    echo 'Rôles : ' . implode(', ', $user->roles);
}

`getAccessToken()`

Retourne le token d’accès courant. Rafraîchit automatiquement si le token est expiré et qu’un refresh token est disponible.

Signature :


public function getAccessToken(): ?string


<?php
$token = $client->getAccessToken();
// Utiliser le token dans les requêtes API
$ch = curl_init('https://api.votresite.com/data');
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer $token"]);

`refreshToken()`

Échange manuellement le refresh token pour une nouvelle paire de tokens.

Signature :


public function refreshToken(): TokenResult


<?php
try {
    $result = $client->refreshToken();
    echo 'Token rafraîchi. Expire dans : ' . $result->expiresIn . ' secondes';
} catch (\Auris\AurisException $e) {
    // Refresh token expiré ou révoqué — forcer la reconnexion
    header('Location: /login');
    exit;
}

`logout(returnTo?)`

Révoque le refresh token, supprime les tokens mémorisés et redirige optionnellement l’utilisateur.

Signature :


public function logout(?string $returnTo = null): void


<?php
$client->logout('https://votresite.com');
// La redirection est effectuée automatiquement

Classes de Données

`TokenResult`

Retourné par handleCallback() et refreshToken().


interface TokenResult {
    public string $accessToken;
    public ?string $refreshToken;
    public int $expiresIn;     // secondes avant expiration du token d'accès
    public string $tokenType;  // 'Bearer'
    public ?string $idToken;
    public function getUser(): AurisUser;
}

`AurisUser`

Représente un utilisateur authentifié.


interface AurisUser {
    public string $id;
    public string $sub;
    public string $email;
    public bool $emailVerified;
    public string $name;
    public string $firstName;
    public string $lastName;
    public string $username;
    public ?string $picture;
    public array $roles;      // string[]
    public array $metadata;   // array<string, mixed>
    public string $tenant;
    public string $createdAt; // datetime ISO 8601
}

Stockage des Tokens

Par défaut, le SDK utilise SessionTokenStore qui persiste les tokens dans $_SESSION. Tu peux fournir ta propre implémentation en respectant l’interface TokenStore.


interface TokenStore {
    public function get(string $key): ?string;
    public function set(string $key, string $value): void;
    public function remove(string $key): void;
}

Exemple — Stockage Redis :


<?php
use Auris\TokenStore;
 
class RedisTokenStore implements TokenStore
{
    public function __construct(private \Redis $redis, private string $prefix = 'auris:') {}
 
    public function get(string $key): ?string
    {
        $value = $this->redis->get($this->prefix . $key);
        return $value !== false ? $value : null;
    }
 
    public function set(string $key, string $value): void
    {
        $this->redis->setex($this->prefix . $key, 86400, $value); // 24 heures
    }
 
    public function remove(string $key): void
    {
        $this->redis->del($this->prefix . $key);
    }
}
 
$config = new AurisConfig([
    'domain'     => $_ENV['AURIS_DOMAIN'],
    'clientId'   => $_ENV['AURIS_CLIENT_ID'],
    'redirectUri' => $_ENV['AURIS_REDIRECT_URI'],
    'tokenStore' => new RedisTokenStore($redis),
]);

Gestion des Erreurs

Toutes les méthodes lèvent AurisException en cas d’erreur.


<?php
use Auris\AurisException;
 
try {
    $result = $client->handleCallback($_GET['code'], $_GET['state']);
} catch (AurisException $e) {
    echo $e->getCode();       // ex. 'invalid_state', 'invalid_grant', 'network_error'
    echo $e->getMessage();    // Message lisible
    echo $e->getHttpStatus(); // Code de statut HTTP (ex. 400, 401, 500)
}

Codes d’erreur courants :

Code	Description
`invalid_state`	Le paramètre state ne correspond pas — possible attaque CSRF
`invalid_grant`	Code d’autorisation expiré, déjà utilisé ou invalide
`invalid_client`	Client ID ou secret incorrect
`network_error`	Impossible de joindre le serveur d’autorisation Auris
`token_expired`	Le token d’accès est expiré et aucun refresh token n’est disponible
`no_refresh_token`	`refreshToken()` appelé mais aucun refresh token n’est mémorisé

Exemple PHP Vanilla (4 Fichiers)

Exemple complet d’une application PHP simple sans framework.


<?php
// login.php
session_start();
require 'vendor/autoload.php';
 
use Auris\AurisClient;
use Auris\AurisConfig;
 
$client = new AurisClient(new AurisConfig([
    'domain'      => $_ENV['AURIS_DOMAIN'],
    'clientId'    => $_ENV['AURIS_CLIENT_ID'],
    'redirectUri' => $_ENV['AURIS_REDIRECT_URI'],
    'tenant'      => $_ENV['AURIS_TENANT'],
]));
 
$loginUrl = $client->getLoginUrl();
header('Location: ' . $loginUrl);
exit;


<?php
// callback.php
session_start();
require 'vendor/autoload.php';
 
use Auris\AurisClient;
use Auris\AurisConfig;
use Auris\AurisException;
 
$client = new AurisClient(new AurisConfig([
    'domain'      => $_ENV['AURIS_DOMAIN'],
    'clientId'    => $_ENV['AURIS_CLIENT_ID'],
    'redirectUri' => $_ENV['AURIS_REDIRECT_URI'],
    'tenant'      => $_ENV['AURIS_TENANT'],
]));
 
try {
    $client->handleCallback($_GET['code'] ?? '', $_GET['state'] ?? '');
    header('Location: /dashboard.php');
    exit;
} catch (AurisException $e) {
    http_response_code(400);
    echo 'Erreur de connexion : ' . htmlspecialchars($e->getMessage());
}


<?php
// dashboard.php
session_start();
require 'vendor/autoload.php';
 
use Auris\AurisClient;
use Auris\AurisConfig;
 
$client = new AurisClient(new AurisConfig([
    'domain'      => $_ENV['AURIS_DOMAIN'],
    'clientId'    => $_ENV['AURIS_CLIENT_ID'],
    'redirectUri' => $_ENV['AURIS_REDIRECT_URI'],
]));
 
if (!$client->isAuthenticated()) {
    header('Location: /login.php');
    exit;
}
 
$user = $client->getUser();
?>
<!DOCTYPE html>
<html lang="fr">
<body>
  <h1>Bonjour, <?= htmlspecialchars($user->firstName) ?> !</h1>
  <p>Email : <?= htmlspecialchars($user->email) ?></p>
  <p>Rôles : <?= htmlspecialchars(implode(', ', $user->roles)) ?></p>
  <a href="/logout.php">Déconnexion</a>
</body>
</html>


<?php
// logout.php
session_start();
require 'vendor/autoload.php';
 
use Auris\AurisClient;
use Auris\AurisConfig;
 
$client = new AurisClient(new AurisConfig([
    'domain'      => $_ENV['AURIS_DOMAIN'],
    'clientId'    => $_ENV['AURIS_CLIENT_ID'],
    'redirectUri' => $_ENV['AURIS_REDIRECT_URI'],
]));
 
$client->logout('https://votresite.com');

Intégration Laravel

Pour les applications Laravel, le SDK fournit un ServiceProvider et un middleware prêts à l’emploi.

1. Enregistrer le ServiceProvider


// config/app.php
'providers' => [
    // ...
    Auris\Laravel\AurisServiceProvider::class,
],

2. Publier la configuration


php artisan vendor:publish --provider="Auris\Laravel\AurisServiceProvider"

Cela crée config/auris.php :


// config/auris.php
return [
    'domain'       => env('AURIS_DOMAIN'),
    'client_id'    => env('AURIS_CLIENT_ID'),
    'client_secret' => env('AURIS_CLIENT_SECRET'),
    'redirect_uri'  => env('AURIS_REDIRECT_URI'),
    'tenant'        => env('AURIS_TENANT', 'default'),
    'scope'         => env('AURIS_SCOPE', 'openid profile email'),
];

3. Créer l’AuthController


<?php
namespace App\Http\Controllers;
 
use Illuminate\Http\Request;
use Auris\AurisClient;
 
class AuthController extends Controller
{
    public function __construct(private AurisClient $client) {}
 
    public function login()
    {
        return redirect($this->client->getLoginUrl());
    }
 
    public function callback(Request $request)
    {
        try {
            $this->client->handleCallback(
                $request->query('code'),
                $request->query('state')
            );
            return redirect('/dashboard');
        } catch (\Auris\AurisException $e) {
            return redirect('/login')->withErrors(['auth' => $e->getMessage()]);
        }
    }
 
    public function logout()
    {
        $this->client->logout(config('app.url'));
    }
}

4. Créer le middleware `RequireAurisAuth`


<?php
namespace App\Http\Middleware;
 
use Auris\AurisClient;
use Closure;
use Illuminate\Http\Request;
 
class RequireAurisAuth
{
    public function __construct(private AurisClient $client) {}
 
    public function handle(Request $request, Closure $next)
    {
        if (!$this->client->isAuthenticated()) {
            return redirect('/login');
        }
        return $next($request);
    }
}

5. Définir les routes


// routes/web.php
use App\Http\Controllers\AuthController;
use App\Http\Middleware\RequireAurisAuth;
 
Route::get('/login', [AuthController::class, 'login']);
Route::get('/auth/callback', [AuthController::class, 'callback']);
Route::get('/logout', [AuthController::class, 'logout']);
 
Route::middleware(RequireAurisAuth::class)->group(function () {
    Route::get('/dashboard', function () {
        $user = app(AurisClient::class)->getUser();
        return view('dashboard', ['user' => $user]);
    });
});

Corrélés

Plugin WordPress — SSO WordPress utilisant ce SDK PHP
Guide Connexion Hébergée — Procédure complète du flux PKCE
SDK JavaScript — SDK équivalent pour les environnements JavaScript

SDK PHP (auris/sdk)

Prérequis

Installation

AurisConfig

AurisClient

getLoginUrl(options?)

handleCallback(code, state)

isAuthenticated()

getUser()

getAccessToken()

refreshToken()

logout(returnTo?)

Classes de Données

TokenResult

AurisUser

Stockage des Tokens

Gestion des Erreurs

Exemple PHP Vanilla (4 Fichiers)

Intégration Laravel

1. Enregistrer le ServiceProvider

2. Publier la configuration

3. Créer l’AuthController

4. Créer le middleware RequireAurisAuth

5. Définir les routes

Corrélés

`getLoginUrl(options?)`

`handleCallback(code, state)`

`isAuthenticated()`

`getUser()`

`getAccessToken()`

`refreshToken()`

`logout(returnTo?)`

`TokenResult`

`AurisUser`

4. Créer le middleware `RequireAurisAuth`