Vue d'ensemble de l'authentification et de l'autorisation

Lagoon s'appuie sur ASP.NET Core Identity pour gérer les utilisateurs, les rôles, les mots de passe hachés, la récupération de compte, la confirmation de compte et les mécanismes associés. Une application ne doit donc pas définir ses propres tables utilisateurs/rôles : le framework ajoute les tables Identity préfixées par AspNet dans le modèle de données.

Table	Rôle
`AspNetUsers`	Utilisateurs de l'application.
`AspNetRoles`	Rôles déclarés pour l'application.
`AspNetUserRoles`	Association entre utilisateurs et rôles.

Les autres tables AspNet* servent aux mécanismes Identity comme les jetons de réinitialisation de mot de passe, la confirmation d'adresse email ou l'authentification à double facteur.

Une application connectée uniquement par SSO ou Windows peut aussi n'enregistrer aucun utilisateur dans ces tables : voir Utilisateurs sans stockage en base.

Modes d'authentification supportés

Les modes d'authentification documentés pour Lagoon sont :

mode anonyme, pour ouvrir tout ou partie de l'application sans identification ;
authentification Windows ;
authentification Forms, avec login et mot de passe ;
SAML2, voir section SAML2 ;
OpenID Connect / OAuth2, voir section OIDC ;
fournisseurs externes OAuth compatibles ASP.NET Core.

Le cumul de plusieurs méthodes est possible. Par exemple, une application peut activer Forms et Windows : la page de connexion affiche alors le formulaire et le bouton de connexion Windows.

Exemples de configuration des modes

Windows seul

Main.cs
protected override void OnConfigureAuthentification(AuthenticationOptions options)
{
    // Active l'authentification Windows.
    options.AllowWindowsAuthentication = true;
}

Forms seul

Main.cs
protected override void OnConfigureAuthentification(AuthenticationOptions options)
{
    // Active l'authentification par formulaire.
    options.AllowFormAuthentication = true;
}

Forms + Windows

Main.cs
protected override void OnConfigureAuthentification(AuthenticationOptions options)
{
    // Affiche le formulaire et le bouton de connexion Windows.
    options.AllowFormAuthentication = true;
    options.AllowWindowsAuthentication = true;
}

Fournisseurs externes

Pour utiliser un fournisseur externe, une application doit être créée auprès de ce fournisseur. Celui-ci doit être configuré pour rediriger l'utilisateur authentifié vers l'application. Après création, récupérez le ClientId et le ClientSecret et renseignez-les dans l'application.

Main.cs
protected override void OnConfigureServices(IServiceCollection services)
{
    services.AddAuthentication().AddGoogle("Google", "Explicit", options =>
    {
        // Renseigne les informations obtenues auprès du fournisseur externe.
        options.ClientId = "";
        options.ClientSecret = "";
    });
}

Le paramètre Explicit affiche un bouton libellé Google sur la page de connexion. Une configuration implicite est possible avec une expression régulière à la place de Explicit pour choisir le fournisseur selon l'identifiant saisi.

Main.cs
protected override void OnConfigureServices(IServiceCollection services)
{
    services.AddAuthentication().AddGoogle("Google", "^(.*)@(gmail.com)$", options =>
    {
        // Renseigne les informations obtenues auprès du fournisseur externe.
        options.ClientId = "";
        options.ClientSecret = "";
    });
}

Avec cette configuration, un.utilisateur@gmail.com est authentifié auprès de Google, tandis que admin continue vers la saisie du mot de passe Forms si Forms est activé.

Câblage serveur

Côté serveur, le point d'entrée appelle LagoonWebApplication.Run<Main>(args). La classe Main hérite de LgAuthApplication<TDbContext, TUser> et centralise la configuration de l'authentification, de l'autorisation, du pipeline HTTP, du DbContext et des services.

Program.cs
namespace Demo.Server;

/// <summary>
/// The entry point of the application.
/// </summary>
public class Program
{
    /// <summary>
    /// Application startup.
    /// </summary>
    /// <param name="args">The arguments.</param>
    public static void Main(string[] args)
    {
        // Délègue le démarrage du serveur ASP.NET Core à Lagoon.
        LagoonWebApplication.Run<Main>(args);
    }
}

Main.cs
public class Main : LgAuthApplication<ApplicationDbContext, ApplicationUser>
{
    protected override void OnConfigureAuthentification(AuthenticationOptions options)
    {
        // Autorise l'accès non authentifié au fichier index.html.
        options.AllowAnonymousIndex = true;

        // Active l'authentification par formulaire.
        options.AllowFormAuthentication = true;
    }

    protected override void OnConfigureAuthorization(AuthorizationOptions options)
    {
        // Enregistre les policies partagées par le serveur et le client.
        Policies.ConfigureAuthorization(options);
    }
}

Pipeline HTTP

Le pipeline serveur doit activer l'authentification avant l'autorisation et conserver le fallback Lagoon pour le routage Blazor WebAssembly.

Main.cs
protected override void OnConfigure(IApplicationBuilder app)
{
    if (ApplicationInformation.IsDevelopment)
    {
        app.UseWebAssemblyDebugging();
    }

    app.UseBlazorFrameworkFiles();
    app.UseStaticFiles();
    app.UseRouting();

    // Active les middlewares ASP.NET Core d'authentification et d'autorisation.
    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
        endpoints.MapControllers();
        endpoints.MapLagoonFallback();
    });
}

Point clé

MapLagoonFallback() est obligatoire : il gère le routage SPA Blazor, les endpoints Lagoon et le fallback vers index.html.

Câblage client

Côté client Blazor WebAssembly, le point d'entrée appelle LagoonWebAssemblyApplication.RunAsync<Main>(args). Les policies doivent être enregistrées côté client avec la même méthode que côté serveur.

Main.cs
public class Main : LgCustomApplication
{
    protected override void OnConfigureAuthorization(AuthorizationOptions options)
    {
        // Le client connaît les mêmes policies que le serveur.
        Policies.ConfigureAuthorization(options);
    }
}

Page de connexion automatique

La page de connexion s'adapte à la configuration :

Configuration	Comportement
Windows seul	Connexion automatique de l'utilisateur.
Un seul fournisseur externe	Connexion automatique si l'utilisateur est déjà authentifié auprès du fournisseur, sinon redirection vers ce fournisseur.
Forms seul	Saisie du login et du mot de passe.
Forms + fournisseur externe	Saisie du login, détection éventuelle d'un fournisseur associé au domaine, puis redirection SSO ou saisie du mot de passe.

Accès anonyme

Par défaut, Lagoon demande une authentification avant de laisser accéder à l'application. Pour ouvrir l'accueil, il faut autoriser index.html côté serveur et marquer la page comme anonyme.

Main.cs
protected override void OnConfigureAuthentification(AuthenticationOptions options)
{
    // Autorise l'accès à index.html sans utilisateur authentifié.
    options.AllowAnonymousIndex = true;
}

Index.razor.cs
[AllowAnonymous]
public partial class Index : LgPage
{
}

Options avancées d'authentification

Certaines options sont portées par AuthenticationOptions.

Option	Usage
`AllowFormAuthentication`	Active Forms.
`AllowWindowsAuthentication`	Active Windows.
`AllowAnonymousIndex`	Autorise `index.html` aux utilisateurs non authentifiés.
`FormAuthenticationCookieLifeTime`	Durée, en jours, du ticket Forms stocké dans le cookie.
`SsoAuthenticationCookieLifeTime`	Durée, en jours, du ticket Windows/SSO stocké dans le cookie.
`AccessTokenLifetime`	Durée de vie du jeton d'accès, en secondes. Valeur par défaut : 1800.
`PasswordOptions`	Règles de complexité du mot de passe Forms.
`AccessTokenClaims`	Claims émis dans le jeton d'accès : voir Policy fondée sur un claim personnalisé.
`PreserveStoredClaims`	Conserve à la connexion les claims stockés (`AspNetUserClaims`) dont le type n'est pas ajouté par la connexion. Valeur par défaut : `false`. Voir Claims stockés en base.

Main.cs
protected override void OnConfigureAuthentification(AuthenticationOptions options)
{
    options.AllowFormAuthentication = true;

    // Durée du ticket Forms lorsque l'utilisateur conserve sa session.
    options.FormAuthenticationCookieLifeTime = 365;

    // Durée du ticket Windows/SSO.
    options.SsoAuthenticationCookieLifeTime = 1;

    // Durée de vie du jeton d'accès en secondes.
    options.AccessTokenLifetime = 1800;

    // Règles de complexité du mot de passe Forms.
    options.PasswordOptions.RequiredLength = 6;
    options.PasswordOptions.RequiredUniqueChars = 1;
    options.PasswordOptions.RequireDigit = true;
    options.PasswordOptions.RequireNonAlphanumeric = true;
    options.PasswordOptions.RequireLowercase = true;
    options.PasswordOptions.RequireUppercase = true;
}

Déconnexion et jetons

Lagoon utilise des jetons d'accès JWT. Lors de la déconnexion, le jeton est supprimé du stockage navigateur client et ne peut plus être renouvelé à partir du jeton de rafraîchissement.

Remarque

Un jeton d'accès déjà copié ou stocké avant la déconnexion reste valide jusqu'à son expiration. Un JWT est sans état : il n'est pas possible de l'expirer manuellement côté serveur après sa création.

Voir aussi : logout.md.

Modes d'authentification supportés​

Exemples de configuration des modes​

Windows seul​

Forms seul​

Forms + Windows​

Fournisseurs externes​

Câblage serveur​

Pipeline HTTP​

Câblage client​

Page de connexion automatique​

Accès anonyme​

Options avancées d'authentification​

Déconnexion et jetons​