.Net core : comment implémenter l’authentification par clé API.

Vous pouvez trouver le code source complet sur github

Contexte

Alors, qu’est-ce que l’authentification par clé API dans ASP.NET Core ?

Prenons un exemple concret.

Imaginez que vous ayez développé un tableau de bord météo qui récupère les données de votre propre API météo.
Ce tableau de bord affiche des données météorologiques, des prévisions et d’autres informations en temps réel.

Cependant, vous souhaitez :

• Limiter l’accès : vous ne voulez pas que n’importe qui puisse accéder à votre API et commencer à en extraire des données.
• Suivre l’utilisation : vous souhaitez savoir quels clients utilisent votre API, à quelle fréquence et à quelles fins.
• Prévenir les abus : sans une certaine sorte d’authentification, quelqu’un pourrait spammer votre API avec des requêtes, consommant des ressources et potentiellement vous coûtant de l’argent.
• Commercialisation : Si votre API fournit des données précieuses, vous souhaiterez peut-être les monétiser. Avoir une clé API pour chaque client vous permet de mettre en œuvre facilement différents niveaux de tarification.

De cette façon, vous pouvez vous assurer que seuls les clients autorisés accèdent à vos données, savoir qui y accède et potentiellement même à quelle quantité ils y accèdent. Ainsi, en implémentant l’authentification par clé API comme dans l’exemple, vous pouvez sécuriser votre API pour vous assurer qu’elle est utilisée uniquement de la manière que vous avez explicitement autorisée.

Vraiment sympa, non ?

Voyons comment implémenter l’authentification par clé API dans ASP.NET Core à l’aide de C#.

Création de l’attribut de clé API

Pourquoi as-tu besoin de ça ?

La classe ApiKeyAttribute dérive de ServiceFilterAttribute et est utilisée pour décorer les contrôleurs ou les actions où vous souhaitez que cette autorisation spécifique ait lieu.

Par exemple, vous souhaitez décorer ce point de terminaison :

[ApiKey]
[HttpGet(Name = "GetAllUsers")]
public List<string> GetAll()
{
    return new List<string> { "Stefan" };
}

Pour y parvenir, vous devez procéder comme suit :

public class ApiKeyAttribute : ServiceFilterAttribute
{
    public ApiKeyAttribute() : base(typeof(ApiKeyAuthorizationFilter))
}

Le constructeur appelle le constructeur de base avec typeof( ApiKeyAuthorizationFilter ), ce qui signifie qu’il attache le ApiKeyAuthorizationFilter aux actions décorées avec cet attribut.

Dans la classe ApiKeyAttribute, la ligne : base(typeof(ApiKeyAuthorizationFilter)) signifie que cet attribut est essentiellement un wrapper autour de ApiKeyAuthorizationFilter.

Lorsque vous décorez un contrôleur ou une méthode d’action avec [ApiKey] , cela déclenchera la méthode OnAuthorization d’ApiKeyAuthorizationFilter pour ce contrôleur ou cette action spécifique.

Nous avons donc besoin d’ApiKeyAuthorizationFilter avec la méthode OnAuthorization – créons-le à l’étape suivante.

Implémenter du filtre d’autorisation ApiKey

La classe ApiKeyAuthorizationFilter implémente IAuthorizationFilter , ce qui signifie qu’elle contient une logique à exécuter lorsqu’une requête nécessite une autorisation. Ce filtre vérifie si une clé API est présente et si elle est valide.

public class ApiKeyAuthorizationFilter : IAuthorizationFilter
{
    private const string ApiKeyHeaderName = "x-api-key";
    private readonly IApiKeyValidator _apiKeyValidator;

    public ApiKeyAuthorizationFilter(IApiKeyValidatior apiKeyValidator)
    {
        _apiKeyValidator = apiKeyValidator;
    }

    public void OnAuthorization(AuthorizationFilterContext context)
    {
        string apiKey = context.HttpContext.Request.Headers[ApiKeyHeaderName];

        if(!_apiKeyValidator.IsValid(apiKey))
        {
            context.Result = new UnauthorizedResult();
        }
    }
}

Méthode OnAuthorization :

• Cette méthode est appelée lorsque la demande est autorisée. Il extrait la clé API de l’en-tête de la requête

var apiKey = context.HttpContext.Request.Headers[ApiKeyHeaderName];

Ensuite, il utilise la méthode _apiKeyValidator.IsValid(apiKey) pour vérifier si la clé API est valide.

Si la clé API n’est pas valide, context.Result = new UnauthorizedResult(); définit la réponse sur non autorisé, rejetant ainsi la demande.

Super. Mais vous n’avez pas _apiKeyValidator, n’est-ce pas ?

Aucun problème. Mettons-le en œuvre.

implémentation de l’ApiKeyValidator

Votre classe ApiKeyAuthorizationFilter s’appuie sur une instance d’une classe qui implémente IApiKeyValidator pour valider les clés API. La méthode IsValid de cette instance sera appelée pour vérifier si une clé API est valide ou non. Actuellement, puisque IsValid renvoie false, toutes les demandes seraient considérées comme non autorisées.

public class ApiKeyValidator : IApiKeyValidator
{
    public bool IsValid(string apiKey)
    {
        //Change logic for validation api key
        return false;
    }
}

public interface IApiKeyValidator
{
    bool IsValid(string apiKey);
}

Bien sûr, rien de tout cela ne fonctionnerait sans l’injection de dépendances, enregistrons donc les services nécessaires.

builder.Services.AddSingleton<ApiKeyAuthorizationFilter>();
builder.Services.AddSingleton<IApiKeyValidator, ApiKeyValidator>();

Tester l’API

Et c’est tout. Vous avez implémenté l’authentification par clé API.

Utilisez le middleware

Vous pouvez obtenir absolument le même effet en utilisant un middleware.

Voici comment procéder :

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private const string ApiKeyHeaderName = "x-api-key";

    public ApiKeyMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if(!context.Request.Headers.TryGetValue(ApiKeyHeaderName, out var extractedApiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("Api Key was not provided.");
            return;
        }

        if(extractedApiKey != "API_KEY")
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("Unauthorized.");
            return;
        }

        await _next(context);
    }
}

Et c’est tout.

Conclusion

Dans l’article d’aujourd’hui, je vous ai montré comment implémenter l’authentification par clé API dans ASP.NET Core en un petit nombre d’étapes et en peu de temps.

Il faut mettre en œuvre 3 choses :

1. ApiKeyAttribute – Vous permet de décorer les contrôleurs et les points de terminaison avec [ApiKey].
2. ApiKeyAuthoizationFilter – Exécute la méthode OnAuthorization à chaque requête. C’est là que vous mettez réellement la logique complète de votre authentification.
3. ApiKeyValidator – Uniquement la logique encapsulée de la façon dont vous validerez la clé API que vous recevez dans la demande.

Vous pouvez accéder au référentiel GitHub du projet et vous familiariser avec les détails.

C’est tout pour moi aujourd’hui.

Derniers Articles

• Hangfire avec ASP.NET Core
• Premiers pas avec AutoMapper dans ASP.NET Core
• Serilog dans ASP.NET Core 3.1-La journalisation structurée simplifiée