Pourquoi onAuthorization s'exécute-t-il avant l'authentification?

Je suis en train de faire quelques personnalisé autorisation j'ai donc créé un contrôleur de substitution de la OnAuthorization méthode. J'ai aussi appliqué le Authorize attribut à ce contrôleur.
La question est de savoir pourquoi le OnAuthorization méthode appelée AVANT les formes de base du processus d'authentification?

Je voudrais autoriser l'utilisateur après qu'il est authentifié.
Ai-je raté quelque chose?

Voici le code:

[Authorize]
    public class AuthorizationController : Controller
    {
        protected override void OnAuthorization(AuthorizationContext filterContext)
        {
            base.OnAuthorization(filterContext);

            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            List<string> allowedControllers = new List<string>() { "SecurityController" };
            List<string> allowedActions = new List<string>() { "Index" };

            string controllerName = filterContext.Controller.GetType().Name;
            string actionName = filterContext.ActionDescriptor.ActionName;

            if (!allowedControllers.Contains(controllerName)
            || !allowedActions.Contains(actionName))
            {
                filterContext.Result = View("UnauthorizedAccess");
            }
        }
    }

Le contrôleur que j'ai testé avec quelque chose comme:

public class SecurityController : AuthorizationController
{

    public ActionResult Index()
    {
        return View();
    }

    public ActionResult AnotherIndex()
    {
        return View();
    }
}

source d'informationauteur misha

  1. 16

    L'une des premières choses que les AuthorizeAttribute n'est de vérifier pour voir si l'utilisateur est authentifié. Si elles ne sont pas alors que c'est quand une redirection vers la page de connexion sera émis.

    La AuthorizeAttribute fondamentalement encapsule le contrôle d'authentification avec l'autorisation de la pièce:

    protected virtual bool AuthorizeCore(HttpContextBase httpContext) {
        if (httpContext == null) {
            throw new ArgumentNullException("httpContext");
        }

        IPrincipal user = httpContext.User;
        if (!user.Identity.IsAuthenticated) {
            return false;
        }

    Lorsque vous utilisez le AuthorizeAttribute sans rôles/utilisateurs, comme vous le faites dans votre exemple ([Autoriser]), il s'agit essentiellement de vérifier que l'utilisateur est authentifié dans ce cas.

    Je serais probablement changer votre code pour remplacer la AuthorizeAttribute au lieu de faire de ce code dans votre contrôleur. Vous pouvez effectuer les opérations suivantes:

    public class CustomAuthorizeAttribute : AuthorizeAttribute
{
    public override void OnAuthorization(AuthorizationContext filterContext)
    {
        filterContext.Result = CreateResult(filterContext);
    }

    protected ActionResult CreateResult(AuthorizationContext filterContext)
    {
        var controllerContext = new ControllerContext(filterContext.RequestContext, filterContext.Controller);
        var controller = (string)filterContext.RouteData.Values["controller"];
        var action = (string)filterContext.RouteData.Values["action"];
        //any custom model here
        var model = new UnauthorizedModel(); 

        //custom logic to determine proper view here - i'm just hardcoding it
        var viewName = "~/Views/Shared/Unauthorized.cshtml"; 

        return new ViewResult
        {
            ViewName = viewName,
            ViewData = new ViewDataDictionary<UnauthorizedModel>(model)
        };
    }
}
  2. 2

    Qui suit est un échantillon Personnalisé de l'Autorisation de l'Attribut.

     public class AuthLogAttribute:AuthorizeAttribute
    {

        public string View { get; set; }

        public AuthLogAttribute()
        {
            View = "AuthorizeFailed";
        }
        public override void OnAuthorization(AuthorizationContext filterContext)

        {
            base.OnAuthorization(filterContext);
            IsUserAuthorized(filterContext);
        }

        private void IsUserAuthorized(AuthorizationContext filterContext)
        {
            //If the Result returns null then the user is Authorized 
            if(filterContext.Result ==null)
                return;

            //If the user is Un-Authorized then Navigate to Auth Failed View 
            if(filterContext.HttpContext.User.Identity.IsAuthenticated)

            {
                var vr = new ViewResult();
                vr.ViewName = View;

                ViewDataDictionary dict = new ViewDataDictionary();
                dict.Add("Message", "Sorry you are not Authorized to Perform this Action");
                vr.ViewData = dict;

                var result = vr;
                filterContext.Result = vr;
            }

        }
    }

    Votre Contrôleur sera comme suit,

     [AuthLog(Roles ="Manager")]     
        public ActionResult Create()
        {
            var product = new Product();
            return View(product);
        }

    Enfin de créer de nouveaux avis Partagé Appel "AuthorizeFailed".

  3. -2
    public override void OnAuthorization(AuthorizationContext filterContext)
{
    base.OnAuthorization(filterContext);
    bool flag = false;
    string UserId;
    string[] AssignedRights = null;

    //Check if Http Context Contains User Name
    if (HttpContext.Current.User.Identity.Name != null && HttpContext.Current.User.Identity.Name != string.Empty)
    {
        //Get User Id from HttpContext
        UserId = HttpContext.Current.User.Identity.Name;
        RoleRepository roleRepository = new RoleRepository();
        AssignedRights = roleRepository.GetRolesByUser(Convert.ToInt32(UserId));
        flag = IsUserAuthorized(filterContext, flag, AssignedRights);

        if (flag == false)
       {

           filterContext.Result = new HttpUnauthorizedResult();
        }
    }

}