.net 6 Basic Authentication Handler

4 min read Jun 03, 2024

Gestionnaire d'authentification de base pour .NET 6

L'authentification de base est un mécanisme simple et largement utilisé pour sécuriser les API REST. Dans .NET 6, vous pouvez facilement implémenter un gestionnaire d'authentification de base personnalisé pour authentifier les utilisateurs.

Qu'est-ce que l'authentification de base ?

L'authentification de base utilise un schéma simple où les identifiants d'utilisateur (nom d'utilisateur et mot de passe) sont envoyés au serveur dans l'en-tête de la requête HTTP. Ces identifiants sont ensuite vérifiés par le serveur pour valider l'accès à la ressource demandée.

Créer un gestionnaire d'authentification de base personnalisé

Voici les étapes pour créer un gestionnaire d'authentification de base personnalisé pour votre API .NET 6 :

Créer un projet d'API Web .NET 6.

Créer un service pour gérer l'authentification.

public class AuthenticationService
{
    public bool Authenticate(string username, string password)
    {
        // Vérifier les identifiants contre une source de données (base de données, fichier, etc.).
        // Remplacez cet exemple par votre logique d'authentification.
        if (username == "admin" && password == "password")
        {
            return true;
        }
        return false;
    }
}

Créer un gestionnaire d'authentification personnalisé.

public class BasicAuthenticationHandler : AuthenticationHandler
{
    private readonly AuthenticationService _authenticationService;

    public BasicAuthenticationHandler(IOptionsMonitor options, ILoggerFactory logger, AuthenticationService authenticationService) 
        : base(options, logger)
    {
        _authenticationService = authenticationService;
    }

    protected override async Task HandleAuthenticateAsync()
    {
        if (!Request.Headers.ContainsKey("Authorization"))
        {
            return AuthenticateResult.Fail("Authorization header missing.");
        }

        var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
        if (authHeader.Scheme != "Basic")
        {
            return AuthenticateResult.Fail("Invalid authorization scheme.");
        }

        var credentialBytes = Convert.FromBase64String(authHeader.Parameter);
        var credentials = Encoding.UTF8.GetString(credentialBytes).Split(':');
        if (credentials.Length != 2)
        {
            return AuthenticateResult.Fail("Invalid credentials format.");
        }

        var username = credentials[0];
        var password = credentials[1];

        if (!_authenticationService.Authenticate(username, password))
        {
            return AuthenticateResult.Fail("Invalid username or password.");
        }

        var claims = new[] 
        {
            new Claim(ClaimTypes.Name, username),
        };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, Scheme.Name);

        return AuthenticateResult.Success(ticket);
    }
}

Configurer l'authentification de base dans votre API.

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication("BasicAuthentication")
        .AddScheme("BasicAuthentication", options => { });

    services.AddScoped();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ...
    app.UseAuthentication();
    app.UseAuthorization();
    // ...
}

Utiliser l'authentification de base

Maintenant, votre API est sécurisée avec l'authentification de base. Vous pouvez tester l'authentification en utilisant un client HTTP comme Postman ou curl. Ajoutez l'en-tête "Authorization" avec le schéma "Basic" et les identifiants d'utilisateur encodés en base64 dans la requête.

Conclusion

L'authentification de base est un moyen simple de sécuriser votre API .NET 6. Cependant, il est important de noter que l'authentification de base transmet les identifiants d'utilisateur en texte clair, ce qui n'est pas recommandé pour les environnements sensibles. Envisagez d'utiliser des mécanismes d'authentification plus sécurisés comme OAuth2 ou JWT pour une sécurité accrue.