2016-03-18 16 views
12

Ich arbeite an einer Webanwendung, die in eine vorhandene Benutzerdatenbank integriert werden muss. Ich möchte immer noch die [Authorize] Attribute verwenden, aber ich möchte nicht das Identity-Framework verwenden. Wenn ich die Identität Framework verwenden wollte würde ich so etwas wie dies in der startup.cs Datei hinzufügen:Benutzerdefinierte Authentifizierung in ASP.Net-Core

services.AddIdentity<ApplicationUser, IdentityRole>(options => 
{ 
    options.Password.RequireNonLetterOrDigit = false; 
}).AddEntityFrameworkStores<ApplicationDbContext>() 
    .AddDefaultTokenProviders(); 

Ich gehe davon aus mir etwas anderes dort hinzuzufügen, und dann eine Art von Klasse, die Geräte erstellen eine spezifische Schnittstelle? Kann mir jemand in die richtige Richtung zeigen? Ich benutze jetzt RC1 von asp.net 5.

Antwort

20

Das Erstellen einer benutzerdefinierten Authentifizierung in ASP.NET Core kann auf verschiedene Arten erfolgen. Wenn Sie vorhandene Komponenten erstellen möchten (aber keine Identität verwenden möchten), überprüfen Sie die Kategorie "Sicherheit" der Dokumentation auf docs.asp.net. https://docs.asp.net/en/latest/security/index.html

Einige Artikel, die Sie vielleicht nützlich finden:

Using Cookie Middleware without ASP.NET Identity

Custom Policy-Based Authorization

Und natürlich, wenn das fehlschlägt oder Dokumente sind nicht klar genug, ist der Quellcode bei https://github.com/aspnet/Security welche umfasst einige Proben.

+6

Diese Antwort ist auch sehr gut http://stackoverflow.com/a/31688792/632495 – Jon49

0

Von dem, was habe ich gelernt, nach einigen Tagen der Forschung, Hier ist die Leitfaden für ASP .Net-Core MVC 2.x Angepasste Benutzerauthentifizierung

In Startup.cs:

unter lines In den ConfigureServices Verfahren :

public void ConfigureServices(IServiceCollection services) 
{ 

services.AddAuthentication(
    CookieAuthenticationDefaults.AuthenticationScheme 
).AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, 
    options => 
    { 
     options.LoginPath = "/Account/Login"; 
     options.LogoutPath = "/Account/Logout"; 
    }); 

    services.AddMvc(); 

    // authentication 
    services.AddAuthentication(options => 
    { 
     options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme; 
    }); 

    services.AddTransient(
     m => new UserManager(
      Configuration 
       .GetValue<string>(
        DEFAULT_CONNECTIONSTRING //this is a string constant 
       ) 
      ) 
     ); 
    services.AddDistributedMemoryCache(); 
} 

bedenken, dass wir in obigen Code sagte, wenn jede unauthenticated Benutzer fordert eine Aktion an, die mit [Authorize] annotiert ist, sie erzwingen die Weiterleitung an /Account/Login URL.

unten Linien Configure Methode hinzufügen:

public void Configure(IApplicationBuilder app, IHostingEnvironment env) 
{ 
    if (env.IsDevelopment()) 
    { 
     app.UseDeveloperExceptionPage(); 
     app.UseBrowserLink(); 
     app.UseDatabaseErrorPage(); 
    } 
    else 
    { 
     app.UseExceptionHandler(ERROR_URL); 
    } 
    app.UseStaticFiles(); 
    app.UseAuthentication(); 
    app.UseMvc(routes => 
    { 
     routes.MapRoute(
      name: "default", 
      template: DEFAULT_ROUTING); 
    }); 
} 

Erstellen Sie Ihre UserManager Klasse, die auch Anmelde- und Abmelde verwalten wird. es sollte wie unten Schnipsel aussehen (beachten Sie, dass ich adrett bin mit):

public class UserManager 
{ 
    string _connectionString; 

    public UserManager(string connectionString) 
    { 
     _connectionString = connectionString; 
    } 

    public async void SignIn(HttpContext httpContext, UserDbModel user, bool isPersistent = false) 
    { 
     using (var con = new SqlConnection(_connectionString)) 
     { 
      var queryString = "sp_user_login"; 
      var dbUserData = con.Query<UserDbModel>(
       queryString, 
       new 
       { 
        UserEmail = user.UserEmail, 
        UserPassword = user.UserPassword, 
        UserCellphone = user.UserCellphone 
       }, 
       commandType: CommandType.StoredProcedure 
      ).FirstOrDefault(); 

      ClaimsIdentity identity = new ClaimsIdentity(this.GetUserClaims(dbUserData), CookieAuthenticationDefaults.AuthenticationScheme); 
      ClaimsPrincipal principal = new ClaimsPrincipal(identity); 

      await httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal); 
     } 
    } 

    public async void SignOut(HttpContext httpContext) 
    { 
     await httpContext.SignOutAsync(); 
    } 

    private IEnumerable<Claim> GetUserClaims(UserDbModel user) 
    { 
     List<Claim> claims = new List<Claim>(); 

     claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id().ToString())); 
     claims.Add(new Claim(ClaimTypes.Name, user.UserFirstName)); 
     claims.Add(new Claim(ClaimTypes.Email, user.UserEmail)); 
     claims.AddRange(this.GetUserRoleClaims(user)); 
     return claims; 
    } 

    private IEnumerable<Claim> GetUserRoleClaims(UserDbModel user) 
    { 
     List<Claim> claims = new List<Claim>(); 

     claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id().ToString())); 
     claims.Add(new Claim(ClaimTypes.Role, user.UserPermissionType.ToString())); 
     return claims; 
    } 
} 

Dann vielleicht haben Sie eine AccountController haben, die eine Login Aktion hat, die wie folgt aussehen sollte: Jetzt

public class AccountController : Controller 
{ 
    UserManager _userManager; 

    public AccountController(UserManager userManager) 
    { 
     _userManager = userManager; 
    } 

    [HttpPost] 
    public IActionResult LogIn(LogInViewModel form) 
    { 
     if (!ModelState.IsValid) 
      return View(form); 
     try 
     { 
      //authenticate 
      var user = new UserDbModel() 
      { 
       UserEmail = form.Email, 
       UserCellphone = form.Cellphone, 
       UserPassword = form.Password 
      }; 
      _userManager.SignIn(this.HttpContext, user); 
      return RedirectToAction("Search", "Home", null); 
     } 
     catch (Exception ex) 
     { 
      ModelState.AddModelError("summary", ex.Message); 
      return View(form); 
     } 
    } 
} 

Sie sind Kann [Authorize] Annotation auf jedem Action oder Controller verwenden.

Fühlen Sie sich frei, irgendwelche Fragen oder Fehler zu kommentieren.

Verwandte Themen