API OpenFlyers: Difference between revisions

From Documentation de la solution web de gestion OpenFlyers
Jump to navigation Jump to search
imported>Gobin
m (Text replacement - "Fichier:" to "File:")
 
(133 intermediate revisions by 4 users not shown)
Line 1: Line 1:
=Présentation=
=Présentation=
L'objet de cette page est de décrire :
L'objet de cette page est de décrire l'API OpenFlyers.
*l'[[#Ancien-module-d'identification-checkIdent.php|ancien module de vérification d'un couple identifiant/mot de passe basé sur le script checkIdent.php]]
*Le [[#OAuth2|nouveau module d'identification]] basé sur le protocole OAuth2.
L'ancien module checkIdent.php est prévu être désactivé au 31/12/2021.


=<s>Ancien module d'identification checkIdent.php</s> (obsolète)=
;Description de l'API
'''Ce module d'identification est prévu être désactivé à compter du 01/03/2022.''' Il est remplacé par [[#Authorization-Code|Authorization Code]] de l'[[API-OpenFlyers#OAuth2|API OpenFlyers basée sur OAuth 2.0]].
OpenFlyers possède une API basée sur [[Wikipedia-en:OAuth#OAuth_2.0|OAuth2]] qui permet à des serveurs extérieurs, dûment [[#Enregistrer-un-client|enregistrés]], de mettre en œuvre un processus d'[[Wikipedia-fr:Authentification_unique|authentification unique (SSO)]] et/ou de récupération des résultats des requêtes SQL de la [[Bibliothèque-des-rapports|bibliothèque des rapports]] ou des rapports personnalisés sous la forme de fichiers CSV.


Ce chapitre explique comment vérifier qu'un couple identifiant/mot de passe envoyé, par vos propres scripts, est conforme à la base de données d'OpenFlyers.
OAuth2 propose plusieurs mécanismes pour permettre l'authentification. Un mécanisme d'authentification détermine la séquence exacte des étapes impliquées dans le processus d'authentification d'OAuth2. OpenFlyers met à disposition deux mécanismes d'authentification :
*[[#Authorization Code|Authorization Code]] basé sur la méthode d'authentification par code d'autorisation et qui correspond au mécanisme associé à l'[[Wikipedia-fr:Authentification_unique|authentification unique (SSO)]],
*[[#Client Credentials|Client Credentials]] basé sur la méthode d'authentification avec les identifiants clients et qui est utilisé dans un contexte d'automatisme sans autorisation de l'utilisateur au préalable.


Le script retourne une valeur indiquant si la connexion, avec des identifiants données, a réussi et son état. Un cookie OpenFlyers est aussi retourné, permettant de gérer une session utilisateur sur votre site, en utilisant le compte utilisateur OpenFlyers de l'utilisateur connecté.
Dans les chapitres qui suivent, le terme ''ressource'' fait référence à la définition OAuth2. Une ressource dans OAuth2 est un élément qui peut être :
*une ou des données comme des photos, des documents, des contacts ou des informations personnelles,
*un ou plusieurs services comme des transferts de fonds, la récupération de rapports ou l'ajout d'articles sur un blog,
*toute ressource nécessitant un accès restreint.


;Comment ça marche
OpenFlyers définit plusieurs [[#Utiliser-l'API|types de ressources]] :
Si votre plateforme OpenFlyers se situe sur le lien https://openflyers.com/nom-plateforme/, envoyez simplement une requête POST sur le lien https://openflyers.com/nom-plateforme/checkIdent.php avec comme paramètres les variables '''login''' et '''rawPassword'''.
*les [[#Récupérer-les-informations-de-l'utilisateur-connecté|informations de l'utilisateur connecté]],
*les [[#Récupérer les rapports génériques|rapports génériques]] ou [[#Récupérer les rapports personnalisés|personnalisés]] au format CSV.


'''Attention:''' Le mot de passe nécessite d'être chiffré en MD5 (cf. la ligne $postData dans le script PHP).
OAuth2 dispose de ''scopes''. Un scope est un privilège définit de manière explicite permettant l'accès à une ressource protégée. OpenFlyers met à disposition une [[#Liste des scopes disponibles|liste de scopes]] utilisables à travers l'API.


;Valeurs de retour possibles
Deux protocoles de sécurité sont présents dans l'API OpenFlyers :
Le script retourne un chiffre parmi les suivant :
*[[#Authentification-TLS-Mutuelle-(mTLS)|mTLS]] : il permet d'authentifier le client avec un certificat TLS, en plus d'authentifier le serveur avec un certificat. Ce protocole permet d'éviter les usurpations d'identité.
*0 : OK
*[[#HTTP-Signature|HTTP-Signature]] : il permet de signer les en-têtes et le corps (lorsqu'il y en a un) des messages échangés afin d'en garantir leur intégrité.
*1 : OK mais plusieurs profils disponibles. OpenFlyers sélectionne automatiquement le meilleur profil.
*2 : Expiré mais autorisé
*3 : Expiré mais autorisé, avec un profil expiré
*4 : Abonnement expiré, refusé
*5 : Mauvais identifiants, refusé
*6 : IP ou identifiants bloqués, refusé
*7 : Aucun identifiant donné, ils sont demandés
*8 : Authentification réussie mais avec des contrats non signés, bloquant tant qu'il reste des contrats à signer. Pour signer les contrats se connecter sur la plateforme OpenFlyers avec le compte bloqué puis signer les contrats à la connexion.
*9 : L'abonnement à la plateforme est périmé, le couple identifiant/mot de passe n'est pas vérifié, accès refusé


Nous vous recommandons de considérer un code de retour entre 0 et 2 comme bon et mauvais entre 3 et 8.
;Premiers pas - Client de démonstration
Un client de démonstration est disponible pour comprendre les mécanismes décrits ci-dessous.


'''Attention:''' Vous devez filtrer les identifiants de connexion libres (sans droits) puisque pour OpenFlyers, ils correspondent à des accès autorisés !!!
L'utilisation de ce client de démonstration est décrite dans la procédure [[#Utiliser-le-client|Utiliser le client]] de cette page.


;JavaScript
Le client de démonstration est lui-même accessible à cette adresse : https://openflyers.com/oauth2-demo/index.php
Si vous utilisez votre propre formulaire d'authentification, utilisez la fonction javascript submit_pwd() située dans \javascript\submitPwd.js .


;Exemple de code PHP
Le code source du client de démonstration est mis à disposition par OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/oauth2-demo-src.zip
Voici un exemple de code PHP permettant d'envoyer une requête POST :
<php>// PHP 5.6 is required
// OpenSSL 1.0.1 is required
function httpPostRequest($host, $path, $postData) {
    $result= "";
   
    $request = "POST $path HTTP/1.1\n".
    "Host: $host\n".
    (isset($referer) ? "Referer: $referer\n" : "").
    "Content-type: Application/x-www-form-urlencoded\n".
    "Content-length: ".strlen($postData)."\n".
    "Connection: close\n\n".
    $postData."\n";
   
    // Some debug informations:
    print("<pre>Request:\n".htmlentities($request)."</pre>");
   
    if ($fp = fsockopen($host, 443, $errno, $errstr, 3)) {
        // Set cryptology method
        // @link http://php.net/manual/en/function.stream-socket-enable-crypto.php
        if (!defined('STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT')) {
            die('STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT IS REQUIRED');
        }
        $cryptoMethod = STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT;
        // Activate encryption while authenticating
        stream_socket_enable_crypto($fp, true, $cryptoMethod);
        if (fputs($fp, $request)) {
            while(! feof($fp)) {
                $result.= fgets($fp, 128);
            }
            // Deactivate encryption once authenticating done
            stream_socket_enable_crypto($fp, false);
            fclose($fp);
            //print($result);
            return $result;
        }
    }
}


$postData  = 'login=jbond&rawPassword='.md5('007');
L'utilisation du code source est décrite dans la procédure [[#Créer-un-client-à-partir-du-code-source|Créer un client à partir du code source]].
$rawContent = httpPostRequest('openflyers.com','https://openflyers.com/plateform-name/checkIdent.php',$postData);


list($header, $content) = explode("\r\n\r\n", $rawContent, 2);
=Définitions=
list($byteQty, $realContent, $dummy) = explode("\r\n", $content, 3);
==Authentification TLS Mutuelle (mTLS)==
En général dans une communication TLS, seul le serveur a l'obligation de fournir un certificat. Il est également possible pour le client de fournir un certificat. Ce principe s'appelle l'authentification mutuelle et est mise en place avec Mutual TLS (ou [[Wikipedia-en:Mutual_authentication#mTLS|mTLS]]).


// the answer is in $realContent</php>
OpenFlyers associe un certificat pour l'authentification mutuelle unique à chaque client OAuth2.


==Plugin d'authentification Joomla==
;Envoyer un certificat client
Si vous avez un site Joomla et que vous désirer de permettre aux utilisateurs OpenFlyers de se connecter à votre espace restreint Joomla, vous devriez ajouter ce plugin de manière à avoir une unique base de données de comptes utilisateurs : celle d'OpenFlyers.
Côté client, le code suivant peut être utilisé pour fournir à cURL le certificat et la clé correspondante ainsi que le certificat du CA d'OpenFlyers à utiliser pour la connexion :
<php>curl_setopt_array($request, [
    CURLOPT_SSLVERSION => CURL_SSLVERSION_TLSv1_2,
    CURLOPT_CAINFO    => $caCertificatePath,
    CURLOPT_SSLCERT    => $certificatePath,
    CURLOPT_SSLKEY    => $keyPath
]);</php>


Vous n'avez pas besoin de mettre à jour votre base de données Joomla, ce plugin interroge directement OpenFlyers grâce au script PHP CheckIdent.php.
'''À noter''' : le certificat du CA d'OpenFlyers est nécessaire pour assurer la validité des certificats utilisés.


*[[Media:Joomla_authentication_plugin.zip|Joomla plugin for OpenFlyers]]
==HTTP Signature==
HTTP Signature utilise le principe de la signature numérique pour garantir l'authenticité et l'intégrité du message HTTP.


=OAuth2=
La signature est générée à l'aide d'une clé privée et vérifiée à l'aide de la clé publique correspondante ou d'un certificat contenant cette clé publique.
OpenFlyers possède une API basée sur [[Wikipedia-en:OAuth#OAuth_2.0|OAuth2]] qui permet à des serveurs extérieurs de mettre en oeuvre un processus d'[[Wikipedia-fr:Authentification_unique|authentification unique (SSO)]] et/ou de récupération des résultats des requêtes SQL de la [[Bibliothèque-des-rapports|bibliothèque des rapports]] sous la forme de fichiers CSV.


OAuth2 propose plusieurs mécanismes pour permettre l'authentification. Un mécanisme d'authentification détermine la séquence exacte des étapes impliquées dans le processus d'authentification d'OAuth2. OpenFlyers met à disposition deux mécanismes d'authentification :
HTTP Signature utilise deux en-têtes HTTP :
* [[#Authorization Code|Authorization Code]] basé sur la méthode d'authentification par code d'autorisation et qui correspond au mécanisme associé à l'[[Wikipedia-fr:Authentification_unique|authentification unique (SSO)]],
*Signature : contient la signature et ses métadonnées.
* [[#Client Credentials|Client Credentials]] basé sur la méthode d'authentification avec les identifiants clients et qui est utilisé dans un contexte d'automatisme sans autorisation de l'utilisateur au préalable.
*Digest : contient le corps du message haché.


Dans les chapitres qui suivent, le terme ''ressource'' fait référence à la définition OAuth2. Une ressource dans OAuth2 est un élément qui peut être :
===Digest===
* une ou des données comme des photos, des documents, des contacts ou des informations personnelles,
Le ''digest'' est calculé comme ceci : <code>digest = base64encode(sha256(corps du message))</code>
* un ou plusieurs services comme des transferts de fonds, la récupération de rapports ou l'ajout d'articles sur un blog,
* toute ressource nécessitant un accès restreint.


OpenFlyers définit plusieurs [[#Utiliser-l'API|types de ressources]] :
Et l'en-tête est structuré de la manière suivante : <code>Digest: SHA-256=<digest></code>
* les [[#Récupérer-les-informations-de-l'utilisateur-connecté|informations de l'utilisateur connecté]],
* les [[#Récupérer les rapports génériques|rapports génériques]] ou [[#Récupérer les rapports personnalisés|personnalisés]] au format CSV.


OAuth2 dispose de ''scopes''. Un scope est un privilège définit de manière explicite permettant l'accès à une ressource protégée. OpenFlyers met à disposition une [[#Liste des scopes disponibles|liste de scopes]] utilisables à travers l'API.
Un autre algorithme de hachage peut être utilisé, SHA-256 reste cependant le plus répendu.


==Préparation==
;Exemple en php
===Enregistrer un client===
<php>$digestHeader = 'Digest: SHA-256=' . base64_encode(hash('sha256', $postData, true));</php>
Pour utiliser l'API OAuth2, il faut enregistrer un client OAuth2 auprès d'OpenFlyers. Pour ceci, suivre les étapes suivantes :


;Pour le mécanisme d'authentification Client Credentials
===Signature===
*Créer un [[Gestion-des-profils#Ajouter-un-profil|nouveau profil]]. Ce profil permet de gérer les droits du client OAuth2.
L'en-tête HTTP de signature est structuré de la manière suivante : <code>Signature: keyId="<keyId>",algorithm="<algo>",headers="<signed_headers>",signature="<signature>"</code>
**''Choisir un nom explicite, par exemple "Client OAuth rapports".''


*Sélectionner les droits à assigner à ce profil. Ces droits limitent les données auxquelles le client OAuth2 a accès.
Le champ ''keyId'' correspond à un identifiant permettant l'identification de la clé utilisée pour vérifier la signature. Pour l'API d'OpenFlyers, sa valeur correspond à l'empreinte SHA-1 du certificat au format PEM à utiliser pour vérifier la signature.
**Sélectionner les droits relatifs à l'enregistrement de clients OAuth2 dans '''Généralités admin''' (colonne '''Associé aux clients OAuth2''').
**Sélectionner les rapports accessibles par le profil précédemment créé.


*Créer un nouvel utilisateur à partir du panneau de gestion. Cet utilisateur est virtuel et représente le serveur sur lequel fonctionne le client OAuth2.
L'algorithme ''algo'' correspond à celui utilisé pour générer la signature, exemple : <code>rsa-sha256</code>.
**''Des identifiant et nom explicites sont recommandés (exemple : "serv1_oauth_client")''
**'''Attention''' : tout utilisateur désactivé et associé à un client OAuth2 rend le client inactif, il faut donc changer l'utilisateur associé au client pour réactiver le client.


;Pour le mécanisme d'authentification Authorization Code
La valeur de ''signed_headers'' correspond à la liste des en-têtes inclus dans la signature séparés d'un espace. Exemple : <code>date digest (request-target)</code>
*Se rendre dans le menu '''Profil''' depuis le panneau d'administration.
*Dans l'onglet '''Généralités''', cocher la case relative à la colonne '''Connexion depuis l'extérieur (OAuth2)''' pour le profil souhaité.


Une fois les opérations précédentes exécutées,
Pour générer la signature, une chaîne de caractères appelée <code>signing string</code> contenant les en-têtes au format <code>lowercase_header_name: value</code> séparés par une nouvelle ligne au format LF (<code>\n</code>) est d'abord générée. Exemple avec les en-têtes "date" et "(request-target)" :
*Créer un nouveau client OAuth2 à partir du menu '''Imports''' dans le panneau d'administration.
**Choisir un nom pour le client.
**Sélectionner le mécanisme d'autorisation utilisé par le client :
***Pour utiliser OAuth2 comme solution SSO ou accéder à des données utilisateurs, choisir ''Authorization Code''. Cette méthode peut être couplée avec le mécanisme de mémorisation de connexion (''Refresh Token'').
***Pour utiliser OAuth2 dans un contexte d'automatisme, choisir ''Client Credentials''.
**Saisir l'URI de redirection vers le client pour le mécanisme ''Authorization Code''.
**Sélectionner l'utilisateur virtuel créé précédemment pour le mécanisme ''Client Credentials''.
**[[#Génération-des-certificats|Générer deux CSR]] afin d'obtenir deux certificats signés et les saisir :
***Le premier est utilisé pour l'authentification mutuelle avec mTLS.
***Le second est utilisé pour la signature des en-têtes HTTP.
;Un couple ID/passphrase est généré. La passphrase n'est communiquée qu'une seule fois. Elle doit être sauvegardée en lieu sûr et rester confidentielle.


'''À noter''' : les certificats du CA d'OpenFlyers et de signature HTTP du serveur sont nécessaires. Ils sont téléchargeables depuis l'interface de configuration des clients OAuth2.
<pre>(request-target): post /some/uri\ndate: Tue, 07 Jun 2014 20:51:35 GMT</pre>


Dans certains cas d'utilisation, il peut être nécessaire d'ajouter le certificat du CA d'OpenFlyers au Trust Store du système. Si cette étape n'est pas réalisée, les certificats peuvent être considérés comme invalides et peuvent ne pas être utilisables. Pour ajouter le certificat CA au Trust Store du système,
La signature est ensuite générée comme ceci : <code>base64encode(algo(signing string))</code>


* Sous Linux, copier le certificat CA d'OpenFlyers dans le dossier <code>/usr/local/share/ca-certificates</code> et exécuter la commande <code>sudo update-ca-certificates</code>
;Exemple en php
* Sous Windows,
<php>function generateSignatureHeader(array $headersToSign, string $certificateFingerprint, string $privateKey): string
** Double-cliquer sur le certificat CA d'OpenFlyers téléchargé depuis l'interface d'enregistrement des clients OAuth2
{
** Cliquer sur '''Installer un certificat...'''
    // generating the signing string and header list
** Choisir l'emplacement de stockage (utilisateur ou ordinateur) et cliquer sur '''Suivant''' puis '''Suivant''' et enfin '''Terminer'''
    $headers        = '';
    $signatureString = '';
    foreach ($headersToSign as $key => $value) {
        $normalizedHeaderKey = trim(strtolower($key));
        $headers            .= $normalizedHeaderKey . ' ';
        $signatureString    .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
    }


===Générer des certificats===
    // trim extra whitespace
L'API OAuth2 implémente [https://tools.ietf.org/html/draft-cavage-http-signatures-10 HTTP Signature] et l'[[Wikipedia-en:Mutual_authentication#mTLS|authentification TLS mutuelle]]. Ces mécanismes utilisent chacun une paire certificat/clé privée différente.
    $headers        = trim($headers);
    $signatureString = trim($signatureString);


Pour obtenir ces certificats, il faut d'abord générer des Certificate Signing Request (CSR).
    // signing the signing string
    $signature = '';
    openssl_sign($signatureString, $signature, $privateKey, 'RSA-SHA256');
    $signature = base64_encode($signature);


La procédure est la suivante :
    // compiling the header line
*Se connecter au serveur qui devra utiliser l'API.
    return "Signature: keyId=\"$certificateFingerprint\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";
*Naviguer dans le répertoire dans lequel les fichiers doivent être créés.
}</php>
*Utiliser les deux fichiers de configuration ''sign_cert.conf'' et ''auth_cert.conf'' ci-dessous et les remplir.
Les variables ''$certificateFingerprint'' et ''$privateKey'' correspondent respectivement à une empreinte SHA-1 de certificat et à une clé privée, tous deux au format PEM.  


;Fichier de configuration OpenSSL - sign_cert.conf
La variable ''$headersToSign'' est un tableau formaté de la manière suivante :
<pre>[req]
<php>[
default_bits      = 4096                    # taille par défaut des nouvelles clés, peut être surchargé dans la commande
    $headerName => $headerValue,
encrypt_key        = no                      # chiffrer la clé générée
    ...
distinguished_name = req_distinguished_name  # pointe vers la catégorie spécifiée pour le Distinguished Name
]</php>
x509_extensions    = v3_req                  # pointe vers la catégorie spécifiée pour les extensions x509
 
prompt            = no
'''À noter''' : les en-têtes sont à signer côté client avec le certificat de signature signé par le CA d'OpenFlyers et dédié au client ainsi que la clé privée associée. Le certificat de signature dédié au client est téléchargeable depuis l'interface de gestion des clients OAuth2. Les en-têtes de la réponse du serveur quant à elles doivent être vérifiées avec le certificat de signature HTTP du serveur, téléchargeable aussi depuis l'interface de configuration des clients OAuth2.


[req_distinguished_name]
=Client OAuth2=
C                  =                         # code à deux chiffres du pays (ex: FR)
Une fois le client OAuth2 configuré sur OpenFlyers, il faut l'utiliser avec un client créé au préalable pour communiquer avec le serveur d'autorisation et l'API.
ST                =                         # région/état (ex: Gironde)
L                  =                          # ville (ex: Bordeaux)
O                  =                          # organisation (ex: OpenFlyers)
OU                =                          # unité organisationelle (ex: IT)
CN                =                          # nom de domaine (ex: openflyers.com)


[v3_req]
Plusieurs [https://oauth.net/code/ bibliothèques] simplifiant la création d'un client sont disponibles.
keyUsage          = digitalSignature        # pour quelles opérations la clé peut-elle être utilisée</pre>


;Fichier de configuration OpenSSL - auth_cert.conf
Des scripts client basiques écrits en php sont aussi fournis pour les mécanismes [[#Script-client-:-authorization-code|''authorization_code'']] et [[#Script-client-:-client-credentials|''client_credentials'']]
<pre>[req]
default_bits      = 4096                    # taille par défaut des nouvelles clés, peut être surchargé dans la commande
encrypt_key        = no                      # chiffrer la clé générée
distinguished_name = req_distinguished_name  # pointe vers la catégorie spécifiée pour le Distinguished Name
x509_extensions    = v3_req                  # pointe vers la catégorie spécifiée pour les extensions x509
prompt            = no


[req_distinguished_name]
==Authorization Code==
C                  =                          # code à deux chiffres du pays (ex: FR)
Ce flux OAuth2 se déroule en plusieurs étapes :
ST                =                          # région/état (ex: Gironde)
*Le client redirige le navigateur de l'utilisateur vers l'URL d'autorisation.
L                  =                          # ville (ex: Bordeaux)
*Le navigateur de l'utilisateur est redirigé vers l'URL fourni durant la demande ou durant l'enregistrement du client.
O                  =                          # organisation (ex: OpenFlyers)
*Le client récupère un code d'autorisation grâce à la redirection précédente, et échange ce code contre un jeton d'accès auprès du serveur d'autorisation.
OU                =                          # unité organisationelle (ex: IT)
*Le client peut utiliser ce code d'accès :
CN                =                          # nom de domaine (ex: openflyers.com)
**Comme preuve d'authentification pour une solution SSO (Single Sign-On).
**Pour accéder à des données sur le serveur distant en utilisant l'API.


[v3_req]
extendedKeyUsage  = clientAuth              # pour quelles opérations la clé peut-elle être utilisée</pre>


    +-----------+                  +------+                +-----------+                  +-------------+                  +-----------+
    |Utilisateur|                  |Client|                |Navigateur |                  |  Serveur  |                  |  Serveur  |
    +-----+-----+                  +--+---+                +-----+-----+                  |Autorisation |                  | Ressources|
          |                            |                          |                        +------+------+                  +-----+-----+
          |                            |                          |                              |                              |
          |                            |                  Demande|d'autorisation                |                              |
          |                            +------------------------->+------------------------------>|                              |
          |                            |                          |                              |                              |
          |                            |Authentification + Formulaire d'autorisation              |                              |
          |<---------------------------+--------------------------+<------------------------------+                              |
          |                            |                          |                              |                              |
          |                            |      Autorisation        |                              |                              |
          +----------------------------+------------------------->+------------------------------>|                              |
          |                            |                          |                              |                              |
          |                            |                      Code|d'autorisation                |                              |
          |                            |<-------------------------+<------------------------------+                              |
          |                            |                          |                              |                              |
          |                            |                Demande de|token                          |                              |
          |                            +--------------------------+------------------------------>|                              |
          |                            |                          |                              |                              |
          |                            |                Access (+|Refresh) token                |                              |
          |                            |<-------------------------+-------------------------------+                              |
          |                            |                          |                              |                              |
          |                            |                          |      Requête vers API        |                              |
          |                            +--------------------------+-------------------------------+------------------------------>|
          |                            |                          |                              |                              |
          |                            |                          |                              |                              |
          |                            |                          |                              |<------------------------------+
          |                            |                          |                              |  Vérification d'autorisation  |
          |                            |                          |                              +------------------------------>|
          |                            |                          |                              |                              |
          |                            |                          |      Données/Réponse          |                              |
          |                            |<-------------------------+-------------------------------+-------------------------------+
          |                            |                          |                              |                              |


Exécuter les commandes suivantes :
*<bash>openssl req -sha256 -newkey rsa -keyout sign.key -out sign_cert.csr.pem -outform PEM -config sign_cert.conf</bash>
*<bash>openssl req -sha256 -newkey rsa -keyout auth.key -out auth_cert.csr.pem -outform PEM -config auth_cert.conf</bash>
Ces commandes prennent chacune en entrée le fichier de configuration et génèrent une clé privée et un Certificate Signing Request.
Une fois ces CSR obtenus :
*Les renseigner dans les champs prévus à cet effet lors de la [[#Enregistrement-du-client|création d'un client]] et télécharger les certificats signés depuis l'interface une fois le client créé.
*Garder la clé privée confidentielle. Une fuite poserait un risque de sécurité. Elle va de paire avec le certificat distribué par l'autorité de certification OpenFlyers.
==Authentification TLS Mutuelle (mTLS)==
En général dans une communication TLS, seul le serveur a l'obligation de fournir un certificat. Il est également possible pour le client de fournir un certificat. Ce principe s'appelle l'authentification mutuelle et est mise en place avec Mutual TLS (ou [[Wikipedia-en:Mutual_authentication#mTLS|mTLS]]).
OpenFlyers associe un certificat pour l'authentification mutuelle unique à chaque client OAuth2.
;Envoyer un certificat client
Côté client, le code suivant peut être utilisé pour fournir à cURL le certificat et la clé correspondante ainsi que le certificat du CA d'OpenFlyers à utiliser pour la connexion :
<php>curl_setopt_array($request, [
    CURLOPT_SSLVERSION => CURL_SSLVERSION_TLSv1_2,
    CURLOPT_CAINFO    => $caCertificatePath,
    CURLOPT_SSLCERT    => $certificatePath,
    CURLOPT_SSLKEY    => $keyPath
]);</php>
'''À noter''' : le certificat du CA d'OpenFlyers est nécessaire pour assurer la validité des certificats utilisés.


==HTTP Signature==


HTTP Signature utilise le principe de la signature numérique pour garantir l'authenticité et l'intégrité du message HTTP.
===Générer les codes pour PKCE===
Pour faire fonctionner le client OAuth2, il faut générer deux codes pour l'extension PKCE :
*Un ''code_verifier'' échangé pendant la demande de jeton d'accès.
*Un ''code_challenge'' dérivé du ''code_verifier'' et échangé pendant la demande d'autorisation.


La signature est générée à l'aide d'une clé privée et vérifiée à l'aide de la clé publique correspondante ou d'un certificat contenant cette clé publique.
;Générer le ''code_verifier''
<php>function generateCodeVerifier($length = 128): string
{
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~';
    $outputCode = '';


HTTP Signature utilise deux en-têtes HTTP :
    for ($i = 0; $i < $length; $i++) {
*Signature : contient la signature et ses métadonnées.
        $index      = random_int(0, strlen($characters) - 1);
*Digest : contient le corps du message haché.
        $outputCode .= $characters[$index];
    }


===Digest===
    return $outputCode;
Le ''digest'' est calculé comme ceci : <code>digest = base64encode(sha256(corps du message))</code>
}</php>


Et l'en-tête est structuré de la manière suivante : <code>Digest: SHA-256=<digest></code>
Cette fonction permet de générer un ''code_verifier'' avec une longueur donnée. Le ''code_verifier'' doit avoir une longueur entre 43 et 128 caractères.


Un autre algorithme de hachage peut être utilisé, SHA-256 reste cependant le plus répendu.
;Générer le ''code_challenge''
 
<php>function computeCodeChallenge(string $codeVerifier): string
;Exemple en php
{
<php>$digestHeader = 'Digest: SHA-256=' . base64_encode(hash('sha256', $postData, true));</php>
    return strtr(rtrim(base64_encode(hash('sha256', $codeVerifier, true)), '='), '+/', '-_');
}</php>


===Signature===
Cette fonction génère le ''code_challenge'' à partir du ''code_verifier'' fourni.
L'en-tête HTTP de signature est structuré de la manière suivante : <code>Signature: keyId="<keyId>",algorithm="<algo>",headers="<signed_headers>",signature="<signature>"</code>


Le champ ''keyId'' correspond à un identifiant permettant l'identification de la clé utilisée pour vérifier la signature. Pour l'API d'OpenFlyers, sa valeur correspond à l'empreinte SHA-1 du certificat au format PEM à utiliser pour vérifier la signature.


L'algorithme ''algo'' correspond à celui utilisé pour générer la signature, exemple : <code>rsa-sha256</code>.
===Demande d'autorisation===
Pour initier la demande d'autorisation, rediriger le navigateur de l'utilisateur vers l'URL : <code>GET https://openflyers.com/nom-de-plateforme/oauth/authorize.php</code>. Remplacer <code>nom-de-plateforme</code> par le nom de la plateforme utilisée.


La valeur de ''signed_headers'' correspond à la liste des en-têtes inclus dans la signature séparés d'un espace. Exemple : <code>date digest (request-target)</code>
Envoyer également les paramètres suivants :
 
{| class="wikitable"
Pour générer la signature, une chaîne de caractères appelée <code>signing string</code> contenant les en-têtes au format <code>lowercase_header_name: value</code> séparés par une nouvelle ligne au format LF (<code>\n</code>) est d'abord générée. Exemple avec les en-têtes "date" et "(request-target)" :
!Nom!!Type!!Description
 
|-
<pre>(request-target): post /some/uri\ndate: Tue, 07 Jun 2014 20:51:35 GMT</pre>
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
 
|-
La signature est ensuite générée comme ceci : <code>base64encode(algo(signing string))</code>
|response_type||string||Le type de réponse envoyée par le serveur. Doit utiliser la valeur "code" (sans guillements) pour ce mécanisme.
 
|-
;Exemple en php
|redirect_uri||string||L'URI (ou l'URL) fourni pendant l'enregistrement du client et vers lequel l'utilisateur est redirigé après la demande d'autorisation.
<php>function generateSignatureHeader(array $headersToSign, string $certificateFingerprint, string $privateKey): string
|-
{
|scope||string||[[#Liste-des-scopes-disponibles|Liste des droits demandés par le client]], séparés par des espaces.
    // generating the signing string and header list
|-
    $headers        = '';
|state||string||Chaîne de caractère aléatoire utilisée pour éviter les [https://fr.wikipedia.org/wiki/Cross-site_request_forgery attaques CSRF]. '''Fortement recommandé'''.
    $signatureString = '';
|-
    foreach ($headersToSign as $key => $value) {
|code_challenge||string||Code nécessaire pour le fonctionnement de l'extension [[#Générer-les-codes-pour-PKCE|PKCE]].
        $normalizedHeaderKey = trim(strtolower($key));
|-
        $headers            .= $normalizedHeaderKey . ' ';
|code_challenge_method||string||Méthode utilisée pour générer le ''code_challenge''. Ici, la valeur est "S256".
        $signatureString    .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
|}
    }
 
===Demande de jeton d'accès===
Après avoir répondu à la demande, l'utilisateur est redirigé vers l'URI fourni pendant l'enregistrement du client. Si la demande est acceptée, un code temporaire : ''code'' est fourni, ainsi que le paramètre ''state'' fourni pendant la demande avec la même valeur. Si la demande est refusée, un code d'erreur est renvoyé.
;Si le paramètre ''state'' a une valeur différente de celle envoyée avec la demande, c'est peut-être une tentative d'attaque et il faut refuser la réponse.


    // trim extra whitespace
Echanger ce ''code'' contre un jeton d'accès via l'URL : <code>POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php</code>. Remplacer <code>nom-de-plateforme</code> par le nom de la plateforme utilisée.
    $headers        = trim($headers);
    $signatureString = trim($signatureString);


    // signing the signing string
Les paramètres suivants sont également nécessaires :
    $signature = '';
{| class="wikitable"
    openssl_sign($signatureString, $signature, $privateKey, 'RSA-SHA256');
!Nom!!Type!!Description
    $signature = base64_encode($signature);
|-
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
|-
|client_secret||string||La passphrase reçue pendant l'enregistrement du client.
|-
|code||string||Le code temporaire reçu dans la réponse à la demande d'autorisation.
|-
|grant_type||string||Le mécanisme d'autorisation utilisé. Ici, sa valeur doit être ''authorization_code''
|-
|redirect_uri||string||L'URI (ou l'URL) de redirection fourni pendant l'enregistrement du client.
|-
|code_verifier||string||Le ''code_verifier'' utilisé pour générer le ''code_challenge'' de la demande d'autorisation.
|}


    // compiling the header line
Si la requête est correcte, un jeton d'accès (Access Token) ainsi qu'un jeton de rafraîchissement (Refresh Token) sont fournis en réponse dans un objet au format JSON.
    return "Signature: keyId=\"$certificateFingerprint\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";
<javascript>{
}</php>
  "token_type": "Bearer",
Les variables ''$certificateFingerprint'' et ''$privateKey'' correspondent respectivement à une empreinte SHA-1 de certificat et à une clé privée, tous deux au format PEM.
  "expires_in": 3600,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw",
  "refresh_token": "a59ef39fa9bab9b95cd554f921e7f3080a34c90f23d2b8031d692b5ff2d0993dcc392d9c7f9a43242337ef144c1a5fe1d0174413ade973e1b628ac0bbfc39b23973534"
}</javascript>


La variable ''$headersToSign'' est un tableau formaté de la manière suivante :  
===Script client : Authorization Code===
<php>[
Voici un exemple simple de client OAuth2 pour le mécanisme d'authentification par code d'autorisation (Authorization Code).
    $headerName => $headerValue,
    ...
]</php>


'''À noter''' : les en-têtes sont à signer côté client avec le certificat de signature signé par le CA d'OpenFlyers et dédié au client ainsi que la clé privée associée. Le certificat de signature dédié au client est téléchargeable depuis l'interface de gestion des clients OAuth2. Les en-têtes de la réponse du serveur quant à elles doivent être vérifiées avec le certificat de signature HTTP du serveur, téléchargeable aussi depuis l'interface de configuration des clients OAuth2.
Fichier de configuration ''config.authcode.json'' :
<javascript>{
  "client_id": "",
  "client_secret": "",
  "authorize_uri": "https://openflyers.com/nom-de-plateforme/oauth/authorize.php",
  "token_uri": "https://openflyers.com/nom-de-plateforme/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/nom-de-plateforme/oauth/resources.php",
  "auth_cert": "/path/to/client/auth_cert.crt",
  "auth_key": "/path/to/client/auth.key",
  "sign_cert": "/path/to/client/sign_cert.crt",
  "sign_key": "/path/to/client/sign.key",
  "auth_cacert": "/path/to/ca.crt",
  "sign_cert_server": "/path/to/server/sign_cert_server.crt"
}</javascript>
Où <code>/path/to/client/</code> est le chemin d'accès vers le dossier qui contient le code source du client de démonstration.
*Exemple sur '''windows''': <code>C:/wamp64/www/4.0/oauth-demo/ssl/AuthCodeDemo/</code>.
*Exemple sur un serveur Linux '''debian''': <code>./ssl/AuthCodeDemo/</code>.


==Client OAuth2==
Ce fichier de configuration doit se situer au même niveau que le script PHP dans le système de fichiers.
Une fois le client OAuth2 configuré sur OpenFlyers, il faut l'utiliser avec un client créé au préalable pour communiquer avec le serveur d'autorisation et l'API.


Plusieurs [https://oauth.net/code/ bibliothèques] simplifiant la création d'un client sont disponibles.
Script PHP :
<php><?php
$localTokenFile    = 'token.json';
// create token file if it does not exist
if (!file_exists($localTokenFile))
    file_put_contents($localTokenFile, '');


Des scripts client basiques écrits en php sont aussi fournis pour les mécanismes [[#Script-client-:-authorization-code|''authorization_code'']] et [[#Script-client-:-client-credentials|''client_credentials'']]
$config                = json_decode(file_get_contents('config.authcode.json'), true);
$localToken            = json_decode(file_get_contents($localTokenFile), true);
$GLOBALS['config']     = $config;


===Authorization Code===
// Build the baseURL, accounting for protocol, port, name and endpoint. Used for redirection
Ce flux OAuth2 se déroule en plusieurs étapes :
$protocol = isset($_SERVER['HTTPS']) ? 'https://' : 'http://';
*Le client redirige le navigateur de l'utilisateur vers l'URL d'autorisation.
$port    = ($protocol == 'https://' && $_SERVER['SERVER_PORT'] == 443)
*Le navigateur de l'utilisateur est redirigé vers l'URL fourni durant la demande ou durant l'enregistrement du client.
    || ($protocol == 'http://' && $_SERVER['SERVER_PORT'] == 80) ? '' : ':' . $_SERVER['SERVER_PORT'];
*Le client récupère un code d'autorisation grâce à la redirection précédente, et échange ce code contre un jeton d'accès auprès du serveur d'autorisation.
*Le client peut utiliser ce code d'accès :
**Comme preuve d'authentification pour une solution SSO (Single Sign-On).
**Pour accéder à des données sur le serveur distant en utilisant l'API.


$baseURL            = $protocol . $_SERVER['SERVER_NAME'] . $port . $_SERVER['PHP_SELF'];
$errorLog          = 'error_log.log';
$responseLog        = 'response_log.log';
$GLOBALS['baseURL'] = $baseURL;


    +-----------+                  +------+                +-----------+                  +-------------+                  +-----------+
//Session cookies are used to store information necessary for the authorization code flow
    |Utilisateur|                  |Client|                |Navigateur |                  |  Serveur  |                  |  Serveur  |
session_start();
    +-----+-----+                  +--+---+                +-----+-----+                  |Autorisation |                  | Ressources|
 
          |                            |                          |                        +------+------+                  +-----+-----+
/**
          |                            |                          |                              |                              |
* This function is used to make api calls to the Authorization Server and the Resource Server
          |                            |                  Demande|d'autorisation                |                              |
*
          |                            +------------------------->+------------------------------>|                              |
* @param      $url
          |                            |                          |                              |                              |
* @param      $post
          |                            |Authentification + Formulaire d'autorisation              |                              |
* @param array $headers
          |<---------------------------+--------------------------+<------------------------------+                              |
*
          |                            |                          |                              |                              |
* @return mixed
          |                            |      Autorisation        |                              |                              |
*/
          +----------------------------+------------------------->+------------------------------>|                              |
function apiRequest($url, $post = null, $token = false, $auth = true, $refresh = false, $headers = array())
          |                            |                          |                              |                              |
{
          |                            |                      Code|d'autorisation                |                              |
    $ch = curl_init($url);
          |                            |<-------------------------+<------------------------------+                              |
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
          |                            |                          |                              |                              |
    curl_setopt($ch, CURLOPT_HEADER, true);
          |                            |                Demande de|token                         |                              |
          |                            +--------------------------+------------------------------>|                              |
          |                            |                          |                              |                              |
          |                            |                Access (+|Refresh) token                |                              |
          |                            |<-------------------------+-------------------------------+                              |
          |                            |                          |                              |                              |
          |                            |                          |      Requête vers API        |                              |
          |                            +--------------------------+-------------------------------+------------------------------>|
          |                            |                          |                              |                              |
          |                            |                          |                              |                              |
          |                            |                          |                              |<------------------------------+
          |                            |                          |                              |  Vérification d'autorisation  |
          |                            |                          |                              +------------------------------>|
          |                            |                          |                              |                              |
          |                            |                          |      Données/Réponse          |                              |
          |                            |<-------------------------+-------------------------------+-------------------------------+
          |                            |                          |                              |                              |


    $method = 'get';


    if ($post) {
        $method  = 'post';
        $postData = http_build_query($post);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);


====Générer les codes pour PKCE====
        $headersToSign['Content-Type'] = 'application/x-www-form-urlencoded';
Pour faire fonctionner le client OAuth2, il faut générer deux codes pour l'extension PKCE :
        $headersToSign['digest']      = 'SHA-256=' . base64_encode(hash('sha256', $postData, true));
*Un ''code_verifier'' échangé pendant la demande de jeton d'accès.
*Un ''code_challenge'' dérivé du ''code_verifier'' et échangé pendant la demande d'autorisation.
 
;Générer le ''code_verifier''
<php>function generateCodeVerifier($length = 128): string
{
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~';
    $outputCode = '';
 
    for ($i = 0; $i < $length; $i++) {
        $index      = random_int(0, strlen($characters) - 1);
        $outputCode .= $characters[$index];
     }
     }


     return $outputCode;
     $urlComponents = parse_url($url);
}</php>


Cette fonction permet de générer un ''code_verifier'' avec une longueur donnée. Le ''code_verifier'' doit avoir une longueur entre 43 et 128 caractères.
    $headersToSign['(request-target)'] = $method . ' ' . $urlComponents['path'];
    $headersToSign['Host']            = $urlComponents['host'];
    $headersToSign['Date']            = gmdate('D, j M Y H:i:s T');


;Générer le ''code_challenge''
    // generating the signature header
<php>function computeCodeChallenge(string $codeVerifier): string
    $keyId                = openssl_x509_fingerprint(file_get_contents($GLOBALS['config']['sign_cert']));
{
     $privateKey          = file_get_contents($GLOBALS['config']['sign_key']);
     return strtr(rtrim(base64_encode(hash('sha256', $codeVerifier, true)), '='), '+/', '-_');
    $headers['Signature'] = generateSignatureHeader($headersToSign, $keyId, $privateKey);
}</php>


Cette fonction génère le ''code_challenge'' à partir du ''code_verifier'' fourni.
    $headers['Accept']    = 'application/json';
    $headers['User-Agent'] = $GLOBALS['baseURL'];
    unset($headersToSign['(request-target)']);
    $headers              += $headersToSign;


    if ($token) {
        $headers['Authorization'] = $token['token_type'] . ' ' . $token['access_token'];
    }


====Demande d'autorisation====
    // formatting the headers
Pour initier la demande d'autorisation, rediriger le navigateur de l'utilisateur vers l'URL : <code>GET https://openflyers.com/nom-de-plateforme/oauth/authorize.php</code>.
    $httpFormattedHeaders = [];
    foreach ($headers as $key => $value) {
        $httpFormattedHeaders[] = trim($key) . ': ' . trim($value);
    }


Envoyer également les paramètres suivants :
    curl_setopt($ch, CURLOPT_HTTPHEADER, $httpFormattedHeaders);
{| class="wikitable"
    curl_setopt($ch, CURLINFO_HEADER_OUT, true);
!Nom!!Type!!Description
 
|-
    // for development environment only
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
    //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
|-
    //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
|response_type||string||Le type de réponse envoyée par le serveur. Doit utiliser la valeur "code" (sans guillements) pour ce mécanisme.
    //curl_setopt($ch, CURLOPT_VERBOSE, true);
|-
|redirect_uri||string||L'URI (ou l'URL) fourni pendant l'enregistrement du client et vers lequel l'utilisateur est redirigé après la demande d'autorisation.
|-
|scope||string||[[#Liste-des-scopes-disponibles|Liste des droits demandés par le client]], séparés par des espaces.
|-
|state||string||Chaîne de caractère aléatoire utilisée pour éviter les [https://fr.wikipedia.org/wiki/Cross-site_request_forgery attaques CSRF]. '''Fortement recommandé'''.
|-
|code_challenge||string||Code nécessaire pour le fonctionnement de l'extension [[#Générer-les-codes-pour-PKCE|PKCE]].
|-
|code_challenge_method||string||Méthode utilisée pour générer le ''code_challenge''. Ici, la valeur est "S256".
|}


====Demande de jeton d'accès====
    // defining TLS client certificates for Mutual TLS
Après avoir répondu à la demande, l'utilisateur est redirigé vers l'URI fourni pendant l'enregistrement du client. Si la demande est acceptée, un code temporaire : ''code'' est fourni, ainsi que le paramètre ''state'' fourni pendant la demande avec la même valeur. Si la demande est refusée, un code d'erreur est renvoyé.
    curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
;Si le paramètre ''state'' a une valeur différente de celle envoyée avec la demande, c'est peut-être une tentative d'attaque et il faut refuser la réponse.
    curl_setopt($ch, CURLOPT_CAINFO, $GLOBALS['config']['auth_cacert']);
    curl_setopt($ch, CURLOPT_SSLCERT, $GLOBALS['config']['auth_cert']);
    curl_setopt($ch, CURLOPT_SSLKEY, $GLOBALS['config']['auth_key']);


Echanger ce ''code'' contre un jeton d'accès via l'URL : <code>POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php</code>
    $response = curl_exec($ch);


Les paramètres suivants sont également nécessaires :
    // logging errors and responses
{| class="wikitable"
    errorLog(true, $response, $ch);
!Nom!!Type!!Description
|-
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
|-
|client_secret||string||La passphrase reçue pendant l'enregistrement du client.
|-
|code||string||Le code temporaire reçu dans la réponse à la demande d'autorisation.
|-
|grant_type||string||Le mécanisme d'autorisation utilisé. Ici, sa valeur doit être ''authorization_code''
|-
|redirect_uri||string||L'URI (ou l'URL) de redirection fourni pendant l'enregistrement du client.
|-
|code_verifier||string||Le ''code_verifier'' utilisé pour générer le ''code_challenge'' de la demande d'autorisation.
|}


Si la requête est correcte, un jeton d'accès (Access Token) ainsi qu'un jeton de rafraîchissement (Refresh Token) sont fournis en réponse dans un objet au format JSON.
    curl_close($ch);
<javascript>{
  "token_type": "Bearer",
  "expires_in": 3600,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw",
  "refresh_token": "a59ef39fa9bab9b95cd554f921e7f3080a34c90f23d2b8031d692b5ff2d0993dcc392d9c7f9a43242337ef144c1a5fe1d0174413ade973e1b628ac0bbfc39b23973534"
}</javascript>


====Script client : Authorization Code====
    // in case an authentication request is executed
Voici un exemple simple de client OAuth2 pour le mécanisme d'authentification par code d'autorisation (Authorization Code).
    if ($auth) {
 
        // required when a refresh token request is issued
Fichier de configuration ''config.authcode.json'' :
        // because there is only one header in the response
<javascript>{
        // while there are two for regular auth requests
  "client_id": "",
        if (!$refresh) {
  "client_secret": "",
            list($firstResponseHeaders, $secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 3);
  "authorize_uri": "https://openflyers.com/nom-de-plateforme/oauth/authorize.php",
            if (!$responseBody) {
  "token_uri": "https://openflyers.com/nom-de-plateforme/oauth/access_token.php",
                list($secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 2);
  "resource_uri": "https://openflyers.com/nom-de-plateforme/oauth/resources.php",
            }
  "auth_cert": "/path/to/client/auth_cert.crt",
        } else {
  "auth_key": "/path/to/client/auth.key",
            list($secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 2);
  "sign_cert": "/path/to/client/sign_cert.crt",
        }
  "sign_key": "/path/to/client/sign.key",
  "auth_cacert": "/path/to/ca.crt",
  "sign_cert_server": "/path/to/server/sign_cert_server.crt"
}</javascript>


Ce fichier de configuration doit se situer au même niveau que le script PHP dans le système de fichiers.
        $responseHeadersDigest = '';
        $responseHeadersSignature = '';
        // extracting digest and signature from headers
        $responseHeadersArray = explode("\r\n", $secondResponseHeaders);
        $responseProtocol = array_shift($responseHeadersArray);


Script PHP :
        foreach ($responseHeadersArray as $value) {
<php><?php
            list($responseHeadersKeys, $responseHeadersValue) = explode(": ", $value, 2);
$localTokenFile    = 'token.json';
            $responseHeaders[strtolower($responseHeadersKeys)] = $responseHeadersValue;
// create token file if it does not exist
        }
if (!file_exists($localTokenFile))
    file_put_contents($localTokenFile, '');


$config                = json_decode(file_get_contents('config.authcode.json'), true);
        $responseDigestAlgo = '';
$localToken            = json_decode(file_get_contents($localTokenFile), true);
        $responseDigestKey = '';
$GLOBALS['config']      = $config;
        foreach ($responseHeaders as $key => $value) {
            if ($key === "digest") {
                $responseHeadersDigest = $value;
                // stripping SHA algorithm for later comparison
                list($responseDigestAlgo, $responseDigestKey) = explode("=", $responseHeadersDigest, 2);
            } else if ($key === "signature")
                $responseHeadersSignature = $value;
        }


// Build the baseURL, accounting for protocol, port, name and endpoint. Used for redirection
        // calculating response digest
$protocol = isset($_SERVER['HTTPS']) ? 'https://' : 'http://';
        $responseDigest = base64_encode(hash(strtolower(str_replace("-", "", $responseDigestAlgo)), $responseBody, true));
$port    = ($protocol == 'https://' && $_SERVER['SERVER_PORT'] == 443)
    || ($protocol == 'http://' && $_SERVER['SERVER_PORT'] == 80) ? '' : ':' . $_SERVER['SERVER_PORT'];


$baseURL            = $protocol . $_SERVER['SERVER_NAME'] . $port . $_SERVER['PHP_SELF'];
        // checking digest validity
$errorLog           = 'error_log.log';
        if ($responseDigest !== $responseDigestKey) {
$responseLog        = 'response_log.log';
            errorLog(false, false, "Digests are not the same");
$GLOBALS['baseURL'] = $baseURL;
            die();
        }


//Session cookies are used to store information necessary for the authorization code flow
        // extracting variables from signature header
session_start();
        $signatureArray = explode(",", $responseHeadersSignature);
        foreach ($signatureArray as $value) {
            list($signatureKey, $signatureValue) = explode("=", $value, 2);
            $signature[$signatureKey] = trim($signatureValue, '"');
        }


/**
        // generating siging string
* This function is used to make api calls to the Authorization Server and the Resource Server
        $signingStringArray = explode(" ", $signature['headers']);
*
        $signingString = '';
* @param      $url
        foreach ($signingStringArray as $value) {
* @param      $post
            $signingString = $signingString . trim($value) . ": " . trim($responseHeaders[$value]) . "\n";
* @param array $headers
        }
*
* @return mixed
*/
function apiRequest($url, $post = null, $token = false, $auth = true, $refresh = false, $headers = array())
{
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, true);


    $method = 'get';
        // trimming last '\n' character
        $signingString = trim($signingString);


    if ($post) {
         // decoding signature
         $method  = 'post';
         $decodedSignature = base64_decode($signature['signature']);
         $postData = http_build_query($post);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);


         $headersToSign['Content-Type'] = 'application/x-www-form-urlencoded';
         // verifying signature
        $headersToSign['digest']       = 'SHA-256=' . base64_encode(hash('sha256', $postData, true));
        $signatureVerify = openssl_verify($signingString, $decodedSignature, openssl_get_publickey(file_get_contents($GLOBALS['config']['sign_cert_server'])), 'RSA-SHA256');
    }


    $urlComponents = parse_url($url);
        if (!$signatureVerify) {
            errorLog(false, false, "Signature is not correct");
            while (($err = openssl_error_string()))
                errorLog(false, false, $err);
            die();
        }


    $headersToSign['(request-target)'] = $method . ' ' . $urlComponents['path'];
        return json_decode($responseBody, true);
    $headersToSign['Host']            = $urlComponents['host'];
     }
     $headersToSign['Date']            = gmdate('D, j M Y H:i:s T');


     // generating the signature header
     return $response;
    $keyId                = openssl_x509_fingerprint(file_get_contents($GLOBALS['config']['sign_cert']));
}
    $privateKey          = file_get_contents($GLOBALS['config']['sign_key']);
    $headers['Signature'] = generateSignatureHeader($headersToSign, $keyId, $privateKey);


    $headers['Accept']    = 'application/json';
/**
    $headers['User-Agent'] = $GLOBALS['baseURL'];
* This function logs curl responses and errors in text files
     unset($headersToSign['(request-target)']);
*
     $headers              += $headersToSign;
* @param mixed $response the response
* @param mixed $request  the request handle, used to get errors
*/
function errorLog($curl, $response, $request = false)
{
     $timestamp = '[' . date('Y-m-d H:i:s') . ']:';
     global $errorLog;
    global $responseLog;


     if ($token) {
     if ($response === false) {
         $headers['Authorization'] = $token['token_type'] . ' ' . $token['access_token'];
         if ($curl)
            file_put_contents($errorLog, $timestamp . curl_error($request) . "\n", FILE_APPEND);
        else
            file_put_contents($errorLog, $timestamp . $request . "\n", FILE_APPEND);
    } else {
        file_put_contents($responseLog, $timestamp . "\n" . $response . "\n", FILE_APPEND);
     }
     }
}


     // formatting the headers
/**
     $httpFormattedHeaders = [];
* This function generates the full signature header line from a set of headers, a certificate and the linked private key
     foreach ($headers as $key => $value) {
*
         $httpFormattedHeaders[] = trim($key) . ': ' . trim($value);
* @param array  $headersToSign the headers to sign, in the $key => $value format
* @param string $certificate  the certificate linked to the used private key
* @param string $privateKey    the private key used to sign the headers
*
* @return string the full signature header line
*/
function generateSignatureHeader(array $headersToSign, string $certificate, string $privateKey): string
{
     // generating the signing string and header list
    $headers         = '';
     $signatureString = '';
     foreach ($headersToSign as $key => $value) {
         $normalizedHeaderKey = trim(strtolower($key));
        $headers            .= $normalizedHeaderKey . ' ';
        $signatureString    .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
     }
     }
    $headers        = trim($headers);
    $signatureString = trim($signatureString);


     curl_setopt($ch, CURLOPT_HTTPHEADER, $httpFormattedHeaders);
     // signing the signing string
     curl_setopt($ch, CURLINFO_HEADER_OUT, true);
    $signature = '';
    openssl_sign($signatureString, $signature, openssl_get_privatekey($privateKey), 'RSA-SHA256');
     $signature = base64_encode($signature);


     // for development environment only
     // compiling the header line
     //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
     return "keyId=\"$certificate\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";
    //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
}
    //curl_setopt($ch, CURLOPT_VERBOSE, true);


    // defining TLS client certificates for Mutual TLS
/**
    curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
* This function takes a code_verifier and outputs the corresponding code_challenge
     curl_setopt($ch, CURLOPT_CAINFO, $GLOBALS['config']['auth_cacert']);
*
    curl_setopt($ch, CURLOPT_SSLCERT, $GLOBALS['config']['auth_cert']);
* @param string $codeVerifier the generated code_verifier
    curl_setopt($ch, CURLOPT_SSLKEY, $GLOBALS['config']['auth_key']);
*
* @return string the computed code_challenge
*/
function computeCodeChallenge(string $codeVerifier): string
{
     return strtr(rtrim(base64_encode(hash('sha256', $codeVerifier, true)), '='), '+/', '-_');
}


    $response = curl_exec($ch);
/**
 
* This function takes an optional string length and outputs a random code_verifier string
     // logging errors and responses
*
     errorLog(true, $response, $ch);
* @param int $length the length of the output code_verifier. Default = 128
*
* @return string the code_verifier
* @throws Exception
*/
function generateCodeVerifier($length = 128): string
{
     $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~';
     $outputCode = '';


     curl_close($ch);
     for ($i = 0; $i < $length; $i++) {
        $index      = random_int(0, strlen($characters) - 1);
        $outputCode .= $characters[$index];
    }
 
    return $outputCode;
}


    // in case an authentication request is executed
/**
    if ($auth) {
* This function calculates the entropy of a given string
        // required when a refresh token request is issued
*
        // because there is only one header in the response
* @param string $string  the string for which to calculate the entropy
        // while there are two for regular auth requests
* @param string $charset a string with all the usable characters. Default = 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~
        if (!$refresh) {
*
            list($firstResponseHeaders, $secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 3);
* @return float|int
            if (!$responseBody) {
*/
                list($secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 2);
function computeEntropy(string $string, string $charset = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~')
            }
{
        } else {
    $chars = str_split($charset);
            list($secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 2);
    $probs = [];
        }


        $responseHeadersDigest = '';
    foreach ($chars as $char) {
         $responseHeadersSignature = '';
         $probs[$char] = floatval(substr_count($string, $char)) / strlen($string);
        // extracting digest and signature from headers
    }
        $responseHeadersArray = explode("\r\n", $secondResponseHeaders);
        $responseProtocol = array_shift($responseHeadersArray);


        foreach ($responseHeadersArray as $value) {
    $sum = 0.0;
            list($responseHeadersKeys, $responseHeadersValue) = explode(": ", $value, 2);
    foreach ($probs as $prob) {
            $responseHeaders[strtolower($responseHeadersKeys)] = $responseHeadersValue;
        $sum += $prob != 0 ? $prob * log($prob, 2) : 0.0;
        }
    }


        $responseDigestAlgo = '';
    return -$sum;
        $responseDigestKey = '';
}
        foreach ($responseHeaders as $key => $value) {
            if ($key === "digest") {
                $responseHeadersDigest = $value;
                // stripping SHA algorithm for later comparison
                list($responseDigestAlgo, $responseDigestKey) = explode("=", $responseHeadersDigest, 2);
            } else if ($key === "signature")
                $responseHeadersSignature = $value;
        }


        // calculating response digest
/**
        $responseDigest = base64_encode(hash(strtolower(str_replace("-", "", $responseDigestAlgo)), $responseBody, true));
* This function calculates the ideal (maximum) entropy for a string of a given length
*
* @param int $length length of the string. Default = 128
*
* @return float|int
*/
function idealEntropy(int $length = 128)
{
    $prob = 1.0 / $length;


        // checking digest validity
    return -1.0 * $length * $prob * log($prob, 2);
        if ($responseDigest !== $responseDigestKey) {
}
            errorLog(false, false, "Digests are not the same");
            die();
        }


        // extracting variables from signature header
/**
        $signatureArray = explode(",", $responseHeadersSignature);
* This function is used to initiate the authentication code flow.
        foreach ($signatureArray as $value) {
*
            list($signatureKey, $signatureValue) = explode("=", $value, 2);
* @param string $clientID    the client's ID
            $signature[$signatureKey] = trim($signatureValue, '"');
* @param string $redirectURL  the URL where to redirect after auth
        }
* @param string $authorizeURL the target URL to request authorization
*
* @throws Exception
*/
function login(string $clientID, string $redirectURL, string $authorizeURL): void
{
    global $localTokenFile;
    file_put_contents($localTokenFile, '');


        // generating siging string
    // This unguessable string is used to prevent csrf attacks
        $signingStringArray = explode(" ", $signature['headers']);
    $_SESSION['state'] = bin2hex(random_bytes(16));
        $signingString = '';
        foreach ($signingStringArray as $value) {
            $signingString = $signingString . trim($value) . ": " . trim($responseHeaders[$value]) . "\n";
        }


        // trimming last '\n' character
    // Generate code_verifier and code_challenge for PKCE   
        $signingString = trim($signingString);
    $_SESSION['code_verifier']  = generateCodeVerifier();
    $_SESSION['code_challenge'] = computeCodeChallenge($_SESSION['code_verifier']);


        // decoding signature
    // required parameters for the redirection, redirect_uri is where the browser should be redirected
         $decodedSignature = base64_decode($signature['signature']);
    // when the user grants (or denies) access, scope are the authorizations (rights) requested
    $params = [
         'response_type'        => 'code',
        'client_id'            => $clientID,
        'redirect_uri'          => $redirectURL,
        'scope'                => 'default.login',
        'state'                => $_SESSION['state'],
        'code_challenge'        => $_SESSION['code_challenge'],
        'code_challenge_method' => 'S256'
    ];


        // verifying signature
    // redirecting the browser to the AS authorization endpoint to obtain the authorization code
        $signatureVerify = openssl_verify($signingString, $decodedSignature, openssl_get_publickey(file_get_contents($GLOBALS['config']['sign_cert_server'])), 'RSA-SHA256');
    header('Location: ' . $authorizeURL . '?' . http_build_query($params));
 
        if (!$signatureVerify) {
            errorLog(false, false, "Signature is not correct");
            while (($err = openssl_error_string()))
                errorLog(false, false, $err);
            die();
        }
 
        return json_decode($responseBody, true);
    }
 
    return $response;
}
}


/**
/**
  * This function logs curl responses and errors in text files
  * This function deletes the access token from the session
  *
  *
  * @param mixed $response the response
  * @param string $baseURL
* @param mixed $request  the request handle, used to get errors
  */
  */
function errorLog($curl, $response, $request = false)
function logout(string $baseURL): void
{
{
    $timestamp = '[' . date('Y-m-d H:i:s') . ']:';
     global $localTokenFile;
     global $errorLog;
     file_put_contents($localTokenFile, '');
     global $responseLog;


     if ($response === false) {
     header('Location: ' . $baseURL);
        if ($curl)
            file_put_contents($errorLog, $timestamp . curl_error($request) . "\n", FILE_APPEND);
        else
            file_put_contents($errorLog, $timestamp . $request . "\n", FILE_APPEND);
    } else {
        file_put_contents($responseLog, $timestamp . "\n" . $response . "\n", FILE_APPEND);
    }
}
}


/**
function displayMenuLoggedIn(): void
* This function generates the full signature header line from a set of headers, a certificate and the linked private key
*
* @param array  $headersToSign the headers to sign, in the $key => $value format
* @param string $certificate  the certificate linked to the used private key
* @param string $privateKey    the private key used to sign the headers
*
* @return string the full signature header line
*/
function generateSignatureHeader(array $headersToSign, string $certificate, string $privateKey): string
{
{
     // generating the signing string and header list
     echo '<h2><a href="/">Home</a></h2>';
     $headers        = '';
     echo '<h3>Logged In</h3>';
     $signatureString = '';
 
     foreach ($headersToSign as $key => $value) {
     echo '<form id="view_repos" method="post">';
        $normalizedHeaderKey = trim(strtolower($key));
     echo '<input type="hidden" id="action" name="action" value="view">';
        $headers            .= $normalizedHeaderKey . ' ';
     echo '<p><a href="javascript:{}" onclick="document.getElementById(\'view_repos\').submit(); return false;">View Repos</a></p>';
        $signatureString     .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
     echo '</form>';
     }
    $headers        = trim($headers);
    $signatureString = trim($signatureString);


     // signing the signing string
     echo '<form id="logout" method="post">';
    $signature = '';
     echo '<input type="hidden" id="action" name="action" value="logout">';
     openssl_sign($signatureString, $signature, openssl_get_privatekey($privateKey), 'RSA-SHA256');
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'logout\').submit(); return false;">Log Out</a></p>';
    $signature = base64_encode($signature);
    echo '</form>';
 
    // compiling the header line
    return "keyId=\"$certificate\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";
}
}


/**
function displayMenuLoggedOut(): void
* This function takes a code_verifier and outputs the corresponding code_challenge
{
*
    echo '<h2><a href="/">Home</a></h2>';
* @param string $codeVerifier the generated code_verifier
    echo '<h3>Not logged in</h3>';
*
    echo '<form id="login" method="post">';
* @return string the computed code_challenge
    echo '<input type="hidden" id="action" name="action" value="login">';
*/
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'login\').submit(); return false;">Log In</a></p>';
function computeCodeChallenge(string $codeVerifier): string
    echo '</form>';
{
    return strtr(rtrim(base64_encode(hash('sha256', $codeVerifier, true)), '='), '+/', '-_');
}
}


/**
// display client "home" page
* This function takes an optional string length and outputs a random code_verifier string
if (!isset($_POST['action'])) {
*
     if (!empty($localToken['access_token'])) {
* @param int $length the length of the output code_verifier. Default = 128
        displayMenuLoggedIn();
*
     } else {
* @return string the code_verifier
        displayMenuLoggedOut();
* @throws Exception
    }
*/
}
function generateCodeVerifier($length = 128): string
{
     $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~';
     $outputCode = '';


     for ($i = 0; $i < $length; $i++) {
if (isset($_POST['action'])) {
         $index      = random_int(0, strlen($characters) - 1);
     // Building query array for resource dumping
        $outputCode .= $characters[$index];
    $repoQueryParameters = [
    }
        'resource_type' => 'user_information',
 
        'client_id' => $config['client_id']
    return $outputCode;
    ];
}
    switch ($_POST['action']) {
 
         case 'login':
/**
            login($config['client_id'], $baseURL, $config['authorize_uri']);
* This function calculates the entropy of a given string
            break;
*
        case 'logout':
* @param string $string  the string for which to calculate the entropy
            logout($baseURL);
* @param string $charset a string with all the usable characters. Default = 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~
            break;
*
        case 'view':
* @return float|int
            // call to the resource server to retreive user information
*/
            $resources = apiRequest(
function computeEntropy(string $string, string $charset = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~')
                $config['resource_uri'],
{
                $repoQueryParameters,
    $chars = str_split($charset);
                $localToken,
    $probs = [];
                false
            );


    foreach ($chars as $char) {
            // Separating headers from body
        $probs[$char] = floatval(substr_count($string, $char)) / strlen($string);
            list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
    }


    $sum = 0.0;
            $resourceHeaders = explode("\r\n", $resourceHeader);
    foreach ($probs as $prob) {
            $firstHeaderLine = array_shift($resourceHeaders);
        $sum += $prob != 0 ? $prob * log($prob, 2) : 0.0;
    }


    return -$sum;
            // Displaying user information
}
            echo '<pre>';
            echo $resourceBody;
            echo '</pre>';


/**
            // Automatic refreshing token once access token is expired
* This function calculates the ideal (maximum) entropy for a string of a given length
            if (strpos($firstHeaderLine, "401")) {
*
                $errorBody = json_decode($resourceBody, true);
* @param int $length length of the string. Default = 128
                if ($errorBody['error'] == 'access_denied' && isset($errorBody['hint'])) {
*
                    if ($errorBody['hint'] == 'Access token could not be verified') {
* @return float|int
                        $token = apiRequest(
*/
                            $config['token_uri'],
function idealEntropy(int $length = 128)
                            [
{
                                'grant_type'    => 'refresh_token',
    $prob = 1.0 / $length;
                                'refresh_token' => $localToken['refresh_token'],
                                'client_id'    => $config['client_id'],
                                'client_secret' => empty($config['client_secret']) ? null : $config['client_secret']
                            ],
                            false,
                            true,
                            true
                        );
 
                        // We store the access token in the session so the user is "connected"
                        // Only if the request has been successfully executed
                        if (isset($token['access_token'])) {
                            file_put_contents($localTokenFile, json_encode($token, true));


    return -1.0 * $length * $prob * log($prob, 2);
                            // Redirecting the user's browser to the "home" page
                            header('Location: ' . $baseURL);
                        }
                    }
                }
            }
            break;
    }
}
}


/**
// Once the browser has been redirected to the AS to ask for the user's authorization, assuming it has been granted,
* This function is used to initiate the authentication code flow.
// the browser will get back here with a "code" parameter in the query string
*
if (isset($_GET['code'])) {
* @param string $clientID    the client's ID
    // The AS MUST redirect the browser here with the exact same state parameter we sent it before, so we check if it is indeed the same
* @param string $redirectURL  the URL where to redirect after auth
    // to detect if the oauth flow has been tampered with
* @param string $authorizeURL the target URL to request authorization
    if (!isset($_GET['state']) || $_SESSION['state'] != $_GET['state']) {
*
        header('Location: ' . $baseURL . '?error=invalid_state');
* @throws Exception
        die();
*/
    }
function login(string $clientID, string $redirectURL, string $authorizeURL): void
{
    global $localTokenFile;
    file_put_contents($localTokenFile, '');


     // This unguessable string is used to prevent csrf attacks
     // We communicate directly with the AS to exchange the code received against an access token.
     $_SESSION['state'] = bin2hex(random_bytes(16));
    // The id/secret pair is send to authenticate the client, the redirect_uri is sent to verify the code's validity
 
     $token = apiRequest(
    // Generate code_verifier and code_challenge for PKCE    
        $config['token_uri'],
     $_SESSION['code_verifier'] = generateCodeVerifier();
        [
    $_SESSION['code_challenge'] = computeCodeChallenge($_SESSION['code_verifier']);
            'grant_type'   => 'authorization_code',
            'client_id'     => $config['client_id'],
            'client_secret' => empty($config['client_secret']) ? null : $config['client_secret'],
            'redirect_uri'  => $baseURL,
            'code'          => $_GET['code'],
            'code_verifier' => $_SESSION['code_verifier']
        ]
    );


     // required parameters for the redirection, redirect_uri is where the browser should be redirected
     // We store the access token in the session so the user is "connected"
     // when the user grants (or denies) access, scope are the authorizations (rights) requested
     // Only if the request has been successfully executed
    $params = [
    if (isset($token['access_token'])) {
        'response_type'         => 'code',
         file_put_contents($localTokenFile, json_encode($token, true));
         'client_id'            => $clientID,
        'redirect_uri'          => $redirectURL,
        'scope'                => 'default.login',
        'state'                => $_SESSION['state'],
        'code_challenge'        => $_SESSION['code_challenge'],
        'code_challenge_method' => 'S256'
    ];


    // redirecting the browser to the AS authorization endpoint to obtain the authorization code
        // Redirecting the user's browser to the "home" page
    header('Location: ' . $authorizeURL . '?' . http_build_query($params));
        header('Location: ' . $baseURL);
}
    } else {
        echo $token;
    }
    die();
}</php>


/**
;Ce script a été conçu pour montrer le fonctionnement du mécanisme afin de tester l'implémentation d'un serveur et n'a pas été testé extensivement. Il est conseillé d'utiliser une solution adaptée à un environnement de production.
* This function deletes the access token from the session
*
* @param string $baseURL
*/
function logout(string $baseURL): void
{
    global $localTokenFile;
    file_put_contents($localTokenFile, '');


    header('Location: ' . $baseURL);
==Client Credentials==
}
Ce mécanisme d'autorisation est adapté pour l'automatisation. Il fonctionne de la manière suivante :
*Le client effectue la demande de jeton d'accès au serveur d'autorisation en fournissant ses identifiants.
*Le serveur authentifie le client avec les identifiants fournis et renvoie un jeton d'accès.
*Le client utilise ce jeton d'accès pour accéder à des données via l'API.


function displayMenuLoggedIn(): void
{
    echo '<h2><a href="/">Home</a></h2>';
    echo '<h3>Logged In</h3>';


     echo '<form id="view_repos" method="post">';
     +------+                      +-------------+                  +-----------+
     echo '<input type="hidden" id="action" name="action" value="view">';
    |Client|                      |  Serveur  |                  |  Serveur  |
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'view_repos\').submit(); return false;">View Repos</a></p>';
     +--+---+                      |Autorisation |                  | Ressources|
    echo '</form>';
      |                          +------+------+                  +-----+-----+
      |        Authentification          |                              |
      |        + Demande token          |                              |
      +--------------------------------->|                              |
      |                                  |                              |
      |          Access token            |                              |
      |<---------------------------------+                              |
      |                                  |                              |
      |                      Requête vers|API                            |
      +----------------------------------+------------------------------>|
      |                                  |                              |
      |                                  |                              |
      |                                  |<------------------------------+
      |                                  |  Vérification d'autorisation  |
      |                                  +------------------------------>|
      |                                  |                              |
      |                        Données /|Réponse                        |
      |<---------------------------------+-------------------------------+
      |                                  |                              |
 


    echo '<form id="logout" method="post">';
    echo '<input type="hidden" id="action" name="action" value="logout">';
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'logout\').submit(); return false;">Log Out</a></p>';
    echo '</form>';
}


function displayMenuLoggedOut(): void
===Demande de jeton d'accès===
{
Pour obtenir un jeton d'accès, il faut effectuer la requête suivante : <code>POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php</code>. Remplacer <code>nom-de-plateforme</code> par le nom de la plateforme utilisée.
    echo '<h2><a href="/">Home</a></h2>';
    echo '<h3>Not logged in</h3>';
    echo '<form id="login" method="post">';
    echo '<input type="hidden" id="action" name="action" value="login">';
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'login\').submit(); return false;">Log In</a></p>';
    echo '</form>';
}


// display client "home" page
Les paramètres suivants sont nécessaires :
if (!isset($_POST['action'])) {
{| class="wikitable"
    if (!empty($localToken['access_token'])) {
!Nom!!Type!!Description
        displayMenuLoggedIn();
|-
    } else {
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
        displayMenuLoggedOut();
|-
    }
|client_secret||string||La passphrase reçue pendant l'enregistrement du client.
}
|-
|grant_type||string||Le mécanisme d'autorisation utilisé. Ici, la valeur doit être ''client_credentials''.
|-
|scope||string||[[#Liste-des-scopes-disponibles|Liste des droits demandés par le client]], séparé par des espaces.
|}
 
;Ce mécanisme a la particularité de ne pas nécessiter d'URI de redirection, il n'est donc pas utile d'en renseigner un lors de l'enregistrement d'un client.
 
Si la requête est correcte, un jeton d'accès (Access Token) est fourni en réponse dans un objet au format JSON.
<javascript>{
  "token_type": "Bearer",
  "expires_in": 3600,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw"
}</javascript>


if (isset($_POST['action'])) {
===Script client : Client Credentials===
    // Building query array for resource dumping
Voici un exemple simple d'un client OAuth2 pour le mécanisme d'authentification par les identifiants client (Client Credentials).
    $repoQueryParameters = [
        'resource_type' => 'user_information',
        'client_id' => $config['client_id']
    ];
    switch ($_POST['action']) {
        case 'login':
            login($config['client_id'], $baseURL, $config['authorize_uri']);
            break;
        case 'logout':
            logout($baseURL);
            break;
        case 'view':
            // call to the resource server to retreive user information
            $resources = apiRequest(
                $config['resource_uri'],
                $repoQueryParameters,
                $localToken,
                false
            );


            // Separating headers from body
Fichier de configuration ''config.clientcred.json'' :
            list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
<javascript>{
  "client_id": "",
  "client_secret": "",
  "token_uri": "https://openflyers.com/nom-de-plateforme/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/nom-de-plateforme/oauth/resources.php",
  "revoke_uri": "https://openflyers.com/nom-de-plateforme/oauth/revoke.php",
  "auth_cert": "/path/to/client/auth_cert.crt",
  "auth_key": "/path/to/client/auth.key",
  "sign_cert": "/path/to/client/sign_cert.crt",
  "sign_key": "/path/to/client/sign.key",
  "auth_cacert": "/path/to/ca.crt",
  "sign_cert_server": "/path/to/server/sign_cert_server.crt"
}</javascript>
Où <code>/path/to/client/</code> est le chemin d'accès vers le dossier qui contient le code source du client de démonstration.
*Exemple sur '''windows''': <code>C:/wamp64/www/4.0/oauth-demo/ssl/ClientCredDemo/</code>.
*Exemple sur un serveur Linux '''debian''': <code>./ssl/ClientCredDemo/</code>.


            $resourceHeaders = explode("\r\n", $resourceHeader);
Ce fichier de configuration doit se situer au même niveau que le script PHP dans le système de fichiers.
            $firstHeaderLine = array_shift($resourceHeaders);
 
Script php :
<php><?php
$localTokenFile    = 'token.json';
// create token file if it does not exist
if (!file_exists($localTokenFile))
    file_put_contents($localTokenFile, '');


            // Displaying user information
$config                = json_decode(file_get_contents('config.clientcred.json'), true);
            echo '<pre>';
$localToken             = json_decode(file_get_contents($localTokenFile), true);
             echo $resourceBody;
$GLOBALS['config']      = $config;
            echo '</pre>';


            // Automatic refreshing token once access token is expired
// Build the baseURL, accounting for protocol, port, name and endpoint. Used for redirection
            if (strpos($firstHeaderLine, "401")) {
$protocol = isset($_SERVER['HTTPS']) ? 'https://' : 'http://';
                $errorBody = json_decode($resourceBody, true);
$port    = ($protocol == 'https://' && $_SERVER['SERVER_PORT'] == 443)
                if ($errorBody['error'] == 'access_denied' && isset($errorBody['hint'])) {
     || ($protocol == 'http://' && $_SERVER['SERVER_PORT'] == 80) ? '' : ':' . $_SERVER['SERVER_PORT'];
                    if ($errorBody['hint'] == 'Access token could not be verified') {
                        $token = apiRequest(
                            $config['token_uri'],
                            [
                                'grant_type'    => 'refresh_token',
                                'refresh_token' => $localToken['refresh_token'],
                                'client_id'     => $config['client_id'],
                                'client_secret' => empty($config['client_secret']) ? null : $config['client_secret']
                            ],
                            false,
                            true,
                            true
                        );


                        // We store the access token in the session so the user is "connected"
$baseURL            = $protocol . $_SERVER['SERVER_NAME'] . $port . $_SERVER['PHP_SELF'];
                        // Only if the request has been successfully executed
$errorLog          = 'error_log.log';
                        if (isset($token['access_token'])) {
$responseLog        = 'response_log.log';
                            file_put_contents($localTokenFile, json_encode($token, true));
$GLOBALS['baseURL'] = $baseURL;


                            // Redirecting the user's browser to the "home" page
$replacementListItems = [
                            header('Location: ' . $baseURL);
    1 => "year",
                        }
    2 => "validityTypeId",
                    }
    3 => "icao",
                }
    4 => "profileId",
            }
    7 => "accountingId",
            break;
    8 => "paymentType",
    }
    9 => "startDate",
}
    10 => "endDate",
    11 => "occupiedSeat",
    12 => "date",
    13 => "activityTypeId",
    14 => "age",
    15 => "resourceId",
    16 => "personId",
    17 => "accountId",
    20 => "rightPlacePersonId",
    21 => "month",
    22 => "numberMonth",
    23 => "oneValidityTypeId",
];
 
//Session cookies are used to store information necessary for the authorization code flow
session_start();


// Once the browser has been redirected to the AS to ask for the user's authorization, assuming it has been granted,
/**
// the browser will get back here with a "code" parameter in the query string
* This function is used to make api calls to the RS
if (isset($_GET['code'])) {
*
     // The AS MUST redirect the browser here with the exact same state parameter we sent it before, so we check if it is indeed the same
* @param      $url
    // to detect if the oauth flow has been tampered with
* @param      $post
    if (!isset($_GET['state']) || $_SESSION['state'] != $_GET['state']) {
* @param array $headers
        header('Location: ' . $baseURL . '?error=invalid_state');
*
        die();
* @return mixed
     }
*/
function apiRequest($url, $post = null, $token = false, $auth = true, $headers = array())
{
     $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, true);
 
     $method = 'get';


     // We communicate directly with the AS to exchange the code received against an access token.
     if ($post) {
    // The id/secret pair is send to authenticate the client, the redirect_uri is sent to verify the code's validity
         $method  = 'post';
    $token = apiRequest(
         $postData = http_build_query($post);
         $config['token_uri'],
        curl_setopt($ch, CURLOPT_POST, true);
         [
        curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
            'grant_type'    => 'authorization_code',
            'client_id'    => $config['client_id'],
            'client_secret' => empty($config['client_secret']) ? null : $config['client_secret'],
            'redirect_uri'  => $baseURL,
            'code'          => $_GET['code'],
            'code_verifier' => $_SESSION['code_verifier']
        ]
    );


    // We store the access token in the session so the user is "connected"
        $headersToSign['Content-Type'] = 'application/x-www-form-urlencoded';
    // Only if the request has been successfully executed
        $headersToSign['digest']       = 'SHA-256=' . base64_encode(hash('sha256', $postData, true));
    if (isset($token['access_token'])) {
        file_put_contents($localTokenFile, json_encode($token, true));
 
        // Redirecting the user's browser to the "home" page
        header('Location: ' . $baseURL);
    } else {
        echo $token;
     }
     }
    die();
}</php>


;Ce script a été conçu pour montrer le fonctionnement du mécanisme afin de tester l'implémentation d'un serveur et n'a pas été testé extensivement. Il est conseillé d'utiliser une solution adaptée à un environnement de production.
    $urlComponents = parse_url($url);


===Client Credentials===
    $headersToSign['(request-target)'] = $method . ' ' . $urlComponents['path'];
Ce mécanisme d'autorisation est adapté pour l'automatisation. Il fonctionne de la manière suivante :
    $headersToSign['Host']            = $urlComponents['host'];
*Le client effectue la demande de jeton d'accès au serveur d'autorisation en fournissant ses identifiants.
    $headersToSign['Date']            = gmdate('D, j M Y H:i:s T');
*Le serveur authentifie le client avec les identifiants fournis et renvoie un jeton d'accès.
*Le client utilise ce jeton d'accès pour accéder à des données via l'API.


    // generating the signature header
    $keyId                = openssl_x509_fingerprint(file_get_contents($GLOBALS['config']['sign_cert']));
    $privateKey          = file_get_contents($GLOBALS['config']['sign_key']);
    $headers['Signature'] = generateSignatureHeader($headersToSign, $keyId, $privateKey);


     +------+                      +-------------+                  +-----------+
     $headers['Accept']    = 'application/json';
     |Client|                      |  Serveur  |                  |  Serveur  |
    $headers['User-Agent'] = $GLOBALS['baseURL'];
     +--+---+                      |Autorisation |                  | Ressources|
     unset($headersToSign['(request-target)']);
      |                          +------+------+                  +-----+-----+
     $headers              += $headersToSign;
      |        Authentification          |                              |
 
      |         + Demande token         |                              |
    if ($token) {
      +--------------------------------->|                              |
         $headers['Authorization'] = $token['token_type'] . ' ' . $token['access_token'];
      |                                  |                              |
    }
      |          Access token           |                              |
      |<---------------------------------+                              |
      |                                  |                              |
      |                      Requête vers|API                            |
      +----------------------------------+------------------------------>|
      |                                  |                              |
      |                                  |                              |
      |                                  |<------------------------------+
      |                                  |  Vérification d'autorisation  |
      |                                  +------------------------------>|
      |                                  |                              |
      |                        Données /|Réponse                        |
      |<---------------------------------+-------------------------------+
      |                                  |                              |


    // formatting the headers
    $httpFormattedHeaders = [];
    foreach ($headers as $key => $value) {
        $httpFormattedHeaders[] = trim($key) . ': ' . trim($value);
    }


    curl_setopt($ch, CURLOPT_HTTPHEADER, $httpFormattedHeaders);
    curl_setopt($ch, CURLINFO_HEADER_OUT, true);


====Demande de jeton d'accès====
    // for development environment only
Pour obtenir un jeton d'accès, il faut effectuer la requête suivante : <code>POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php</code>
    //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
    //curl_setopt($ch, CURLOPT_VERBOSE, true);


Les paramètres suivants sont nécessaires :
    // defining TLS client certificates for Mutual TLS
{| class="wikitable"
    curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
!Nom!!Type!!Description
    curl_setopt($ch, CURLOPT_CAINFO, $GLOBALS['config']['auth_cacert']);
|-
    curl_setopt($ch, CURLOPT_SSLCERT, $GLOBALS['config']['auth_cert']);
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
    curl_setopt($ch, CURLOPT_SSLKEY, $GLOBALS['config']['auth_key']);
|-
|client_secret||string||La passphrase reçue pendant l'enregistrement du client.
|-
|grant_type||string||Le mécanisme d'autorisation utilisé. Ici, la valeur doit être ''client_credentials''.
|-
|scope||string||[[#Liste-des-scopes-disponibles|Liste des droits demandés par le client]], séparé par des espaces.
|}


;Ce mécanisme a la particularité de ne pas nécessiter d'URI de redirection, il n'est donc pas utile d'en renseigner un lors de l'enregistrement d'un client.
    $response = curl_exec($ch);


Si la requête est correcte, un jeton d'accès (Access Token) est fourni en réponse dans un objet au format JSON.
    // logging errors and responses
<javascript>{
    errorLog(true, $response, $ch);
  "token_type": "Bearer",
  "expires_in": 3600,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw"
}</javascript>


====Script client : Client Credentials====
    curl_close($ch);
Voici un exemple simple d'un client OAuth2 pour le mécanisme d'authentification par les identifiants client (Client Credentials).


Fichier de configuration ''config.clientcred.json'' :
    // in case an authentication request is executed
<javascript>{
    if ($auth) {
  "client_id": "",
        list($responseHeader, $responseBody) = explode("\r\n\r\n", $response, 2);
  "client_secret": "",
  "token_uri": "https://openflyers.com/nom-de-plateforme/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/nom-de-plateforme/oauth/resource.php",
  "auth_cert": "/path/to/client/auth_cert.crt",
  "auth_key": "/path/to/client/auth.key",
  "sign_cert": "/path/to/client/sign_cert.crt",
  "sign_key": "/path/to/client/sign.key",
  "auth_cacert": "/path/to/ca.crt",
  "sign_cert_server": "/path/to/server/sign_cert_server.crt"
}</javascript>


Ce fichier de configuration doit se situer au même niveau que le script PHP dans le système de fichiers.
        $responseHeadersDigest = '';
        $responseHeadersSignature = '';
        // extracting digest and signature from headers
        $responseHeadersArray = explode("\r\n", $responseHeader);
        $responseProtocol = array_shift($responseHeadersArray);


Script php :
        foreach ($responseHeadersArray as $value) {
<php><?php
            list($responseHeadersKeys, $responseHeadersValue) = explode(": ", $value, 2);
$localTokenFile    = 'token.json';
            $responseHeaders[strtolower($responseHeadersKeys)] = $responseHeadersValue;
// create token file if it does not exist
        }
if (!file_exists($localTokenFile))
    file_put_contents($localTokenFile, '');


$config                = json_decode(file_get_contents('config.clientcred.json'), true);
        $responseDigestAlgo = '';
$localToken            = json_decode(file_get_contents($localTokenFile), true);
        $responseDigestKey = '';
$GLOBALS['config']      = $config;
        foreach ($responseHeaders as $key => $value) {
            if ($key === "digest") {
                $responseHeadersDigest = $value;
                // stripping SHA algorithm for later comparison
                list($responseDigestAlgo, $responseDigestKey) = explode("=", $responseHeadersDigest, 2);
            } else if ($key === "signature")
                $responseHeadersSignature = $value;
        }


// Build the baseURL, accounting for protocol, port, name and endpoint. Used for redirection
        // calculating response digest
$protocol = isset($_SERVER['HTTPS']) ? 'https://' : 'http://';
        $responseDigest = base64_encode(hash(strtolower(str_replace("-", "", $responseDigestAlgo)), $responseBody, true));
$port    = ($protocol == 'https://' && $_SERVER['SERVER_PORT'] == 443)
    || ($protocol == 'http://' && $_SERVER['SERVER_PORT'] == 80) ? '' : ':' . $_SERVER['SERVER_PORT'];


$baseURL            = $protocol . $_SERVER['SERVER_NAME'] . $port . $_SERVER['PHP_SELF'];
        // checking digest validity
$errorLog          = 'error_log.log';
        if ($responseDigest !== $responseDigestKey) {
$responseLog        = 'response_log.log';
            errorLog(false, false, "Digests are not the same");
$GLOBALS['baseURL'] = $baseURL;
            die();
        }
 
        // extracting variables from signature header
        $signatureArray = explode(",", $responseHeadersSignature);
        foreach ($signatureArray as $value) {
            list($signatureKey, $signatureValue) = explode("=", $value, 2);
            $signature[$signatureKey] = trim($signatureValue, '"');
        }


$replacementListItems = [
        // generating siging string
    1 => "year",
        $signingStringArray = explode(" ", $signature['headers']);
    2 => "validityTypeId",
        $signingString = '';
    3 => "icao",
        foreach ($signingStringArray as $value) {
    4 => "profileId",
            $signingString = $signingString . trim($value) . ": " . trim($responseHeaders[$value]) . "\n";
    7 => "accountingId",
        }
    8 => "paymentType",
 
    9 => "startDate",
        // trimming last '\n' character
    10 => "endDate",
        $signingString = trim($signingString);
    11 => "occupiedSeat",
    12 => "date",
    13 => "activityTypeId",
    14 => "age",
    15 => "resourceId",
    16 => "personId",
    17 => "accountId",
    20 => "rightPlacePersonId",
    21 => "month",
    22 => "numberMonth",
    23 => "oneValidityTypeId",
];


//Session cookies are used to store information necessary for the authorization code flow
        // decoding signature
session_start();
        $decodedSignature = base64_decode($signature['signature']);


/**
        // verifying signature
* This function is used to make api calls to the RS
        $signatureVerify = openssl_verify($signingString, $decodedSignature, openssl_get_publickey(file_get_contents($GLOBALS['config']['sign_cert_server'])), 'RSA-SHA256');
*
* @param      $url
* @param      $post
* @param array $headers
*
* @return mixed
*/
function apiRequest($url, $post = null, $token = false, $auth = true, $headers = array())
{
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, true);


    $method = 'get';
        if (!$signatureVerify) {
            errorLog(false, false, "Signature is not correct");
            while (($err = openssl_error_string()))
                errorLog(false, false, $err);
            die();
        }


    if ($post) {
         return json_decode($responseBody, true);
        $method  = 'post';
         $postData = http_build_query($post);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
 
        $headersToSign['Content-Type'] = 'application/x-www-form-urlencoded';
        $headersToSign['digest']      = 'SHA-256=' . base64_encode(hash('sha256', $postData, true));
     }
     }


     $urlComponents = parse_url($url);
     return $response;
}


    $headersToSign['(request-target)'] = $method . ' ' . $urlComponents['path'];
/**
     $headersToSign['Host']            = $urlComponents['host'];
* This function logs curl responses and errors in text files
    $headersToSign['Date']            = gmdate('D, j M Y H:i:s T');
*
* @param mixed $response the response
* @param mixed $request  the request handle, used to get errors
*/
function errorLog($curl, $response, $request = false)
{
     $timestamp = '[' . date('Y-m-d H:i:s') . ']:';
    global $errorLog;
    global $responseLog;


     // generating the signature header
     if ($response === false) {
    $keyId                = openssl_x509_fingerprint(file_get_contents($GLOBALS['config']['sign_cert']));
        if ($curl)
    $privateKey          = file_get_contents($GLOBALS['config']['sign_key']);
            file_put_contents($errorLog, $timestamp . curl_error($request) . "\n", FILE_APPEND);
    $headers['Signature'] = generateSignatureHeader($headersToSign, $keyId, $privateKey);
        else
 
            file_put_contents($errorLog, $timestamp . $request . "\n", FILE_APPEND);
    $headers['Accept']    = 'application/json';
     } else {
    $headers['User-Agent'] = $GLOBALS['baseURL'];
         file_put_contents($responseLog, $timestamp . "\n" . $response . "\n", FILE_APPEND);
    unset($headersToSign['(request-target)']);
     $headers              += $headersToSign;
 
    if ($token) {
         $headers['Authorization'] = $token['token_type'] . ' ' . $token['access_token'];
     }
     }
}


     // formatting the headers
/**
     $httpFormattedHeaders = [];
* This function generates the full signature header line from a set of headers, a certificate and the linked private key
     foreach ($headers as $key => $value) {
*
         $httpFormattedHeaders[] = trim($key) . ': ' . trim($value);
* @param array  $headersToSign the headers to sign, in the $key => $value format
     }
* @param string $certificate  the certificate linked to the used private key
 
* @param string $privateKey    the private key used to sign the headers
     curl_setopt($ch, CURLOPT_HTTPHEADER, $httpFormattedHeaders);
*
    curl_setopt($ch, CURLINFO_HEADER_OUT, true);
* @return string the full signature header line
 
*/
    // for development environment only
function generateSignatureHeader(array $headersToSign, string $certificate, string $privateKey): string
     //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
{
    //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
     // generating the signing string and header list
    //curl_setopt($ch, CURLOPT_VERBOSE, true);
    $headers         = '';
     $signatureString = '';
     foreach ($headersToSign as $key => $value) {
         $normalizedHeaderKey = trim(strtolower($key));
        $headers            .= $normalizedHeaderKey . ' ';
        $signatureString    .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
     }
     $headers        = trim($headers);
     $signatureString = trim($signatureString);


     // defining TLS client certificates for Mutual TLS
     // signing the signing string
     curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
     $signature = '';
     curl_setopt($ch, CURLOPT_CAINFO, $GLOBALS['config']['auth_cacert']);
     openssl_sign($signatureString, $signature, openssl_get_privatekey($privateKey), 'RSA-SHA256');
    curl_setopt($ch, CURLOPT_SSLCERT, $GLOBALS['config']['auth_cert']);
     $signature = base64_encode($signature);
     curl_setopt($ch, CURLOPT_SSLKEY, $GLOBALS['config']['auth_key']);


     $response = curl_exec($ch);
     // compiling the header line
    return "keyId=\"$certificate\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";
}


    // logging errors and responses
/**
     errorLog(true, $response, $ch);
* This function deletes the access token from the session
*
* @param string $baseURL
*/
function logout(string $baseURL): void
{
     global $localTokenFile;
    file_put_contents($localTokenFile, '');


     curl_close($ch);
     header('Location: ' . $baseURL);
}


    // in case an authentication request is executed
function displayMenuLoggedIn(): void
    if ($auth) {
{
        list($responseHeader, $responseBody) = explode("\r\n\r\n", $response, 2);
    global $replacementListItems;
    echo '<h2><a href="/">Home</a></h2>';
    echo '<h3>Logged In</h3>';


         $responseHeadersDigest = '';
    echo '<form id="view_repos" method="post">';
         $responseHeadersSignature = '';
    echo '<label for="report_id">Report ID: </label>';
        // extracting digest and signature from headers
    echo '<input type="number" id="report_id" name="report_id"><br><br>';
        $responseHeadersArray = explode("\r\n", $responseHeader);
    foreach ($replacementListItems as $value) {
        $responseProtocol = array_shift($responseHeadersArray);
         echo '<label for="' . $value . '">' . $value . ': </label>';
         echo '<input type="text" id="' . $value . '" name="' . $value . '"><br><br>';
    }
    echo '<input type="hidden" id="action" name="action" value="view">';
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'view_repos\').submit(); return false;">View Repos</a></p>';
    echo '</form>';


        foreach ($responseHeadersArray as $value) {
    echo '<form id="logout" method="post">';
            list($responseHeadersKeys, $responseHeadersValue) = explode(": ", $value, 2);
    echo '<input type="hidden" id="action" name="action" value="logout">';
            $responseHeaders[strtolower($responseHeadersKeys)] = $responseHeadersValue;
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'logout\').submit(); return false;">Log Out</a></p>';
        }
    echo '</form>';
}


        $responseDigestAlgo = '';
function displayMenuLoggedOut(): void
        $responseDigestKey = '';
{
        foreach ($responseHeaders as $key => $value) {
    echo '<h2><a href="/">Home</a></h2>';
            if ($key === "digest") {
    echo '<h3>Not logged in</h3>';
                $responseHeadersDigest = $value;
    echo '<form id="login" method="post">';
                // stripping SHA algorithm for later comparison
    echo '<input type="hidden" id="action" name="action" value="login">';
                list($responseDigestAlgo, $responseDigestKey) = explode("=", $responseHeadersDigest, 2);
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'login\').submit(); return false;">Log In</a></p>';
            } else if ($key === "signature")
    echo '</form>';
                $responseHeadersSignature = $value;
}
        }


        // calculating response digest
// display client "home" page
        $responseDigest = base64_encode(hash(strtolower(str_replace("-", "", $responseDigestAlgo)), $responseBody, true));
if (!isset($_POST['action'])) {
    if (!empty($localToken['access_token'])) {
        displayMenuLoggedIn();
    } else {
        displayMenuLoggedOut();
    }
}


        // checking digest validity
if (isset($_POST['action'])) {
        if ($responseDigest !== $responseDigestKey) {
    $replacementList = [];
            errorLog(false, false, "Digests are not the same");
    // Building replacement list
            die();
    foreach ($replacementListItems as $key => $value) {
        }
         $replacementList[$value] = (isset($_POST[$value]) && strlen($_POST[$value]) > 0) ? $_POST[$value] : null;
 
    }
        // extracting variables from signature header
    // Building query array
        $signatureArray = explode(",", $responseHeadersSignature);
    $repoQueryParameters = [
         foreach ($signatureArray as $value) {
         'resource_type' => 'generic_report',
            list($signatureKey, $signatureValue) = explode("=", $value, 2);
         'client_id' => $config['client_id'],
            $signature[$signatureKey] = trim($signatureValue, '"');
        'report_id' => (isset($_POST['report_id']) && strlen($_POST['report_id']) > 0) ? $_POST['report_id'] : null,
        }
         'replacementList' => $replacementList
 
    ];
         // generating siging string
    switch ($_POST['action']) {
         $signingStringArray = explode(" ", $signature['headers']);
        case 'login':
         $signingString = '';
             $token = apiRequest(
        foreach ($signingStringArray as $value) {
                $config['token_uri'],
             $signingString = $signingString . trim($value) . ": " . trim($responseHeaders[$value]) . "\n";
                [
        }
                    'grant_type'    => 'client_credentials',
                    'client_id'    => $config['client_id'],
                    'client_secret' => empty($config['client_secret']) ? null : $config['client_secret'],
                    'scope'        => 'genericreports.readonly reports.readonly'
                ]
            );
            // We store the access token in the session so the user is "connected"
            // Only if the request has been successfully executed
            if (isset($token['access_token'])) {
                file_put_contents($localTokenFile, json_encode($token, true));


        // trimming last '\n' character
                // Redirecting the user's browser to the "home" page
        $signingString = trim($signingString);
                header('Location: ' . $baseURL);
 
            } else {
         // decoding signature
                echo $token;
        $decodedSignature = base64_decode($signature['signature']);
            }
 
            break;
         // verifying signature
         case 'logout':
        $signatureVerify = openssl_verify($signingString, $decodedSignature, openssl_get_publickey(file_get_contents($GLOBALS['config']['sign_cert_server'])), 'RSA-SHA256');
            logout($baseURL);
            break;
         case 'view':
            // call to the resource server
            $resources = apiRequest(
                $config['resource_uri'],
                $repoQueryParameters,
                $localToken,
                false
            );


        if (!$signatureVerify) {
            // Separating headers from body
             errorLog(false, false, "Signature is not correct");
             list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
            while (($err = openssl_error_string()))
                errorLog(false, false, $err);
            die();
        }


        return json_decode($responseBody, true);
            $resourceHeaders = explode("\r\n", $resourceHeader);
    }
            $firstHeaderLine = array_shift($resourceHeaders);


    return $response;
            // Building form for download CSV button
}
            echo '<form method="post">';
            foreach ($_POST as $key => $value) {
                if ($key == "action") {
                    $value = "download";
                }
                echo '<input type="hidden" id="' . $key . '" name="' . $key . '" value="' . $value . '">';
            }
            if (isset($_POST['report_id']) && strlen($_POST['report_id']) > 0 && !isset(json_decode($resourceBody, true)['error'])) {
                echo '<button>Download as CSV</button>';
            }
            echo '</form>';


/**
            // Displaying requested content
* This function logs curl responses and errors in text files
            echo '<pre>';
*
            echo (strpos($firstHeaderLine, "200")) ? json_decode($resourceBody) : $resourceBody;
* @param mixed $response the response
            echo '</pre>';
* @param mixed $request  the request handle, used to get errors
            break;
*/
        case 'download':
function errorLog($curl, $response, $request = false)
            // call to the resource server
{
            $resources = apiRequest(
    $timestamp = '[' . date('Y-m-d H:i:s') . ']:';
                $config['resource_uri'],
    global $errorLog;
                $repoQueryParameters,
    global $responseLog;
                $localToken,
                false
            );


    if ($response === false) {
            // Separating headers from body
        if ($curl)
             list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
             file_put_contents($errorLog, $timestamp . curl_error($request) . "\n", FILE_APPEND);
             $resourceHeaders = explode("\r\n", $resourceHeader);
        else
            array_shift($resourceHeaders);
             file_put_contents($errorLog, $timestamp . $request . "\n", FILE_APPEND);
    } else {
        file_put_contents($responseLog, $timestamp . "\n" . $response . "\n", FILE_APPEND);
    }
}


/**
            // Dumping headers to insert them in current page
* This function generates the full signature header line from a set of headers, a certificate and the linked private key
            foreach ($resourceHeaders as $key => $value) {
*
                header($value);
* @param array  $headersToSign the headers to sign, in the $key => $value format
             }
* @param string $certificate  the certificate linked to the used private key
            echo json_decode($resourceBody);
* @param string $privateKey    the private key used to sign the headers
            break;
*
* @return string the full signature header line
*/
function generateSignatureHeader(array $headersToSign, string $certificate, string $privateKey): string
{
    // generating the signing string and header list
    $headers        = '';
    $signatureString = '';
    foreach ($headersToSign as $key => $value) {
        $normalizedHeaderKey = trim(strtolower($key));
        $headers             .= $normalizedHeaderKey . ' ';
        $signatureString    .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
     }
     }
    $headers        = trim($headers);
}</php>
    $signatureString = trim($signatureString);


    // signing the signing string
;Ce script a été conçu pour montrer le fonctionnement du mécanisme et tester l'implémentation d'un serveur, il n'a pas été testé extensivement. Il est conseillé d'utiliser une solution adaptée à un environnement de production.
    $signature = '';
    openssl_sign($signatureString, $signature, openssl_get_privatekey($privateKey), 'RSA-SHA256');
    $signature = base64_encode($signature);


    // compiling the header line
==Refresh Token==
    return "keyId=\"$certificate\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";
Refresh Token (ou jeton de rafraîchissement en français) est un mécanisme d'autorisation particulier. Il ne peut fonctionner en tant que tel, il fonctionne de pair avec [[#Authorization-Code|Authorization Code]]. Lorsqu'un jeton d'accès arrive est arrivé en fin de vie, si le client y est autorisé, il peut faire une demande de renouvellement de son jeton d'accès auprès du serveur d'autorisation en présentant son jeton de rafraîchissement. Le serveur d'autorisation vérifie la validité et génère un autre jeton d'accès qu'il transmet au client, sans que l'utilisateur final n'aît à se connecter de nouveau.
}


/**
Le principe de fonctionnement du rafraîchissement d'un jeton est le suivant :
* This function deletes the access token from the session
* Le jeton d'accès du client est arrivé à péremption. Le client effectue une demande de renouvellement en transmettant son Refresh Token au serveur d'autorisation.
*
* Le serveur d'autorisation vérifie la validité des informations, "consomme" le jeton de rafraîchissement et génère une nouvelle paire de jetons
* @param string $baseURL
* Le client reçoit sa nouvelle paire et utilise le nouveau jeton d'accès pour accéder aux ressources
*/
function logout(string $baseURL): void
{
    global $localTokenFile;
    file_put_contents($localTokenFile, '');


     header('Location: ' . $baseURL);
     +------+                      +-------------+                  +-----------+
}
    |Client|                      |  Serveur  |                  |  Serveur  |
 
    +--+---+                      |Autorisation |                  | Ressources|
function displayMenuLoggedIn(): void
      |                          +------+------+                  +-----+-----+
{
      |        Authentification          |                              |
    global $replacementListItems;
      |        + Refresh Token          |                              |
    echo '<h2><a href="/">Home</a></h2>';
      +--------------------------------->|                              |
    echo '<h3>Logged In</h3>';
      |                                  |                              |
      |    Access (+ Refresh) token      |                              |
      |<---------------------------------+                              |
      |                                  |                              |
      |                      Requête vers|API                            |
      +----------------------------------+------------------------------>|
      |                                  |                              |
      |                                  |                              |
      |                                  |<------------------------------+
      |                                  |  Vérification d'autorisation  |
      |                                  +------------------------------>|
      |                                  |                              |
      |                        Données /|Réponse                        |
      |<---------------------------------+-------------------------------+
      |                                  |                              |
 
===Demande de renouvellement d'un jeton===
Pour obtenir un renouvellement de jeton d'accès, il faut effectuer la requête suivante : <code>POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php</code>. Remplacer <code>nom-de-plateforme</code> par le nom de la plateforme utilisée.


    echo '<form id="view_repos" method="post">';
Les paramètres suivants sont nécessaires :
    echo '<label for="report_id">Report ID: </label>';
{| class="wikitable"
    echo '<input type="number" id="report_id" name="report_id"><br><br>';
!Nom!!Type!!Description
    foreach ($replacementListItems as $value) {
|-
        echo '<label for="' . $value . '">' . $value . ': </label>';
|client_id||string||L'identifiant ''client_id'' reçu pendant l'enregistrement du client.
        echo '<input type="text" id="' . $value . '" name="' . $value . '"><br><br>';
|-
    }
|client_secret||string||La passphrase ''client_secret'' reçue pendant l'enregistrement du client.
    echo '<input type="hidden" id="action" name="action" value="view">';
|-
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'view_repos\').submit(); return false;">View Repos</a></p>';
|grant_type||string||Le mécanisme d'autorisation utilisé. Ici, la valeur doit être "refresh_token" (sans guillements).
    echo '</form>';
|-
|scope||string||('''OPTIONNEL''') Liste des droits demandés par le client, séparés par des espaces.
|}


    echo '<form id="logout" method="post">';
Si la requête est correcte, un jeton d'accès ''access_token'' est fourni en réponse dans un objet au format JSON.
    echo '<input type="hidden" id="action" name="action" value="logout">';
<javascript>{
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'logout\').submit(); return false;">Log Out</a></p>';
  "token_type": "Bearer",
    echo '</form>';
  "expires_in": 3600,
}
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw",
  "refresh_token": "a59ef39fa9bab9b95cd554f921e7f3080a34c90f23d2b8031d692b5ff2d0993dcc392d9c7f9a43242337ef144c1a5fe1d0174413ade973e1b628ac0bbfc39b23973534"
}</javascript>
 
==Liste des scopes disponibles==
Un scope sur OAuth2 correspond à un droit d'accès sur une ressource particulière. Chaque scope est unique et indique de manière explicite le privilège qu'il donne. Il n'y a aucune restriction d'utilisation des scopes par rapport aux mécanismes. Chaque scope peut être utilisé avec n'importe quel mécanisme. Il n'y a que des recommandations vis à vis de leur utilisation. OpenFlyers définit une liste de scopes dédiée aux ressources accessibles par les clients. Ces scopes sont les suivants :
{| class="wikitable"
!Nom!!Description
|-
|default.login||Comportement par défaut lorsqu'aucun scope n'est précisé ou qu'un scope est invalide. Ce scope est recommandé pour '''Authorization Code'''.
|-
|genericreports.readonly||Accéder aux rapports génériques autorisés pour le client en lecture seule. Ce scope est recommandé pour '''Client Credentials'''.
|-
|reports.readonly||Accéder aux rapports personnalisés autorisés pour le client en lecture seule. Ce scope est recommandé pour '''Client Credentials'''.
|}
==Prolonger la durée de vie de la session du client de démonstration==
La session du client de démonstration est initiée avec la méthode PHP [https://www.php.net/manual/en/function.session-start.php session_start]. Cette session peut être interrompue soit en cliquant sur le bouton de déconnexion, soit en fermant le navigateur (car les cookies associés à cette session se détruisent par défaut lorsque le navigateur est fermé).


function displayMenuLoggedOut(): void
Pour permettre à la session de rester active même après la fermeture du navigateur, il faut utiliser la méthode PHP [https://www.php.net/manual/en/function.session-set-cookie-params.php session_set_cookie_params]. Cette méthode donne la possibilité de définir une durée de vie pour les différents cookies associés à la session.
{
<php>// Set the parameters for the session cookie in a PHP session in order to configure its lifetime in 30 days
    echo '<h2><a href="/">Home</a></h2>';
$oauth2DemoSessionLifeTime = time() + (86400 * 30);
    echo '<h3>Not logged in</h3>';
session_set_cookie_params($oauth2DemoSessionLifeTime);</php>
    echo '<form id="login" method="post">';
 
    echo '<input type="hidden" id="action" name="action" value="login">';
NB: Cette approche n'est pas particulièrement sécurisée et peut présenter des risques de sécurité pour OpenFlyers. Par conséquent, elle doit être utilisée avec précaution.
    echo '<p><a href="javascript:{}" onclick="document.getElementById(\'login\').submit(); return false;">Log In</a></p>';
 
    echo '</form>';
==Révocation de token==
}
Pour initier la demande de révocation, rediriger le navigateur de l'utilisateur vers l'URL : <code>POST https://openflyers.com/nom-de-plateforme/oauth/revoke.php</code>. Remplacer <code>nom-de-plateforme</code> par le nom de la plateforme utilisée.


// display client "home" page
Envoyer également le paramètre suivant:
if (!isset($_POST['action'])) {
{| class="wikitable"
    if (!empty($localToken['access_token'])) {
!Nom!!Type!!Description
        displayMenuLoggedIn();
|-
    } else {
|access_token||string||Le jeton d'accès (Chaîne de caractère unique permettant de prouver qu'un client OAuth a le droit d'accéder à une ressource.)
        displayMenuLoggedOut();
|}
    }
<php> apiRequest(
}
                $config['revoke_uri'],
                ['access_token' => $_SESSION['auth_token']['access_token']],
                null,
                false
            );</php>
 
La demande de révocation se fait quand l'utilisateur clique sur le bouton '''Se déconnecter''' pour l'un des deux Clients '''Authorization Code''' et '''Client Credentials'''.
 
Si les jetons sont révoqués, l'utilisateur ne peut pas accéder à la plateforme OpenFlyers, il doit se reconnecter.
 
==Utiliser l'API==
Une fois un jeton d'accès obtenu, les données sont accessibles par une requête POST exécutée vers l'URL : <code>https://openflyers.com/nom-de-plateforme/oauth/resources.php</code>. Remplacer <code>nom-de-plateforme</code> par le nom de la plateforme utilisée. La requête POST doit respecter une structure particulière. Cette structure diffère en fonction du type de ressource souhaité et chaque ressource ne peut être accédée qu'[[#Liste-des-scopes-disponibles|avec le scope qui lui est associé]]. Le jeton d'accès doit être renseigné dans l'en-tête HTTP ''Authorization'' en y indiquant la valeur complète du jeton d'accès reçu précédé du type de jeton reçu  : <code>Authorization: <token_type> <access_token></code>.
 
===Récupérer les informations de l'utilisateur connecté===
Ce type de ressource est nommé '''user_information'''. Cette ressource n'est accessible qu'avec le scope '''default.login'''. Cette ressource permet la récupération des informations de l'utilisateur connecté, en d'autre termes, l'utilisateur connecté lors de l'étape d'autorisation et correspondant à celui ayant émis la demande de jeton d'accès. À l'heure actuelle, seul l'identifiant de l'utilisateur connecté est retourné. La requête POST est construite de la manière suivante :


if (isset($_POST['action'])) {
{| class="wikitable"
    $replacementList = [];
!Nom!!Type!!Description
    // Building replacement list
|-
    foreach ($replacementListItems as $key => $value) {
|resource_type||string||Le type de ressource demandé, ici, ce champ correspond à '''user_information'''.
        $replacementList[$value] = (isset($_POST[$value]) && strlen($_POST[$value]) > 0) ? $_POST[$value] : null;
|-
    }
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
    // Building query array
|}
    $repoQueryParameters = [
        'resource_type' => 'generic_report',
        'client_id' => $config['client_id'],
        'report_id' => (isset($_POST['report_id']) && strlen($_POST['report_id']) > 0) ? $_POST['report_id'] : null,
        'replacementList' => $replacementList
    ];
    switch ($_POST['action']) {
        case 'login':
            $token = apiRequest(
                $config['token_uri'],
                [
                    'grant_type'    => 'client_credentials',
                    'client_id'    => $config['client_id'],
                    'client_secret' => empty($config['client_secret']) ? null : $config['client_secret'],
                    'scope'        => 'genericreports.readonly reports.readonly'
                ]
            );
            // We store the access token in the session so the user is "connected"
            // Only if the request has been successfully executed
            if (isset($token['access_token'])) {
                file_put_contents($localTokenFile, json_encode($token, true));


                // Redirecting the user's browser to the "home" page
Un exemple de requête complète au format JSON :
                header('Location: ' . $baseURL);
<javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1
            } else {
Content-Type: application/x-www-form-urlencoded
                echo $token;
Host: openflyers.com
            }
Date: Wed, 04 Aug 2021 13:57:51 GMT
            break;
Accept: application/json
        case 'logout':
User-Agent: curl/7.64.1
            logout($baseURL);
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU
            break;
Signature: keyId="58c450d937953829c8cca3613001f865a918da07",
        case 'view':
          algorithm="rsa-sha256",
            // call to the resource server
          headers="host content-type digest",
            $resources = apiRequest(
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="
                $config['resource_uri'],
Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=
                $repoQueryParameters,
                $localToken,
                false
            );


            // Separating headers from body
{
            list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
    "resource_type":"user_information",
    "client_id":"d2615fe2020ec476"
}</javascript>


            $resourceHeaders = explode("\r\n", $resourceHeader);
La réponse est retournée dans un conteneur JSON.
            $firstHeaderLine = array_shift($resourceHeaders);


            // Building form for download CSV button
===Récupérer les rapports génériques===
            echo '<form method="post">';
Ce type de ressource est nommé '''generic_report'''. Cette ressource n'est accessible qu'avec le scope '''genericreports.readonly'''. Cette ressource permet la récupération des rapports génériques au format CSV autorisés pour le profil de l'utilisateur associé au client OAuth2 enregistré. La requête POST est construite de la manière suivante :
            foreach ($_POST as $key => $value) {
                if ($key == "action") {
                    $value = "download";
                }
                echo '<input type="hidden" id="' . $key . '" name="' . $key . '" value="' . $value . '">';
            }
            if (isset($_POST['report_id']) && strlen($_POST['report_id']) > 0 && !isset(json_decode($resourceBody, true)['error'])) {
                echo '<button>Download as CSV</button>';
            }
            echo '</form>';


            // Displaying requested content
{| class="wikitable"
            echo '<pre>';
!Nom!!Type!!Description
            echo (strpos($firstHeaderLine, "200")) ? json_decode($resourceBody) : $resourceBody;
|-
            echo '</pre>';
|resource_type||string||Le type de ressource demandé, ici, ce champ correspond à '''generic_report'''.
            break;
|-
        case 'download':
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
            // call to the resource server
|-
            $resources = apiRequest(
|report_id||int||Identifiant du rapport souhaité.
                $config['resource_uri'],
|-
                $repoQueryParameters,
|replacementList||array||Tableau correspondant aux différents paramètres modifiables pour générer le rapport souhaité.
                $localToken,
|}
                false
            );


            // Separating headers from body
Un exemple de requête complète au format JSON :
            list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
<javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1
            $resourceHeaders = explode("\r\n", $resourceHeader);
Content-Type: application/x-www-form-urlencoded
            array_shift($resourceHeaders);
Host: openflyers.com
 
Date: Wed, 04 Aug 2021 13:57:51 GMT
            // Dumping headers to insert them in current page
Accept: application/json
            foreach ($resourceHeaders as $key => $value) {
User-Agent: curl/7.64.1
                header($value);
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU
            }
Signature: keyId="58c450d937953829c8cca3613001f865a918da07",
            echo json_decode($resourceBody);
          algorithm="rsa-sha256",
            break;
          headers="host content-type digest",
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="
Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=
 
{
    "resource_type":"generic_report",
    "client_id":"d2615fe2020ec476",
    "report_id":135,
    "replacementList":{
        "year":2018
     }
     }
}</php>
}</javascript>


;Ce script a été conçu pour montrer le fonctionnement du mécanisme et tester l'implémentation d'un serveur, il n'a pas été testé extensivement. Il est conseillé d'utiliser une solution adaptée à un environnement de production.
La réponse est un fichier CSV retourné dans un conteneur JSON.


===Refresh Token===
===Récupérer les rapports personnalisés===
Refresh Token (ou jeton de rafraîchissement en français) est un mécanisme d'autorisation particulier. Il ne peut fonctionner en tant que tel, il fonctionne de pair avec [[#Authorization-Code|Authorization Code]]. Lorsqu'un jeton d'accès arrive est arrivé en fin de vie, si le client y est autorisé, il peut faire une demande de renouvellement de son jeton d'accès auprès du serveur d'autorisation en présentant son jeton de rafraîchissement. Le serveur d'autorisation vérifie la validité et génère un autre jeton d'accès qu'il transmet au client, sans que l'utilisateur final n'aît à se connecter de nouveau.
Ce type de ressource est nommé '''report'''. Cette ressource n'est accessible qu'avec le scope '''reports.readonly'''. Cette ressource permet la récupération des rapports personnalisés au format CSV autorisés pour le profil de l'utilisateur associé au client OAuth2 enregistré. La requête POST est construite de la manière suivante :


Le principe de fonctionnement du rafraîchissement d'un jeton est le suivant :
{| class="wikitable"
* Le jeton d'accès du client est arrivé à péremption. Le client effectue une demande de renouvellement en transmettant son Refresh Token au serveur d'autorisation.
!Nom!!Type!!Description
* Le serveur d'autorisation vérifie la validité des informations, "consomme" le jeton de rafraîchissement et génère une nouvelle paire de jetons
|-
* Le client reçoit sa nouvelle paire et utilise le nouveau jeton d'accès pour accéder aux ressources
|resource_type||string||Le type de ressource demandé, ici, ce champ correspond à '''report'''.
|-
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
|-
|report_id||int||Identifiant du rapport souhaité.
|-
|replacementList||array||Tableau correspondant aux différents paramètres modifiables pour générer le rapport souhaité.
|}


    +------+                      +-------------+                  +-----------+
Un exemple de requête complète au format JSON :
    |Client|                      |  Serveur  |                  |  Serveur  |
<javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1
    +--+---+                      |Autorisation |                  | Ressources|
Content-Type: application/x-www-form-urlencoded
      |                          +------+------+                  +-----+-----+
Host: openflyers.com
      |        Authentification          |                              |
Date: Wed, 04 Aug 2021 13:57:51 GMT
      |        + Refresh Token          |                              |
Accept: application/json
      +--------------------------------->|                              |
User-Agent: curl/7.64.1
      |                                  |                              |
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU
      |    Access (+ Refresh) token      |                              |
Signature: keyId="58c450d937953829c8cca3613001f865a918da07",
      |<---------------------------------+                              |
          algorithm="rsa-sha256",
      |                                  |                              |
          headers="host content-type digest",
      |                      Requête vers|API                            |
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="
      +----------------------------------+------------------------------>|
Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=
      |                                  |                              |
      |                                  |                              |
      |                                  |<------------------------------+
      |                                  |  Vérification d'autorisation  |
      |                                  +------------------------------>|
      |                                  |                              |
      |                        Données /|Réponse                        |
      |<---------------------------------+-------------------------------+
      |                                  |                              |


====Demande de renouvellement d'un jeton====
{
Pour obtenir un renouvellement de jeton d'accès, il faut effectuer la requête suivante : <code>POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php</code>
    "resource_type":"report",
 
    "client_id":"d2615fe2020ec476",
Les paramètres suivants sont nécessaires :
    "report_id":1,
{| class="wikitable"
    "replacementList":{
!Nom!!Type!!Description
        "year":2020
|-
    }
|client_id||string||L'identifiant ''client_id'' reçu pendant l'enregistrement du client.
}</javascript>
|-
|client_secret||string||La passphrase ''client_secret'' reçue pendant l'enregistrement du client.
|-
|grant_type||string||Le mécanisme d'autorisation utilisé. Ici, la valeur doit être "refresh_token" (sans guillements).
|-
|scope||string||('''OPTIONNEL''') Liste des droits demandés par le client, séparés par des espaces.
|}


Si la requête est correcte, un jeton d'accès ''access_token'' est fourni en réponse dans un objet au format JSON.
La réponse est un fichier CSV retourné dans un conteneur JSON.
<javascript>{
  "token_type": "Bearer",
  "expires_in": 3600,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw",
  "refresh_token": "a59ef39fa9bab9b95cd554f921e7f3080a34c90f23d2b8031d692b5ff2d0993dcc392d9c7f9a43242337ef144c1a5fe1d0174413ade973e1b628ac0bbfc39b23973534"
}</javascript>


===Liste des scopes disponibles===
=Procédures=
Un scope sur OAuth2 correspond à un droit d'accès sur une ressource particulière. Chaque scope est unique et indique de manière explicite le privilège qu'il donne. Il n'y a aucune restriction d'utilisation des scopes par rapport aux mécanismes. Chaque scope peut être utilisé avec n'importe quel mécanisme. Il n'y a que des recommandations vis à vis de leur utilisation. OpenFlyers définit une liste de scopes dédiée aux ressources accessibles par les clients. Ces scopes sont les suivants :
==Créer un client à partir du code source==
{| class="wikitable"
;Prérequis
!Nom!!Description
Un client de démonstration est disponible pour le logiciel OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/index.php
|-
 
|default.login||Comportement par défaut lorsqu'aucun scope n'est précisé ou qu'un scope est invalide. Ce scope est recommandé pour '''Authorization Code'''.
;Télécharger Le code source du client de démonstration :
|-
 
|genericreports.readonly||Accéder aux rapports génériques autorisés pour le client en lecture seule. Ce scope est recommandé pour '''Client Credentials'''.
Le code source est mis à disposition par OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/oauth2-demo-src.zip
|-
|reports.readonly||Accéder aux rapports personnalisés autorisés pour le client en lecture seule. Ce scope est recommandé pour '''Client Credentials'''.
|}


===Utiliser l'API===
Le code source est structuré de la manière suivante :
Une fois un jeton d'accès obtenu, les données sont accessibles par une requête POST exécutée vers l'URL : <code>https://openflyers.com/nom-de-plateforme/oauth/resources.php</code>. La requête POST doit respecter une structure particulière. Cette structure diffère en fonction du type de ressource souhaité et chaque ressource ne peut être accédée qu'[[#Liste-des-scopes-disponibles|avec le scope qui lui est associé]]. Le jeton d'accès doit être renseigné dans l'en-tête HTTP ''Authorization'' en y indiquant la valeur complète du jeton d'accès reçu précédé du type de jeton reçu  : <code>Authorization: <token_type> <access_token></code>.


====Récupérer les informations de l'utilisateur connecté====
[[File:Oauth2 src demo folder.png|800px]]
Ce type de ressource est nommé '''user_information'''. Cette ressource n'est accessible qu'avec le scope '''default.login'''. Cette ressource permet la récupération des informations de l'utilisateur connecté, en d'autre termes, l'utilisateur connecté lors de l'étape d'autorisation et correspondant à celui ayant émis la demande de jeton d'accès. À l'heure actuelle, seul l'identifiant de l'utilisateur connecté est retourné. La requête POST est construite de la manière suivante :


{| class="wikitable"
* Le dossier '''css''' contient tout le matériel nécessaire à la stylisation de la page web.
!Nom!!Type!!Description
* Le dossier '''img''' contient les images affichées sur la page web.
|-
* Le dossier '''ssl''' est le dossier contenant tous les certificats et les clé privées associées à chaque client. Il doit respecter une structure particulière décrite ci-dessous.
|resource_type||string||Le type de ressource demandé, ici, ce champ correspond à '''user_information'''.
* Le fichier '''ClientDemo.php''' contient la classe '''ClientDemo'''. Cette classe contient toutes les méthodes nécessaires au fonctionnement du client de démonstration OAuth2.
|-
* Le fichier '''index.php''' est le fichier à appeler depuis le navigateur. Ce fichier correspond au fichier qui gère les appels à la classe '''ClientDemo''' et exécute les méthodes dans l'ordre.
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
|}


Un exemple de requête complète au format JSON :
Le dossier '''ssl''' doit respecter la structure suivante :
<javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1
 
Content-Type: application/x-www-form-urlencoded
[[File:Oauth2 demo tree.png]]
Host: openflyers.com
Date: Wed, 04 Aug 2021 13:57:51 GMT
Accept: application/json
User-Agent: curl/7.64.1
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU
Signature: keyId="58c450d937953829c8cca3613001f865a918da07",
          algorithm="rsa-sha256",
          headers="host content-type digest",
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="
Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=


{
;[[#Générer des certificats|Générer les certificats]] :
    "resource_type":"user_information",
Après la génération des certificats, les clés privées 'auth.key' et 'sign.key' remplacent celles présentes dans les dossiers 'ssl/AuthCodeDemo' et 'ssl/ClientCredDemo'.
    "client_id":"d2615fe2020ec476"
}</javascript>


La réponse est retournée dans un conteneur JSON.
;[[#Enregistrer un client|Enregistrer les clients]] :


====Récupérer les rapports génériques====
*Deux clients doivent être créés :
Ce type de ressource est nommé '''generic_report'''. Cette ressource n'est accessible qu'avec le scope '''genericreports.readonly'''. Cette ressource permet la récupération des rapports génériques au format CSV autorisés pour le profil de l'utilisateur associé au client OAuth2 enregistré. La requête POST est construite de la manière suivante :
**Le premier pour le mécanisme d'autorisation '''Authorization Code''',
**Le second pour le mécanisme d'autorisation '''Client Credentials'''.


{| class="wikitable"
[[File:Oauth2 demo manage.png|800px]]
!Nom!!Type!!Description
|-
|resource_type||string||Le type de ressource demandé, ici, ce champ correspond à '''generic_report'''.
|-
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
|-
|report_id||int||Identifiant du rapport souhaité.
|-
|replacementList||array||Tableau correspondant aux différents paramètres modifiables pour générer le rapport souhaité.
|}


Un exemple de requête complète au format JSON :
*Télécharger le certificat du CA OpenFlyers en cliquant sur le bouton '''Télécharger le certificat CA''' de la page de gestion. Télécharger aussi le certificat de signature du serveur en cliquant sur le bouton '''Télécharger le certificat de signature du serveur''' de la page de gestion. Placer les deux certificats téléchargés à la racine du dossier '''ssl'''.
<javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: openflyers.com
Date: Wed, 04 Aug 2021 13:57:51 GMT
Accept: application/json
User-Agent: curl/7.64.1
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU
Signature: keyId="58c450d937953829c8cca3613001f865a918da07",
          algorithm="rsa-sha256",
          headers="host content-type digest",
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="
Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=


{
*Télécharger les deux certificats ''Certificat d'authentification'' et ''Certificat de signature'' du client '''Authorization Code''' et les placer dans le répertoire '''ssl/AuthCodeDemo'''.
    "resource_type":"generic_report",
*Modifier le fichier '''ssl/AuthCodeDemo/config.authcode.json''' en le remplissant de la manière suivante.
    "client_id":"d2615fe2020ec476",
<php>{
    "report_id":135,
  "client_id": "XXXXXXXXXXXXXXXX",
    "replacementList":{
  "client_secret": "XXXXXXXXXXXXXXXX",
        "year":2018
  "authorize_uri": "https://openflyers.com/mastructure/oauth/authorize.php",
    }
  "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
}</javascript>
  "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
  "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
  "auth_cert": "path_to_client/ssl/AuthCodeDemo/auth_cert.crt",
  "auth_key": "path_to_client/ssl/AuthCodeDemo/auth.key",
  "sign_cert": "path_to_client/ssl/AuthCodeDemo/sign_cert.crt",
  "sign_key": "path_to_client/ssl/AuthCodeDemo/sign.key",
  "auth_cacert": "path_to_client/ssl/ca.crt",
  "sign_cert_server": "path_to_client/ssl/sign_cert_server.crt"
}</php>
 
*Remplacer les <code>XXXXXXXXXXXXXXXX</code> des champs <code>client_id</code> et <code>client_secret</code> par les valeurs obtenues lors de [[#Enregistrer-un-client|l'enregistrement du client]].
*Remplacer <code>mastructure</code> par le nom de la structure sur laquelle la démo est testée.
*Remplacer <code>path_to_client/</code> par le chemin d'accès vers le dossier qui contient le code source du client de démonstration.
**Exemple sur '''windows''': <code>C:/wamp64/www/4.0/oauth-demo/</code>.
**Exemple sur un serveur Linux '''debian''': <code>./</code>.
 
 
*Télécharger les deux certificats ''Certificat d'authentification'' et ''Certificat de signature'' du client '''Client Credentials''' et les placer dans le répertoire '''ssl/ClientCredDemo'''.
*Modifier le fichier '''ssl/ClientCredDemo/config.clientcred.json''' en le remplissant de la manière suivante.
<php>{
  "client_id": "XXXXXXXXXXXXXXXX",
  "client_secret": "XXXXXXXXXXXXXXXX",
  "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
  "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
  "auth_cert": "path_to_client/ssl/ClientCredDemo/auth_cert.crt",
  "auth_key": "path_to_client/ssl/ClientCredDemo/auth.key",
  "sign_cert": "path_to_client/ssl/ClientCredDemo/sign_cert.crt",
  "sign_key": "path_to_client/ssl/ClientCredDemo/sign.key",
  "auth_cacert": "path_to_client/ssl/ca.crt",
  "sign_cert_server": "path_to_client/ssl/sign_cert_server.crt"
}</php>
 
*Remplacer les <code>XXXXXXXXXXXXXXXX</code> des champs <code>client_id</code> et <code>client_secret</code> par les valeurs obtenues lors de [[#Enregistrer-un-client|l'enregistrement du client]].
*Remplacer <code>mastructure</code> par le nom de la structure sur laquelle la démo est testée.
*Remplacer <code>path_to_client/</code> par le chemin d'accès vers le dossier qui contient le code source du client de démonstration.
**Exemple sur '''windows''': <code>C:/wamp64/www/4.0/oauth-demo/</code>.
**Exemple sur un serveur Linux '''debian''': <code>./</code>.


La réponse est un fichier CSV retourné dans un conteneur JSON.


====Récupérer les rapports personnalisés====
*Suivre la [[#Utiliser le client|procédure d'utilisation du client de démonstration]] pour faire fonctionner le client.
Ce type de ressource est nommé '''report'''. Cette ressource n'est accessible qu'avec le scope '''reports.readonly'''. Cette ressource permet la récupération des rapports personnalisés au format CSV autorisés pour le profil de l'utilisateur associé au client OAuth2 enregistré. La requête POST est construite de la manière suivante :


{| class="wikitable"
!Nom!!Type!!Description
|-
|resource_type||string||Le type de ressource demandé, ici, ce champ correspond à '''report'''.
|-
|client_id||string||L'identifiant unique reçu pendant l'enregistrement du client.
|-
|report_id||int||Identifiant du rapport souhaité.
|-
|replacementList||array||Tableau correspondant aux différents paramètres modifiables pour générer le rapport souhaité.
|}


Un exemple de requête complète au format JSON :
'''NB''': Le certificat de signature du serveur est unique à chaque plateforme et serveur. Ainsi, si le serveur ou la plateforme est modifié, le certificat doit être renouvelé.
<javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1
 
Content-Type: application/x-www-form-urlencoded
==Enregistrer un client==
Host: openflyers.com
Pour utiliser l'API OAuth2, il faut enregistrer un client OAuth2 auprès d'OpenFlyers. Pour ceci, suivre les étapes suivantes :
Date: Wed, 04 Aug 2021 13:57:51 GMT
 
Accept: application/json
 
User-Agent: curl/7.64.1
;Pour le mécanisme d'authentification Client Credentials
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU
*Créer un [[Gestion-des-profils#Ajouter-un-profil|nouveau profil]]. Ce profil doit permettre de gérer les droits du client OAuth2. Choisir un nom explicite, par exemple "Client OAuth rapports".
Signature: keyId="58c450d937953829c8cca3613001f865a918da07",
 
          algorithm="rsa-sha256",
*Sélectionner les droits à assigner à ce profil. Ces droits limitent les données auxquelles le client OAuth2 a accès.
          headers="host content-type digest",
**Sélectionner les droits relatifs à l'enregistrement de clients OAuth2 dans l'onglet '''Admin''' (colonne '''Associé aux clients OAuth2''').
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="
**Sélectionner les rapports accessibles par le profil précédemment créé.
Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=
 
*Créer un nouvel utilisateur à partir du panneau de gestion. Cet utilisateur est virtuel et représente le serveur sur lequel fonctionne le client OAuth2.
**''Des identifiant et nom explicites sont recommandés (exemple : "serv1_oauth_client")''
**'''Attention''' : tout utilisateur désactivé et associé à un client OAuth2 rend le client inactif, il faut donc changer l'utilisateur associé au client pour réactiver le client.
 
 
;Pour le mécanisme d'authentification Authorization Code
*Aller dans '''Admin > Utilisateurs > Profils'''
*Dans l'onglet '''Généralités''', cocher la case relative à la colonne '''Connexion depuis l'extérieur (OAuth2)''' pour le profil souhaité.
 
 
;Créer un nouveau client OAuth2
*Aller dans '''Admin > Transferts > Exports > API OAuth2'''
[[File:Oauth2 manage.png|800px]]
*Cliquer sur le bouton Ajouter '''+''' ou '''Ajouter un client'''
[[File:Oauth2 client creation.png|800px]]
*Choisir un nom pour le client.
*Sélectionner le mécanisme d'autorisation utilisé par le client :
**'''Authorization Code''': permet d'utiliser OAuth2 comme solution SSO ou accéder à des données utilisateurs. Cette méthode peut être couplée avec le mécanisme de mémorisation de connexion (''Refresh Token'').
**'''Client Credentials''': permet d'utiliser OAuth2 dans un contexte d'automatisme.
*Saisir l'URI de redirection vers le client pour le mécanisme ''Authorization Code''.
*Sélectionner l'utilisateur virtuel créé précédemment pour le mécanisme ''Client Credentials''.
*[[#Générer-des-certificats|Générer deux CSR]] afin d'obtenir deux certificats signés et les saisir :
**'''Certificate Signing Request pour le certificat d'authentification''' est utilisé pour l'authentification mutuelle avec mTLS (auth_cert.csr.pem).
**'''Certificate Signing Request pour le certificat de signature''' est utilisé pour la signature des en-têtes HTTP (sign_cert.csr.pem).


{
[[File:PublicKeysCopyScreen.png|900px]]
    "resource_type":"report",
 
    "client_id":"d2615fe2020ec476",
 
    "report_id":1,
*Cliquer sur '''Enregistrer'''.
    "replacementList":{
 
        "year":2020
NB: La validité des certificats générés s'étend sur une période de '''3 années'''.
    }
 
}</javascript>
 
;Sauvegarder le couple ID/passphrase
Un couple ID/passphrase (client_id/client_secret) est généré. Ces deux clées ne sont communiquées qu'une seule fois. Elle doivent être stockées en toute sécurité et gardées confidentielles,
et Mettre ces identifiants dans le fichier '''config.clientcred.json'''.
[[File:Oauth2 client created.png]]
 
[[File:ConfigCredJsonScreen.png|600px]]
 
 
;Télécharger les certificats crt
Les certificats signés sont téléchargeables depuis l'interface de gestion des clients OAuth2, les certificats sont disponibles dans les onglets '''Certificat d'authentification''' et '''Certificat de signature''' et les mettre dans le dossier '''/ssl''' du client OAuth2.
[[File:Oauth2 client certificates.png]]
 
;Téléchargez les certificats du serveur.
*Les certificats du CA d'OpenFlyers et de signature HTTP du serveur sont nécessaires. Ils sont téléchargeables depuis l'interface de configuration des clients OAuth2.
[[File:DownloadServerCertifScreen.png|900px]]
*Dans certains cas d'utilisation, il peut être nécessaire d'ajouter le certificat du CA d'OpenFlyers au Trust Store du système. Si cette étape n'est pas réalisée, les certificats peuvent être considérés comme invalides et peuvent ne pas être utilisables.
*Pour ajouter le certificat CA au Trust Store du système, suivre les étapes suivantes:
**Sous Linux, copier le certificat CA d'OpenFlyers dans le dossier <code>/usr/local/share/ca-certificates</code> et exécuter la commande <code>sudo update-ca-certificates</code>
**Sous Windows,
***Double-cliquer sur le certificat CA d'OpenFlyers téléchargé depuis l'interface d'enregistrement des clients OAuth2
***Cliquer sur '''Installer un certificat...'''
***Choisir l'emplacement de stockage (utilisateur ou ordinateur) et cliquer sur '''Suivant''' puis '''Suivant''' et enfin '''Terminer'''
 
==Générer des certificats==
L'API OAuth2 implémente [https://tools.ietf.org/html/draft-cavage-http-signatures-10 HTTP Signature] et l'[[Wikipedia-en:Mutual_authentication#mTLS|authentification TLS mutuelle]]. Ces mécanismes utilisent chacun une paire certificat/clé privée différente.
 
Pour obtenir ces certificats, il faut d'abord générer des Certificate Signing Request (CSR).
 
La procédure est la suivante :
*[[OpenSSL#Installer-OpenSSL-dans-un-environnement-Windows|Télécharger OpenSSL pour Windows]] ou [[OpenSSL#Utiliser-Openssl-d'Apache-sous-WAMP|utiliser Openssl d'Apache sous WAMP]].
*Utiliser les deux fichiers de configuration ''sign_cert.conf'' et ''auth_cert.conf'' ci-dessous et les remplir.
 
;Fichier de configuration OpenSSL - sign_cert.conf
<pre>[req]
default_bits      = 4096                    # taille par défaut des nouvelles clés, peut être surchargé dans la commande
encrypt_key        = no                      # chiffrer la clé générée
distinguished_name = req_distinguished_name  # pointe vers la catégorie spécifiée pour le Distinguished Name
x509_extensions    = v3_req                  # pointe vers la catégorie spécifiée pour les extensions x509
prompt            = no
 
[req_distinguished_name]
C                  =                          # code à deux chiffres du pays (ex: FR)
ST                =                          # région/état (ex: Gironde)
L                  =                          # ville (ex: Bordeaux)
O                  =                          # organisation (ex: OpenFlyers)
OU                =                          # unité organisationelle (ex: IT)
CN                =                          # nom de domaine (ex: openflyers.com)
 
[v3_req]
keyUsage          = digitalSignature        # pour quelles opérations la clé peut-elle être utilisée</pre>
 
;Fichier de configuration OpenSSL - auth_cert.conf
<pre>[req]
default_bits      = 4096                    # taille par défaut des nouvelles clés, peut être surchargé dans la commande
encrypt_key        = no                      # chiffrer la clé générée
distinguished_name = req_distinguished_name  # pointe vers la catégorie spécifiée pour le Distinguished Name
x509_extensions    = v3_req                  # pointe vers la catégorie spécifiée pour les extensions x509
prompt            = no
 
[req_distinguished_name]
C                  =                          # code à deux chiffres du pays (ex: FR)
ST                =                          # région/état (ex: Gironde)
L                  =                          # ville (ex: Bordeaux)
O                  =                          # organisation (ex: OpenFlyers)
OU                =                          # unité organisationelle (ex: IT)
CN                =                          # nom de domaine (ex: openflyers.com)
 
[v3_req]
extendedKeyUsage  = clientAuth              # pour quelles opérations la clé peut-elle être utilisée</pre>
 
 
Exécuter les commandes suivantes :
*<bash>openssl req -sha256 -newkey rsa -keyout sign.key -out sign_cert.csr.pem -outform PEM -config sign_cert.conf</bash>
*<bash>openssl req -sha256 -newkey rsa -keyout auth.key -out auth_cert.csr.pem -outform PEM -config auth_cert.conf</bash>
 
Ces commandes prennent chacune en entrée le fichier de configuration et génèrent une clé privée et un Certificate Signing Request.
 
Une fois ces CSR obtenus :
*Les renseigner dans les champs prévus à cet effet lors de la [[#Enregistrer-un-client|création d'un client]] et télécharger les certificats signés depuis l'interface une fois le client créé.
*Garder la clé privée confidentielle. Une fuite poserait un risque de sécurité. Elle va de paire avec le certificat distribué par l'autorité de certification OpenFlyers.
 
==Mettre en place une connexion à l'API OpenFlyers sur un serveur mutualisé==
;Note
La procédure ci-après est destinée à une mise en place lorsqu'il n'y a pas d'accès SSH en ligne de commande mais uniquement un accès FTP. Dans ce cas, la création des clés privées et publics est effectuée "en local". Dans la procédure suivante elle est effectuée depuis un PC sous '''Windows'''.
 
;Prérequis
*Posséder les accès FTP :
**Hôte : XXXXXXXXXXXXXXXXXX
**Login : XXXXXXXX
**Mot de passe :  XXXXXXXX
**Port : XX (par exemple 21)
*Télécharger Le code source du client de démonstration à disposition par OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/oauth2-demo-src.zip
 
;Procédure
*[[#Générer des certificats|Générer les certificats]] en local.
*Remplacer les clés privées 'auth.key' et 'sign.key' présentes dans les dossiers 'ssl/AuthCodeDemo' et 'ssl/ClientCredDemo' par les clés générées.
*[[#Enregistrer un client|Enregistrer les deux clients]] :
**Le premier pour le mécanisme d'autorisation '''Authorization Code'''.
**Le second pour le mécanisme d'autorisation '''Client Credentials'''.
 
[[File:Oauth2 demo manage.png|800px]]
 
*Télécharger le certificat du CA OpenFlyers en cliquant sur le bouton '''Télécharger le certificat CA''' de la page de gestion.
*Télécharger aussi le certificat de signature du serveur en cliquant sur le bouton '''Télécharger le certificat de signature du serveur''' de la page de gestion.
*Placer les deux certificats téléchargés à la racine du dossier '''ssl'''.
 
*Télécharger les deux certificats ''Certificat d'authentification'' et ''Certificat de signature'' du client '''Authorization Code''' et les placer dans le répertoire '''ssl/AuthCodeDemo'''.
*Modifier le fichier '''ssl/AuthCodeDemo/config.authcode.json''' en le remplissant de la manière suivante.
<php>{
  "client_id": "XXXXXXXXXXXXXXXX",
  "client_secret": "XXXXXXXXXXXXXXXX",
  "authorize_uri": "https://openflyers.com/mastructure/oauth/authorize.php",
  "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
  "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
  "auth_cert": "./ssl/AuthCodeDemo/auth_cert.crt",
  "auth_key": "./ssl/AuthCodeDemo/auth.key",
  "sign_cert": "./ssl/AuthCodeDemo/sign_cert.crt",
  "sign_key": "./ssl/AuthCodeDemo/sign.key",
  "auth_cacert": "./ssl/ca.crt",
  "sign_cert_server": "./ssl/sign_cert_server.crt"
}</php>
 
 
*Télécharger les deux certificats ''Certificat d'authentification'' et ''Certificat de signature'' du client '''Client Credentials''' et les placer dans le répertoire '''ssl/ClientCredDemo'''.
*Modifier le fichier '''ssl/ClientCredDemo/config.clientcred.json''' en le remplissant de la manière suivante.
<php>{
  "client_id": "XXXXXXXXXXXXXXXX",
  "client_secret": "XXXXXXXXXXXXXXXX",
  "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
  "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
  "auth_cert": "./ssl/ClientCredDemo/auth_cert.crt",
  "auth_key": "./ssl/ClientCredDemo/auth.key",
  "sign_cert": "./ssl/ClientCredDemo/sign_cert.crt",
  "sign_key": "./ssl/ClientCredDemo/sign.key",
  "auth_cacert": "./ssl/ca.crt",
  "sign_cert_server": "./ssl/sign_cert_server.crt"
}</php>
 
*Remplacer les <code>XXXXXXXXXXXXXXXX</code> des champs <code>client_id</code> et <code>client_secret</code> par les valeurs obtenues lors de [[#Enregistrer-un-client|l'enregistrement du client]].
*Remplacer <code>mastructure</code> par le nom de la structure sur laquelle la démo est testée.
 
*Transférer le fichier "oauth-demo" vers le serveur mutualisé :
**Télécharger [http://filezilla-project.org/download.php?type=client FileZilla].
**Lancer FileZilla.
**Entrer l'URl du serveur mutualisé dans le champ '''Hôte'''.
**Entrer le login dans le champ '''Nom d'utilisateur'''.
**Entrer le mot de passe dans le champ '''Mot de passe'''.
**Entrer le port dans le champ '''Port'''.
**Cliquer sur le bouton Connexion.
**Accéder à l'emplacement du répertoire "oauth-demo" en local à gauche dans l'onglet "Site local".
**Choisir l'emplacement où placer le répértoire oauth-demo dans l'anglet '''Site distant''' à droite.
**Glisser et déposer le oauth-demo à l'emplacement choisi.
[[File:Transfer OauthDemo To Shared Server.png|800px]]
*Accéder au client OAuth-demo depuis le serveur mutualisé en utilisant l'URL du domaine du serveur : url_de_domaine_de_serveur/oauth-demo/index.php
*Modifier la valeur '''URI de redirection vers le client''' du client '''AuthCodeDemo''' précédemment créé en remplaçant l'ancienne URL par la nouvelle.
 
*Suivre la [[#Utiliser le client|procédure d'utilisation du client de démonstration]] pour faire fonctionner le client.
 
 
'''NB''': Le certificat de signature du serveur est unique à chaque plateforme et serveur. Ainsi, si le serveur ou la plateforme est modifié, le certificat doit être renouvelé.
 
==Récupérer les données d'un utilisateur==
*Cliquer sur le bouton '''Récupérer les informations utilisateur''', l'identifiant de l'utilisateur s'affiche.
*Utiliser l'identifiant récupérer afin de récupérer toute information associée à cet utilisateur en [[Gestion-des-rapports#Ajouter-un-rapport|créant de nouveaux rapports personnalisés]]
 
==Utiliser le client==
;Prérequis
Un client de démonstration est disponible pour le logiciel OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/index.php
 
Le client de démonstration se présente de la manière suivante.
 
[[File:Oauth2-client-demo.png]]
 
La démonstration est composée de deux colonnes. La première, nommée '''Authorization Code''' correspond [[#Authorization Code|au mécanisme d'autorisation du même nom]]. Elle dispose d'un bouton permettant de se connecter ainsi que d'une section indiquant les informations relatives à l'état de la connexion. La seconde colonne, nommée '''Client Credentials''' correspond elle aussi [[#Client Credentials|au mécanisme d'autorisation du même nom]]. Comme pour la première colonne, les éléments qui y sont présentés sont identiques. La différence étant que le bouton de connexion n'a pas le même effet étant donné que ces deux mécanismes sont différents. Chaque mécanisme est indépendant et il est possible de se connecter à un des deux mécanismes sans se connecter à l'autre ou se connecter aux deux en même temps.
 
;Le mécanisme '''Authorization Code'''
*Cliquer sur le bouton '''Se connecter''' (ce qui redirige le navigateur vers la page de connexion du logiciel OpenFlyers).
*Renseigner les identifiants de l'administrateur pour s'y connecter.
*Nom d'utilisateur : '''admini'''.
*Mot de passe : '''azerty'''.
 
Une fois les informations saisies, la page suivante est affichée.


La réponse est un fichier CSV retourné dans un conteneur JSON.
[[File:Oauth authorize demo.png]]


==Démonstration de client==
*Cliquer sur le bouton '''Autoriser l'application''' pour autoriser la connexion (ce qui se redirige le navigateur vers la page du client de démonstration OAuth2).
Un client de démonstration [https://openflyers.com/oauth2-demo/index.php est disponible pour le logiciel OpenFlyers].


===Utiliser le client===
La première colonne doit afficher l'état de connexion '''Connecté''' ainsi qu'un nouveau bouton '''Récupèrer les informations utilisateurs''' qui permet de récupérer les informations de l'utilisateur connecté.
Le client de démonstration se présente de la manière suivante.


[[Fichier:Oauth2-client-demo.png]]
;Le mécanisme '''Client Credentials'''
*Cliquer sur le bouton de connexion '''Se connecter''': contrairement à celui du mécanisme '''Authorization Code''', ne redirige pas le navigateur vers la page de connexion du logiciel OpenFlyers. Le bouton de connexion utilise les identifiants du client, ici le couple clé privée/clé publique, pour initier la connexion avec le serveur d'autorisation et obtenir un jeton d'accès.


La démonstration est composée de deux colonnes. La première, nommée '''Authorization Code''' correspond [[#Authorization Code|au mécanisme d'autorisation du même nom]]. Elle dispose d'un bouton permettant de se connecter ainsi que d'une section indiquant les informations relatives à l'état de la connexion. La seconde colonne, nommée '''Client Credentials''' correspond elle aussi [[#Client Credentials|au mécanisme d'autorisation du même nom]]. Comme pour la première colonne, les éléments qui y sont présentés sont identiques. La différence étant que le bouton de connexion n'a pas le même effet étant donné que ces deux mécanismes sont différents. Chaque mécanisme est indépendant et il est possible de se connecter à un des deux mécanismes sans se connecter à l'autre ou se connecter aux deux en même temps.
Une fois la connexion établie, la seconde colonne doit afficher l'état de connexion '''Connecté''' ainsi qu'un menu déroulant '''Rapport à récupèrer''' et un nouveau bouton '''Récupèrer le rapport''' qui permet de récupérer les rapports génériques et personnalisés.


Pour le mécanisme '''Authorization Code''', le bouton de connexion redirige le navigateur vers la page de connexion du logiciel OpenFlyers. Renseigner les identifiants de l'administrateur pour s'y connecter.
* Nom d'utilisateur : '''admini'''.
* Mot de passe : '''azerty'''.
Une fois les informations saisies, la page suivante est affichée.
[[Fichier:Oauth authorize demo.png]]
Cliquer sur le bouton '''Autoriser l'application''' pour autoriser la connexion. Une fois le bouton cliqué, le navigateur est redirigé vers la page du client de démonstration OAuth2. La première colonne doit afficher l'état de connexion '''Connecté''' ainsi qu'un nouveau bouton.
Pour le mécanisme '''Client Credentials''', le bouton de connexion, contrairement à celui du mécanisme '''Authorization Code''', ne redirige pas le navigateur vers la page de connexion du logiciel OpenFlyers. Le bouton de connexion utilise les identifiants du client, ici le couple clé privée/clé publique, pour initier la connexion avec le serveur d'autorisation et obtenir un jeton d'accès. Une fois la connexion établie, la seconde colonne doit afficher l'état de connexion '''Connecté''' ainsi qu'un nouveau bouton et un menu déroulant.


Le client, une fois connecté sur les deux mécanismes, se présente de la manière suivante.
Le client, une fois connecté sur les deux mécanismes, se présente de la manière suivante.


[[Fichier:Oauth2 connected demo.png]]
[[File:Oauth2 connected demo.png]]
 
Les deux mécanismes proposent deux types de ressources différentes. Le mécanisme '''Authorization Code''' propose de récupérer les informations de l'utilisateur connecté. Le mécanisme '''Client Credentials''' permet de récupérer les rapports génériques et personnalisés. Les ressources sont interchangeables et ne sont pas restreintes à un mécanisme particulier. Cependant, il est recommandé de suivre le schéma de la démonstration.
 
Pour récupérer les informations de l'utilisateur connecté avec '''Authorization Code''', cliquer sur '''Récupérer les informations utilisateur'''.
 
Pour récupérer un rapport avec '''Client Credentials''', sélectionner le rapport souhaité dans le menu déroulant et cliquer sur '''Récupérer le rapport'''.
 
===Configurer le client à partir du code source===
Le [https://openflyers.com/oauth2-demo/oauth2-demo-src.zip code source du client de démonstration] est mis à disposition par OpenFlyers. Le code source est structuré de la manière suivante.
 
[[Fichier:Oauth2 src demo folder.png]]
 
* Le dossier '''css''' contient tout le matériel nécessaire à la stylisation de la page web.
* Le dossier '''img''' contient les images affichées sur la page web.
* Le dossier '''ssl''' est le dossier contenant tous les certificats et les clé privées associées à chaque client. Il doit respecter une structure particulière.
* Le fichier '''ClientDemo.php''' contient la classe '''ClientDemo'''. Cette classe contient toutes les méthodes nécessaires au fonctionnement du client de démonstration OAuth2.
* Le fichier '''index.php''' est le fichier à appeler depuis le navigateur. Ce fichier correspond au fichier qui gère les appels à la classe '''ClientDemo''' et exécute les méthodes dans l'ordre.
 
Le dossier '''ssl''' doit respecter la structure suivante.
<bash>.
??? AuthCodeDemo
?   ??? auth_cert.conf
?   ??? auth_cert.crt
?   ??? auth_cert.csr.pem
?   ??? auth.key
?   ??? config.authcode.json
?   ??? sign_cert.conf
?   ??? sign_cert.crt
?   ??? sign_cert.csr.pem
?   ??? sign.key
??? ca.crt
??? ClientCredDemo
?   ??? auth_cert.conf
?   ??? auth_cert.crt
?   ??? auth_cert.csr.pem
?   ??? auth.key
?   ??? config.clientcred.json
?   ??? sign_cert.conf
?   ??? sign_cert.crt
?   ??? sign_cert.csr.pem
?   ??? sign.key
??? sign_cert_server.crt</bash>
 
Les deux procédures [[#Enregistrer un client|d'enregistrement des clients]] et de [[#Générer des certificats|génération des certificats]] doivent être suivies. Deux clients doivent être créés.
* Le premier pour le mécanisme d'autorisation '''Authorization Code''',
* Le second pour le mécanisme d'autorisation '''Client Credentials'''.


[[Fichier:Oauth2 demo manage.png|1600px]]
=Troubleshooting=
==500 Internal Server Error en récupérant le rapport==
La démo utilise les valeurs par défaut pour extraire les rapports. Une erreur 500 indique une "Erreur de syntaxe ou violation d'accès" lors de l'exécution de la requête du rapport. Cela se produit parce que le rapport n'a pas de valeurs par défaut associées, étant donné qu'il n'a jamais été visualisé dans l'interface web. Pour résoudre ce problème, il vous suffit de visualiser le rapport et de cocher la case "Mémoriser ce choix".


Télécharger le certificat du CA OpenFlyers en cliquant sur le bouton '''Télécharger le certificat CA''' de la page de gestion. Télécharger aussi le certificat de signature du serveur en cliquant sur le bouton '''Télécharger le certificat de signature du serveur''' de la page de gestion. Placer les deux certificats téléchargés à la racine du dossier '''ssl'''.
==Erreur "File not found."==
Cette erreur se produit lorsque l'URI utilisé n'existe pas sur le serveur OpenFlyers. Vérifier les URIs mis en place dans les fichiers de configuration et essayer de nouveau.


Télécharger les deux certificats du client '''Authorization Code''' et les placer dans le répertoire '''ssl/AuthCodeDemo'''. Y placer également les clé privées associées. Modifier le fichier '''ssl/AuthCodeDemo/config.authcode.json''' en le remplissant de la manière suivante.
==int_rsa_verify : longueur de signature incorrecte==
<php>{
Ce problème pourrait survenir si les fichiers ca.cert et sign_cert_server.cert ne proviennent pas du même serveur que celui du client oauth2.
  "client_id": "XXXXXXXXXXXXXXXX",
La solution est :
  "client_secret": "XXXXXXXXXXXXXXXX",
  "authorize_uri": "https://openflyers.com/mastructure/oauth/authorize.php",
  "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
  "auth_cert": "./ssl/AuthCodeDemo/auth_cert.crt",
  "auth_key": "./ssl/AuthCodeDemo/auth.key",
  "sign_cert": "./ssl/AuthCodeDemo/sign_cert.crt",
  "sign_key": "./ssl/AuthCodeDemo/sign.key",
  "auth_cacert": "./ssl/ca.crt",
  "sign_cert_server": "./ssl/sign_cert_server.crt"
}</php>


Remplacer les <code>XXXXXXXXXXXXXXXX</code> des champs <code>client_id</code> et <code>client_secret</code> par les valeurs obtenues lors de l'enregistrement du client. Remplacer <code>mastructure</code> par le nom de la structure sur laquelle la démo est testée.
*D'essayer depuis le début l'étape de [[#Générer-des-certificats|génération]] et de [[#Enregistrer-un-client|configuration des certificats]] avec jsut la modification du client existant.
 
De même pour le deuxième client, télécharger les deux certificats du client '''Client Credentials''' et les placer dans le répertoire '''ssl/ClientCredDemo'''. Y placer également les clé privées associées. Modifier le fichier '''ssl/ClientCredDemo/config.clientcred.json''' en le remplissant de la manière suivante.
<php>{
  "client_id": "XXXXXXXXXXXXXXXX",
  "client_secret": "XXXXXXXXXXXXXXXX",
  "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
  "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
  "auth_cert": "./ssl/ClientCredDemo/auth_cert.crt",
  "auth_key": "./ssl/ClientCredDemo/auth.key",
  "sign_cert": "./ssl/ClientCredDemo/sign_cert.crt",
  "sign_key": "./ssl/ClientCredDemo/sign.key",
  "auth_cacert": "./ssl/ca.crt",
  "sign_cert_server": "./ssl/sign_cert_server.crt"
}</php>


Remplacer les <code>XXXXXXXXXXXXXXXX</code> des champs <code>client_id</code> et <code>client_secret</code> par les valeurs obtenues lors de l'enregistrement du client. Remplacer <code>mastructure</code> par le nom de la structure sur laquelle la démo est testée.
;Si cela ne fonctionne pas:


Suivre la [[#Utiliser le client|procédure d'utilisation du client de démonstration]] pour faire fonctionner le client.
*Essayez de créer [[#Enregistrer-un-client|un nouveau client]] et refaites la configuration des certificats.

Latest revision as of 17:27, 2 October 2024

Présentation

L'objet de cette page est de décrire l'API OpenFlyers.

Description de l'API

OpenFlyers possède une API basée sur OAuth2 qui permet à des serveurs extérieurs, dûment enregistrés, de mettre en œuvre un processus d'authentification unique (SSO) et/ou de récupération des résultats des requêtes SQL de la bibliothèque des rapports ou des rapports personnalisés sous la forme de fichiers CSV.

OAuth2 propose plusieurs mécanismes pour permettre l'authentification. Un mécanisme d'authentification détermine la séquence exacte des étapes impliquées dans le processus d'authentification d'OAuth2. OpenFlyers met à disposition deux mécanismes d'authentification :

  • Authorization Code basé sur la méthode d'authentification par code d'autorisation et qui correspond au mécanisme associé à l'authentification unique (SSO),
  • Client Credentials basé sur la méthode d'authentification avec les identifiants clients et qui est utilisé dans un contexte d'automatisme sans autorisation de l'utilisateur au préalable.

Dans les chapitres qui suivent, le terme ressource fait référence à la définition OAuth2. Une ressource dans OAuth2 est un élément qui peut être :

  • une ou des données comme des photos, des documents, des contacts ou des informations personnelles,
  • un ou plusieurs services comme des transferts de fonds, la récupération de rapports ou l'ajout d'articles sur un blog,
  • toute ressource nécessitant un accès restreint.

OpenFlyers définit plusieurs types de ressources :

OAuth2 dispose de scopes. Un scope est un privilège définit de manière explicite permettant l'accès à une ressource protégée. OpenFlyers met à disposition une liste de scopes utilisables à travers l'API.

Deux protocoles de sécurité sont présents dans l'API OpenFlyers :

  • mTLS : il permet d'authentifier le client avec un certificat TLS, en plus d'authentifier le serveur avec un certificat. Ce protocole permet d'éviter les usurpations d'identité.
  • HTTP-Signature : il permet de signer les en-têtes et le corps (lorsqu'il y en a un) des messages échangés afin d'en garantir leur intégrité.
Premiers pas - Client de démonstration

Un client de démonstration est disponible pour comprendre les mécanismes décrits ci-dessous.

L'utilisation de ce client de démonstration est décrite dans la procédure Utiliser le client de cette page.

Le client de démonstration est lui-même accessible à cette adresse : https://openflyers.com/oauth2-demo/index.php

Le code source du client de démonstration est mis à disposition par OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/oauth2-demo-src.zip

L'utilisation du code source est décrite dans la procédure Créer un client à partir du code source.

Définitions

Authentification TLS Mutuelle (mTLS)

En général dans une communication TLS, seul le serveur a l'obligation de fournir un certificat. Il est également possible pour le client de fournir un certificat. Ce principe s'appelle l'authentification mutuelle et est mise en place avec Mutual TLS (ou mTLS).

OpenFlyers associe un certificat pour l'authentification mutuelle unique à chaque client OAuth2.

Envoyer un certificat client

Côté client, le code suivant peut être utilisé pour fournir à cURL le certificat et la clé correspondante ainsi que le certificat du CA d'OpenFlyers à utiliser pour la connexion : <php>curl_setopt_array($request, [ 

   CURLOPT_SSLVERSION => CURL_SSLVERSION_TLSv1_2,
   CURLOPT_CAINFO     => $caCertificatePath,
   CURLOPT_SSLCERT    => $certificatePath,
   CURLOPT_SSLKEY     => $keyPath

]);</php>

À noter : le certificat du CA d'OpenFlyers est nécessaire pour assurer la validité des certificats utilisés.

HTTP Signature

HTTP Signature utilise le principe de la signature numérique pour garantir l'authenticité et l'intégrité du message HTTP.

La signature est générée à l'aide d'une clé privée et vérifiée à l'aide de la clé publique correspondante ou d'un certificat contenant cette clé publique.

HTTP Signature utilise deux en-têtes HTTP :

  • Signature : contient la signature et ses métadonnées.
  • Digest : contient le corps du message haché.

Digest

Le digest est calculé comme ceci : digest = base64encode(sha256(corps du message))

Et l'en-tête est structuré de la manière suivante : Digest: SHA-256=<digest>

Un autre algorithme de hachage peut être utilisé, SHA-256 reste cependant le plus répendu.

Exemple en php

<php>$digestHeader = 'Digest: SHA-256=' . base64_encode(hash('sha256', $postData, true));</php>

Signature

L'en-tête HTTP de signature est structuré de la manière suivante : Signature: keyId="<keyId>",algorithm="<algo>",headers="<signed_headers>",signature="<signature>"

Le champ keyId correspond à un identifiant permettant l'identification de la clé utilisée pour vérifier la signature. Pour l'API d'OpenFlyers, sa valeur correspond à l'empreinte SHA-1 du certificat au format PEM à utiliser pour vérifier la signature.

L'algorithme algo correspond à celui utilisé pour générer la signature, exemple : rsa-sha256.

La valeur de signed_headers correspond à la liste des en-têtes inclus dans la signature séparés d'un espace. Exemple : date digest (request-target)

Pour générer la signature, une chaîne de caractères appelée signing string contenant les en-têtes au format lowercase_header_name: value séparés par une nouvelle ligne au format LF (\n) est d'abord générée. Exemple avec les en-têtes "date" et "(request-target)" : 

(request-target): post /some/uri\ndate: Tue, 07 Jun 2014 20:51:35 GMT

La signature est ensuite générée comme ceci : base64encode(algo(signing string))

Exemple en php

<php>function generateSignatureHeader(array $headersToSign, string $certificateFingerprint, string $privateKey): string { 

   // generating the signing string and header list
   $headers         = ;
   $signatureString = ;
   foreach ($headersToSign as $key => $value) {
       $normalizedHeaderKey = trim(strtolower($key));
       $headers             .= $normalizedHeaderKey . ' ';
       $signatureString     .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
   }

   // trim extra whitespace
   $headers         = trim($headers);
   $signatureString = trim($signatureString);

   // signing the signing string
   $signature = ;
   openssl_sign($signatureString, $signature, $privateKey, 'RSA-SHA256');
   $signature = base64_encode($signature);

   // compiling the header line
   return "Signature: keyId=\"$certificateFingerprint\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";

}</php> Les variables $certificateFingerprint et $privateKey correspondent respectivement à une empreinte SHA-1 de certificat et à une clé privée, tous deux au format PEM.

La variable $headersToSign est un tableau formaté de la manière suivante : <php>[ 

   $headerName => $headerValue,
   ...

]</php>

À noter : les en-têtes sont à signer côté client avec le certificat de signature signé par le CA d'OpenFlyers et dédié au client ainsi que la clé privée associée. Le certificat de signature dédié au client est téléchargeable depuis l'interface de gestion des clients OAuth2. Les en-têtes de la réponse du serveur quant à elles doivent être vérifiées avec le certificat de signature HTTP du serveur, téléchargeable aussi depuis l'interface de configuration des clients OAuth2.

Client OAuth2

Une fois le client OAuth2 configuré sur OpenFlyers, il faut l'utiliser avec un client créé au préalable pour communiquer avec le serveur d'autorisation et l'API.

Plusieurs bibliothèques simplifiant la création d'un client sont disponibles.

Des scripts client basiques écrits en php sont aussi fournis pour les mécanismes authorization_code et client_credentials

Authorization Code

Ce flux OAuth2 se déroule en plusieurs étapes :

  • Le client redirige le navigateur de l'utilisateur vers l'URL d'autorisation.
  • Le navigateur de l'utilisateur est redirigé vers l'URL fourni durant la demande ou durant l'enregistrement du client.
  • Le client récupère un code d'autorisation grâce à la redirection précédente, et échange ce code contre un jeton d'accès auprès du serveur d'autorisation.
  • Le client peut utiliser ce code d'accès :
    • Comme preuve d'authentification pour une solution SSO (Single Sign-On).
    • Pour accéder à des données sur le serveur distant en utilisant l'API.


   +-----------+                   +------+                +-----------+                  +-------------+                  +-----------+
   |Utilisateur|                   |Client|                |Navigateur |                  |   Serveur   |                  |  Serveur  |
   +-----+-----+                   +--+---+                +-----+-----+                  |Autorisation |                  | Ressources|
         |                            |                          |                        +------+------+                  +-----+-----+
         |                            |                          |                               |                               |
         |                            |                   Demande|d'autorisation                 |                               |
         |                            +------------------------->+------------------------------>|                               |
         |                            |                          |                               |                               |
         |                            |Authentification + Formulaire d'autorisation              |                               |
         |<---------------------------+--------------------------+<------------------------------+                               |
         |                            |                          |                               |                               |
         |                            |      Autorisation        |                               |                               |
         +----------------------------+------------------------->+------------------------------>|                               |
         |                            |                          |                               |                               |
         |                            |                      Code|d'autorisation                 |                               |
         |                            |<-------------------------+<------------------------------+                               |
         |                            |                          |                               |                               |
         |                            |                Demande de|token                          |                               |
         |                            +--------------------------+------------------------------>|                               |
         |                            |                          |                               |                               |
         |                            |                 Access (+|Refresh) token                 |                               |
         |                            |<-------------------------+-------------------------------+                               |
         |                            |                          |                               |                               |
         |                            |                          |       Requête vers API        |                               |
         |                            +--------------------------+-------------------------------+------------------------------>|
         |                            |                          |                               |                               |
         |                            |                          |                               |                               |
         |                            |                          |                               |<------------------------------+
         |                            |                          |                               |  Vérification d'autorisation  |
         |                            |                          |                               +------------------------------>|
         |                            |                          |                               |                               |
         |                            |                          |      Données/Réponse          |                               |
         |                            |<-------------------------+-------------------------------+-------------------------------+
         |                            |                          |                               |                               |


Générer les codes pour PKCE

Pour faire fonctionner le client OAuth2, il faut générer deux codes pour l'extension PKCE :

  • Un code_verifier échangé pendant la demande de jeton d'accès.
  • Un code_challenge dérivé du code_verifier et échangé pendant la demande d'autorisation.
Générer le code_verifier

<php>function generateCodeVerifier($length = 128): string { 

   $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~';
   $outputCode = ;

   for ($i = 0; $i < $length; $i++) {
       $index      = random_int(0, strlen($characters) - 1);
       $outputCode .= $characters[$index];
   }

   return $outputCode;

}</php>

Cette fonction permet de générer un code_verifier avec une longueur donnée. Le code_verifier doit avoir une longueur entre 43 et 128 caractères.

Générer le code_challenge

<php>function computeCodeChallenge(string $codeVerifier): string { 

   return strtr(rtrim(base64_encode(hash('sha256', $codeVerifier, true)), '='), '+/', '-_');

}</php>

Cette fonction génère le code_challenge à partir du code_verifier fourni.


Demande d'autorisation

Pour initier la demande d'autorisation, rediriger le navigateur de l'utilisateur vers l'URL : GET https://openflyers.com/nom-de-plateforme/oauth/authorize.php. Remplacer nom-de-plateforme par le nom de la plateforme utilisée.

Envoyer également les paramètres suivants :

Nom Type Description
client_id string L'identifiant unique reçu pendant l'enregistrement du client.
response_type string Le type de réponse envoyée par le serveur. Doit utiliser la valeur "code" (sans guillements) pour ce mécanisme.
redirect_uri string L'URI (ou l'URL) fourni pendant l'enregistrement du client et vers lequel l'utilisateur est redirigé après la demande d'autorisation.
scope string Liste des droits demandés par le client, séparés par des espaces.
state string Chaîne de caractère aléatoire utilisée pour éviter les attaques CSRF. Fortement recommandé.
code_challenge string Code nécessaire pour le fonctionnement de l'extension PKCE.
code_challenge_method string Méthode utilisée pour générer le code_challenge. Ici, la valeur est "S256".

Demande de jeton d'accès

Après avoir répondu à la demande, l'utilisateur est redirigé vers l'URI fourni pendant l'enregistrement du client. Si la demande est acceptée, un code temporaire : code est fourni, ainsi que le paramètre state fourni pendant la demande avec la même valeur. Si la demande est refusée, un code d'erreur est renvoyé.

Si le paramètre state a une valeur différente de celle envoyée avec la demande, c'est peut-être une tentative d'attaque et il faut refuser la réponse.

Echanger ce code contre un jeton d'accès via l'URL : POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php. Remplacer nom-de-plateforme par le nom de la plateforme utilisée.

Les paramètres suivants sont également nécessaires :

Nom Type Description
client_id string L'identifiant unique reçu pendant l'enregistrement du client.
client_secret string La passphrase reçue pendant l'enregistrement du client.
code string Le code temporaire reçu dans la réponse à la demande d'autorisation.
grant_type string Le mécanisme d'autorisation utilisé. Ici, sa valeur doit être authorization_code
redirect_uri string L'URI (ou l'URL) de redirection fourni pendant l'enregistrement du client.
code_verifier string Le code_verifier utilisé pour générer le code_challenge de la demande d'autorisation.

Si la requête est correcte, un jeton d'accès (Access Token) ainsi qu'un jeton de rafraîchissement (Refresh Token) sont fournis en réponse dans un objet au format JSON. <javascript>{ 

 "token_type": "Bearer",
 "expires_in": 3600,
 "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw",
 "refresh_token": "a59ef39fa9bab9b95cd554f921e7f3080a34c90f23d2b8031d692b5ff2d0993dcc392d9c7f9a43242337ef144c1a5fe1d0174413ade973e1b628ac0bbfc39b23973534"

}</javascript>

Script client : Authorization Code

Voici un exemple simple de client OAuth2 pour le mécanisme d'authentification par code d'autorisation (Authorization Code).

Fichier de configuration config.authcode.json : <javascript>{ 

 "client_id": "",
 "client_secret": "",
 "authorize_uri": "https://openflyers.com/nom-de-plateforme/oauth/authorize.php",
 "token_uri": "https://openflyers.com/nom-de-plateforme/oauth/access_token.php",
 "resource_uri": "https://openflyers.com/nom-de-plateforme/oauth/resources.php",
 "auth_cert": "/path/to/client/auth_cert.crt",
 "auth_key": "/path/to/client/auth.key",
 "sign_cert": "/path/to/client/sign_cert.crt",
 "sign_key": "/path/to/client/sign.key",
 "auth_cacert": "/path/to/ca.crt",
 "sign_cert_server": "/path/to/server/sign_cert_server.crt"

}</javascript> Où /path/to/client/ est le chemin d'accès vers le dossier qui contient le code source du client de démonstration.

  • Exemple sur windows: C:/wamp64/www/4.0/oauth-demo/ssl/AuthCodeDemo/.
  • Exemple sur un serveur Linux debian: ./ssl/AuthCodeDemo/.

Ce fichier de configuration doit se situer au même niveau que le script PHP dans le système de fichiers.

Script PHP : <php><?php $localTokenFile = 'token.json'; // create token file if it does not exist if (!file_exists($localTokenFile)) 

   file_put_contents($localTokenFile, );

$config = json_decode(file_get_contents('config.authcode.json'), true); $localToken = json_decode(file_get_contents($localTokenFile), true); $GLOBALS['config'] = $config;

// Build the baseURL, accounting for protocol, port, name and endpoint. Used for redirection $protocol = isset($_SERVER['HTTPS']) ? 'https://' : 'http://'; $port = ($protocol == 'https://' && $_SERVER['SERVER_PORT'] == 443) 

   || ($protocol == 'http://' && $_SERVER['SERVER_PORT'] == 80) ?  : ':' . $_SERVER['SERVER_PORT'];

$baseURL = $protocol . $_SERVER['SERVER_NAME'] . $port . $_SERVER['PHP_SELF']; $errorLog = 'error_log.log'; $responseLog = 'response_log.log'; $GLOBALS['baseURL'] = $baseURL;

//Session cookies are used to store information necessary for the authorization code flow session_start();

/** 

* This function is used to make api calls to the Authorization Server and the Resource Server
*
* @param       $url
* @param       $post
* @param array $headers
*
* @return mixed
*/

function apiRequest($url, $post = null, $token = false, $auth = true, $refresh = false, $headers = array()) { 

   $ch = curl_init($url);
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
   curl_setopt($ch, CURLOPT_HEADER, true);

   $method = 'get';

   if ($post) {
       $method   = 'post';
       $postData = http_build_query($post);
       curl_setopt($ch, CURLOPT_POST, true);
       curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);

       $headersToSign['Content-Type'] = 'application/x-www-form-urlencoded';
       $headersToSign['digest']       = 'SHA-256=' . base64_encode(hash('sha256', $postData, true));
   }

   $urlComponents = parse_url($url);

   $headersToSign['(request-target)'] = $method . ' ' . $urlComponents['path'];
   $headersToSign['Host']             = $urlComponents['host'];
   $headersToSign['Date']             = gmdate('D, j M Y H:i:s T');

   // generating the signature header
   $keyId                = openssl_x509_fingerprint(file_get_contents($GLOBALS['config']['sign_cert']));
   $privateKey           = file_get_contents($GLOBALS['config']['sign_key']);
   $headers['Signature'] = generateSignatureHeader($headersToSign, $keyId, $privateKey);

   $headers['Accept']     = 'application/json';
   $headers['User-Agent'] = $GLOBALS['baseURL'];
   unset($headersToSign['(request-target)']);
   $headers               += $headersToSign;

   if ($token) {
       $headers['Authorization'] = $token['token_type'] . ' ' . $token['access_token'];
   }

   // formatting the headers
   $httpFormattedHeaders = [];
   foreach ($headers as $key => $value) {
       $httpFormattedHeaders[] = trim($key) . ': ' . trim($value);
   }

   curl_setopt($ch, CURLOPT_HTTPHEADER, $httpFormattedHeaders);
   curl_setopt($ch, CURLINFO_HEADER_OUT, true);

   // for development environment only
   //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
   //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
   //curl_setopt($ch, CURLOPT_VERBOSE, true);

   // defining TLS client certificates for Mutual TLS
   curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
   curl_setopt($ch, CURLOPT_CAINFO, $GLOBALS['config']['auth_cacert']);
   curl_setopt($ch, CURLOPT_SSLCERT, $GLOBALS['config']['auth_cert']);
   curl_setopt($ch, CURLOPT_SSLKEY, $GLOBALS['config']['auth_key']);

   $response = curl_exec($ch);

   // logging errors and responses
   errorLog(true, $response, $ch);

   curl_close($ch);

   // in case an authentication request is executed
   if ($auth) {
       // required when a refresh token request is issued
       // because there is only one header in the response
       // while there are two for regular auth requests
       if (!$refresh) {
           list($firstResponseHeaders, $secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 3);
           if (!$responseBody) {
               list($secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 2);
           }
       } else {
           list($secondResponseHeaders, $responseBody) = explode("\r\n\r\n", $response, 2);
       }

       $responseHeadersDigest = ;
       $responseHeadersSignature = ;
       // extracting digest and signature from headers
       $responseHeadersArray = explode("\r\n", $secondResponseHeaders);
       $responseProtocol = array_shift($responseHeadersArray);

       foreach ($responseHeadersArray as $value) {
           list($responseHeadersKeys, $responseHeadersValue) = explode(": ", $value, 2);
           $responseHeaders[strtolower($responseHeadersKeys)] = $responseHeadersValue;
       }

       $responseDigestAlgo = ;
       $responseDigestKey = ;
       foreach ($responseHeaders as $key => $value) {
           if ($key === "digest") {
               $responseHeadersDigest = $value;
               // stripping SHA algorithm for later comparison
               list($responseDigestAlgo, $responseDigestKey) = explode("=", $responseHeadersDigest, 2);
           } else if ($key === "signature")
               $responseHeadersSignature = $value;
       }

       // calculating response digest
       $responseDigest = base64_encode(hash(strtolower(str_replace("-", "", $responseDigestAlgo)), $responseBody, true));

       // checking digest validity
       if ($responseDigest !== $responseDigestKey) {
           errorLog(false, false, "Digests are not the same");
           die();
       }

       // extracting variables from signature header
       $signatureArray = explode(",", $responseHeadersSignature);
       foreach ($signatureArray as $value) {
           list($signatureKey, $signatureValue) = explode("=", $value, 2);
           $signature[$signatureKey] = trim($signatureValue, '"');
       }

       // generating siging string
       $signingStringArray = explode(" ", $signature['headers']);
       $signingString = ;
       foreach ($signingStringArray as $value) {
           $signingString = $signingString . trim($value) . ": " . trim($responseHeaders[$value]) . "\n";
       }

       // trimming last '\n' character
       $signingString = trim($signingString);

       // decoding signature
       $decodedSignature = base64_decode($signature['signature']);

       // verifying signature
       $signatureVerify = openssl_verify($signingString, $decodedSignature, openssl_get_publickey(file_get_contents($GLOBALS['config']['sign_cert_server'])), 'RSA-SHA256');

       if (!$signatureVerify) {
           errorLog(false, false, "Signature is not correct");
           while (($err = openssl_error_string()))
               errorLog(false, false, $err);
           die();
       }

       return json_decode($responseBody, true);
   }

   return $response;

}

/** 

* This function logs curl responses and errors in text files
*
* @param mixed $response the response
* @param mixed $request  the request handle, used to get errors
*/

function errorLog($curl, $response, $request = false) { 

   $timestamp = '[' . date('Y-m-d H:i:s') . ']:';
   global $errorLog;
   global $responseLog;

   if ($response === false) {
       if ($curl)
           file_put_contents($errorLog, $timestamp . curl_error($request) . "\n", FILE_APPEND);
       else
           file_put_contents($errorLog, $timestamp . $request . "\n", FILE_APPEND);
   } else {
       file_put_contents($responseLog, $timestamp . "\n" . $response . "\n", FILE_APPEND);
   }

}

/** 

* This function generates the full signature header line from a set of headers, a certificate and the linked private key
*
* @param array  $headersToSign the headers to sign, in the $key => $value format
* @param string $certificate   the certificate linked to the used private key
* @param string $privateKey    the private key used to sign the headers
*
* @return string the full signature header line
*/

function generateSignatureHeader(array $headersToSign, string $certificate, string $privateKey): string { 

   // generating the signing string and header list
   $headers         = ;
   $signatureString = ;
   foreach ($headersToSign as $key => $value) {
       $normalizedHeaderKey = trim(strtolower($key));
       $headers             .= $normalizedHeaderKey . ' ';
       $signatureString     .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
   }
   $headers         = trim($headers);
   $signatureString = trim($signatureString);

   // signing the signing string
   $signature = ;
   openssl_sign($signatureString, $signature, openssl_get_privatekey($privateKey), 'RSA-SHA256');
   $signature = base64_encode($signature);

   // compiling the header line
   return "keyId=\"$certificate\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";

}

/** 

* This function takes a code_verifier and outputs the corresponding code_challenge
*
* @param string $codeVerifier the generated code_verifier
*
* @return string the computed code_challenge
*/

function computeCodeChallenge(string $codeVerifier): string { 

   return strtr(rtrim(base64_encode(hash('sha256', $codeVerifier, true)), '='), '+/', '-_');

}

/** 

* This function takes an optional string length and outputs a random code_verifier string
*
* @param int $length the length of the output code_verifier. Default = 128
*
* @return string the code_verifier
* @throws Exception
*/

function generateCodeVerifier($length = 128): string { 

   $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~';
   $outputCode = ;

   for ($i = 0; $i < $length; $i++) {
       $index      = random_int(0, strlen($characters) - 1);
       $outputCode .= $characters[$index];
   }

   return $outputCode;

}

/** 

* This function calculates the entropy of a given string
*
* @param string $string  the string for which to calculate the entropy
* @param string $charset a string with all the usable characters. Default = 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~
*
* @return float|int
*/

function computeEntropy(string $string, string $charset = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-._~') { 

   $chars = str_split($charset);
   $probs = [];

   foreach ($chars as $char) {
       $probs[$char] = floatval(substr_count($string, $char)) / strlen($string);
   }

   $sum = 0.0;
   foreach ($probs as $prob) {
       $sum += $prob != 0 ? $prob * log($prob, 2) : 0.0;
   }

   return -$sum;

}

/** 

* This function calculates the ideal (maximum) entropy for a string of a given length
*
* @param int $length length of the string. Default = 128
*
* @return float|int
*/

function idealEntropy(int $length = 128) { 

   $prob = 1.0 / $length;

   return -1.0 * $length * $prob * log($prob, 2);

}

/** 

* This function is used to initiate the authentication code flow.
*
* @param string $clientID     the client's ID
* @param string $redirectURL  the URL where to redirect after auth
* @param string $authorizeURL the target URL to request authorization
*
* @throws Exception
*/

function login(string $clientID, string $redirectURL, string $authorizeURL): void { 

   global $localTokenFile;
   file_put_contents($localTokenFile, );

   // This unguessable string is used to prevent csrf attacks
   $_SESSION['state'] = bin2hex(random_bytes(16));

   // Generate code_verifier and code_challenge for PKCE    
   $_SESSION['code_verifier']  = generateCodeVerifier();
   $_SESSION['code_challenge'] = computeCodeChallenge($_SESSION['code_verifier']);

   // required parameters for the redirection, redirect_uri is where the browser should be redirected
   // when the user grants (or denies) access, scope are the authorizations (rights) requested
   $params = [
       'response_type'         => 'code',
       'client_id'             => $clientID,
       'redirect_uri'          => $redirectURL,
       'scope'                 => 'default.login',
       'state'                 => $_SESSION['state'],
       'code_challenge'        => $_SESSION['code_challenge'],
       'code_challenge_method' => 'S256'
   ];

   // redirecting the browser to the AS authorization endpoint to obtain the authorization code
   header('Location: ' . $authorizeURL . '?' . http_build_query($params));

}

/** 

* This function deletes the access token from the session
*
* @param string $baseURL
*/

function logout(string $baseURL): void { 

   global $localTokenFile;
   file_put_contents($localTokenFile, );

   header('Location: ' . $baseURL);

}

function displayMenuLoggedIn(): void {

echo '

<a href="/">Home</a>

'; echo '

Logged In

'; 

   echo '<form id="view_repos" method="post">';
   echo '<input type="hidden" id="action" name="action" value="view">';

echo '

<a href="javascript:{}" onclick="document.getElementById(\'view_repos\').submit(); return false;">View Repos</a>

'; 

   echo '</form>';

   echo '<form id="logout" method="post">';
   echo '<input type="hidden" id="action" name="action" value="logout">';

echo '

<a href="javascript:{}" onclick="document.getElementById(\'logout\').submit(); return false;">Log Out</a>

'; 

   echo '</form>';

}

function displayMenuLoggedOut(): void {

echo '

<a href="/">Home</a>

'; echo '

Not logged in

'; 

   echo '<form id="login" method="post">';
   echo '<input type="hidden" id="action" name="action" value="login">';

echo '

<a href="javascript:{}" onclick="document.getElementById(\'login\').submit(); return false;">Log In</a>

'; 

   echo '</form>';

}

// display client "home" page if (!isset($_POST['action'])) { 

   if (!empty($localToken['access_token'])) {
       displayMenuLoggedIn();
   } else {
       displayMenuLoggedOut();
   }

}

if (isset($_POST['action'])) { 

   // Building query array for resource dumping
   $repoQueryParameters = [
       'resource_type' => 'user_information',
       'client_id' => $config['client_id']
   ];
   switch ($_POST['action']) {
       case 'login':
           login($config['client_id'], $baseURL, $config['authorize_uri']);
           break;
       case 'logout':
           logout($baseURL);
           break;
       case 'view':
           // call to the resource server to retreive user information
           $resources = apiRequest(
               $config['resource_uri'],
               $repoQueryParameters,
               $localToken,
               false
           );

           // Separating headers from body
           list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);

           $resourceHeaders = explode("\r\n", $resourceHeader);
           $firstHeaderLine = array_shift($resourceHeaders);

           // Displaying user information

echo '

';
            echo $resourceBody;
            echo '

'; 

           // Automatic refreshing token once access token is expired
           if (strpos($firstHeaderLine, "401")) {
               $errorBody = json_decode($resourceBody, true);
               if ($errorBody['error'] == 'access_denied' && isset($errorBody['hint'])) {
                   if ($errorBody['hint'] == 'Access token could not be verified') {
                       $token = apiRequest(
                           $config['token_uri'],
                           [
                               'grant_type'    => 'refresh_token',
                               'refresh_token' => $localToken['refresh_token'],
                               'client_id'     => $config['client_id'],
                               'client_secret' => empty($config['client_secret']) ? null : $config['client_secret']
                           ],
                           false,
                           true,
                           true
                       );

                       // We store the access token in the session so the user is "connected"
                       // Only if the request has been successfully executed
                       if (isset($token['access_token'])) {
                           file_put_contents($localTokenFile, json_encode($token, true));

                           // Redirecting the user's browser to the "home" page
                           header('Location: ' . $baseURL);
                       }
                   }
               }
           }
           break;
   }

}

// Once the browser has been redirected to the AS to ask for the user's authorization, assuming it has been granted, // the browser will get back here with a "code" parameter in the query string if (isset($_GET['code'])) { 

   // The AS MUST redirect the browser here with the exact same state parameter we sent it before, so we check if it is indeed the same
   // to detect if the oauth flow has been tampered with
   if (!isset($_GET['state']) || $_SESSION['state'] != $_GET['state']) {
       header('Location: ' . $baseURL . '?error=invalid_state');
       die();
   }

   // We communicate directly with the AS to exchange the code received against an access token.
   // The id/secret pair is send to authenticate the client, the redirect_uri is sent to verify the code's validity
   $token = apiRequest(
       $config['token_uri'],
       [
           'grant_type'    => 'authorization_code',
           'client_id'     => $config['client_id'],
           'client_secret' => empty($config['client_secret']) ? null : $config['client_secret'],
           'redirect_uri'  => $baseURL,
           'code'          => $_GET['code'],
           'code_verifier' => $_SESSION['code_verifier']
       ]
   );

   // We store the access token in the session so the user is "connected"
   // Only if the request has been successfully executed
   if (isset($token['access_token'])) {
       file_put_contents($localTokenFile, json_encode($token, true));

       // Redirecting the user's browser to the "home" page
       header('Location: ' . $baseURL);
   } else {
       echo $token;
   }
   die();

}</php>

Ce script a été conçu pour montrer le fonctionnement du mécanisme afin de tester l'implémentation d'un serveur et n'a pas été testé extensivement. Il est conseillé d'utiliser une solution adaptée à un environnement de production.

Client Credentials

Ce mécanisme d'autorisation est adapté pour l'automatisation. Il fonctionne de la manière suivante :

  • Le client effectue la demande de jeton d'accès au serveur d'autorisation en fournissant ses identifiants.
  • Le serveur authentifie le client avec les identifiants fournis et renvoie un jeton d'accès.
  • Le client utilise ce jeton d'accès pour accéder à des données via l'API.


   +------+                       +-------------+                  +-----------+
   |Client|                       |   Serveur   |                  |  Serveur  |
   +--+---+                       |Autorisation |                  | Ressources|
      |                           +------+------+                  +-----+-----+
      |        Authentification          |                               |
      |         + Demande token          |                               |
      +--------------------------------->|                               |
      |                                  |                               |
      |          Access token            |                               |
      |<---------------------------------+                               |
      |                                  |                               |
      |                      Requête vers|API                            |
      +----------------------------------+------------------------------>|
      |                                  |                               |
      |                                  |                               |
      |                                  |<------------------------------+
      |                                  |  Vérification d'autorisation  |
      |                                  +------------------------------>|
      |                                  |                               |
      |                         Données /|Réponse                        |
      |<---------------------------------+-------------------------------+
      |                                  |                               |


Demande de jeton d'accès

Pour obtenir un jeton d'accès, il faut effectuer la requête suivante : POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php. Remplacer nom-de-plateforme par le nom de la plateforme utilisée.

Les paramètres suivants sont nécessaires :

Nom Type Description
client_id string L'identifiant unique reçu pendant l'enregistrement du client.
client_secret string La passphrase reçue pendant l'enregistrement du client.
grant_type string Le mécanisme d'autorisation utilisé. Ici, la valeur doit être client_credentials.
scope string Liste des droits demandés par le client, séparé par des espaces.
Ce mécanisme a la particularité de ne pas nécessiter d'URI de redirection, il n'est donc pas utile d'en renseigner un lors de l'enregistrement d'un client.

Si la requête est correcte, un jeton d'accès (Access Token) est fourni en réponse dans un objet au format JSON. <javascript>{ 

 "token_type": "Bearer",
 "expires_in": 3600,
 "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw"

}</javascript>

Script client : Client Credentials

Voici un exemple simple d'un client OAuth2 pour le mécanisme d'authentification par les identifiants client (Client Credentials).

Fichier de configuration config.clientcred.json : <javascript>{ 

 "client_id": "",
 "client_secret": "",
 "token_uri": "https://openflyers.com/nom-de-plateforme/oauth/access_token.php",
 "resource_uri": "https://openflyers.com/nom-de-plateforme/oauth/resources.php",
 "revoke_uri": "https://openflyers.com/nom-de-plateforme/oauth/revoke.php",
 "auth_cert": "/path/to/client/auth_cert.crt",
 "auth_key": "/path/to/client/auth.key",
 "sign_cert": "/path/to/client/sign_cert.crt",
 "sign_key": "/path/to/client/sign.key",
 "auth_cacert": "/path/to/ca.crt",
 "sign_cert_server": "/path/to/server/sign_cert_server.crt"

}</javascript> Où /path/to/client/ est le chemin d'accès vers le dossier qui contient le code source du client de démonstration.

  • Exemple sur windows: C:/wamp64/www/4.0/oauth-demo/ssl/ClientCredDemo/.
  • Exemple sur un serveur Linux debian: ./ssl/ClientCredDemo/.

Ce fichier de configuration doit se situer au même niveau que le script PHP dans le système de fichiers.

Script php : <php><?php $localTokenFile = 'token.json'; // create token file if it does not exist if (!file_exists($localTokenFile)) 

   file_put_contents($localTokenFile, );

$config = json_decode(file_get_contents('config.clientcred.json'), true); $localToken = json_decode(file_get_contents($localTokenFile), true); $GLOBALS['config'] = $config;

// Build the baseURL, accounting for protocol, port, name and endpoint. Used for redirection $protocol = isset($_SERVER['HTTPS']) ? 'https://' : 'http://'; $port = ($protocol == 'https://' && $_SERVER['SERVER_PORT'] == 443) 

   || ($protocol == 'http://' && $_SERVER['SERVER_PORT'] == 80) ?  : ':' . $_SERVER['SERVER_PORT'];

$baseURL = $protocol . $_SERVER['SERVER_NAME'] . $port . $_SERVER['PHP_SELF']; $errorLog = 'error_log.log'; $responseLog = 'response_log.log'; $GLOBALS['baseURL'] = $baseURL;

$replacementListItems = [ 

   1 => "year",
   2 => "validityTypeId",
   3 => "icao",
   4 => "profileId",
   7 => "accountingId",
   8 => "paymentType",
   9 => "startDate",
   10 => "endDate",
   11 => "occupiedSeat",
   12 => "date",
   13 => "activityTypeId",
   14 => "age",
   15 => "resourceId",
   16 => "personId",
   17 => "accountId",
   20 => "rightPlacePersonId",
   21 => "month",
   22 => "numberMonth",
   23 => "oneValidityTypeId",

];

//Session cookies are used to store information necessary for the authorization code flow session_start();

/** 

* This function is used to make api calls to the RS
*
* @param       $url
* @param       $post
* @param array $headers
*
* @return mixed
*/

function apiRequest($url, $post = null, $token = false, $auth = true, $headers = array()) { 

   $ch = curl_init($url);
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
   curl_setopt($ch, CURLOPT_HEADER, true);

   $method = 'get';

   if ($post) {
       $method   = 'post';
       $postData = http_build_query($post);
       curl_setopt($ch, CURLOPT_POST, true);
       curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);

       $headersToSign['Content-Type'] = 'application/x-www-form-urlencoded';
       $headersToSign['digest']       = 'SHA-256=' . base64_encode(hash('sha256', $postData, true));
   }

   $urlComponents = parse_url($url);

   $headersToSign['(request-target)'] = $method . ' ' . $urlComponents['path'];
   $headersToSign['Host']             = $urlComponents['host'];
   $headersToSign['Date']             = gmdate('D, j M Y H:i:s T');

   // generating the signature header
   $keyId                = openssl_x509_fingerprint(file_get_contents($GLOBALS['config']['sign_cert']));
   $privateKey           = file_get_contents($GLOBALS['config']['sign_key']);
   $headers['Signature'] = generateSignatureHeader($headersToSign, $keyId, $privateKey);

   $headers['Accept']     = 'application/json';
   $headers['User-Agent'] = $GLOBALS['baseURL'];
   unset($headersToSign['(request-target)']);
   $headers               += $headersToSign;

   if ($token) {
       $headers['Authorization'] = $token['token_type'] . ' ' . $token['access_token'];
   }

   // formatting the headers
   $httpFormattedHeaders = [];
   foreach ($headers as $key => $value) {
       $httpFormattedHeaders[] = trim($key) . ': ' . trim($value);
   }

   curl_setopt($ch, CURLOPT_HTTPHEADER, $httpFormattedHeaders);
   curl_setopt($ch, CURLINFO_HEADER_OUT, true);

   // for development environment only
   //curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
   //curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
   //curl_setopt($ch, CURLOPT_VERBOSE, true);

   // defining TLS client certificates for Mutual TLS
   curl_setopt($ch, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
   curl_setopt($ch, CURLOPT_CAINFO, $GLOBALS['config']['auth_cacert']);
   curl_setopt($ch, CURLOPT_SSLCERT, $GLOBALS['config']['auth_cert']);
   curl_setopt($ch, CURLOPT_SSLKEY, $GLOBALS['config']['auth_key']);

   $response = curl_exec($ch);

   // logging errors and responses
   errorLog(true, $response, $ch);

   curl_close($ch);

   // in case an authentication request is executed
   if ($auth) {
       list($responseHeader, $responseBody) = explode("\r\n\r\n", $response, 2);

       $responseHeadersDigest = ;
       $responseHeadersSignature = ;
       // extracting digest and signature from headers
       $responseHeadersArray = explode("\r\n", $responseHeader);
       $responseProtocol = array_shift($responseHeadersArray);

       foreach ($responseHeadersArray as $value) {
           list($responseHeadersKeys, $responseHeadersValue) = explode(": ", $value, 2);
           $responseHeaders[strtolower($responseHeadersKeys)] = $responseHeadersValue;
       }

       $responseDigestAlgo = ;
       $responseDigestKey = ;
       foreach ($responseHeaders as $key => $value) {
           if ($key === "digest") {
               $responseHeadersDigest = $value;
               // stripping SHA algorithm for later comparison
               list($responseDigestAlgo, $responseDigestKey) = explode("=", $responseHeadersDigest, 2);
           } else if ($key === "signature")
               $responseHeadersSignature = $value;
       }

       // calculating response digest
       $responseDigest = base64_encode(hash(strtolower(str_replace("-", "", $responseDigestAlgo)), $responseBody, true));

       // checking digest validity
       if ($responseDigest !== $responseDigestKey) {
           errorLog(false, false, "Digests are not the same");
           die();
       }

       // extracting variables from signature header
       $signatureArray = explode(",", $responseHeadersSignature);
       foreach ($signatureArray as $value) {
           list($signatureKey, $signatureValue) = explode("=", $value, 2);
           $signature[$signatureKey] = trim($signatureValue, '"');
       }

       // generating siging string
       $signingStringArray = explode(" ", $signature['headers']);
       $signingString = ;
       foreach ($signingStringArray as $value) {
           $signingString = $signingString . trim($value) . ": " . trim($responseHeaders[$value]) . "\n";
       }

       // trimming last '\n' character
       $signingString = trim($signingString);

       // decoding signature
       $decodedSignature = base64_decode($signature['signature']);

       // verifying signature
       $signatureVerify = openssl_verify($signingString, $decodedSignature, openssl_get_publickey(file_get_contents($GLOBALS['config']['sign_cert_server'])), 'RSA-SHA256');

       if (!$signatureVerify) {
           errorLog(false, false, "Signature is not correct");
           while (($err = openssl_error_string()))
               errorLog(false, false, $err);
           die();
       }

       return json_decode($responseBody, true);
   }

   return $response;

}

/** 

* This function logs curl responses and errors in text files
*
* @param mixed $response the response
* @param mixed $request  the request handle, used to get errors
*/

function errorLog($curl, $response, $request = false) { 

   $timestamp = '[' . date('Y-m-d H:i:s') . ']:';
   global $errorLog;
   global $responseLog;

   if ($response === false) {
       if ($curl)
           file_put_contents($errorLog, $timestamp . curl_error($request) . "\n", FILE_APPEND);
       else
           file_put_contents($errorLog, $timestamp . $request . "\n", FILE_APPEND);
   } else {
       file_put_contents($responseLog, $timestamp . "\n" . $response . "\n", FILE_APPEND);
   }

}

/** 

* This function generates the full signature header line from a set of headers, a certificate and the linked private key
*
* @param array  $headersToSign the headers to sign, in the $key => $value format
* @param string $certificate   the certificate linked to the used private key
* @param string $privateKey    the private key used to sign the headers
*
* @return string the full signature header line
*/

function generateSignatureHeader(array $headersToSign, string $certificate, string $privateKey): string { 

   // generating the signing string and header list
   $headers         = ;
   $signatureString = ;
   foreach ($headersToSign as $key => $value) {
       $normalizedHeaderKey = trim(strtolower($key));
       $headers             .= $normalizedHeaderKey . ' ';
       $signatureString     .= $normalizedHeaderKey . ': ' . trim($value) . "\n";
   }
   $headers         = trim($headers);
   $signatureString = trim($signatureString);

   // signing the signing string
   $signature = ;
   openssl_sign($signatureString, $signature, openssl_get_privatekey($privateKey), 'RSA-SHA256');
   $signature = base64_encode($signature);

   // compiling the header line
   return "keyId=\"$certificate\",algorithm=\"rsa-sha256\",headers=\"$headers\",signature=\"$signature\"";

}

/** 

* This function deletes the access token from the session
*
* @param string $baseURL
*/

function logout(string $baseURL): void { 

   global $localTokenFile;
   file_put_contents($localTokenFile, );

   header('Location: ' . $baseURL);

}

function displayMenuLoggedIn(): void { 

   global $replacementListItems;

echo '

<a href="/">Home</a>

'; echo '

Logged In

'; 

   echo '<form id="view_repos" method="post">';
   echo '<label for="report_id">Report ID: </label>';
   echo '<input type="number" id="report_id" name="report_id">

';
   foreach ($replacementListItems as $value) {
       echo '<label for="' . $value . '">' . $value . ': </label>';
       echo '<input type="text" id="' . $value . '" name="' . $value . '">

';
   }
   echo '<input type="hidden" id="action" name="action" value="view">';

echo '

<a href="javascript:{}" onclick="document.getElementById(\'view_repos\').submit(); return false;">View Repos</a>

'; 

   echo '</form>';

   echo '<form id="logout" method="post">';
   echo '<input type="hidden" id="action" name="action" value="logout">';

echo '

<a href="javascript:{}" onclick="document.getElementById(\'logout\').submit(); return false;">Log Out</a>

'; 

   echo '</form>';

}

function displayMenuLoggedOut(): void {

echo '

<a href="/">Home</a>

'; echo '

Not logged in

'; 

   echo '<form id="login" method="post">';
   echo '<input type="hidden" id="action" name="action" value="login">';

echo '

<a href="javascript:{}" onclick="document.getElementById(\'login\').submit(); return false;">Log In</a>

'; 

   echo '</form>';

}

// display client "home" page if (!isset($_POST['action'])) { 

   if (!empty($localToken['access_token'])) {
       displayMenuLoggedIn();
   } else {
       displayMenuLoggedOut();
   }

}

if (isset($_POST['action'])) { 

   $replacementList = [];
   // Building replacement list
   foreach ($replacementListItems as $key => $value) {
       $replacementList[$value] = (isset($_POST[$value]) && strlen($_POST[$value]) > 0) ? $_POST[$value] : null;
   }
   // Building query array
   $repoQueryParameters = [
       'resource_type' => 'generic_report',
       'client_id' => $config['client_id'],
       'report_id' => (isset($_POST['report_id']) && strlen($_POST['report_id']) > 0) ? $_POST['report_id'] : null,
       'replacementList' => $replacementList
   ];
   switch ($_POST['action']) {
       case 'login':
           $token = apiRequest(
               $config['token_uri'],
               [
                   'grant_type'    => 'client_credentials',
                   'client_id'     => $config['client_id'],
                   'client_secret' => empty($config['client_secret']) ? null : $config['client_secret'],
                   'scope'         => 'genericreports.readonly reports.readonly'
               ]
           );
           // We store the access token in the session so the user is "connected"
           // Only if the request has been successfully executed
           if (isset($token['access_token'])) {
               file_put_contents($localTokenFile, json_encode($token, true));

               // Redirecting the user's browser to the "home" page
               header('Location: ' . $baseURL);
           } else {
               echo $token;
           }
           break;
       case 'logout':
           logout($baseURL);
           break;
       case 'view':
           // call to the resource server
           $resources = apiRequest(
               $config['resource_uri'],
               $repoQueryParameters,
               $localToken,
               false
           );

           // Separating headers from body
           list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);

           $resourceHeaders = explode("\r\n", $resourceHeader);
           $firstHeaderLine = array_shift($resourceHeaders);

           // Building form for download CSV button
           echo '<form method="post">';
           foreach ($_POST as $key => $value) {
               if ($key == "action") {
                   $value = "download";
               }
               echo '<input type="hidden" id="' . $key . '" name="' . $key . '" value="' . $value . '">';
           }
           if (isset($_POST['report_id']) && strlen($_POST['report_id']) > 0 && !isset(json_decode($resourceBody, true)['error'])) {
               echo '<button>Download as CSV</button>';
           }
           echo '</form>';

           // Displaying requested content

echo '

';
            echo (strpos($firstHeaderLine, "200")) ? json_decode($resourceBody) : $resourceBody;
            echo '

'; 

           break;
       case 'download':
           // call to the resource server
           $resources = apiRequest(
               $config['resource_uri'],
               $repoQueryParameters,
               $localToken,
               false
           );

           // Separating headers from body
           list($resourceHeader, $resourceBody) = explode("\r\n\r\n", $resources, 2);
           $resourceHeaders = explode("\r\n", $resourceHeader);
           array_shift($resourceHeaders);

           // Dumping headers to insert them in current page
           foreach ($resourceHeaders as $key => $value) {
               header($value);
           }
           echo json_decode($resourceBody);
           break;
   }

}</php>

Ce script a été conçu pour montrer le fonctionnement du mécanisme et tester l'implémentation d'un serveur, il n'a pas été testé extensivement. Il est conseillé d'utiliser une solution adaptée à un environnement de production.

Refresh Token

Refresh Token (ou jeton de rafraîchissement en français) est un mécanisme d'autorisation particulier. Il ne peut fonctionner en tant que tel, il fonctionne de pair avec Authorization Code. Lorsqu'un jeton d'accès arrive est arrivé en fin de vie, si le client y est autorisé, il peut faire une demande de renouvellement de son jeton d'accès auprès du serveur d'autorisation en présentant son jeton de rafraîchissement. Le serveur d'autorisation vérifie la validité et génère un autre jeton d'accès qu'il transmet au client, sans que l'utilisateur final n'aît à se connecter de nouveau.

Le principe de fonctionnement du rafraîchissement d'un jeton est le suivant :

  • Le jeton d'accès du client est arrivé à péremption. Le client effectue une demande de renouvellement en transmettant son Refresh Token au serveur d'autorisation.
  • Le serveur d'autorisation vérifie la validité des informations, "consomme" le jeton de rafraîchissement et génère une nouvelle paire de jetons
  • Le client reçoit sa nouvelle paire et utilise le nouveau jeton d'accès pour accéder aux ressources
   +------+                       +-------------+                  +-----------+
   |Client|                       |   Serveur   |                  |  Serveur  |
   +--+---+                       |Autorisation |                  | Ressources|
      |                           +------+------+                  +-----+-----+
      |        Authentification          |                               |
      |         + Refresh Token          |                               |
      +--------------------------------->|                               |
      |                                  |                               |
      |    Access (+ Refresh) token      |                               |
      |<---------------------------------+                               |
      |                                  |                               |
      |                      Requête vers|API                            |
      +----------------------------------+------------------------------>|
      |                                  |                               |
      |                                  |                               |
      |                                  |<------------------------------+
      |                                  |  Vérification d'autorisation  |
      |                                  +------------------------------>|
      |                                  |                               |
      |                         Données /|Réponse                        |
      |<---------------------------------+-------------------------------+
      |                                  |                               |

Demande de renouvellement d'un jeton

Pour obtenir un renouvellement de jeton d'accès, il faut effectuer la requête suivante : POST https://openflyers.com/nom-de-plateforme/oauth/access_token.php. Remplacer nom-de-plateforme par le nom de la plateforme utilisée.

Les paramètres suivants sont nécessaires :

Nom Type Description
client_id string L'identifiant client_id reçu pendant l'enregistrement du client.
client_secret string La passphrase client_secret reçue pendant l'enregistrement du client.
grant_type string Le mécanisme d'autorisation utilisé. Ici, la valeur doit être "refresh_token" (sans guillements).
scope string (OPTIONNEL) Liste des droits demandés par le client, séparés par des espaces.

Si la requête est correcte, un jeton d'accès access_token est fourni en réponse dans un objet au format JSON. <javascript>{ 

 "token_type": "Bearer",
 "expires_in": 3600,
 "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSU-G7fOBOYzOgioSGNIQKI2A2OxjsNBbOOoaHsqNpsQxWZse3rofExAaGKh2tXbeuz1YAVhdLUGYgq-oKRK4ONFhw2NvcRf3QPxQXZImLWw",
 "refresh_token": "a59ef39fa9bab9b95cd554f921e7f3080a34c90f23d2b8031d692b5ff2d0993dcc392d9c7f9a43242337ef144c1a5fe1d0174413ade973e1b628ac0bbfc39b23973534"

}</javascript>

Liste des scopes disponibles

Un scope sur OAuth2 correspond à un droit d'accès sur une ressource particulière. Chaque scope est unique et indique de manière explicite le privilège qu'il donne. Il n'y a aucune restriction d'utilisation des scopes par rapport aux mécanismes. Chaque scope peut être utilisé avec n'importe quel mécanisme. Il n'y a que des recommandations vis à vis de leur utilisation. OpenFlyers définit une liste de scopes dédiée aux ressources accessibles par les clients. Ces scopes sont les suivants :

Nom Description
default.login Comportement par défaut lorsqu'aucun scope n'est précisé ou qu'un scope est invalide. Ce scope est recommandé pour Authorization Code.
genericreports.readonly Accéder aux rapports génériques autorisés pour le client en lecture seule. Ce scope est recommandé pour Client Credentials.
reports.readonly Accéder aux rapports personnalisés autorisés pour le client en lecture seule. Ce scope est recommandé pour Client Credentials.

Prolonger la durée de vie de la session du client de démonstration

La session du client de démonstration est initiée avec la méthode PHP session_start. Cette session peut être interrompue soit en cliquant sur le bouton de déconnexion, soit en fermant le navigateur (car les cookies associés à cette session se détruisent par défaut lorsque le navigateur est fermé).

Pour permettre à la session de rester active même après la fermeture du navigateur, il faut utiliser la méthode PHP session_set_cookie_params. Cette méthode donne la possibilité de définir une durée de vie pour les différents cookies associés à la session. <php>// Set the parameters for the session cookie in a PHP session in order to configure its lifetime in 30 days $oauth2DemoSessionLifeTime = time() + (86400 * 30); session_set_cookie_params($oauth2DemoSessionLifeTime);</php>

NB: Cette approche n'est pas particulièrement sécurisée et peut présenter des risques de sécurité pour OpenFlyers. Par conséquent, elle doit être utilisée avec précaution.

Révocation de token

Pour initier la demande de révocation, rediriger le navigateur de l'utilisateur vers l'URL : POST https://openflyers.com/nom-de-plateforme/oauth/revoke.php. Remplacer nom-de-plateforme par le nom de la plateforme utilisée.

Envoyer également le paramètre suivant:

Nom Type Description
access_token string Le jeton d'accès (Chaîne de caractère unique permettant de prouver qu'un client OAuth a le droit d'accéder à une ressource.)

<php> apiRequest( 

               $config['revoke_uri'],
               ['access_token' => $_SESSION['auth_token']['access_token']],
               null,
               false
           );</php>

La demande de révocation se fait quand l'utilisateur clique sur le bouton Se déconnecter pour l'un des deux Clients Authorization Code et Client Credentials.

Si les jetons sont révoqués, l'utilisateur ne peut pas accéder à la plateforme OpenFlyers, il doit se reconnecter.

Utiliser l'API

Une fois un jeton d'accès obtenu, les données sont accessibles par une requête POST exécutée vers l'URL : https://openflyers.com/nom-de-plateforme/oauth/resources.php. Remplacer nom-de-plateforme par le nom de la plateforme utilisée. La requête POST doit respecter une structure particulière. Cette structure diffère en fonction du type de ressource souhaité et chaque ressource ne peut être accédée qu'avec le scope qui lui est associé. Le jeton d'accès doit être renseigné dans l'en-tête HTTP Authorization en y indiquant la valeur complète du jeton d'accès reçu précédé du type de jeton reçu  : Authorization: <token_type> <access_token>.

Récupérer les informations de l'utilisateur connecté

Ce type de ressource est nommé user_information. Cette ressource n'est accessible qu'avec le scope default.login. Cette ressource permet la récupération des informations de l'utilisateur connecté, en d'autre termes, l'utilisateur connecté lors de l'étape d'autorisation et correspondant à celui ayant émis la demande de jeton d'accès. À l'heure actuelle, seul l'identifiant de l'utilisateur connecté est retourné. La requête POST est construite de la manière suivante :

Nom Type Description
resource_type string Le type de ressource demandé, ici, ce champ correspond à user_information.
client_id string L'identifiant unique reçu pendant l'enregistrement du client.

Un exemple de requête complète au format JSON : <javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1 Content-Type: application/x-www-form-urlencoded Host: openflyers.com Date: Wed, 04 Aug 2021 13:57:51 GMT Accept: application/json User-Agent: curl/7.64.1 Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU Signature: keyId="58c450d937953829c8cca3613001f865a918da07", 

          algorithm="rsa-sha256",
          headers="host content-type digest",
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="

Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=

{ 

   "resource_type":"user_information",
   "client_id":"d2615fe2020ec476"

}</javascript>

La réponse est retournée dans un conteneur JSON.

Récupérer les rapports génériques

Ce type de ressource est nommé generic_report. Cette ressource n'est accessible qu'avec le scope genericreports.readonly. Cette ressource permet la récupération des rapports génériques au format CSV autorisés pour le profil de l'utilisateur associé au client OAuth2 enregistré. La requête POST est construite de la manière suivante :

Nom Type Description
resource_type string Le type de ressource demandé, ici, ce champ correspond à generic_report.
client_id string L'identifiant unique reçu pendant l'enregistrement du client.
report_id int Identifiant du rapport souhaité.
replacementList array Tableau correspondant aux différents paramètres modifiables pour générer le rapport souhaité.

Un exemple de requête complète au format JSON : <javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1 Content-Type: application/x-www-form-urlencoded Host: openflyers.com Date: Wed, 04 Aug 2021 13:57:51 GMT Accept: application/json User-Agent: curl/7.64.1 Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU Signature: keyId="58c450d937953829c8cca3613001f865a918da07", 

          algorithm="rsa-sha256",
          headers="host content-type digest",
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="

Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=

{ 

   "resource_type":"generic_report",
   "client_id":"d2615fe2020ec476",
   "report_id":135,
   "replacementList":{
       "year":2018
   }

}</javascript>

La réponse est un fichier CSV retourné dans un conteneur JSON.

Récupérer les rapports personnalisés

Ce type de ressource est nommé report. Cette ressource n'est accessible qu'avec le scope reports.readonly. Cette ressource permet la récupération des rapports personnalisés au format CSV autorisés pour le profil de l'utilisateur associé au client OAuth2 enregistré. La requête POST est construite de la manière suivante :

Nom Type Description
resource_type string Le type de ressource demandé, ici, ce champ correspond à report.
client_id string L'identifiant unique reçu pendant l'enregistrement du client.
report_id int Identifiant du rapport souhaité.
replacementList array Tableau correspondant aux différents paramètres modifiables pour générer le rapport souhaité.

Un exemple de requête complète au format JSON : <javascript>POST /nom-de-plateforme/oauth/resources.php HTTP/1.1 Content-Type: application/x-www-form-urlencoded Host: openflyers.com Date: Wed, 04 Aug 2021 13:57:51 GMT Accept: application/json User-Agent: curl/7.64.1 Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSU Signature: keyId="58c450d937953829c8cca3613001f865a918da07", 

          algorithm="rsa-sha256",
          headers="host content-type digest",
          signature="UsTjCPLsXzmo1b8FrA18SdLgaPamCpqR7tDHBhaiBnro6RbOkoD7="

Digest: SHA-256=Bi6/9qfJXEWme2/9o7VQMyvf+MED523bWdtdi91opwk=

{ 

   "resource_type":"report",
   "client_id":"d2615fe2020ec476",
   "report_id":1,
   "replacementList":{
       "year":2020
   }

}</javascript>

La réponse est un fichier CSV retourné dans un conteneur JSON.

Procédures

Créer un client à partir du code source

Prérequis

Un client de démonstration est disponible pour le logiciel OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/index.php

Télécharger Le code source du client de démonstration

Le code source est mis à disposition par OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/oauth2-demo-src.zip

Le code source est structuré de la manière suivante :

Oauth2 src demo folder.png

  • Le dossier css contient tout le matériel nécessaire à la stylisation de la page web.
  • Le dossier img contient les images affichées sur la page web.
  • Le dossier ssl est le dossier contenant tous les certificats et les clé privées associées à chaque client. Il doit respecter une structure particulière décrite ci-dessous.
  • Le fichier ClientDemo.php contient la classe ClientDemo. Cette classe contient toutes les méthodes nécessaires au fonctionnement du client de démonstration OAuth2.
  • Le fichier index.php est le fichier à appeler depuis le navigateur. Ce fichier correspond au fichier qui gère les appels à la classe ClientDemo et exécute les méthodes dans l'ordre.

Le dossier ssl doit respecter la structure suivante :

Oauth2 demo tree.png

Générer les certificats

Après la génération des certificats, les clés privées 'auth.key' et 'sign.key' remplacent celles présentes dans les dossiers 'ssl/AuthCodeDemo' et 'ssl/ClientCredDemo'.

Enregistrer les clients
  • Deux clients doivent être créés :
    • Le premier pour le mécanisme d'autorisation Authorization Code,
    • Le second pour le mécanisme d'autorisation Client Credentials.

Oauth2 demo manage.png

  • Télécharger le certificat du CA OpenFlyers en cliquant sur le bouton Télécharger le certificat CA de la page de gestion. Télécharger aussi le certificat de signature du serveur en cliquant sur le bouton Télécharger le certificat de signature du serveur de la page de gestion. Placer les deux certificats téléchargés à la racine du dossier ssl.
  • Télécharger les deux certificats Certificat d'authentification et Certificat de signature du client Authorization Code et les placer dans le répertoire ssl/AuthCodeDemo.
  • Modifier le fichier ssl/AuthCodeDemo/config.authcode.json en le remplissant de la manière suivante.

<php>{ 

 "client_id": "XXXXXXXXXXXXXXXX",
 "client_secret": "XXXXXXXXXXXXXXXX",
 "authorize_uri": "https://openflyers.com/mastructure/oauth/authorize.php",
 "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
 "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
 "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
 "auth_cert": "path_to_client/ssl/AuthCodeDemo/auth_cert.crt",
 "auth_key": "path_to_client/ssl/AuthCodeDemo/auth.key",
 "sign_cert": "path_to_client/ssl/AuthCodeDemo/sign_cert.crt",
 "sign_key": "path_to_client/ssl/AuthCodeDemo/sign.key",
 "auth_cacert": "path_to_client/ssl/ca.crt",
 "sign_cert_server": "path_to_client/ssl/sign_cert_server.crt"

}</php>

  • Remplacer les XXXXXXXXXXXXXXXX des champs client_id et client_secret par les valeurs obtenues lors de l'enregistrement du client.
  • Remplacer mastructure par le nom de la structure sur laquelle la démo est testée.
  • Remplacer path_to_client/ par le chemin d'accès vers le dossier qui contient le code source du client de démonstration.
    • Exemple sur windows: C:/wamp64/www/4.0/oauth-demo/.
    • Exemple sur un serveur Linux debian: ./.


  • Télécharger les deux certificats Certificat d'authentification et Certificat de signature du client Client Credentials et les placer dans le répertoire ssl/ClientCredDemo.
  • Modifier le fichier ssl/ClientCredDemo/config.clientcred.json en le remplissant de la manière suivante.

<php>{ 

 "client_id": "XXXXXXXXXXXXXXXX",
 "client_secret": "XXXXXXXXXXXXXXXX",
 "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
 "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
 "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
 "auth_cert": "path_to_client/ssl/ClientCredDemo/auth_cert.crt",
 "auth_key": "path_to_client/ssl/ClientCredDemo/auth.key",
 "sign_cert": "path_to_client/ssl/ClientCredDemo/sign_cert.crt",
 "sign_key": "path_to_client/ssl/ClientCredDemo/sign.key",
 "auth_cacert": "path_to_client/ssl/ca.crt",
 "sign_cert_server": "path_to_client/ssl/sign_cert_server.crt"

}</php>

  • Remplacer les XXXXXXXXXXXXXXXX des champs client_id et client_secret par les valeurs obtenues lors de l'enregistrement du client.
  • Remplacer mastructure par le nom de la structure sur laquelle la démo est testée.
  • Remplacer path_to_client/ par le chemin d'accès vers le dossier qui contient le code source du client de démonstration.
    • Exemple sur windows: C:/wamp64/www/4.0/oauth-demo/.
    • Exemple sur un serveur Linux debian: ./.



NB: Le certificat de signature du serveur est unique à chaque plateforme et serveur. Ainsi, si le serveur ou la plateforme est modifié, le certificat doit être renouvelé.

Enregistrer un client

Pour utiliser l'API OAuth2, il faut enregistrer un client OAuth2 auprès d'OpenFlyers. Pour ceci, suivre les étapes suivantes :


Pour le mécanisme d'authentification Client Credentials
  • Créer un nouveau profil. Ce profil doit permettre de gérer les droits du client OAuth2. Choisir un nom explicite, par exemple "Client OAuth rapports".
  • Sélectionner les droits à assigner à ce profil. Ces droits limitent les données auxquelles le client OAuth2 a accès.
    • Sélectionner les droits relatifs à l'enregistrement de clients OAuth2 dans l'onglet Admin (colonne Associé aux clients OAuth2).
    • Sélectionner les rapports accessibles par le profil précédemment créé.
  • Créer un nouvel utilisateur à partir du panneau de gestion. Cet utilisateur est virtuel et représente le serveur sur lequel fonctionne le client OAuth2.
    • Des identifiant et nom explicites sont recommandés (exemple : "serv1_oauth_client")
    • Attention : tout utilisateur désactivé et associé à un client OAuth2 rend le client inactif, il faut donc changer l'utilisateur associé au client pour réactiver le client.


Pour le mécanisme d'authentification Authorization Code
  • Aller dans Admin > Utilisateurs > Profils
  • Dans l'onglet Généralités, cocher la case relative à la colonne Connexion depuis l'extérieur (OAuth2) pour le profil souhaité.


Créer un nouveau client OAuth2
  • Aller dans Admin > Transferts > Exports > API OAuth2

Oauth2 manage.png

  • Cliquer sur le bouton Ajouter + ou Ajouter un client

Oauth2 client creation.png

  • Choisir un nom pour le client.
  • Sélectionner le mécanisme d'autorisation utilisé par le client :
    • Authorization Code: permet d'utiliser OAuth2 comme solution SSO ou accéder à des données utilisateurs. Cette méthode peut être couplée avec le mécanisme de mémorisation de connexion (Refresh Token).
    • Client Credentials: permet d'utiliser OAuth2 dans un contexte d'automatisme.
  • Saisir l'URI de redirection vers le client pour le mécanisme Authorization Code.
  • Sélectionner l'utilisateur virtuel créé précédemment pour le mécanisme Client Credentials.
  • Générer deux CSR afin d'obtenir deux certificats signés et les saisir :
    • Certificate Signing Request pour le certificat d'authentification est utilisé pour l'authentification mutuelle avec mTLS (auth_cert.csr.pem).
    • Certificate Signing Request pour le certificat de signature est utilisé pour la signature des en-têtes HTTP (sign_cert.csr.pem).

PublicKeysCopyScreen.png


  • Cliquer sur Enregistrer.

NB: La validité des certificats générés s'étend sur une période de 3 années.


Sauvegarder le couple ID/passphrase

Un couple ID/passphrase (client_id/client_secret) est généré. Ces deux clées ne sont communiquées qu'une seule fois. Elle doivent être stockées en toute sécurité et gardées confidentielles, et Mettre ces identifiants dans le fichier config.clientcred.json. Oauth2 client created.png

ConfigCredJsonScreen.png


Télécharger les certificats crt

Les certificats signés sont téléchargeables depuis l'interface de gestion des clients OAuth2, les certificats sont disponibles dans les onglets Certificat d'authentification et Certificat de signature et les mettre dans le dossier /ssl du client OAuth2. Oauth2 client certificates.png

Téléchargez les certificats du serveur.
  • Les certificats du CA d'OpenFlyers et de signature HTTP du serveur sont nécessaires. Ils sont téléchargeables depuis l'interface de configuration des clients OAuth2.

DownloadServerCertifScreen.png

  • Dans certains cas d'utilisation, il peut être nécessaire d'ajouter le certificat du CA d'OpenFlyers au Trust Store du système. Si cette étape n'est pas réalisée, les certificats peuvent être considérés comme invalides et peuvent ne pas être utilisables.
  • Pour ajouter le certificat CA au Trust Store du système, suivre les étapes suivantes:
    • Sous Linux, copier le certificat CA d'OpenFlyers dans le dossier /usr/local/share/ca-certificates et exécuter la commande sudo update-ca-certificates
    • Sous Windows,
      • Double-cliquer sur le certificat CA d'OpenFlyers téléchargé depuis l'interface d'enregistrement des clients OAuth2
      • Cliquer sur Installer un certificat...
      • Choisir l'emplacement de stockage (utilisateur ou ordinateur) et cliquer sur Suivant puis Suivant et enfin Terminer

Générer des certificats

L'API OAuth2 implémente HTTP Signature et l'authentification TLS mutuelle. Ces mécanismes utilisent chacun une paire certificat/clé privée différente.

Pour obtenir ces certificats, il faut d'abord générer des Certificate Signing Request (CSR).

La procédure est la suivante :

Fichier de configuration OpenSSL - sign_cert.conf
[req]
default_bits       = 4096                     # taille par défaut des nouvelles clés, peut être surchargé dans la commande
encrypt_key        = no                       # chiffrer la clé générée
distinguished_name = req_distinguished_name   # pointe vers la catégorie spécifiée pour le Distinguished Name
x509_extensions    = v3_req                   # pointe vers la catégorie spécifiée pour les extensions x509
prompt             = no

[req_distinguished_name]
C                  =                          # code à deux chiffres du pays (ex: FR)
ST                 =                          # région/état (ex: Gironde)
L                  =                          # ville (ex: Bordeaux)
O                  =                          # organisation (ex: OpenFlyers)
OU                 =                          # unité organisationelle (ex: IT)
CN                 =                          # nom de domaine (ex: openflyers.com)

[v3_req]
keyUsage           = digitalSignature         # pour quelles opérations la clé peut-elle être utilisée
Fichier de configuration OpenSSL - auth_cert.conf
[req]
default_bits       = 4096                     # taille par défaut des nouvelles clés, peut être surchargé dans la commande
encrypt_key        = no                       # chiffrer la clé générée
distinguished_name = req_distinguished_name   # pointe vers la catégorie spécifiée pour le Distinguished Name
x509_extensions    = v3_req                   # pointe vers la catégorie spécifiée pour les extensions x509
prompt             = no

[req_distinguished_name]
C                  =                          # code à deux chiffres du pays (ex: FR)
ST                 =                          # région/état (ex: Gironde)
L                  =                          # ville (ex: Bordeaux)
O                  =                          # organisation (ex: OpenFlyers)
OU                 =                          # unité organisationelle (ex: IT)
CN                 =                          # nom de domaine (ex: openflyers.com)

[v3_req]
extendedKeyUsage   = clientAuth               # pour quelles opérations la clé peut-elle être utilisée


Exécuter les commandes suivantes :

  • <bash>openssl req -sha256 -newkey rsa -keyout sign.key -out sign_cert.csr.pem -outform PEM -config sign_cert.conf</bash>
  • <bash>openssl req -sha256 -newkey rsa -keyout auth.key -out auth_cert.csr.pem -outform PEM -config auth_cert.conf</bash>

Ces commandes prennent chacune en entrée le fichier de configuration et génèrent une clé privée et un Certificate Signing Request.

Une fois ces CSR obtenus :

  • Les renseigner dans les champs prévus à cet effet lors de la création d'un client et télécharger les certificats signés depuis l'interface une fois le client créé.
  • Garder la clé privée confidentielle. Une fuite poserait un risque de sécurité. Elle va de paire avec le certificat distribué par l'autorité de certification OpenFlyers.

Mettre en place une connexion à l'API OpenFlyers sur un serveur mutualisé

Note

La procédure ci-après est destinée à une mise en place lorsqu'il n'y a pas d'accès SSH en ligne de commande mais uniquement un accès FTP. Dans ce cas, la création des clés privées et publics est effectuée "en local". Dans la procédure suivante elle est effectuée depuis un PC sous Windows.

Prérequis
  • Posséder les accès FTP :
    • Hôte : XXXXXXXXXXXXXXXXXX
    • Login : XXXXXXXX
    • Mot de passe : XXXXXXXX
    • Port : XX (par exemple 21)
  • Télécharger Le code source du client de démonstration à disposition par OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/oauth2-demo-src.zip
Procédure
  • Générer les certificats en local.
  • Remplacer les clés privées 'auth.key' et 'sign.key' présentes dans les dossiers 'ssl/AuthCodeDemo' et 'ssl/ClientCredDemo' par les clés générées.
  • Enregistrer les deux clients :
    • Le premier pour le mécanisme d'autorisation Authorization Code.
    • Le second pour le mécanisme d'autorisation Client Credentials.

Oauth2 demo manage.png

  • Télécharger le certificat du CA OpenFlyers en cliquant sur le bouton Télécharger le certificat CA de la page de gestion.
  • Télécharger aussi le certificat de signature du serveur en cliquant sur le bouton Télécharger le certificat de signature du serveur de la page de gestion.
  • Placer les deux certificats téléchargés à la racine du dossier ssl.
  • Télécharger les deux certificats Certificat d'authentification et Certificat de signature du client Authorization Code et les placer dans le répertoire ssl/AuthCodeDemo.
  • Modifier le fichier ssl/AuthCodeDemo/config.authcode.json en le remplissant de la manière suivante.

<php>{ 

 "client_id": "XXXXXXXXXXXXXXXX",
 "client_secret": "XXXXXXXXXXXXXXXX",
 "authorize_uri": "https://openflyers.com/mastructure/oauth/authorize.php",
 "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
 "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
 "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
 "auth_cert": "./ssl/AuthCodeDemo/auth_cert.crt",
 "auth_key": "./ssl/AuthCodeDemo/auth.key",
 "sign_cert": "./ssl/AuthCodeDemo/sign_cert.crt",
 "sign_key": "./ssl/AuthCodeDemo/sign.key",
 "auth_cacert": "./ssl/ca.crt",
 "sign_cert_server": "./ssl/sign_cert_server.crt"

}</php>


  • Télécharger les deux certificats Certificat d'authentification et Certificat de signature du client Client Credentials et les placer dans le répertoire ssl/ClientCredDemo.
  • Modifier le fichier ssl/ClientCredDemo/config.clientcred.json en le remplissant de la manière suivante.

<php>{ 

 "client_id": "XXXXXXXXXXXXXXXX",
 "client_secret": "XXXXXXXXXXXXXXXX",
 "token_uri": "https://openflyers.com/mastructure/oauth/access_token.php",
 "resource_uri": "https://openflyers.com/mastructure/oauth/resources.php",
 "revoke_uri": "https://openflyers.com/mastructure/oauth/revoke.php",
 "auth_cert": "./ssl/ClientCredDemo/auth_cert.crt",
 "auth_key": "./ssl/ClientCredDemo/auth.key",
 "sign_cert": "./ssl/ClientCredDemo/sign_cert.crt",
 "sign_key": "./ssl/ClientCredDemo/sign.key",
 "auth_cacert": "./ssl/ca.crt",
 "sign_cert_server": "./ssl/sign_cert_server.crt"

}</php>

  • Remplacer les XXXXXXXXXXXXXXXX des champs client_id et client_secret par les valeurs obtenues lors de l'enregistrement du client.
  • Remplacer mastructure par le nom de la structure sur laquelle la démo est testée.
  • Transférer le fichier "oauth-demo" vers le serveur mutualisé :
    • Télécharger FileZilla.
    • Lancer FileZilla.
    • Entrer l'URl du serveur mutualisé dans le champ Hôte.
    • Entrer le login dans le champ Nom d'utilisateur.
    • Entrer le mot de passe dans le champ Mot de passe.
    • Entrer le port dans le champ Port.
    • Cliquer sur le bouton Connexion.
    • Accéder à l'emplacement du répertoire "oauth-demo" en local à gauche dans l'onglet "Site local".
    • Choisir l'emplacement où placer le répértoire oauth-demo dans l'anglet Site distant à droite.
    • Glisser et déposer le oauth-demo à l'emplacement choisi.

Transfer OauthDemo To Shared Server.png

  • Accéder au client OAuth-demo depuis le serveur mutualisé en utilisant l'URL du domaine du serveur : url_de_domaine_de_serveur/oauth-demo/index.php
  • Modifier la valeur URI de redirection vers le client du client AuthCodeDemo précédemment créé en remplaçant l'ancienne URL par la nouvelle.


NB: Le certificat de signature du serveur est unique à chaque plateforme et serveur. Ainsi, si le serveur ou la plateforme est modifié, le certificat doit être renouvelé.

Récupérer les données d'un utilisateur

  • Cliquer sur le bouton Récupérer les informations utilisateur, l'identifiant de l'utilisateur s'affiche.
  • Utiliser l'identifiant récupérer afin de récupérer toute information associée à cet utilisateur en créant de nouveaux rapports personnalisés

Utiliser le client

Prérequis

Un client de démonstration est disponible pour le logiciel OpenFlyers à cette adresse : https://openflyers.com/oauth2-demo/index.php

Le client de démonstration se présente de la manière suivante.

Oauth2 client demo.png

La démonstration est composée de deux colonnes. La première, nommée Authorization Code correspond au mécanisme d'autorisation du même nom. Elle dispose d'un bouton permettant de se connecter ainsi que d'une section indiquant les informations relatives à l'état de la connexion. La seconde colonne, nommée Client Credentials correspond elle aussi au mécanisme d'autorisation du même nom. Comme pour la première colonne, les éléments qui y sont présentés sont identiques. La différence étant que le bouton de connexion n'a pas le même effet étant donné que ces deux mécanismes sont différents. Chaque mécanisme est indépendant et il est possible de se connecter à un des deux mécanismes sans se connecter à l'autre ou se connecter aux deux en même temps.

Le mécanisme Authorization Code
  • Cliquer sur le bouton Se connecter (ce qui redirige le navigateur vers la page de connexion du logiciel OpenFlyers).
  • Renseigner les identifiants de l'administrateur pour s'y connecter.
  • Nom d'utilisateur : admini.
  • Mot de passe : azerty.

Une fois les informations saisies, la page suivante est affichée.

Oauth authorize demo.png

  • Cliquer sur le bouton Autoriser l'application pour autoriser la connexion (ce qui se redirige le navigateur vers la page du client de démonstration OAuth2).

La première colonne doit afficher l'état de connexion Connecté ainsi qu'un nouveau bouton Récupèrer les informations utilisateurs qui permet de récupérer les informations de l'utilisateur connecté.

Le mécanisme Client Credentials
  • Cliquer sur le bouton de connexion Se connecter: contrairement à celui du mécanisme Authorization Code, ne redirige pas le navigateur vers la page de connexion du logiciel OpenFlyers. Le bouton de connexion utilise les identifiants du client, ici le couple clé privée/clé publique, pour initier la connexion avec le serveur d'autorisation et obtenir un jeton d'accès.

Une fois la connexion établie, la seconde colonne doit afficher l'état de connexion Connecté ainsi qu'un menu déroulant Rapport à récupèrer et un nouveau bouton Récupèrer le rapport qui permet de récupérer les rapports génériques et personnalisés.


Le client, une fois connecté sur les deux mécanismes, se présente de la manière suivante.

Oauth2 connected demo.png

Troubleshooting

500 Internal Server Error en récupérant le rapport

La démo utilise les valeurs par défaut pour extraire les rapports. Une erreur 500 indique une "Erreur de syntaxe ou violation d'accès" lors de l'exécution de la requête du rapport. Cela se produit parce que le rapport n'a pas de valeurs par défaut associées, étant donné qu'il n'a jamais été visualisé dans l'interface web. Pour résoudre ce problème, il vous suffit de visualiser le rapport et de cocher la case "Mémoriser ce choix".

Erreur "File not found."

Cette erreur se produit lorsque l'URI utilisé n'existe pas sur le serveur OpenFlyers. Vérifier les URIs mis en place dans les fichiers de configuration et essayer de nouveau.

int_rsa_verify : longueur de signature incorrecte

Ce problème pourrait survenir si les fichiers ca.cert et sign_cert_server.cert ne proviennent pas du même serveur que celui du client oauth2. La solution est :

Si cela ne fonctionne pas
Retrieved from "https://doc4-fr.openflyers.com/index.php?title=API-OpenFlyers&oldid=12876"