Gérer l’authentification JWT dans une API .NET – Tutoriel complet

"Et si tu pouvais protéger ton API comme les pros… sans être expert ?"

Tu viens de créer ton premier projet .NET, tu as ton API qui tourne, mais… comment empêcher n’importe qui d’y accéder ?

Et si je te disais que tu peux sécuriser ton application comme les grandes plateformes (comme Google ou Facebook), sans base de données de sessions ni complexité inutile ?

La réponse s’appelle JWT — ou JSON Web Token. Et aujourd’hui, je t’emmène pas à pas pour mettre en place une authentification robuste dans ton API .NET, même si tu débutes.

Pas de jargon inutile. Pas de magie noire. Juste toi, ton clavier, et une méthode utilisée par des milliers de développeurs chaque jour.

Imagine que tu vas à un festival. À l’entrée, on te donne un bracelet RFID. Ce bracelet contient :

• Ton nom
• La date d’expiration
• Une signature invisible (comme un hologramme)

Dès ce moment, tu n’as plus besoin de montrer ton billet à chaque stand. Le personnel scanne ton bracelet, vérifie qu’il est valide, et te laisse passer.

👉 C’est exactement ce que fait un JWT.

• Header : le type de bracelet et comment il a été signé.
• Payload : tes infos (ton nom, quand ça expire…).
• Signature : la preuve que ce n’est pas un faux bracelet.

Et le plus beau ? Le serveur n’a pas besoin de garder une trace de toi. Il lit le token, vérifie la signature, et décide : "Accès autorisé" ou non.

💬 "Mais… c’est sûr, ça ?"

Oui, à condition d’utiliser une clé secrète bien protégée. Comme un mot de passe ultra-complexe que seul le serveur connaît.

Ouvre ton terminal (ou PowerShell) et tape cette commande :

dotnet new webapi -n MonApiSecurisee
cd MonApiSecurisee

Et voilà ! Tu as une API .NET toute fraîche, prête à être sécurisée.

Pas besoin de Visual Studio : tu peux tout faire avec VS Code et le CLI .NET.

.NET ne gère pas JWT "de base". Il faut ajouter un petit outil :

dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer

C’est comme installer un détecteur de faux bracelets au portail du festival. Il saura reconnaître les vrais tokens.

Ouvre le fichier appsettings.json et ajoute cette section :

"JwtSettings": {
"SecretKey": "UneCleSuperSecreteEtLongueCommeUnRomanDeTolstoï!",
"Issuer": "MonApi",
"Audience": "MesUtilisateurs",
"ExpiryInMinutes": 60
}

⚠️ Astuce de pro :

Cette clé secrète, c’est la clé de ton coffre-fort.

En production, ne la laisse jamais en dur. Utilise un Secret Manager, des variables d’environnement, ou un service comme Azure Key Vault. 

Voici le cœur du système. Dans Program.cs, ajoute cette configuration :

var builder = WebApplication.CreateBuilder(args);

// Récupère les paramètres JWT
var jwtSettings = builder.Configuration.GetSection("JwtSettings");

// Ajoute l'authentification JWT
builder.Services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = jwtSettings["Issuer"],
ValidateAudience = true,
ValidAudience = jwtSettings["Audience"],
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(jwtSettings["SecretKey"])
),
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero // Pas de tolérance sur l'heure
};
});

builder.Services.AddAuthorization();
builder.Services.AddControllers();

var app = builder.Build();

// Active l'authentification et l'autorisation
app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

💬 "Ça fait beaucoup d’un coup…"

Oui, mais regarde bien :

• On dit à .NET : "Utilise JWT comme méthode d’authentification."
• On lui donne les règles : "Vérifie l’émetteur, l’audience, la clé, et l’expiration."
• Et on active le tout avec UseAuthentication().

Crée un fichier AuthController.cs. Dedans, on va simuler une connexion :

[ApiController]
[Route("api/[controller]")]
public class AuthController : ControllerBase
{
private readonly IConfiguration _configuration;

public AuthController(IConfiguration configuration)
{
_configuration = configuration;
}

[HttpPost("login")]
public IActionResult Login([FromBody] LoginRequest request)
{
// En vrai, tu vérifierais dans une base de données
if (request.Username == "admin" && request.Password == "password")
{
var token = GenerateJwtToken(request.Username);
return Ok(new { Token = token });
}

return Unauthorized(); // 401
}

private string GenerateJwtToken(string username)
{
var jwtSettings = _configuration.GetSection("JwtSettings");
var secretKey = new SymmetricSecurityKey(
Encoding.UTF8.GetBytes(jwtSettings["SecretKey"])
);
var signingCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);

var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, username),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) // ID unique
};

var token = new JwtSecurityToken(
issuer: jwtSettings["Issuer"],
audience: jwtSettings["Audience"],
claims: claims,
expires: DateTime.UtcNow.AddMinutes(
double.Parse(jwtSettings["ExpiryInMinutes"])
),
signingCredentials: signingCredentials
);

return new JwtSecurityTokenHandler().WriteToken(token);
}
}

public class LoginRequest
{
public string Username { get; set; }
public string Password { get; set; }
}

Maintenant, rends certaines routes réservées aux utilisateurs authentifiés.

Par exemple, dans WeatherForecastController.cs :

[Authorize] // 🔒 Uniquement pour les gens avec un token valide
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
[HttpGet]
public IActionResult Get()
{
return Ok(new[] { "Il va faire beau… si tu es authentifié !" });
}
}

Teste cette route sans token → tu auras un 401 Unauthorized.

Avec un token valide → ✅ Accès autorisé.

1. Ne jamais exposer ta clé secrète

Même dans un projet perso, habitue-toi à utiliser :

• dotnet user-secrets
• Variables d’environnement
• Un fichier .env (avec .gitignore)

2. Prévois un mécanisme de rafraîchissement (refresh token)

Un token qui expire en 60 minutes ? C’est bien.

Mais si l’utilisateur doit se reconnecter toutes les heures… c’est pénible.

→ En 2025, les apps sérieuses utilisent des refresh tokens pour renouveler le JWT sans demander le mot de passe.

3. Teste avec Swagger ou Postman

Utilise Swagger (intégré par défaut dans .NET) pour tester :

• /api/auth/login → récupère un token
• /weatherforecast → colle le token dans l’en-tête :
• Authorization: Bearer ton_token_ici

Félicitations ! 🎉

Tu viens de mettre en place une authentification moderne, sécurisée et scalable dans ton API .NET.

Tu n’as plus une API ouverte à tous, mais un système protégé comme dans les vraies applis.

Et le meilleur ?

Tu as tout fait en apprenant seul, avec des outils gratuits, sans payer un centime.

✨ Ce que tu peux faire maintenant :

• Ajoute une base de données (SQLite ou SQL Server)
• Implémente un système d’inscription
• Crée un mécanisme de refresh token
• Partage ton code sur GitHub pour montrer ton progrès