> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> La mise en œuvre en ASP.NET Core du scénario d’architecture SSO (authentification unique) pour les Regular Web Apps

# Mise en œuvre ASP.NET Core (Web Apps + SSO)

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Le code source complet de la mise en œuvre en ASP.NET Core se trouve dans [ce dépôt GitHub](https://github.com/auth0-samples/auth0-pnp-webapp-oidc).

<div id="configure-the-cookie-and-oidc-middleware">
  ## Configurer le cookie et le middleware OIDC
</div>

Dans ce guide, nous utiliserons un hosted login simple. Vous pouvez utiliser le cookie standard et le middleware OIDC fournis avec ASP.NET Core; assurez-vous donc d’installer les packages NuGet.

```bash lines theme={null}
Install-Package Microsoft.AspNetCore.Authentication.Cookies
Install-Package Microsoft.AspNetCore.Authentication.OpenIdConnect
```

Ensuite, configurez le middleware de cookie et le middleware OIDC dans le pipeline de middleware de votre application.

export const codeExample = `public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Ajouter les services d'authentification
        services.AddAuthentication(
            options => options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme);

        // Code omis par souci de concision...
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IOptions<Auth0Settings> auth0Settings)
    {
        // Code omis par souci de concision...

        // Ajouter le middleware de cookie
        app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AutomaticAuthenticate = true,
            AutomaticChallenge = true
        });

        // Ajouter le middleware OIDC
        app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
        {
            // Définir l'autorité sur votre domaine Auth0
            Authority = "https://{yourDomain}/",

            // Configurer l'ID client et le secret client d'Auth0
            ClientId = {yourClientId},
            ClientSecret = {yourClientSecret},

            // Ne pas authentifier automatiquement ni lancer de demande d'authentification
            AutomaticAuthenticate = false,
            AutomaticChallenge = false,

            // Définir le type de réponse à code
            ResponseType = "code",

            CallbackPath = new PathString("/signin-auth0"),

            // Configurer l'émetteur des claims pour qu'il soit Auth0
            ClaimsIssuer = "Auth0"
        });

        // Code omis par souci de concision...
    }
}`;

<AuthCodeBlock children={codeExample} language="csharp" />

Comme vous pouvez le voir dans le code ci-dessus, nous avons configuré deux types différents de middleware d’authentification.

Le premier est le middleware de cookie, qui a été enregistré par l’appel à `UseCookieAuthentication`. Le second est le middleware OIDC, configuré par l’appel à `UseOpenIdConnectAuthentication`.

Une fois que l’utilisateur s’est connecté à Auth0 à l’aide du middleware OIDC, ses informations seront automatiquement stockées dans un <Tooltip tip="Cookie de session : entité qui, lorsqu’elle est présente, permet à l’utilisateur d’être considéré comme authentifié." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=session+cookie">cookie de session</Tooltip>. Il vous suffit de configurer le middleware comme ci-dessus, et il se chargera de gérer la session de l’utilisateur.

Le middleware <Tooltip tip="OpenID : norme ouverte d’authentification qui permet aux applications de vérifier l’identité des utilisateurs sans recueillir ni stocker les renseignements de connexion." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OpenID">OpenID</Tooltip> Connect (OIDC) extraira également tous les claims du <Tooltip tip="OpenID : norme ouverte d’authentification qui permet aux applications de vérifier l’identité des utilisateurs sans recueillir ni stocker les renseignements de connexion." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+Token">ID Token</Tooltip>, envoyé par Auth0 une fois l’utilisateur authentifié, et les ajoutera à `ClaimsIdentity` sous forme de claims.

<div id="implement-the-logout">
  ## Implement le Logout
</div>

Vous pouvez contrôler à la fois la session de l’application et la session Auth0 à l’aide de la méthode `SignOutAsync` de la classe `AuthenticationManager`, en transmettant le schéma d’authentification duquel vous souhaitez vous déconnecter.

Par exemple, pour vous déconnecter du middleware de cookies et ainsi effacer le cookie d’authentification de votre application, vous pouvez effectuer la requête suivante :

```csharp wrap lines theme={null}
await HttpContext.Authentication.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
```

De la même façon, vous pouvez déconnecter l’utilisateur d’Auth0 en appelant la méthode `SignOutAsync` et en passant `Auth0` comme schéma d’authentification à déconnecter.

```csharp lines theme={null}
await HttpContext.Authentication.SignOutAsync("Auth0");
```

Pour que ce qui précède fonctionne, vous devrez toutefois également ajouter une configuration supplémentaire lors de l’enregistrement du middleware OIDC en gérant l’événement `OnRedirectToIdentityProviderForSignOut`. Dans cet événement, vous devrez rediriger vers le [endpoint de logout d’Auth0](https://auth0.com/docs/api/authentication/reference#logout), ce qui effacera le cookie Auth0.

```csharp lines theme={null}
app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Certaines parties du code ont été omises par souci de concision
    Events = new OpenIdConnectEvents
    {
        OnRedirectToIdentityProviderForSignOut = context =>
        {
            context.Response.Redirect($"https://{auth0Settings.Value.Domain}/v2/logout?client_id={auth0Settings.Value.ClientId}&returnTo={context.Request.Scheme}://{context.Request.Host}/");
            context.HandleResponse();

            return Task.FromResult(0);
        }
    }
});
```

Vous devrez également veiller à ajouter l’URL de votre application aux **Allowed Logout URLs** de votre application dans le <Tooltip tip="Le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+dashboard">Auth0 Dashboard</Tooltip>. Pour en savoir plus, consultez [Logout](/docs/fr-ca/authenticate/login/logout).

<div id="implement-admin-permissions">
  ## Autorisations Admin d’Implement
</div>

La manière la plus simple d’intégrer les groupes à une application ASP.NET Core consiste à utiliser l’[autorisation fondée sur les rôles](https://docs.asp.net/en/latest/security/authorization/roles.html) intégrée à ASP.NET Core. Pour ce faire, nous devrons ajouter un claim de type

```http lines theme={null}
http://schemas.microsoft.com/ws/2008/06/identity/claims/role
```

pour chacun des groupes qui sont attribués à un utilisateur.

Une fois les claims ajoutés, nous pouvons facilement nous assurer qu’une action donnée est accessible uniquement aux utilisateurs `Admin` en décorant le claim avec l’attribut `[Authorize(Roles = "Admin")]`. Vous pouvez aussi vérifier dans le code si un utilisateur appartient à un `role` précis en appelant `User.IsInRole("Admin")` dans votre contrôleur.

Le middleware OIDC ASP.NET ajoute automatiquement au `ClaimsIdentity` tous les claims renvoyés dans le <Tooltip tip="JSON Web Token (JWT) : format standard de ID Token (et souvent de Access Token) utilisé pour représenter des claims de façon sécurisée entre deux parties." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=JWT">JWT</Tooltip>. Nous devons donc extraire l’information du claim `authorization`, désérialiser le corps JSON du claim et, pour chacun des groupes, ajouter un claim `http://schemas.microsoft.com/ws/2008/06/identity/claims/role` au `ClaimsIdentity`.

```csharp lines expandable theme={null}
app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions("Auth0")
{
    // Certaines configurations omises par souci de concision

    Events = new OpenIdConnectEvents
    {
        OnTicketReceived = context =>
        {
            var options = context.Options as OpenIdConnectOptions;

            // Obtenir le ClaimsIdentity
            var identity = context.Principal.Identity as ClaimsIdentity;
            if (identity != null)
            {
                // Ajouter les groupes en tant que rôles
                var authzClaim = context.Principal.FindFirst(c => c.Type == "authorization");
                if (authzClaim != null)
                {
                    var authorization = JsonConvert.DeserializeObject<Auth0Authorization>(authzClaim.Value);
                    if (authorization != null)
                    {
                        foreach (var group in authorization.Groups)
                        {
                            identity.AddClaim(new Claim(ClaimTypes.Role, group, ClaimValueTypes.String, options.Authority));
                        }
                    }
                }
            }

            return Task.FromResult(0);
        }
    }
});
```

Par la suite, nous pouvons ajouter une action permettant aux administrateurs d’approuver les feuilles de temps :

```csharp lines theme={null}
[Authorize(Roles = "Admin")]
public IActionResult TimesheetApproval()
{          
    return View();
}
```