Erlaube dem Benutzer, [Authorize] Seiten zu besuchen - MVC

Question

Mein Projekt hat Seiten mit [Authorize], wo Benutzer sich anmelden müssen, um diese Seiten zu besuchen.

Nach erfolgreicher Anmeldung mit derselben Benutzerkennung und demselben Kennwort wie in der Datenbank wird die aktuelle Benutzer-ID in der Sitzung gespeichert. Aber wie kann ich Benutzer authentifizieren/erlauben, Seiten mit [Autorisieren] zu besuchen?

[HttpPost] 
    [ValidateAntiForgeryToken] 
    public ActionResult Login(User u) 
    { 

     if (ModelState.IsValid) //this is check validity 
     { 

      using (UserEntities db = new UserEntities()) 
      { 

       var v = db.Users.Where(a=>a.UserName.Equals(u.UserName) && a.Password.Equals(u.Password)).FirstOrDefault(); 
       if (v != null) 
       { 
        Session["LoggedUserID"] = u.Id.ToString(); 
        Session["UserFullname"] = u.Name.ToString(); 

        return RedirectToAction("AfterLogin"); 

       } 

      } 
     } 
     return View(u); 
    } 

Jede Hilfe ist sehr zu schätzen. Vielen Dank.

Answer 1

Wenn Sie Login und Sicherheit unbedingt selbst mit Session verwalten möchten, können Sie einen eigenen Aktionsfilter erstellen, der überprüft, ob für die Sitzung eine Benutzer-ID festgelegt wurde.

So etwas wie dieses

public class AuthorizeWithSession : ActionFilterAttribute 
{  
    public override void OnActionExecuting(ActionExecutingContext context) 
    { 
     if (context.HttpContext.Session == null || 
             context.HttpContext.Session["LoggedUserID"]==null) 
     { 
      context.Result = 
       new RedirectToRouteResult(new RouteValueDictionary(
            new {controller = "Account", action = "Login"})); 
     } 
     base.OnActionExecuting(context); 
    } 
} 

dekorieren nun diese Aktion Filter auf dem sicheren Aktionen/Controller

[AuthorizeWithSession] 
public class TeamController : Controller 
{ 
} 

Answer 2

Sie sollten Ihre eigene Rollenverwaltung haben, wenn Sie steuern möchten, was die Benutzer tun können. Jeder Benutzer sollte eine oder mehrere Rollen haben, jede Rolle kann eine Reihe von Berechtigungen haben und Sie können einen Aktionsfilter erstellen, der von AuthorizeAttribute erbt, um sicherzustellen, dass er so früh wie möglich ausgeführt wird.

In der AuthorizeCore-Methode von AuthorizeAttribute sehen Sie, ob der Benutzer authentifiziert ist oder nicht, und wenn er authentifiziert ist, können Sie seine Identität lesen, seine Rollen und Berechtigungen aus der Datenbank lesen und mit einem übergebenen Wert vergleichen zur Rolle.

ex:

public class RequireRoleAttribute : AuthorizeAttribute 
    { 
     public RoleEnum[] RequiredRoles { get; set; } 


     public RequireRoleAttribute() 
     { 

     } 

     public RequireRoleAttribute(params RoleEnum[] roles) 
      : this() 
     { 
      RequiredRoles = roles; 
     } 

     protected override bool AuthorizeCore(HttpContextBase httpContext) 
     { 
      var principle = httpContext.User; 

      if (principle == null || principle.Identity == null || !principle.Identity.IsAuthenticated) 
      { 
       return false; 
      } 

      if (RequiredRoles != null) 
      { 
       if (!HasRole(RequiredRoles)) 
       { 
        httpContext.Response.Redirect("/AccessDenied"); 
       } 
      } 

      return base.AuthorizeCore(httpContext); 
     } 


     public bool HasRole(RoleEnum[] roles) 
     { 
      foreach (var role in roles) 
      { 
       if (HasRole(role)) 
        return true; 
      } 

      return false; 
     } 

     public bool HasRole(RoleEnum role) 
     { 
      return true if the user role has the role specified (read it from database for example) 
     } 
    } 

Dann in Ihrem Controller, mit Anmerkungen versehen nur den Controller oder der Aktion mit dem Attribute

[RequireRole(RoleEnum.Administator)] 
    public class MySecureController : Controller 
    { 
    }