Configuration de l'authentification dans Program.cs

builder.Services.AddAuthentication(authOptions => { authOptions.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme; authOptions.DefaultChallengeScheme = CookieAuthenticationDefaults.AuthenticationScheme; authOptions.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme; authOptions.DefaultSignOutScheme = CookieAuthenticationDefaults.AuthenticationScheme; authOptions.DefaultForbidScheme = CookieAuthenticationDefaults.AuthenticationScheme; }).AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, cookieOptions => { cookieOptions.LoginPath = "/Utilisateur/Connexion"; // Redirection si non authentifié cookieOptions.AccessDeniedPath = "/Utilisateur/NonAutorise"; // Redirection si accès refusé });

</div><div>```

app.UseAuthentication(); // Middleware d'authentification
app.UseAuthorization();  // Middleware d'autorisation

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Security.Claims;

namespace ApplicationDemo.Controllers
{
    public class UtilisateurController : Controller
    {
        [Authorize]
        public IActionResult TableauDeBord()
        {
            return View();
        }

        [HttpGet]
        public IActionResult Connexion()
        {
            return View();
        }

        [HttpPost]
        public async Task<iactionresult> Connexion(string identifiant, string motDePasse)
        {
            if("admin".Equals(identifiant) && "secret".Equals(motDePasse))
            {
                var revendications = new List<Claim>()
                {
                    new Claim("IdUtilisateur","101"),
                    new Claim(ClaimTypes.Role,"Administrateur"),
                    new Claim(ClaimTypes.Name,identifiant),
                    new Claim(ClaimTypes.Email,"contact@exemple.com"),
                    new Claim("compte","Gestionnaire")
                };
                var identite = new ClaimsIdentity(revendications, "Personnalise");
                var principal = new ClaimsPrincipal(identite);
                await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal, new AuthenticationProperties()
                {
                    ExpiresUtc = DateTime.UtcNow.AddHours(1),
                });
                return RedirectToAction("TableauDeBord");
            }
            else
            {
                ViewBag.Message = "Identifiant ou mot de passe incorrect";
                return View();
            }
        }
    }
}
</iactionresult>

Modèle de données Utilisateur

namespace Modeles
{
    public class Utilisateur
    {
        public string Identifiant { get; set; }
        public string MotDePasse { get; set; }
    }
}

Vue pour la connexion (Connexion.cshtml)

@using Modeles
@model Utilisateur
<section>
    @using (Html.BeginForm("Connexion", "Utilisateur", FormMethod.Post, new { @class = "formulaire-connexion" }))
    {
        @Html.AntiForgeryToken()
        <div>
            <label>Identifiant</label>
            @Html.TextBoxFor(m => m.Identifiant)
        </div>
        <div>
            <label>Mot de passe</label>
            @Html.PasswordFor(m => m.MotDePasse)
        </div>
        <button type="submit">Se connecter</button>
        @ViewBag.Message
    }
</section>

Autorisation par rôle et par stratégie

Configuration des stratégies d'autorisation dans Program.cs :

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("StrategieAdmin", policyBuilder =>
    {
        policyBuilder.RequireRole("Administrateur");
    });
    options.AddPolicy("StrategieCompte", policyBuilder =>
    {
        policyBuilder.RequireClaim("compte", new[] { "Gestionnaire", "Testeur" });
    });
    options.AddPolicy("StrategiePersonnalisee", policyBuilder =>
    {
        policyBuilder.RequireAssertion(contexte =>
        {
            return contexte.User.HasClaim(c => c.Type == ClaimTypes.Role)
                   && contexte.User.Claims.First(c => c.Type == ClaimTypes.Role).Value == "Administrateur"
                   && contexte.User.Claims.Any(c => c.Type == ClaimTypes.Name);
        });
    });
});

Exemples d'utilisation dans le contrôleur :

[Authorize(Roles = "Administrateur")]
public IActionResult TableauDeBordAdmin() { ... }

[Authorize(Policy = "StrategieAdmin")]
public IActionResult SectionAdmin() { ... }

[Authorize(Roles = "Administrateur,Editeur")]
public IActionResult ZonePartagee() { ... }

Intégration de logique métier pour l'autorisation

Création d'un service pour la validation métier :

namespace Services
{
    public interface IValidationService
    {
        bool VerifierAcces(string idUtilisateur, string codeSecret);
    }

    public class ValidationService : IValidationService
    {
        public bool VerifierAcces(string idUtilisateur, string codeSecret)
        {
            return idUtilisateur == "101" && codeSecret == "ABCDE";
        }
    }
}

Définition d'une exigence d'autorisation et d'un gestionnarie :

using Microsoft.AspNetCore.Authorization;

namespace Utilitaires
{
    public class ExigenceCodeSecret : IAuthorizationRequirement { }

    public class GestionnaireCodeSecret : AuthorizationHandler<ExigenceCodeSecret>
    {
        private readonly IValidationService _validationService;

        public GestionnaireCodeSecret(IValidationService service)
        {
            _validationService = service;
        }

        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, ExigenceCodeSecret exigence)
        {
            string idUtilisateur = context.User.Claims.FirstOrDefault(c => c.Type == "IdUtilisateur")?.Value;
            string code = context.User.Claims.FirstOrDefault(c => c.Type == "code")?.Value;

            if (idUtilisateur != null && code != null && _validationService.VerifierAcces(idUtilisateur, code))
            {
                context.Succeed(exigence);
            }
            return Task.CompletedTask;
        }
    }
}

Enregistrement des services et configuraton de la stratégie :

builder.Services.AddScoped<IValidationService, ValidationService>();
builder.Services.AddScoped<IAuthorizationHandler, GestionnaireCodeSecret>();

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("StrategieCodeSecret", policyBuilder =>
    {
        policyBuilder.AddRequirements(new ExigenceCodeSecret());
    });
});

Application dans le contrôleur :

[Authorize(Policy = "StrategieCodeSecret")]
public IActionResult SectionSecrete()
{
    return View();
}