# Intégration Auth0

## Aperçu

Cette section fournit des instructions sur :

* [L'authentification Auth0](#authentification-auth0) : Comment configurer l'authentification WorkflowGen avec OpenID Connect et Auth0.<br>

* [L'approvisionnement des utilisateurs dans Auth0](#approvisionnement-utilisateurs-okta) : Comment créer un annuaire avec le connecteur d'auto-approvisionnement.

* [La configuration d'Auth0 pour WorkflowGen Plus v2](#configuration-apps-mobiles) : Comment autoriser l'accès aux applications mobiles avec OpenID Connect et Auth0.<br>

* [La configuration d'Auth0 pour les scripts côté serveur](#configuration-auth0-scripts-cote-serveur) : Comment autoriser WorkflowGen pour accéder aux scripts côté serveur avec OpenID et Auth0.<br>

* [La configuration d'Auth0 pour les applications monopages](#configuration-auth0-applications-monopages) : Comment autoriser WorkflowGen pour accéder aux applications monopages avec OpenID Connect et Auth0.<br>

* [La configuration d'Auth0 pour la CLI WorkflowGen](#configuration-dauth0-pour-la-cli-workflowgen) : Comment configurer Auth0 pour l'autorisation à l'interface de ligne de commande WorkflowGen.

* [La génération d'un lien universel pour WorkflowGen Plus v2](#lien-universel) : Comment générer un lien universel pour simplifier la connexion des utilisateurs à l'application mobile WorkflowGen Plus.

Elle fournit également des informations supplémentaires sur [le support des services SOAP](#support-des-services-soap) et [l'approvisionnement des utilisateurs et des groupes](#approvisionnement-utilisateurs-groupes).

{% hint style="info" %}
Dans les instructions, remplacez `<workflowgen url>` par le domaine et le chemin de votre instance de WorkflowGen; par exemple, `localhost/wfgen` ou `www.macompagnie.com/wfgen`.
{% endhint %}

### Prérequis

* Assurez-vous d'avoir une instance de WorkflowGen en fonctionnement sur un serveur.<br>
* Assurez-vous d'avoir l'accès d'administrateur à Auth0 pour pouvoir le configurer.<br>
* Assurez-vous d'avoir approvisionné un utilisateur Auth0 existant depuis lequel vous pourrez vous authentifier à WorkflowGen et l'utiliser plus tard.<br>
* Assurez-vous d'avoir configuré l'authentification déléguée à Auth0 sur votre instance de WorkflowGen en suivant les instructions dans la section [Authentification Auth0](#authentification-auth0).

## Authentification Auth0

### Prérequis

* Assurez-vous d'avoir une copie de WorkflowGen sous licence installée et en fonctionnement sur un serveur. Vous devez être un administrateur WorkflowGen.<br>
* Assurez-vous d'avoir l'accès d'administrateur à Auth0.<br>
* Assurez-vous d'avoir approvisionné un utilisateur Auth0 existant depuis lequel vous pourrez vous authentifier à WorkflowGen et que cet utilisateur a les permissions d'accès d'administrateur. Ceci est important car une fois que vous aurez activé la délégation, vous devrez toujours pouvoir gérer l'application. L'utilisateur Auth0 est en fait un utilisateur d'un fournisseur d'identité qui est lié à Auth0, comme GitHub ou Google. Vous devez avoir approvisionné au moins un utilisateur.<br>
* Le mode de chiffrement AES et sa clé sont requis pour que l'authentification fonctionne.

{% hint style="info" %}

* Pour tester la configuration après avoir suivi les étapes suivantes, vous pouvez ajouter un utilisateur Auth0 dans la section **Users** du portail Auth0.<br>
* Lorsque vous importez des utilisateurs dans WorkflowGen depuis la base de données d'Auth0, assurez-vous de définir le nom d'utilisateur comme son adresse email (p.ex. `jean.tremblay@exemple.com`).
  {% endhint %}

### Configuration d'Auth0

La configuration d'Auth0 se fait dans plusieurs étapes. D'abord, vous devez inscrire l'application Web de WorkflowGen et la lier à votre instance de WorkflowGen; ensuite, vous devez inscrire l'API GraphQL de WorkflowGen pour pouvoir inscrire des applications personnalisées pour y accéder.

#### Étape 1 : Créez une nouvelle application Web régulière

1. Naviguez à la section **Applications** dans le portail Auth0.<br>
2. Cliquez sur **Create Application** et renseignez le formulaire :
   * **Name** **:** `WorkflowGen Web App`&#x20;
   * **Type** **:** Regular Web Application<br>
3. Cliquez sur **Create**. Vous devriez maintenant voir la page « Quick Start » de l'application.<br>
4. Dans l'onglet **Settings**, défilez vers le bas jusqu'à la section **Allowed Callback URLs** et ajoutez-y `https://<workflowgen url>/auth/callback`.<br>
5. Défilez vers le bas jusqu'à la section **Allowed Logout URLs** et ajoutez-y `https://<workflowgen url>/auth/logout/return`.

Votre application Web régulière de WorkflowGen est maintenant configurée.

#### Étape 2 : Inscrivez l'API GraphQL

Vous devez maintenant inscrire le module de l'API GraphQL de WorkflowGen afin que les applications externes à WorkflowGen puissent utiliser l'API avec l'authentification Auth0 en utilisant le protocole OpenID Connect.

**Utilisation classique :**

1. Accédez à la section **APIs** dans le portail Auth0.<br>
2. Cliquez sur **Create API** et renseignez le formulaire :
   * **Name** **:** `WorkflowGen GraphQL API`&#x20;
   * **Identifier** **:** `https://<workflowgen url>/graphql`&#x20;
   * **Signing algorithm** **:** `RS256` <br>
3. Cliquez sur **Create**.

**Avec support multi-audiences :**

1. Accédez à la section **APIs** dans le portail Auth0.<br>
2. Cliquez sur **Create API** et renseignez le formulaire :
   * **Name** **:** `My APIs`&#x20;
   * **Identifier** **:** `my-apis`
   * **Signing algorithm** **:** `RS256` <br>
3. Cliquez sur **Create**.<br>
4. Cliquez sur **Permissions**.<br>
5. Dans la section **Define all the permissions (scopes) that this API uses**, saisissez les informations suivantes :
   * **Permission:** `wfgen-graphql-full-access`
   * **Description:** `Full access to the WorkflowGen GraphQL API` <br>
6. Cliquez sur **ADD**.

L'API GraphQL est maintenant inscrite dans Auth0.

#### Étape 3 : Ajoutez une action Auth0

Pour obtenir un bon nom d'utilisateur du jeton d'accès lors de sa réception dans l'API GraphQL, vous devez utilisez une fonctionnalité spéciale d'Auth0 appelée **action**. Les actions agissent en tant qu'intergiciels (« middleware ») entre le fournisseur cloud lié et Auth0 afin de récupérer les valeurs correctes au besoin.

1. Accédez au portail Auth0 et sélectionnez **Actions** dans le menu de gauche, puis sélectionnez **Library** dans le sous-menu.

2. Cliquez sur **Create Action**, puis choisissez le modèle **Build from scratch**.<br>

3. Donnez un nom à l'action (p.ex. `WorkflowGen (Action)`). **Trigger** doit être réglé sur **Login / Post Login** et **Runtime** doit être réglé sur **Node 18 (Recommended)**.![](https://4144579837-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-LQ0Ouysi5pHXnbzdNZj-2115695630%2Fuploads%2FiK7uUeycGHof6h6NwqEL%2Fcreate%20action.png?alt=media\&token=65b834ea-b3bc-4441-8d93-f78294dcb0e4)<br>

4. Remplacez le code par le code suivant :

   <pre><code><strong>exports.onExecutePostLogin = async (event, api) => {
   </strong>    const username = event.user.username || event.user.email || event.user.nickname;
              
       api.accessToken.setCustomClaim('https://api.workflowgen.com/username', username);
       api.idToken.setCustomClaim('https://api.workflowgen.com/username', username);

       return;
   }
   </code></pre>

5. Cliquez sur **Deploy**.<br>

6. Accédez au portail Auth0 et sélectionnez **Actions** dans le menu de gauche, puis sélectionnez **Flows** dans le sous-menu.<br>

7. Sur la page **Flows**, cliquez sur l'icône **Login**.<br>

8. Dans le panneau de droite de la vue graphique, sélectionnez l'onglet **Custom**, où votre action personnalisée doit apparaître.

   <figure><img src="https://4144579837-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-LQ0Ouysi5pHXnbzdNZj-2115695630%2Fuploads%2Fuga9sjIHAlkSInj88YIV%2Flogin%202.png?alt=media&#x26;token=00e7e010-6e81-435b-ad02-d83f7522eb65" alt=""><figcaption></figcaption></figure>

9. Glissez-déplacez votre action entre les actions **Start** et **Complete**.

   <figure><img src="https://4144579837-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-LQ0Ouysi5pHXnbzdNZj-2115695630%2Fuploads%2FYsXNlFtgm4YIRrxwb0Ee%2Flogin%201.png?alt=media&#x26;token=4e148fec-8cb2-43b4-947d-3cbaa8bf0e87" alt=""><figcaption></figcaption></figure>

10. Cliquez sur le bouton **Apply** en haut à droite.

Cette étape assurera que WorkflowGen et l'API GraphQL obtiendront toujours un nom d'utilisateur depuis la même revendication au lieu de devoir faire plusieurs instructions conditionnelles. Cependant, ceci ne s'applique pas à l'authentification de machine à machine car il n'y aucun utilisateur humain impliqué.

Si vous utilisez une revendication de la correspondance Auth0 autre que celle spécifiée dans la fonction ci-dessus (p.ex. `user.username`, `user.email`, `user.nickname`), il suffit tout simplement de modifier cette règle ou ajouter la vôtre. Assurez-vous d'alimenter `https://api.workflowgen.com/username` avec la valeur, ou de configurer l'option `ApplicationSecurityAuthUsernameClaim` dans votre `web.config` avec la bonne revendication à prendre. Notez que cette option est utilisée dans l'application d'authentification ainsi que dans l'API GraphQL.

### Configuration de WorkflowGen

Maintenant, vous devez configurez WorkflowGen pour déléguer son authentification à Auth0.

#### Étape 1 : Ajoutez les valeurs Auth0 au `web.config` de WorkflowGen

1. Ouvrez le fichier `web.config` de WorkflowGen et ajoutez-y les propriétés suivantes sous `<appSettings>` :\
   \
   **Utilisation classique :**

   ```markup
    <!-- Auth0 auth -->
    <add key="ApplicationSecurityAuthProvider" value="auth0"/>
    <add key="ApplicationSecurityAuthClientId" value="<CLIENT ID>" />
    <add key="ApplicationSecurityAuthClientSecret" value="<CLIENT SECRET>" />
    <add key="ApplicationSecurityAuthMetadataUrl" value="<METADATA URL>" />
    <add key="ApplicationSecurityAuthUsernameClaim" value="https://api.workflowgen.com/username" />
    <add key="ApplicationSecurityAuthAppIdClaim" value="azp" />
    <add key="ApplicationSecurityAuthClockTolerance" value="60" />
    <add key="ApplicationSecurityAuthSessionRefreshEnableIFrame" value="Y"/>
   ```

   **Avec support multi-audiences :**

   ```markup
    <!-- Auth0 auth -->
    <add key="ApplicationSecurityAuthProvider" value="auth0"/>
    <add key="ApplicationSecurityAuthClientId" value="<CLIENT ID>" />
    <add key="ApplicationSecurityAuthClientSecret" value="<CLIENT SECRET>" />
    <add key="ApplicationSecurityAuthMetadataUrl" value="<METADATA URL>" />
    <add key="ApplicationSecurityAuthUsernameClaim" value="https://api.workflowgen.com/username" />
    <add key="ApplicationSecurityAuthAppIdClaim" value="azp" />
    <add key="ApplicationSecurityAuthClockTolerance" value="60" />
    <add key="ApplicationSecurityAuthSessionRefreshEnableIFrame" value="Y"/>
    <add key="ApplicationSecurityAuthAudience" value="my-apis"/>
    <add key="ApplicationSecurityAuthAdditionalScopes" value="wfgen-graphql-full-access"/>
    <add key="ApplicationSecurityAuthGraphScope" value="wfgen-graphql-full-access"/>
   ```
2. Remplacez `<CLIENT_ID>` par l'ID client de l'application Web régulière de WorkflowGen dans Auth0.<br>
3. Remplacez `<CLIENT SECRET>` par la clé secrète client de l'application Web régulière de WorkflowGen dans Auth0.<br>
4. Remplacez `<METADATA_URL>` par l'URL que vous avez construit antérieurement depuis votre nom de domaine dans Auth0. La `METADATA URL` est `https://[VOTRE_DOMAINE_AUTH0].auth0.com/.well-known/openid-configuration`.

Notez que la clé `ApplicationSecurityAuthUsernameClaim` est réglée sur la valeur saisie dans la règle antérieurement, donc vous pouvez utiliser n'importe quelle valeur ici à condition que vous modifiez aussi la règle.

{% hint style="info" %}
Pour des informations sur les options de configuration disponibles à utiliser avec votre instance, consultez l'annexe [Paramètres de configuration Web et d'application](https://docs.workflowgen.com/tech-fr/8.0/annexe-parametres-de-configuration-web-et-dapplication).
{% endhint %}

WorkflowGen est maintenant lié à Auth0 et réciproquement. La dernière étape est de configurer quelques options pour finaliser le « câblage interne ».

#### Étape 2 : Ajoutez des valeurs de sécurité pour la génération de session

Pour générer un jeton de session, vous devez ajouter quelques configurations au fichier `web.config`.

1. Ouvrez le fichier `web.config` de WorkflowGen et ajouter la propriété suivante sous `<appSettings>` :

   ```markup
   <!-- Auth -->
   <add key="ApplicationSecurityAuthLogoutUrl" value="https://<your auth0 domain>.auth0.com/v2/logout"/>
   <add key="ApplicationSecurityAuthSessionTokenSigningSecret" value="<SECRET>" />
   ```
2. Remplacez `<SECRET>` par une valeur qui ne peut pas être devinée, comme un UUID.

Le secret sera seulement accessible dans votre instance de WorkflowGen, donc lors de la génération du jeton de session, WorkflowGen le signera avec ce secret afin de vérifier la validité de tous les jetons qui seront envoyés.

#### Étape 3 : Activez la délégation d'authentification

Vous devez maintenant activer la délégation en remplaçant le système d'authentification dans IIS et faire pointer les modules de WorkflowGen au module d'authentification correct.

**Configurez IIS**

1. Dans IIS Manager, cliquez sur l'application WorkflowGen dans l'arborescence.<br>
2. Cliquez sur le bouton **Authentication**.<br>
3. Activez **Anonymous Authentication** et désactivez toutes les autres authentifications.<br>
4. Répétez ces étapes pour toutes les sous-applications.

**Ajoutez des propriétés aux fichiers `web.config` de certains modules**

Certains modules doivent faire vérifier leur authentification par le module d'authentification spécial de WorkflowGen `Advantys.Security.JWTAuthenticationModule`, tandis que certains autres modules ne le doivent pas parce qu'ils sont soit publics ou ne font pas partie du système d'authentification global.

1. Ajoutez la propriété suivante au fichier `web.config` de WorkflowGen :

   ```markup
   <?xml version="1.0" encoding="UTF-8"?>
   <configuration>
       <system.webServer>
           <modules>
               <add name="ApplicationSecurityAuthenticationModule" type="Advantys.Security.Http.JWTAuthenticationModule" />
           </modules>
       </system.webServer>
   </configuration>
   ```
2. Ajoutez la propriété suivante au fichier `web.config` du module `auth` :

   ```markup
   <?xml version="1.0" encoding="UTF-8"?>
   <configuration>
       <system.webServer>
           <modules>
               <remove name="ApplicationSecurityAuthenticationModule"/>
           </modules>
       </system.webServer>
   </configuration>
   ```

   Cette ligne enlève le module d'authentification Node.js du système d'authentification global, car cette application Node.js encapsule les mécanismes d'authentification de OpenID connect.<br>
3. Répétez les deux étapes ci-haut pour les modules `hooks` et `scim`.<br>
4. Copiez les assemblies et bibliothèques de dépendances .NET suivants de `\wfgen\bin` dans les dossiers `\bin` de tous les formulaires Web personnalisés (`\wfgen\wfapps\webforms\<custom webform>\bin`) :<br>
   * `Advantys.My.dll`
   * `Advantys.Security.dll`
   * `Newtonsoft.Json.dll`
   * `jose-jwt.dll`

{% hint style="success" %}
Vous devriez maintenant avoir une instance de WorkflowGen en fonctionnement avec l'authentification déléguée à Auth0 via le protocole OpenID Connect. Assurez-vous d'avoir approvisionné vos utilisateurs à WorkflowGen afin qu'ils puissent accéder à WorkflowGen.
{% endhint %}

### Configurer l'authentification sans l'API GraphQL

{% hint style="warning" %}
Cette fonctionnalité n'est pas supportée pour Auth0. Il est nécessaire de configurer l'API GraphQL sur le fournisseur.
{% endhint %}

## Approvisionnement des utilisateurs dans Auth0 <a href="#approvisionnement-utilisateurs-okta" id="approvisionnement-utilisateurs-okta"></a>

Le connecteur d'auto-approvisionnement est un connecteur d'annuaire qui crée et synchronise un utilisateur automatiquement selon ses revendications des jetons de session qui contiennent les revendications du jeton d'ID du fournisseur OpenID Connect. Cette fonctionnalité est uniquement compatible avec l'authentification OpenID Connect.

### Prérequis

* Assurez-vous d'avoir une instance de WorkflowGen en fonctionnement.<br>
* Assurez-vous de connaître l'adresse IP de l'instance ou son nom complet.<br>
* Assurez-vous de connaître l'adresse de l'instance.<br>
* Assurez-vous d'avoir configuré Okta ou une des autres méthodes conformes OIDC ([Azure Active Directory](https://docs.advantys.com/workflowgen-pour-azure/v/8.0.0/), [AD FS](https://github.com/advantys/workflowgen-doc-technical-fr/tree/e4f86be3cef758d0fa81717ff307ab45f059615d/integration-adfs.md), [Okta](https://docs.workflowgen.com/tech-fr/8.0/integration-okta) ou [Microsoft Identity Platform v2.0](https://docs.advantys.com/workflowgen-pour-azure/v/8.0.0/)).

### Configuration de WorkflowGen

Cette section vous guidera à travers les configurations de WorkflowGen nécessaires pour créer la fonctionnalité d'auto-approvisionnement avec un annuaire.

#### Étape 1 : Créez un annuaire d'auto-approvisionnement

Ce répertoire contiendra tous les utilisateurs qui ne sont pas approvisionnés ailleurs. Pour créer un annuaire d'auto-approvisionnement :

1. Dans la page **Annuaires** du module d'administration de WorkflowGen, cliquez sur **Nouvel annuaire**.<br>
2. Renseignez le formulaire :
   * **Nom** : `AUTO_APPROVISIONNEMENT` (ou n'importe quoi)
   * **Description** : Une bonne description de l'annuaire
   * **Connecteur d'annuaire** : `Approvisionnement automatique` <br>
3. Cliquez sur **Enregistrer**.

#### Étape 2 : Configurez les correspondances entre les champs d'utilisateurs et les revendications

Maintenant que vous avez créé un nouvel annuaire avec le connecteur d'auto-approvisionnement, vous devez définir les correspondances entre les revendications et les champs d'utilisateurs de WorkflowGen. Pour ce faire :

1. Dans la page du nouvel annuaire, cliquez sur **Correspondances**.<br>
2. À droite du nom du champ de l'utilisateur WorkflowGen, saisissez le nom de la revendication dans le jeton de session pour lequel vous voulez créer la correspondance.<br>

   Voici un exemple un jeton de session généré par l'application node `auth` depuis un jeton d'ID Auth0 connecté avec Google Apps :

   ```
    {
        "sub": "some.user@advantys.com",
        "iss": "https://<workflowgen_url>/auth",
        "aud": "https://<workflowgen_url>",
        "exp": 1535627127,
        "https://api.workflowgen.com/username": "some.user@advantys.com",
        "given_name": "Some",
        "family_name": "User",
        "nickname": "some-user",
        "name": "Some User",
        "picture":  "https://lh4.googleusercontent.com/path/to/photo.jpg",
        "gender": "male",
        "locale": "en",
        "updated_at": "1970-01-01T00:00:00Z",
        "email": "some.user@advantys.com",
        "email_verified": true,
        "nonce": "ffdd6d95-31e6-4466-84c4-43f8c0fbaae7",
        "iat": 1535591128
    }
   ```

   ✏️ **Note :** Les champs **Nom d'utilisateur** et **Nom** sont obligatoires.<br>
3. Cliquez sur **Enregistrer**.

{% hint style="success" %}
Vous avez maintenant activé la fonctionnalité d'auto-approvisionnement et les utilisateurs inconnus peuvent être automatiquement approvisionnés et synchronisés avec WorkflowGen sans aucune action externe requise.
{% endhint %}

## Configuration d'Auth0 pour WorkflowGen Plus v2 <a href="#configuration-apps-mobiles" id="configuration-apps-mobiles"></a>

Les applications mobiles doivent suivre une approche semblable à celle des applications Web ordinaires appelée « **Authorization Code Flow with Proof Key for Code Exchange (PKCE)** ». La principale distinction entre PKCE et le « Authorization Code Flow » classique est que l'application mobile ne reçoit pas de clé secrète client; à la place, elle échange une paire de codes pour prouver l'origine de la tentative d'authentification. Le problème est qu'on ne peut pas se fier à une application mobile car elle est distribuée librement aux utilisateurs et donc elle n'est plus sous le contrôle, puis les sources pourraient être décompilées et analysées pour révéler les clés secrètes client.

Cette section contient les instructions sur comment configurer Auth0 pour les applications mobiles afin que vos utilisateurs mobiles puissent aussi bénéficier de l'authentification déléguée.

### Prérequis

* Assurez-vous d'avoir une copie de WorkflowGen sous licence installée et en fonctionnement sur un serveur.<br>
* Assurez-vous d'avoir l'accès d'administrateur Auth0 pour pouvoir le configurer.<br>
* Assurez-vous d'avoir approvisionné un utilisateur Auth0 existant depuis lequel vous pourrez vous authentifier à WorkflowGen pour pouvoir utiliser l'application après.<br>
* Assurez-vous d'avoir installé la plus récente version de WorkflowGen Plus sur votre appareil et que l'appareil est supporté.<br>
* Assurez-vous d'avoir bien configuré l'authentification déléguée à Auth0 sur votre instance de WorkflowGen en suivant les instructions dans la section [Authentification Auth0](#authentification-auth0).

### Configuration d'Auth0

Cette configuration se fait dans plusieurs étapes. D'abord, vous devez inscrire une nouvelle application native dans Auth0. Ensuite, vous devez donner à l'application les permissions requises pour accéder à l'API GraphQL de WorkflowGen.

#### Étape 1: Inscrivez une nouvelle application native

1. Dans la section **Applications** du portail Auth0, cliquez sur **Create Application**.<br>
2. Renseignez le formulaire :
   * **Name** : `WorkflowGen Plus`
   * **Type** : `Native` <br>
3. Cliquez sur **Create** en bas de la page.

Vous avez maintenant inscrit une nouvelle application native dans Auth0.

#### Étape 2 : Ajoutez des URLs de rappel

1. Dans l'onglet **Settings**, défilez vers le bas jusqu'à la section **Allowed Callback URLs** et ajoutez-y l'URL `workflowgenplus://oidc`.<br>
2. Défilez vers le bas jusqu'à la section **Allowed Logout URLs** et ajoutez-y l'URL `workflowgenplus://oidc`.

#### Vérifiez l'inscription

Puisque toutes les applications dans un domaine peuvent automatiquement accéder entre eux, votre application native hérite l'accès à l'API GraphQL. Voici un résumé de toutes les informations dont il vous faut :

* Un ID client, qui se trouve dans l'onglet **Settings** dans la page de l'application native.<br>
* Un nom de domaine Auth0, qui se trouve directement à gauche de votre photo de profil en haut à droite de la page.

{% hint style="success" %}
Toutes ces informations doivent être données aux utilisateurs qui utiliseront l'application mobile; ils devront les copier-coller directement dans l'application.
{% endhint %}

## Configuration d'Auth0 pour les scripts côté serveur <a href="#configuration-auth0-scripts-cote-serveur" id="configuration-auth0-scripts-cote-serveur"></a>

Dans certains cas, vous voudrez effectuer une tâche spécifique qui peut être automatisée mais qui doit pouvoir accéder à l'API GraphQL de WorkflowGen; ce cas d'usage est souvent sous forme de script côté serveur. Pour ceci, OAuth2 fournit un type d'autorisation appelé **Client Credentials** qui échange tout simplement un ID client et une clé secrète client pour un jeton d'accès. Il n'y a aucun jeton ID car ceci ne fait pas partie du standard OpenID Connect, et aucun utilisateur n'est impliqué.

Cette section contient les instructions sur comment configurer Auth0 avec un script côté serveur qui a accès à l'API GraphQL.

### Prérequis

* Assurez-vous d'avoir une copie de WorkflowGen sous licence installée et en fonctionnement sur un serveur.<br>
* Assurez-vous d'avoir l'accès d'administrateur WorkflowGen.<br>
* Assurez-vous d'avoir l'accès d'administrateur Auth0 pour pouvoir le configurer.<br>
* Assurez-vous d'avoir bien configuré l'authentification déléguée à Auth0 sur votre instance de WorkflowGen en suivant les instructions dans la section [Authentification Auth0](https://github.com/advantys/workflowgen-doc-technical-fr/tree/e4f86be3cef758d0fa81717ff307ab45f059615d/integration-auth0/README.md#integration-auth0).

### Configuration d'Auth0

#### Étape 1 : Inscrivez une nouvelle application machine à machine

1. Dans la section **Applications** du portail Auth0, cliquez sur **Create Applications**.<br>
2. Renseignez le formulaire :
   * **Name**: `Votre nom de script`
   * **Application Type**: `machine-to-machine` <br>
3. Cliquez sur **Create**.

Vous avez maintenant inscrit votre script dans Auth0.

#### Étape 2 : Donnez accès à l'API GraphQL

1. Dans la section **APIs** du portail Auth0, cliquez sur **WorkflowGen GraphQL API**.<br>
2. Dans l'onglet **Machine-to-Machine**, autorisez l'application que vous venez de créer.

Vous avez maintenant donné accès l'API GraphQL pour votre script.

#### Vérifiez l'inscription

Voici un résumé des informations dont il vous faut :

1. Un ID client, qui se trouve dans l'onglet des paramètres de l'application inscrite.<br>
2. Une clé secrète client, qui se trouve dans l'onglet des paramètres de l'application inscrite.<br>
3. L'identifiant de l'API GraphQL de WorkflowGen, qui se trouve dans sa page des paramètres.

Vous êtes maintenant prêt à inscrire votre script dans WorkflowGen.

### Configuration de WorkflowGen

Comme pour l'approvisionnement des utilisateurs, WorkflowGen doit savoir quelle application accède à l'API GraphQL. Vous devez donc inscrire l'application, qui est constituée de votre script.

#### Inscrivez une nouvelle application

1. Dans la page **Applications** du module d'administration de WorkflowGen, cliquez sur **Nouvelle application**.<br>
2. Renseignez le formulaire :
   * **Name** : `Mon application serveur`
   * **Description** : Une description qui indique clairement qui identifie clairement le script
   * **Type** : `Non-interactive Client`
   * **Impersonate username** : Un nom d'utilisateur qui a les permissions requises pour accéder à l'API GraphQL
   * **Client ID** : L'ID client que vous avez retrouvée plus tôt
   * **Active** : Cochez cette case à cocher<br>
3. Cliquez sur **Save**.

Votre application devrait maintenant paraître dans la liste d'applications.

{% hint style="success" %}
Vous devriez maintenant avoir mis en place les composants nécessaires à faire des requêtes à l'API GraphQL depuis votre script en passant le jeton d'accès reçu d'Auth0 via le flux Client Credentials Grant.
{% endhint %}

## Configuration d'Auth0 pour les applications monopages <a href="#configuration-auth0-applications-monopages" id="configuration-auth0-applications-monopages"></a>

Les applications JavaScript s'exécutant dans un navigateur sont souvent difficiles à sécuriser à cause de la nature ouverte du Web. Le stockage sécurisé est non-existant, et tout est en texte clair (pour HTTP version 1.1). Voici une citation (en Anglais) de l'équipe Azure Active Directory qui synthétise l'état de l'authentification avec les applications monopages (« single-page applications ») :

> The OAuth2 implicit grant is notorious for being the grant with the longest list of security concerns in the OAuth2 specification. And yet, that is the approach implemented by ADAL JS and the one we recommend when writing SPA applications. What gives? It’s all a matter of tradeoffs: and as it turns out, the implicit grant is the best approach you can pursue for applications that consume a Web API via JavaScript from a browser.
>
> (Source : <https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-dev-understanding-oauth2-implicit-grant>)

Il est donc important de faire toutes les vérifications nécessaires pour assurer la validité de vos demandes et les réponses.

Cette section contient les instructions sur comment configurer Auth0 avec une application monopage (« SPA ») avec laquelle les utilisateurs pourront s'authentifier et faire des requêtes à l'API GraphQL. Cette configuration est constituée de trois étapes : inscrire la SPA, donner accès à l'API et régler quelques URLs de redirection.

### Prérequis

* Assurez-vous d'avoir une copie de WorkflowGen sous licence installée et en fonctionnement sur un serveur.<br>
* Assurez-vous d'avoir l'accès d'administrateur Auth0 pour pouvoir le configurer.<br>
* Assurez-vous d'avoir approvisionné un utilisateur Auth0 existant depuis lequel vous pourrez vous authentifier à WorkflowGen pour pouvoir utiliser l'application.<br>
* Assurez-vous d'avoir bien configuré l'authentification déléguée à Auth0 sur votre instance de WorkflowGen en suivant les instructions dans la section [Authentification Auth0](#authentification-auth0).

#### Étape 1 : Inscrivez une nouvelle application Web

1. Cliquez sur **Create Application** dans la section **Applications** du portail Auth0.<br>
2. Renseignez le formulaire :
   * **Name** : `Votre nom SPA`
   * **Type** : `Single Page Web Applications` <br>
3. Cliquez sur **Create** en bas de la page.

Vous devriez maintenant voir la page de votre application inscrite.

#### Étape 2 : Ajoutez des URLs de redirection

1. Dans l'onglet **Settings**, défilez vers le bas jusqu'à la section **Allowed Callback URLs** et ajoutez-y l'URL de connexion (p.ex. : `https://localhost/login/callback`).<br>
2. Si vous supportez la déconnexion de Auth0, défilez vers le bas à la section **Allowed Logout URLs** et ajoutez votre URL de redirection post-déconnexion (p.ex. : `https://localhost/logout/return`).

#### Vérifiez l'inscription

* Vous devez avoir un ID client, qui se trouve dans l'onglet **Settings** de la page de l'application.<br>
* Vous devez avoir votre nom de domaine Auth0, qui se trouve à côté de votre photo de profil en haut à droite du portail.

{% hint style="success" %}
Votre application devrait maintenant être liée à l'infrastructure et les utilisateurs pourront se connecter depuis l'application. Si vous avez satisfait aux prérequis, votre application recevra un jeton d'accès qu'elle pourra ensuite envoyer à l'API GraphQL de WorkflowGen pour effectuer des demandes autorisées en tant que jeton du porteur via l'en-tête d'autorisation.
{% endhint %}

## Configuration d'Auth0 pour la CLI WorkflowGen

### Mode interactif

#### Étape 1 : Inscrivez une nouvelle application native

1. Dans la section **Applications** du portail Auth0, cliquez sur **Create Application**.<br>
2. Renseignez le formulaire :
   * **Name** **:** `CLI WorkflowGen`
   * **Type** **:** `Native` <br>
3. Cliquez sur **Create** en bas de la page.

Vous avez maintenant inscrit une nouvelle application native dans Auth0.

#### Étape 2 : Ajoutez une URL de rappel

Dans l'onglet **Settings**, défilez vers le bas jusqu'à la section **Allowed Callback URLs** et ajoutez-y l'URL `http://127.0.0.1:8888/callback`.

{% hint style="info" %}
Le port `8888` est celui défini par défaut, vous pouvez le changer s'il est déjà utilisé sur votre poste.&#x20;
{% endhint %}

#### Étape 3 : Vérifiez les types d'octrois

Dans **Settings** > **Advanced Settings** > **Grant Types**, assurez vous que les cases `Implicit` , `Authorization Code` et `Refresh Token` sont bien cochées.

#### Vérifiez l'inscription

Puisque toutes les applications dans un domaine peuvent automatiquement accéder entre eux, votre application native hérite l'accès à l'API GraphQL. Voici un résumé de toutes les informations dont il vous faut :

* Un ID client, qui se trouve dans l'onglet **Settings** dans la page de l'application native.<br>
* Un nom de domaine Auth0, qui se trouve dans l'onglet **Settings** dans la page de l'application native.

{% hint style="success" %}
Toutes ces informations doivent être données aux utilisateurs qui utiliseront la CLI WorkflowGen.
{% endhint %}

### Mode non interactif

La configuration du mode non interactif est la même que dans la section [Configuration d'Auth0 pour les scripts côté serveur](#configuration-auth0-scripts-cote-serveur).

Voici un résumé des informations dont il vous faut :

* Un ID client, qui se trouve dans l'onglet des paramètres de l'application inscrite.<br>
* Une clé secrète client, qui se trouve dans l'onglet des paramètres de l'application inscrite.<br>
* Le domaine, qui se trouve dans l'onglet des paramètres de l'application inscrite.

{% hint style="success" %}
Vous pouvez désormais utiliser la CLI WorkflowGen en mode `Client credentials`.
{% endhint %}

## Génération d'un lien universel pour WorkflowGen Plus v2 <a href="#lien-universel" id="lien-universel"></a>

Depuis la version 7.11.2 de WorkflowGen serveur, vous pouvez générer un lien universel pour simplifier le processus de connexion Auth0 de vos utilisateurs de l'application mobile WorkflowGen Plus.

#### URL de base

* **protocol:** `workflowgenplus://` <br>
* **hostname:** `auth.init`

#### Paramètres

Vous devez régler les paramètres suivants :

* **provider** : `auth0` <br>

* **server\_address** : L'URL de votre application WorkflowGen, dont la valeur doit être encodée URL (p.ex. : `https://macompagnie.com/wfgen`)

* **client\_id** : Utilisez l'ID client que vous avez créé antérieurement dans la configuration (p.ex. : `7gdj4hs92y`).<br>

* **domain** : Le nom du domaine Auth0 sans le protocole URL (p.ex. : `mondomaine.auth0.com`).<br>

* **audience** : L'URL de votre API GraphQL de WorkflowGen (p.ex. : `http://macompagnie.com/wfgen/graphql`). \
  \
  ✏️ **Note :** La valeur doit être encodée URL.

Le lien universel devrait suivre cette structure :

```
workflowgenplus://auth.init?provider=auth0&server_address=https%3A%2F%2Fmycompany.com%2Fwfgen&client_id=7gdj4hs92y&domain=mydomain.auth0.com&audience=https%3A%2F%2Fmycompany.com%2Fwfgen%2Fgraphql
```

{% hint style="success" %}
Une fois que vous aurez généré le lien universel, donnez-le à vos utilisateurs, qui pourront l'utiliser pour se connecter à WorkflowGen Plus par la méthode préconfigurée.
{% endhint %}

## Informations supplémentaires sur l'intégration Auth0 <a href="#informations-supplementaires" id="informations-supplementaires"></a>

### Support des services SOAP

WorkflowGen supporte seulement les requêtes à l'API SOAP en utilisant les méthodes d'authentification classiques. Si vous devez toujours utiliser cette API, vous devez effectuer quelques étapes additionnelles pour la configurer correctement. Pour ce faire :

1. Créez un nouvel annuaire WorkflowGen séparé pour les utilisateurs de l'API SOAP.<br>
2. Approvisionnez-le avec des utilisateurs et des groupes au besoin.<br>
3. Dans **Gestionnaire IIS**, cochez la méthode d'authentification **De base** pour l'application `\ws\wfgen`.<br>
4. Dans le fichier `web.config` (situé dans  `\Inetpub\wwwroot\wfgen`), ajoutez le suivant sous  `<location path="ws" inheritInChildApplications="false">`  : <br>

   ```markup
   <system.webServer>
       <modules>
           <remove name="ApplicationSecurityAuthenticationModule" />
       </modules>
   </system.webServer>
   ```

### Approvisionnement des utilisateurs et des groupes

Il n'y a aucun moyen d'approvisionner vos utilisateurs et vos groupes depuis les fournisseurs d'identité que vous utilisez derrière Auth0 avec WorkflowGen. Vous devez plutôt les synchroniser avec une des [méthodes de synchronisation des annuaires supportées](https://docs.advantys.com/workflowgen-guide-administration/synchronisation-des-annuaires).