Por que AuthorizeAttribute redireciona para a página de logon para falhas de autenticação e autorização?

No ASP.NET MVC, você pode marcar um método de controlador com AuthorizeAttribute, assim:

[Authorize(Roles = "CanDeleteTags")]
public void Delete(string tagName)
{
    // ...
}

Isso significa que, se o usuário conectado no momento não estiver na função "CanDeleteTags", o método do controlador nunca será chamado.

Infelizmente, para falhas, AuthorizeAttributeretorna HttpUnauthorizedResult, que sempre retorna o código de status HTTP 401. Isso causa um redirecionamento para a página de login.

Se o usuário não estiver logado, isso faz todo o sentido. No entanto, se o usuário já estiver conectado, mas não estiver na função necessária, é confuso enviá-lo de volta à página de login.

Parece que AuthorizeAttributeconfunde autenticação e autorização.

Isso parece um pouco de supervisão no ASP.NET MVC, ou estou faltando alguma coisa?

Eu tive que preparar um DemandRoleAttributeque separa os dois. Quando o usuário não é autenticado, ele retorna HTTP 401, enviando-o para a página de login. Quando o usuário está conectado, mas não está na função necessária, ele cria um NotAuthorizedResult. Atualmente, isso é redirecionado para uma página de erro.

Certamente eu não precisava fazer isso?

Quando foi desenvolvido, o System.Web.Mvc.AuthorizeAttribute estava fazendo a coisa certa - as revisões mais antigas da especificação HTTP usavam o código de status 401 para "não autorizado" e "não autenticado".

A partir da especificação original:

Se a solicitação já incluía credenciais de autorização, a resposta 401 indica que a autorização foi recusada para essas credenciais.

De fato, você pode ver a confusão ali - ele usa a palavra "autorização" quando significa "autenticação". Na prática cotidiana, no entanto, faz mais sentido retornar um 403 Proibido quando o usuário é autenticado, mas não autorizado. É improvável que o usuário tenha um segundo conjunto de credenciais que lhes dê acesso - má experiência do usuário.

Considere a maioria dos sistemas operacionais - quando você tenta ler um arquivo que não tem permissão para acessar, não é exibida uma tela de login!

Felizmente, as especificações HTTP foram atualizadas (junho de 2014) para remover a ambiguidade.

Em "Protocolo de transporte de hipertexto (HTTP / 1.1): Autenticação" (RFC 7235):

O código de status 401 (não autorizado) indica que a solicitação não foi aplicada porque não possui credenciais de autenticação válidas para o recurso de destino.

Em "Protocolo de transferência de hipertexto (HTTP / 1.1): Semântica e conteúdo" (RFC 7231):

O código de status 403 (Proibido) indica que o servidor entendeu a solicitação, mas se recusa a autorizá-la.

Curiosamente, no momento em que o ASP.NET MVC 1 foi lançado, o comportamento do AuthorizeAttribute estava correto. Agora, o comportamento está incorreto - a especificação HTTP / 1.1 foi corrigida.

Em vez de tentar alterar os redirecionamentos da página de login do ASP.NET, é mais fácil corrigir o problema na fonte. Você pode criar um novo atributo com o mesmo nome ( AuthorizeAttribute) no espaço de nome padrão do seu site (isso é muito importante) e o compilador o buscará automaticamente em vez do padrão do MVC. Obviamente, você sempre pode atribuir um novo nome ao atributo se preferir usar essa abordagem.

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
public class AuthorizeAttribute : System.Web.Mvc.AuthorizeAttribute
{
    protected override void HandleUnauthorizedRequest(System.Web.Mvc.AuthorizationContext filterContext)
    {
        if (filterContext.HttpContext.Request.IsAuthenticated)
        {
            filterContext.Result = new System.Web.Mvc.HttpStatusCodeResult((int)System.Net.HttpStatusCode.Forbidden);
        }
        else
        {
            base.HandleUnauthorizedRequest(filterContext);
        }
    }
}

Adicione isso à sua função Page_Load de login:

// User was redirected here because of authorization section
if (User.Identity != null && User.Identity.IsAuthenticated)
    Response.Redirect("Unauthorized.aspx");

Quando o usuário é redirecionado para lá, mas já está logado, ele mostra a página não autorizada. Se eles não estiverem conectados, ele será exibido e exibirá a página de login.

Eu sempre pensei que isso fazia sentido. Se você estiver conectado e tentar acessar uma página que exija uma função que não possui, você será encaminhado para a tela de login solicitando que efetue login com um usuário que possui essa função.

Você pode adicionar lógica à página de login que verifica se o usuário já está autenticado. Você pode adicionar uma mensagem amigável que explica por que eles foram levados de volta para lá novamente.

Infelizmente, você está lidando com o comportamento padrão da autenticação de formulários do ASP.NET. Há uma solução alternativa (ainda não tentei) discutida aqui:

http://www.codeproject.com/KB/aspnet/Custon401Page.aspx

(Não é específico para o MVC)

Penso que, na maioria dos casos, a melhor solução é restringir o acesso a recursos não autorizados antes que o usuário tente chegar lá. Removendo / esmaecendo o link ou botão que pode levá-los a esta página não autorizada.

Provavelmente seria bom ter um parâmetro adicional no atributo para especificar para onde redirecionar um usuário não autorizado. Entretanto, olho para o AuthorizeAttribute como uma rede de segurança.

Tente isso no manipulador Application_EndRequest do seu arquivo Global.ascx

if (HttpContext.Current.Response.Status.StartsWith("302") && HttpContext.Current.Request.Url.ToString().Contains("/<restricted_path>/"))
{
    HttpContext.Current.Response.ClearContent();
    Response.Redirect("~/AccessDenied.aspx");
}

Se você estiver usando o aspnetcore 2.0, use o seguinte:

using System;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Core
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public class AuthorizeApiAttribute : Microsoft.AspNetCore.Authorization.AuthorizeAttribute, IAuthorizationFilter
    {
        public void OnAuthorization(AuthorizationFilterContext context)
        {
            var user = context.HttpContext.User;

            if (!user.Identity.IsAuthenticated)
            {
                context.Result = new UnauthorizedResult();
                return;
            }
        }
    }
}

No meu caso, o problema era "a especificação HTTP usava o código de status 401 para" não autorizado "e" não autenticado "". Como o ShadowChaser disse.

Esta solução funciona para mim:

if (User != null &&  User.Identity.IsAuthenticated && Response.StatusCode == 401)
{
    //Do whatever

    //In my case redirect to error page
    Response.RedirectToRoute("Default", new { controller = "Home", action = "ErrorUnauthorized" });
}