Wie Verwenden von Windows Active Directory-Authentifizierung und identitätsbasierten Ansprüchen?

Problem

Wollen wir die Verwendung von Windows Active Directory zu authentifizieren eines Benutzers in der Anwendung. Jedoch, wir wollen nicht für die Verwendung von Active Directory-Gruppen verwalten Genehmigung von Controllern/views.

Soweit ich weiß, gibt es nicht eine einfache Möglichkeit, zu heiraten, AD und identity based Ansprüche.

Ziele

Authentifizierung der Benutzer mit lokalen Active Directory -
Identity framework zum verwalten von Forderungen

Versuche (Fehl)

Windows.Owin.Sicherheit.ActiveDirectory - Doh. Dies ist für Azure AD. Keine LDAP-Unterstützung. Könnten Sie nannten es AzureActiveDirectory statt?
Windows-Authentifizierung - Das ist okay, mit der NTLM-oder Keberos-Authentifizierung. Die Probleme beginnen mit: i) Token und Forderungen sind alle geschafft, sich durch AD-und ich kann nicht herausfinden, wie zu bedienen Identität behauptet.
LDAP - diese Aber scheint zu sein, zwingt mich manuell zu tun forms-Authentifizierung um die Identität behauptet? Sicher muss es einen einfacheren Weg?

Jede Hilfe wäre mehr als willkommen. Habe ich fest auf dieses problem eine Recht lange Zeit und ich würde schätzen Beiträgen von außen auf die Materie.

InformationsquelleAutor der Frage hlyates | 2015-03-05

Schuh Ihre Lösung oben schob mich in eine Richtung, die für mich gearbeitet auf MVC6-Beta3 Identityframework7-Beta3 EntityFramework7-Beta3:

//POST: /Account/Login
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
    if (!ModelState.IsValid)
    {
        return View(model);
    }

    //
    //Check for user existance in Identity Framework
    //
    ApplicationUser applicationUser = await _userManager.FindByNameAsync(model.eID);
    if (applicationUser == null)
    {
        ModelState.AddModelError("", "Invalid username");
        return View(model);
    }

    //
    //Authenticate user credentials against Active Directory
    //
    bool isAuthenticated = await Authentication.ValidateCredentialsAsync(
        _applicationSettings.Options.DomainController, 
        _applicationSettings.Options.DomainControllerSslPort, 
        model.eID, model.Password);
    if (isAuthenticated == false)
    {
        ModelState.AddModelError("", "Invalid username or password.");
        return View(model);
    }

    //
    //Signing the user step 1.
    //
    IdentityResult identityResult 
        = await _userManager.CreateAsync(
            applicationUser, 
            cancellationToken: Context.RequestAborted);

    if(identityResult != IdentityResult.Success)
    {
        foreach (IdentityError error in identityResult.Errors)
        {
            ModelState.AddModelError("", error.Description);
        }
        return View(model);
    }

    //
    //Signing the user step 2.
    //
    await _signInManager.SignInAsync(applicationUser,
        isPersistent: false,
        authenticationMethod:null,
        cancellationToken: Context.RequestAborted);

    return RedirectToLocal(returnUrl);
}

InformationsquelleAutor der Antwort Will

Einfach auf AD mit Benutzername und Passwort, statt der Authentifizierung gegen Ihre DB

//POST: /Account/Login
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
    if (ModelState.IsValid)
    {
        var user = await UserManager.FindByNameAsync(model.UserName);
        if (user != null && AuthenticateAD(model.UserName, model.Password))
        {
            await SignInAsync(user, model.RememberMe);
            return RedirectToLocal(returnUrl);
        }
        else
        {
            ModelState.AddModelError("", "Invalid username or password.");
        }
    }
    return View(model);
}

public bool AuthenticateAD(string username, string password)
{
    using(var context = new PrincipalContext(ContextType.Domain, "MYDOMAIN"))
    {
        return context.ValidateCredentials(username, password);
    }
}

InformationsquelleAutor der Antwort Shoe

Auf ASPNET5 (beta6), die Idee ist CookieAuthentication und Identität : Sie müssen fügen Sie in Ihre Startup-Klasse :

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    services.AddAuthorization();
    services.AddIdentity<MyUser, MyRole>()
        .AddUserStore<MyUserStore<MyUser>>()
        .AddRoleStore<MyRoleStore<MyRole>>()
        .AddUserManager<MyUserManager>()
        .AddDefaultTokenProviders();
}

Im Abschnitt " konfigurieren, hinzufügen:

private void ConfigureAuth(IApplicationBuilder app)
{
    //Use Microsoft.AspNet.Identity & Cookie authentication
    app.UseIdentity();
    app.UseCookieAuthentication(options =>
    {
        options.AutomaticAuthentication = true;
        options.LoginPath = new PathString("/App/Login");
    });
}

Dann werden Sie brauchen, um zu implementieren:

Microsoft.AspNet.Identity.IUserStore
Microsoft.AspNet.Identity.IRoleStore
Microsoft.AspNet.Identity.IUserClaimsPrincipalFactory

und erweitern/überschreiben:

Microsoft.AspNet.Identity.UserManager
Microsoft.AspNet.Identity.SignInManager

Eigentlich habe ich setup ein Beispielprojekt um zu zeigen, wie dies getan werden kann.
GitHub-Link.

Getestet habe ich auf der beta8 und und mit einigen kleinen adaptatons (wie Context => HttpContext) es funktionierte auch.

InformationsquelleAutor der Antwort jesblit

Könnten Sie ClaimTransformation, ich habe es arbeiten an diesem Nachmittag mit dem Artikel und code. Ich bin den Zugriff auf eine Anwendung mit Fenster-Authentifizierung und hinzufügen von Forderungen auf der Grundlage von Berechtigungen in einer SQL Datenbank gespeichert. Dies ist eine gute Artikel, die Ihnen helfen sollten.

https://github.com/aspnet/Security/issues/863

Im überblick ...

services.AddScoped<IClaimsTransformer, ClaimsTransformer>();

app.UseClaimsTransformation(async (context) =>
{
IClaimsTransformer transformer = context.Context.RequestServices.GetRequiredService<IClaimsTransformer>();
return await transformer.TransformAsync(context);
});

public class ClaimsTransformer : IClaimsTransformer
    {
        private readonly DbContext _context;

        public ClaimsTransformer(DbContext dbContext)
        {
            _context = dbContext;
        }
        public async Task<ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
        {

            System.Security.Principal.WindowsIdentity windowsIdentity = null;

            foreach (var i in context.Principal.Identities)
            {
                //windows token
                if (i.GetType() == typeof(System.Security.Principal.WindowsIdentity))
                {
                    windowsIdentity = (System.Security.Principal.WindowsIdentity)i;
                }
            }

            if (windowsIdentity != null)
            {
                //find user in database by username
                var username = windowsIdentity.Name.Remove(0, 6);
                var appUser = _context.User.FirstOrDefault(m => m.Username == username);

                if (appUser != null)
                {

                    ((ClaimsIdentity)context.Principal.Identity).AddClaim(new Claim("Id", Convert.ToString(appUser.Id)));

                    /*//add all claims from security profile
                    foreach (var p in appUser.Id)
                    {
                        ((ClaimsIdentity)context.Principal.Identity).AddClaim(new Claim(p.Permission, "true"));
                    }*/

                }

            }
            return await System.Threading.Tasks.Task.FromResult(context.Principal);
        }
    }

InformationsquelleAutor der Antwort K7Buoy

1

Wissen Sie, wie Sie bei der Implementierung einer benutzerdefinierten System.Web.Security.MembershipProvider? Sie sollten in der Lage sein, diese zu verwenden, (überschreiben ValidateUser) in Verbindung mit System.DirectoryServices.AccountManagement.PrincipalContext.ValidateCredentials() zur Authentifizierung gegen active directory.

versuchen:
var pc = new PrincipalContext(ContextType.Domain, "example.com", "DC=example,DC=com"); pc.ValidateCredentials(username, password);

InformationsquelleAutor der Antwort rybl

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.