ASP.NET Web API (OWIN) : Autorisation

Ajoutez l’autorisation JWT d’Auth0 à une API ASP.NET OWIN à l’aide du middleware JWT standard et de points de terminaison protégés

Vous découvrez Auth0? Découvrez comment fonctionne Auth0 et renseignez-vous sur la mise en œuvre de l’authentification et de l’autorisation des API à l’aide du protocole OAuth 2.0.

​

Pour commencer

Auth0 vous permet d’ajouter l’autorisation à n’importe quel type d’application. Ce guide montre comment intégrer Auth0 à une application Web API ASP.NET OWIN, nouvelle ou existante, à l’aide du package Microsoft.Owin.Security.Jwt. Chaque API Auth0 utilise un identifiant d’API, dont votre application a besoin pour valider le jeton d’accès.

Cet exemple montre :

• Comment vérifier la présence d’un JSON Web Token (JWT) dans l’en-tête Authorization d’une requête HTTP entrante.
• Comment vérifier si le jeton est valide à l’aide du JSON Web Key Set (JWKS) de votre compte Auth0. Pour en savoir plus sur la validation des jetons d’accès, consultez Validate Access Tokens.

1. Créer une API

   Dans la section APIs du tableau de bord Auth0, cliquez sur Create API. Entrez un nom et un identifiant pour votre API, par exemple https://quickstarts/api. Vous utiliserez plus tard cet identifiant comme audience, au moment de configurer la vérification du jeton d’accès. Laissez Signing Algorithm à RS256.

   

   Par défaut, votre API utilise RS256 comme algorithme de signature des jetons. Comme RS256 utilise une paire de clés privée/publique, les jetons sont vérifiés à l’aide de la clé publique de votre compte Auth0. La clé publique est au format JSON Web Key Set (JWKS) et est accessible ici.

2. Définir les permissions

   Les permissions vous permettent de définir comment les ressources peuvent être accessibles au nom de l’utilisateur à l’aide d’un jeton d’accès donné. Par exemple, vous pouvez choisir d’accorder un accès en lecture à la ressource messages si les utilisateurs ont le niveau d’accès de gestionnaire, et un accès en écriture à cette ressource s’ils ont le niveau d’accès d’administrateur.

   Vous pouvez définir les permissions autorisées dans la vue Permissions de la section APIs du tableau de bord Auth0.

   

   Cet exemple utilise la portée read:messages.

3. Configurer le projet d’exemple

   Le code d’exemple comprend une section appsettings dans Web.config qui est configurée pour utiliser le bon domaine Auth0 et le bon identifiant d’API pour votre API. Si vous téléchargez le code à partir de cette page, ces valeurs seront automatiquement renseignées. Si vous utilisez l’exemple de GitHub, vous devrez les renseigner vous-même.

   web.config

   <appSettings>
     <add key="Auth0Domain" value="{yourDomain}" />
     <add key="Auth0ApiIdentifier" value="{yourApiIdentifier}" />
   </appSettings>
   
4. Installer les dépendances

   Pour utiliser les jetons d’accès Auth0 avec ASP.NET, vous utiliserez l’intergiciel JWT OWIN, offert dans le package NuGet Microsoft.Owin.Security.Jwt.

   Install-Package Microsoft.Owin.Security.Jwt
   
5. Vérifier la signature du jeton

   Comme le middleware OWIN JWT n’utilise pas OpenID Connect Discovery par défaut, vous devrez fournir un IssuerSigningKeyResolver personnalisé. Pour ce faire, ajoutez ce qui suit au fichier Support/OpenIdConnectSigningKeyResolver.cs :

   Un tel résolveur personnalisé a déjà été publié dans le package Auth0.OpenIdConnectSigningKeyResolver sur NuGet. Comme ce package n’est plus disponible, vous devrez le fournir vous-même.

   OpenIdConnectSigningKeyResolver.cs

   public class OpenIdConnectSigningKeyResolver
   {
       private readonly OpenIdConnectConfiguration openIdConfig;
   
       public OpenIdConnectSigningKeyResolver(string authority)
       {
           var cm = new ConfigurationManager<OpenIdConnectConfiguration>($"{authority.TrimEnd('/')}/.well-known/openid-configuration", new OpenIdConnectConfigurationRetriever());
           openIdConfig = AsyncHelper.RunSync(async () => await cm.GetConfigurationAsync());
       }
   
       public SecurityKey[] GetSigningKey(string kid)
       {
           return new[] { openIdConfig.JsonWebKeySet.GetSigningKeys().FirstOrDefault(t => t.KeyId == kid) };
       }
   }
   

   Le OpenIdConnectSigningKeyResolver téléchargera automatiquement le JSON Web Key Set utilisé pour signer les jetons RS256 à partir du point de terminaison de configuration OpenID Connect (à /.well-known/openid-configuration). Vous pourrez ensuite l’utiliser pour résoudre la clé de signature de l’émetteur, comme le montre le code d’enregistrement JWT ci-dessous.

6. Configurer l’authentification JWT

   Accédez à la méthode Configuration de votre classe Startup et ajoutez un appel à UseJwtBearerAuthentication en lui transmettant les JwtBearerAuthenticationOptions configurées.

   Les JwtBearerAuthenticationOptions doivent préciser l’identifiant de votre API Auth0 dans la propriété ValidAudience, ainsi que le chemin complet de votre domaine Auth0 dans ValidIssuer. Vous devrez configurer IssuerSigningKeyResolver pour utiliser l’instance de OpenIdConnectSigningKeyResolver afin de résoudre la clé de signature :

   Startup.cs

   public void Configuration(IAppBuilder app)
   {
       var domain = $"https://{ConfigurationManager.AppSettings["Auth0Domain"]}/";
       var apiIdentifier = ConfigurationManager.AppSettings["Auth0ApiIdentifier"];
       var keyResolver = new OpenIdConnectSigningKeyResolver(domain);
   
       app.UseJwtBearerAuthentication(
           new JwtBearerAuthenticationOptions
           {
               AuthenticationMode = AuthenticationMode.Active,
               TokenValidationParameters = new TokenValidationParameters()
               {
                   ValidAudience = apiIdentifier,
                   ValidIssuer = domain,
                   IssuerSigningKeyResolver = (token, securityToken, kid, parameters) => keyResolver.GetSigningKey(kid)
               }
           });
   
       // Configurer l'API Web
       WebApiConfig.Configure(app);
   }
   

   ​

   N’oubliez pas la barre oblique inverse à la fin

   Assurez-vous que l’URL indiquée pour ValidIssuer se termine par une barre oblique inverse, car elle doit correspondre exactement à la revendication d’émetteur du JWT. Il s’agit d’une erreur de configuration fréquente qui empêchera l’authentification correcte de vos appels à l’API.

7. Valider les portées

   L’intergiciel JWT ci-dessus vérifie que le jeton d’accès inclus dans la requête est valide; toutefois, il ne comprend pas encore de mécanisme permettant de vérifier que le jeton dispose du scope nécessaire pour accéder aux ressources demandées.

   Créez une classe nommée ScopeAuthorizeAttribute qui hérite de System.Web.Http.AuthorizeAttribute. Cet attribut d’autorisation vérifiera que la revendication scope émise par votre tenant Auth0 est présente et, le cas échéant, s’assurera qu’elle contient le scope demandé.

   ScopeAuthorizeAttribute.cs

   public class ScopeAuthorizeAttribute : AuthorizeAttribute
   {
       private readonly string scope;
   
       public ScopeAuthorizeAttribute(string scope)
       {
           this.scope = scope;
       }
   
       public override void OnAuthorization(HttpActionContext actionContext)
       {
           base.OnAuthorization(actionContext);
   
           // Récupérer le domaine Auth0 pour valider l'émetteur
           var domain = $"https://{ConfigurationManager.AppSettings["Auth0Domain"]}/";
   
           // Récupérer le principal de revendication
           ClaimsPrincipal principal = actionContext.ControllerContext.RequestContext.Principal as ClaimsPrincipal;
   
           // Récupérer la revendication de portée. S'assurer que l'émetteur correspond au bon domaine Auth0
           var scopeClaim = principal?.Claims.FirstOrDefault(c => c.Type == "scope" && c.Issuer == domain);
           if (scopeClaim != null)
           {
               // Séparer les portées
               var scopes = scopeClaim.Value.Split(' ');
   
               // Réussir si le tableau de portées contient la portée requise
               if (scopes.Any(s => s == scope))
                   return;
           }
   
           HandleUnauthorizedRequest(actionContext);
       }
   }
   
8. Sécuriser les points de terminaison de l’API

   Les routes ci-dessous sont accessibles pour les requêtes suivantes :

   • GET /api/public : accessible pour les requêtes non authentifiées
   • GET /api/private : accessible pour les requêtes authentifiées contenant un jeton d’accès sans portée supplémentaire
   • GET /api/private-scoped : accessible pour les requêtes authentifiées contenant un jeton d’accès auquel la portée read:messages a été accordée

   Le middleware JWT s’intègre aux mécanismes standard d’authentification et d’autorisation d’ASP.NET. Il vous suffit donc de décorer l’action de votre contrôleur avec l’attribut [Authorize] pour sécuriser un point de terminaison. Pour vous assurer qu’une portée est présente avant d’appeler un point de terminaison d’API particulier, décorez l’action avec l’attribut ScopeAuthorize et passez le nom de la portée requise dans le paramètre scope.

   ApiController.cs

   [RoutePrefix("api")]
   public class ApiController : ApiController
   {
       [HttpGet]
       [Route("public")]
       public IHttpActionResult Public()
       {
           return Json(new
           {
               Message = "Hello from a public endpoint!"
           });
       }
   
       [HttpGet]
       [Route("private")]
       [Authorize]
       public IHttpActionResult Private()
       {
           return Json(new
           {
               Message = "Hello from a private endpoint! You need to be authenticated to see this."
           });
       }
   
       [HttpGet]
       [Route("private-scoped")]
       [ScopeAuthorize("read:messages")]
       public IHttpActionResult Scoped()
       {
           return Json(new
           {
               Message = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
           });
       }
   }
   

Point de contrôle

Maintenant que vous avez configuré votre application, exécutez-la et vérifiez que :

• GET /api/public est accessible sans authentification.
• GET /api/private est accessible avec authentification.
• GET /api/private-scoped est accessible avec authentification lorsque le jeton d’accès inclut la portée read:messages.

​

Ressources supplémentaires

Exemple d’application

Exemple d’application complet pour ce guide de démarrage rapide

Fournisseurs d’identité

Configurer d’autres fournisseurs d’identité

Authentification multifacteur

Activer l’authentification multifacteur

Protection contre les attaques

En savoir plus sur la protection contre les attaques

Règles

Étendre Auth0 avec une logique personnalisée

Forum de la communauté

Obtenir de l’aide auprès de la communauté Auth0