L'authentification et l'autorisation sont des éléments essentiels de toutes les applications web. Se familiariser avec la terminologie et les méthodes de l'écosystème .NET peut être particulièrement difficile. Traditionnellement, ces domaines ont été parmi les plus gros points de douleur dans .NET, et de nombreux développeurs trouvent la mise en œuvre de mécanismes d'authentification appropriés inutilement difficile par rapport à d'autres technologies.
Cependant, comprendre quelques principes et méthodes de base peut grandement faciliter les choses. Dans cet article, nous allons examiner quatre des approches d'autorisation les plus courantes et vous guider dans la compréhension et le choix de la méthode la plus appropriée à vos besoins.
Différence entre l'autorisation et l'authentification
Avant d'explorer les différentes méthodes pour gérer l'authentification et l'autorisation, il est important de clarifier la distinction entre ces deux concepts. Bien qu'ils soient souvent utilisés de manière interchangeable, l'authentification et l'autorisation ont des objectifs distincts dans le domaine du contrôle d'accès.
L'authentification signifie identifier qui vous êtes. Lorsque nous nous authentifions ou nous connectons à un système, nous faisons essentiellement une revendication auprès de l'entité d'authentification pour prouver que nous sommes bien ceux que nous prétendons être. Cela se fait généralement en utilisant un nom d'utilisateur/email et un mot de passe. Une fois que le système a validé que cet individu ou cette entité est bien celui ou celle qu'elle prétend être, l'authentification est terminée et l'accès est accordé.
L'autorisation se réfère à ce que vous, en tant qu'entité authentifiée, êtes autorisé à faire. Après que le système a confirmé votre identité, il détermine ensuite si vous avez les permissions appropriées pour accéder à une ressource particulière.
Cet article se concentrera principalement sur l'autorisation et les mécanismes qui la facilitent. L'authentification implique généralement le stockage des données des utilisateurs et la validation des mots de passe avec des techniques telles que le hachage et le salage. C'est un sujet à part entière, mais dans cet article, nous nous concentrons principalement sur les aspects de l'autorisation.
1. Jetons Web Json (JWT)
Qu'est-ce qu'un Jeton Web Json (JWT) ?
Pour comprendre l'utilisation de JWT, nous devons couvrir quelques principes de base.
JWT, une norme ouverte (RFC 7519), est conçu pour transférer des données en toute sécurité sous forme d'objets JSON entre deux parties. Ces données sont signées numériquement avec une clé, ce qui permet qu'elles soient vérifiées et de confiance par d'autres parties qui ont la clé. Cela en fait une technologie idéale pour faciliter l'autorisation. Une fois que le client a été authentifié, il se verra délivrer un JWT. Chaque demande subséquente au serveur contiendra le jeton, que le serveur vérifiera. En fonction des informations contenues dans la charge utile, le serveur autorisera ensuite le client à accéder à certaines routes et ressources.
Les JWT sont une méthode extrêmement populaire pour gérer l'autorisation et constituent un excellent outil à avoir dans votre arsenal.
Un JWT se compose de trois parties, séparées par un point (.).
xxxxx.yyyyy.zzzzzCes parties sont appelées l'en-tête, la charge utile et la signature.
1. En-tête
L'en-tête contient des informations sur le type de jeton et l'algorithme de signature :
{
"alg": "HS256",
"typ": "JWT"
}
2. Charge utile
La charge utile contient les données réelles ou les revendications concernant une certaine entité que nous souhaitons échanger entre les deux parties communicantes. La charge utile contiendra généralement des données utilisateur :
{
"sub": "1234567890",
"name": "John Doe",
"admin": true,
"iat": 1516239022
}
3. Signature
Enfin, la signature est utilisée pour vérifier que le JWT n'a pas été altéré ou manipulé. Elle le fait en signant l'en-tête codé, la charge utile, et le secret en utilisant l'algorithme spécifié dans l'en-tête. Si les données contenues dans le JWT sont modifiées, elles seront détectées par la vérification de la signature du serveur et rejetées.
Flux d'autorisation
La nature inviolable des JWT en fait un outil idéal pour échanger des informations en toute sécurité entre deux parties. Parce que les jetons sont signés, nous pouvons vérifier l'identité de l'expéditeur et détecter si les données incluses dans le jeton ont été modifiées.
Un flux d'autorisation typique utilisant JWT ressemble à ceci :
- Connexion : Le client envoie une demande avec des informations d'identification telles qu'un nom d'utilisateur et un mot de passe au serveur.
- Génération de jeton : Le serveur vérifie les informations d'identification. Cela implique généralement de vérifier le mot de passe par rapport au hachage du mot de passe dans la base de données. Si valide, le serveur génère un JWT contenant les informations de l'utilisateur et le renvoie au client.
- Stockage du jeton : Le client stocke le JWT, généralement dans un cookie.
- Demandes ultérieures : Pour toute demande future, le client envoie le JWT dans l'en-tête HTTP Authorization.
- Vérification du jeton : Le serveur vérifie la signature du JWT et extrait les informations de l'utilisateur de la charge utile du jeton pour authentifier la demande.
Configurer l'autorisation JWT dans une API .NET
Configurer l'authentification Json Web Token peut se faire assez simplement. Voyons un exemple.
Installation des packages nécessaires.
bash
Copier le code
Install-Package Microsoft.AspNetCore.Authentication.JwtBearer
Install-Package Microsoft.IdentityModel.Tokens
Install-Package Microsoft.IdentityModel.JsonWebTokens
Configurer les services d'authentification Json Web Token dans Program.cs.
csharp
Copier le code
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;
var builder = WebApplication.CreateBuilder(args);
var key = "this is my custom Secret key for authentication"; // Cela devrait être stocké en toute sécurité, par exemple dans les variables d'environnement
builder.Services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = false,
ValidateAudience = false,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key))
};
});
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.Run();
D'abord, nous définissons une clé secrète qui sera utilisée pour la signature du jeton.
Note : Assurez-vous que la clé secrète est stockée en toute sécurité. À des fins de démonstration, elle est définie en texte clair ici, mais dans une application en production, elle doit être stockée et accessible en toute sécurité, comme via des variables d'environnement ou un service de gestion des secrets.
Nous configurons ensuite les services d'authentification et spécifions que nous souhaitons utiliser les jetons JSON Web. Nous définissons ValidateIssuerSigningKey à true pour vérifier que le jeton a été signé avec la clé correcte. Cela garantit que le jeton n'a pas été falsifié et provient d'une source de confiance. Enfin, nous spécifions la clé de signature en utilisant la clé secrète que nous avons définie plus tôt.
Créer un contrôleur pour le point de terminaison de connexion
csharp
Copier le code
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens;
namespace JsonWebTokens.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
private readonly string _key;
public AuthController(IConfiguration config)
{
_key = "this is my custom Secret key for authentication";
}
[HttpPost("login")]
public IActionResult Login([FromBody] UserLogin userLogin)
{
if (userLogin.Username == "test" && userLogin.Password == "password")
{
var token = GenerateJwtToken(userLogin.Username);
return Ok(new { token });
}
return Unauthorized();
}
private string GenerateJwtToken(string username)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, username),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_key));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: null,
audience: null,
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds);
return new JwtSecurityTokenHandler().WriteToken(token);
}
}
public class UserLogin
{
public string Username { get; set; }
public string Password { get; set; }
}
}
Nous avons défini un contrôleur avec un point de terminaison de connexion. Si les informations d'identification fournies sont valides, nous générons un JWT contenant le nom d'utilisateur. Le JWT est signé en utilisant une clé secrète et est renvoyé au client.
À ce stade, vous pouvez effectuer une demande POST au point de terminaison /login avec les informations d'identification appropriées (ici, un nom d'utilisateur 'test' et un mot de passe 'password'). Si les informations d'identification sont valides, un JWT sera généré et renvoyé au client.
Le client peut utiliser ce jeton pour authentifier les demandes ultérieures en l'incluant dans l'en-tête HTTP Authorization.
bash
Copier le code
curl -X POST https://localhost:5001/api/auth/login -d '{"username":"test","password":"password"}' -H "Content-Type: application/json"
Cette approche configure l'autorisation des jetons Web JSON dans une API .NET et fournit une structure sécurisée et moderne pour l'autorisation des utilisateurs.
Conclusion
L'autorisation à l'aide de jetons JSON Web (JWT) est un outil puissant pour sécuriser votre API. En appliquant une méthode simple et légère pour l'autorisation des utilisateurs, les JWT sont devenus une norme pour les applications web modernes.
