OAuth 2.0 et autorisation JWT en C# : Guide complet

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

```html

Introduction à OAuth 2.0 et JWT en C#

Les applications web et les API modernes nécessitent un système d'autorisation robuste. Les deux standards les plus populaires — OAuth 2.0 (protocole de délégation d'accès) et JWT (JSON Web Token, format de jeton) — sont devenus la base de la sécurité dans l'écosystème .NET. Dans cet article, nous allons voir comment implémenter l'autorisation OAuth 2.0 et JWT en C# dans ASP.NET Core, créer un exemple de serveur d'autorisation et sécuriser une API.

Que vous créiez une application monolithique ou une architecture de microservices, la compréhension de ces mécanismes est cruciale. OAuth 2.0 définit les rôles (client, serveur d'autorisation, serveur de ressources), tandis que JWT sert de moyen compact et autonome de transmettre les données de l'utilisateur.

Fondamentaux d'OAuth 2.0 : flux et rôles

Qu'est-ce qu'OAuth 2.0 ?

OAuth 2.0 est un protocole d'autorisation qui permet aux applications tierces d'obtenir un accès limité aux ressources d'un utilisateur sans transmettre ses identifiants. Au lieu d'un identifiant et d'un mot de passe, on utilise des jetons d'accès (access tokens).

Rôles principaux dans OAuth 2.0

Resource Owner — l'utilisateur propriétaire des données.
Client — l'application qui demande l'accès.
Authorization Server — le serveur qui délivre les jetons après authentification.
Resource Server — l'API qui protège les ressources et vérifie les jetons.

Flux populaires (grant types)

Authorization Code — pour les applications serveur (le plus sécurisé).
Client Credentials — pour les communications inter-serveurs (sans utilisateur).
Implicit — obsolète, déconseillé.
Refresh Token — pour obtenir un nouveau access token sans ressaisir le mot de passe.

JWT (JSON Web Token) : structure et principe de fonctionnement

De quoi est composé un JWT ?

Un JWT est une chaîne composée de trois parties séparées par des points :

header.payload.signature

Header — le type de jeton et l'algorithme de signature (par exemple, HS256 ou RS256).
Payload — les données (claims) : identifiant utilisateur, rôles, date d'expiration, etc.
Signature — la signature qui vérifie que le jeton n'a pas été modifié.

Avantages de JWT pour C#

Autonomie — toutes les données utilisateur sont à l'intérieur du jeton.
Vérification facile côté serveur de ressources sans accès à la base de données.
Prise en charge dans .NET via la bibliothèque Microsoft.AspNetCore.Authentication.JwtBearer.

Implémentation d'OAuth 2.0 + JWT en C# dans ASP.NET Core

1. Configuration du serveur d'autorisation (émission de JWT)

Créons un serveur minimal qui accepte un identifiant/mot de passe et retourne un JWT. Par simplicité, nous utilisons une clé symétrique (HS256).

// Program.cs — serveur d'autorisationusing Microsoft.AspNetCore.Authentication.JwtBearer;using Microsoft.IdentityModel.Tokens;using System.IdentityModel.Tokens.Jwt;using System.Security.Claims;using System.Text;

var builder = WebApplication.CreateBuilder(args);builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)    .AddJwtBearer(options =>    {        options.TokenValidationParameters = new TokenValidationParameters        {            ValidateIssuer = true,            ValidateAudience = true,            ValidateLifetime = true,            ValidateIssuerSigningKey = true,            ValidIssuer = "MyAuthServer",            ValidAudience = "MyApiClient",            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("SuperSecretKey123!@#$%"))        };    });

builder.Services.AddAuthorization();var app = builder.Build();

app.MapPost(

```