ASP.NET Core 2.0 Authentification LDAP Active Directory

Question

J'ai trouvé beaucoup d'informations du passé disant que L'authentification LDAP n'est pas encore activée mais vous pouvez contourner ce problème en utilisant des paquets tiers. Cependant, il semble que l'authentification LDAP WAS mis en place en janvier dernier . Je n'arrive pas à trouver d'informations sur la façon de le mettre en œuvre.

J'ai déjà authentification personnalisée dans mon projet, j'ai juste besoin de la logique pour remplir les HandleAuthenticateAsync méthode.

J'ai essayé d'utiliser autres exemples mais ils ne semblent pas fonctionner avec .NET Core 2.0.

Voici le seul code pertinent que j'ai et que je pense afficher

protected override Task<AuthenticateResult> HandleAuthenticateAsync()
{
    // Get Authorization header value
    if (!Request.Headers.TryGetValue(HeaderNames.Authorization, out var authorization)) {
        return Task.FromResult(AuthenticateResult.Fail("Cannot read authorization header."));
    }

    // TODO: Authenticate user

    // Create authenticated user ticket
    var identities = new List<ClaimsIdentity> { new ClaimsIdentity("custom auth type") };
    var ticket = new AuthenticationTicket(new ClaimsPrincipal(identities), Options.Scheme);

    return Task.FromResult(AuthenticateResult.Success(ticket));

    // else User not authenticated
    return Task.FromResult(AuthenticateResult.Fail("Invalid auth key."));
}

Ma question est donc la suivante : comment puis-je mettre en œuvre l'authentification LDAP dans .NET Core 2.0 ?

Answer 1

Grâce à Win's Réponse : pour m'avoir fait remarquer que je devais utiliser Pack de compatibilité Windows j'ai réussi à trouver une solution.

La première chose que j'ai eu à faire était d'installer les Paquet Nuget

Install-Package Microsoft.Windows.Compatibility 

À l'époque, j'avais besoin d'une version d'aperçu, alors j'ai ajouté -Version 2.0.0-preview1-26216-02 à la fin de cette commande

Ensuite, ajoutez des déclarations d'utilisation pour System.DirectoryServices y System.DirectoryServices.AccountManagement

Ensuite, il suffit de brancher cette logique dans mon HandleAuthenticateAsync méthode :

const string LDAP_PATH = "EX://exldap.example.com:5555";
const string LDAP_DOMAIN = "exldap.example.com:5555";

using (var context = new PrincipalContext(ContextType.Domain, LDAP_DOMAIN, "service_acct_user", "service_acct_pswd")) {
    if (context.ValidateCredentials(username, password)) {
        using (var de = new DirectoryEntry(LDAP_PATH))
        using (var ds = new DirectorySearcher(de)) {
            // other logic to verify user has correct permissions

            // User authenticated and authorized
            var identities = new List<ClaimsIdentity> { new ClaimsIdentity("custom auth type") };
            var ticket = new AuthenticationTicket(new ClaimsPrincipal(identities), Options.Scheme);
            return Task.FromResult(AuthenticateResult.Success(ticket));
        }
    }
}

// User not authenticated
return Task.FromResult(AuthenticateResult.Fail("Invalid auth key."));

Answer 2

Según #2089 Il n'est disponible que dans le pack de compatibilité Windows pour .NET Core. J'utilise actuellement Novell.Directory.Ldap.NETStandard.

public bool ValidateUser(string domainName, string username, string password)
{
   string userDn = $"{username}@{domainName}";
   try
   {
      using (var connection = new LdapConnection {SecureSocketLayer = false})
      {
         connection.Connect(domainName, LdapConnection.DEFAULT_PORT);
         connection.Bind(userDn, password);
         if (connection.Bound)
            return true;
      }
   }
   catch (LdapException ex)
   {
      // Log exception
   }
   return false;
}

Pour l'authentification et l'autorisation, nous pouvons utiliser Middleware d'authentification des cookies avec des revendications.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, 
   ILoggerFactory loggerFactory)
{
   app.UseCookieAuthentication(new CookieAuthenticationOptions
   {                
      AuthenticationScheme = "AuthenticationScheme",
      LoginPath = new PathString("/Account/Login"),
      AccessDeniedPath = new PathString("/Common/AccessDenied"),
      AutomaticAuthenticate = true,
      AutomaticChallenge = true
   });
}

Il a peu de pièces mobiles, donc j'ai créé un projet d'exemple fonctionnel sur GitHub. Il y a deux pièces principales - LdapAuthenticationService y SignInManager .

Answer 3

namespace: System.DirectoryServices.AccountManagement;

 public bool UserAuthentication(string username, string password)
 {
        PrincipalContext pc = new PrincipalContext(ContextType.Domain, "<DOMAIN NAME>");
        bool isValid = pc.ValidateCredentials(username, password);
        return isValid;
 }

Answer 4

L'authentification LDAP peut être réalisée en utilisant l'espace de nom System.DirectoryServices.Protocols.

public Boolean IsAuthenticated(string username, string password,string domain)
{
    Boolean authenticated = false;
    //pass the connectionString here
    using (LdapConnection connection = new LdapConnection(connectionString))
    {
       try
       {
           username = username + domain;
           connection.AuthType = AuthType.Basic;
           connection.SessionOptions.ProtocolVersion = 3;
           var credential = new NetworkCredential(username, password);
           connection.Bind(credential);
           authenticated = true;
           return authenticated;
       }
       catch (LdapException)
       {
           return authenticated;
       }
       finally
       {
           connection.Dispose();
       }
   }}