Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "définir-les-autorisations",
title: "Définir les autorisations"
}, {
id: "installer-les-dépendances",
title: "Installer les dépendances"
}, {
id: "configurer-l-intergiciel",
title: "Configurer l’intergiciel"
}, {
id: "vérifier-la-signature-du-jeton",
title: "Vérifier la signature du jeton"
}, {
id: "valider-les-permissions",
title: "Valider les permissions"
}, {
id: "protéger-les-points-de-terminaison-des-api",
title: "Protéger les points de terminaison des API"
}];
Auth0 vous permet d’ajouter une autorisation à n’importe quel type d’application. Ce guide explique comment intégrer Auth0 à n’importe quelle application API ASP.NET Owin Web, nouvelle ou ancienne, à l’aide du package `Microsoft.Owin.Security.Jwt`.
Si vous n’avez pas encore créé d’API dans votre Auth0 Dashboard, vous pouvez utiliser le sélecteur interactif pour créer une nouvelle API Auth0 ou sélectionner une API existante pour votre projet.
Pour configurer votre première API via Auth0 Dashboard, consultez notre guide de démarrage.
Chaque API Auth0 utilise l’identificateur API, dont votre application a besoin pour valider le jeton d’accès.
**Vous ne connaissez pas Auth0 ?** Découvrez Auth0 et l’implémentation de l’authentification et de l’autorisation d’API en utilisant le cadre d’applications OAuth 2.0.
Les autorisations vous permettent de définir comment les ressources peuvent être accessibles au nom de l’utilisateur avec 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 gestionnaire et un accès en écriture à cette ressource s’ils ont le niveau d’accès administrateur.
Vous pouvez définir les autorisations autorisées dans la vue **Permissions (Autorisations)** de la section [API](https://manage.auth0.com/#/apis) d’Auth0 Dashboard. L’exemple suivant utilise la permission `read:messages`.
Installez le NuGetPackage `Microsoft.Owin.Security.Jwt`. Ce package contient l’intergiciel OWIN JWT nécessaire pour utiliser les jetons d’accès Auth0 dans l’API Web ASP.NET Owin.
```
Install-Package Microsoft.Owin.Security.Jwt
```
Allez dans la méthode de `Configuration` de votre classe `Startup` et ajoutez un appel à `UseJwtBearerAuthentication` passant dans les `JwtBearerAuthenticationOptions` configurées.
`JwtBearerAuthenticationOptions` doit indiquer votre identificateur API Auth0 dans la propriété `ValidAudience` et le chemin complet vers votre domaine Auth0 en tant que `ValidIssuer`. Vous devrez configurer l’instance `IssuerSigningKeyResolver` pour utiliser l’instance `OpenIdConnectSigningKeyResolver` afin de résoudre la clé de connexion.
**N’oubliez pas la barre oblique finale**.
Assurez-vous que l’URL précisée pour `ValidIssuer` contient une barre oblique (`/`) finale. Cela doit correspondre exactement à la demande de l’émetteur JWT. Les appels d’API ne s’authentifieront pas correctement si vous avez mal configuré cette valeur.
Le logiciel médiateur OWIN JWT n’utilise pas Open ID Connect Discovery par défaut, vous devez donc fournir un `IssuerSigningKeyResolver` personnalisé.
Créez la classe `OpenIdConnectSigningKeyResolver` et assurez-vous de retourner la bonne `SecurityKey` en implémentant `GetSigningKey`. Cette classe est ensuite utilisée comme `TokenValidationParameters.IssuerSigningKeyResolver` lors de la configuration du logiciel médiateur dans `Startup.cs`.
Le logiciel médiateur JWT vérifie que le jeton d’accès inclus dans la requête est valide; cependant, il n’inclut pas encore de mécanisme pour vérifier que le jeton a une **scope (permission)** suffisante pour accéder aux ressources demandées.
Créez une classe appelée `ScopeAuthorizeAttribute` qui hérite de `System.Web.Http.AuthorizeAttribute`. Cet attribut vérifiera que la demande de `scope` émise par votre locataire Auth0 est présente, et si oui, il assurera que la demande de `scope` contient la permission demandée.
Les routes ci-dessous sont disponibles pour les demandes suivantes :
* `GET /api/public` : Disponible pour les demandes non authentifiées.
* `GET /api/private` : Disponible pour les demandes authentifiées contenant un jeton d’accès sans permission supplémentaire.
* `GET /api/private-scoped` : Disponible pour les demandes authentifiées contenant un jeton d’accès dont la permission `read:messages` est accordée.
L’intergiciel JWT s’intègre aux mécanismes d’authentification et d’autorisation standard d’ASP.NET, vous n’avez donc qu’à décorer votre action de contrôleur avec l’attribut `[Authorize]` pour obtenir un point de terminaison.
Mettez à jour l’action avec l’attribut `ScopeAuthorize` et passez le nom de la `scope` requise dans le paramètre `scope`. Cela garantit que la permission adéquate est disponible pour appeler un point de terminaison d’API donné.
##### Point de contrôle
Maintenant que vous avez configuré votre application, lancez votre application et vérifiez que :
`GET /api/public` est disponible pour les demandes non authentifiées.
`GET /api/private` est disponible pour les demandes authentifiées.
`GET /api/private-scoped` est disponible pour les demandes authentifiées contenant un jeton d’accès avec la permission `read:messages`.
## Étapes suivantes
Beau travail! Si vous en êtes arrivé là, vous devriez avoir la connexion, la déconnexion et les informations de profil utilisateur actives dans votre application.
Cela conclut notre tutoriel de démarrage rapide, mais il y a tellement plus à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/#) : apprenez à configurer et gérer votre locataire et vos applications Auth0
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
```cs OpenIdConnectSigningKeyResolver.cs lines highlight={} theme={null}
public class OpenIdConnectSigningKeyResolver
{
private readonly OpenIdConnectConfiguration openIdConfig;
public OpenIdConnectSigningKeyResolver(string authority)
{
var cm = new ConfigurationManager($"{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) };
}
}
```
```cs ScopeAuthorizeAttribute.cs lines highlight={} theme={null}
public class ScopeAuthorizeAttribute : AuthorizeAttribute
{
private readonly string scope;
public ScopeAuthorizeAttribute(string scope)
{
this.scope = scope;
}
public override void OnAuthorization(HttpActionContext actionContext)
{
base.OnAuthorization(actionContext);
// Get the Auth0 domain, in order to validate the issuer
var domain = $"https://{ConfigurationManager.AppSettings["Auth0Domain"]}/";
// Get the claim principal
ClaimsPrincipal principal = actionContext.ControllerContext.RequestContext.Principal as ClaimsPrincipal;
// Get the scope clain. Ensure that the issuer is for the correcr Auth0 domain
var scopeClaim = principal?.Claims.FirstOrDefault(c => c.Type == "scope" && c.Issuer == domain);
if (scopeClaim != null)
{
// Split scopes
var scopes = scopeClaim.Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == scope))
return;
}
HandleUnauthorizedRequest(actionContext);
}
}
```
```cs ApiController.cs lines highlight={} theme={null}
[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."
});
}
}
```
```cs OpenIdConnectSigningKeyResolver.cs lines highlight={} theme={null}
public class OpenIdConnectSigningKeyResolver
{
private readonly OpenIdConnectConfiguration openIdConfig;
public OpenIdConnectSigningKeyResolver(string authority)
{
var cm = new ConfigurationManager($"{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) };
}
}
```
```cs ScopeAuthorizeAttribute.cs lines highlight={} theme={null}
public class ScopeAuthorizeAttribute : AuthorizeAttribute
{
private readonly string scope;
public ScopeAuthorizeAttribute(string scope)
{
this.scope = scope;
}
public override void OnAuthorization(HttpActionContext actionContext)
{
base.OnAuthorization(actionContext);
// Get the Auth0 domain, in order to validate the issuer
var domain = $"https://{ConfigurationManager.AppSettings["Auth0Domain"]}/";
// Get the claim principal
ClaimsPrincipal principal = actionContext.ControllerContext.RequestContext.Principal as ClaimsPrincipal;
// Get the scope clain. Ensure that the issuer is for the correcr Auth0 domain
var scopeClaim = principal?.Claims.FirstOrDefault(c => c.Type == "scope" && c.Issuer == domain);
if (scopeClaim != null)
{
// Split scopes
var scopes = scopeClaim.Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == scope))
return;
}
HandleUnauthorizedRequest(actionContext);
}
}
```
```cs ApiController.cs lines highlight={} theme={null}
[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."
});
}
}
```
```cs ScopeAuthorizeAttribute.cs lines highlight={} theme={null}
public class ScopeAuthorizeAttribute : AuthorizeAttribute
{
private readonly string scope;
public ScopeAuthorizeAttribute(string scope)
{
this.scope = scope;
}
public override void OnAuthorization(HttpActionContext actionContext)
{
base.OnAuthorization(actionContext);
// Get the Auth0 domain, in order to validate the issuer
var domain = $"https://{ConfigurationManager.AppSettings["Auth0Domain"]}/";
// Get the claim principal
ClaimsPrincipal principal = actionContext.ControllerContext.RequestContext.Principal as ClaimsPrincipal;
// Get the scope clain. Ensure that the issuer is for the correcr Auth0 domain
var scopeClaim = principal?.Claims.FirstOrDefault(c => c.Type == "scope" && c.Issuer == domain);
if (scopeClaim != null)
{
// Split scopes
var scopes = scopeClaim.Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == scope))
return;
}
HandleUnauthorizedRequest(actionContext);
}
}
```
```cs OpenIdConnectSigningKeyResolver.cs lines highlight={} theme={null}
public class OpenIdConnectSigningKeyResolver
{
private readonly OpenIdConnectConfiguration openIdConfig;
public OpenIdConnectSigningKeyResolver(string authority)
{
var cm = new ConfigurationManager($"{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) };
}
}
```
```cs ApiController.cs lines highlight={} theme={null}
[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."
});
}
}
```
```cs ApiController.cs lines highlight={} theme={null}
[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."
});
}
}
```
```cs OpenIdConnectSigningKeyResolver.cs lines highlight={} theme={null}
public class OpenIdConnectSigningKeyResolver
{
private readonly OpenIdConnectConfiguration openIdConfig;
public OpenIdConnectSigningKeyResolver(string authority)
{
var cm = new ConfigurationManager($"{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) };
}
}
```
```cs ScopeAuthorizeAttribute.cs lines highlight={} theme={null}
public class ScopeAuthorizeAttribute : AuthorizeAttribute
{
private readonly string scope;
public ScopeAuthorizeAttribute(string scope)
{
this.scope = scope;
}
public override void OnAuthorization(HttpActionContext actionContext)
{
base.OnAuthorization(actionContext);
// Get the Auth0 domain, in order to validate the issuer
var domain = $"https://{ConfigurationManager.AppSettings["Auth0Domain"]}/";
// Get the claim principal
ClaimsPrincipal principal = actionContext.ControllerContext.RequestContext.Principal as ClaimsPrincipal;
// Get the scope clain. Ensure that the issuer is for the correcr Auth0 domain
var scopeClaim = principal?.Claims.FirstOrDefault(c => c.Type == "scope" && c.Issuer == domain);
if (scopeClaim != null)
{
// Split scopes
var scopes = scopeClaim.Value.Split(' ');
// Succeed if the scope array contains the required scope
if (scopes.Any(s => s == scope))
return;
}
HandleUnauthorizedRequest(actionContext);
}
}
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
![Auth0 Dashboard> Applications > APIs (API) > [Specific API (API précise)] > Onglet Permissions (Autorisations)](https://mintcdn.com/docs-dev-docs-event-stream-action-templates/i2ZmWeCuZRFq3k1v/docs/images/fr-ca/cdy7uua7fh8z/1s3Yp5zqJiKiSWqbPSezNO/677a3405b2853f5fdf9e42f6e83ceba7/Quickstarts_API_-_French.png?fit=max&auto=format&n=i2ZmWeCuZRFq3k1v&q=85&s=81fd9c131b7cfcfa0af80517dc295b7d)