> ## 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.

> L’implémentation ASP.NET Core pour le scénario d’architecture d’authentification unique (SSO) des applications Web classiques

# Implémentation ASP.NET Core (applications Web classiques + 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) + "*****MASKED*****";
          }
          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 l’implémentation 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 middleware de cookie et OIDC
</div>

Dans ce guide, nous utiliserons une page de connexion hébergée simple. Vous pouvez utiliser le middleware de cookie et OIDC standard offert 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 cookie et le middleware OIDC dans la chaîne de middlewares 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 cookies
        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 Auth0
            ClientId = {yourClientId},
            ClientSecret = {yourClientSecret},

            // Ne pas authentifier ni demander une vérification automatiquement
            AutomaticAuthenticate = false,
            AutomaticChallenge = false,

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

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

            // Configurer l'émetteur des claims pour qu'il s'agisse d'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 distincts de middleware d’authentification.

Le premier est le middleware de cookie, enregistré au moyen de l’appel à `UseCookieAuthentication`. Le second est le middleware OIDC, configuré au moyen de l’appel à `UseOpenIdConnectAuthentication`.

Une fois que l’utilisateur s’est authentifié auprès d’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 de considérer l’utilisateur comme authentifié." cta="Voir le glossaire" href="/fr-CA/docs/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="/fr-CA/docs/glossary?term=OpenID">OpenID</Tooltip> Connect (OIDC) extraira également toutes 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="/fr-CA/docs/glossary?term=ID+Token">ID Token</Tooltip>, envoyé par Auth0 une fois l’utilisateur authentifié, et les ajoutera comme claims à `ClaimsIdentity`.

<div id="implement-the-logout">
  ## Implémenter la déconnexion
</div>

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

Par exemple, pour vous déconnecter du middleware de cookies et ainsi supprimer le cookie d’authentification de votre application, vous pouvez effectuer l’appel suivant :

```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 duquel se déconnecter.

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

Pour que ce qui précède fonctionne, vous devrez toutefois aussi 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 [point de terminaison de déconnexion 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 vous assurer d’ajouter l’URL de votre application à la liste des **Allowed Logout URLs** de votre application dans l’<Tooltip tip="Auth0 Dashboard : le produit principal d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Auth0+dashboard">Auth0 Dashboard</Tooltip>. Pour en savoir plus, consultez [Déconnexion](/fr-CA/docs/authenticate/login/logout).

<div id="implement-admin-permissions">
  ## Implémenter les autorisations d’administrateur
</div>

La façon la plus simple d’intégrer les groupes à une application ASP.NET Core consiste à utiliser la fonctionnalité intégrée d’[autorisation basée sur les rôles](https://docs.asp.net/en/latest/security/authorization/roles.html) d’ASP.NET Core. Pour ce faire, nous devrons ajouter une revendication de type

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

pour chacun des groupes auxquels un utilisateur est attribué.

Une fois les claims ajoutées, nous pouvons facilement faire en sorte qu’une action donnée soit accessible uniquement aux utilisateurs `Admin` en annotant la claim avec l’attribut `[Authorize(Roles = "Admin")]`. Vous pouvez également vérifier si un utilisateur appartient à un rôle précis dans le code en appelant `User.IsInRole("Admin")` depuis votre contrôleur.

Le middleware OIDC d’ASP.NET ajoutera automatiquement toutes les claims renvoyées dans le <Tooltip tip="JSON Web Token (JWT) : format standard d’ID Token (et souvent de Jeton d’accès) utilisé pour représenter des claims de façon sécurisée entre deux parties." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=JWT">JWT</Tooltip> en tant que claims au `ClaimsIdentity`. Nous devons donc extraire l’information de la claim `authorization`, désérialiser le corps JSON de la claim et, pour chacun des groupes, ajouter une 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;

            // Récupérer 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);
        }
    }
});
```

Nous pouvons ensuite ajouter une Action qui permet aux administrateurs d’approuver les feuilles de temps :

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