401 yerine yetkisiz webapi çağrısı dönen giriş sayfası

Mvc / webapi projemi, ustura görünümünden çağrılan bir webapi yönteminin yetkisiz olduğunda giriş sayfasını döndürmemesi için nasıl yapılandırabilirim?

Javascript üzerinden aramalar için WebApi denetleyicileri de olan bir MVC5 uygulaması.

Aşağıdaki iki yöntem

[Route("api/home/LatestProblems")]      
[HttpGet()]
public List<vmLatestProblems> LatestProblems()
{
    // Something here
}

[Route("api/home/myLatestProblems")]
[HttpGet()]
[Authorize(Roles = "Member")]
public List<vmLatestProblems> mylatestproblems()
{
   // Something there
}

aşağıdaki açısal kod ile çağrılır:

angular.module('appWorship').controller('latest', 
    ['$scope', '$http', function ($scope,$http) {         
        var urlBase = baseurl + '/api/home/LatestProblems';
        $http.get(urlBase).success(function (data) {
            $scope.data = data;
        }).error(function (data) {
            console.log(data);
        });
        $http.get(baseurl + '/api/home/mylatestproblems')
          .success(function (data) {
            $scope.data2 = data;
        }).error(function (data) {
            console.log(data);
        });  
    }]
);

Bu yüzden giriş yapmadım ve ilk yöntem başarıyla veri döndürüyor. ikinci yöntem, bir giriş sayfasının eşdeğerini içeren verileri (başarı işlevinde) döndürür. mesela [Yetkilendir] ile damgalanmış ve giriş yapmadığınız bir denetleyici eylemi isteseydiniz mvc'de alacağınız şey.

Kullanıcıların oturum açmış olup olmadıklarına bağlı olarak farklı veriler görüntüleyebilmeleri için yetkisiz bir 401 döndürmesini istiyorum. İdeal kullanıcı oturum açtıysanız, bu Üyeye özgü verileri döndürebilmek için Kontrolörün Kullanıcı özelliğine erişmek istiyorum.

GÜNCELLEME: Aşağıdaki önerilerin hiçbiri artık işe yaramadığı için (Identity veya WebAPI'de yapılan değişiklikler) , sorunu göstermesi gereken github'da ham bir örnek oluşturdu .

İki AuthorizeAttribute uygulaması vardır ve Web API'leri için doğru olana başvurduğunuzdan emin olmanız gerekir. Orada System.Web.Http.AuthorizeAttribute Web API en için kullanılır ve System.Web.Mvc.AuthorizeAttribute manzaralı denetleyicileri için kullanılır. Http.AuthorizeAttribute yetkilendirme başarısız olursa bir 401 hata döndürür ve Mvc.AuthorizeAttribute giriş sayfasına yönlendirir.

26.11.2013 tarihinde güncellendi

Öyleyse, Brock Allen'ın makalesinde işaret ettiği gibi MVC 5 ile işler önemli ölçüde değişti . Sanırım OWIN boru hattı devraldı ve bazı yeni davranışlar getirdi. Artık kullanıcı yetkilendirilmediğinde, HTTP üstbilgisinde aşağıdaki bilgilerle 200 durumu döndürülür.

X-Responded-JSON: {"status":401,"headers":{"location":"http:\/\/localhost:59540\/Account\/Login?ReturnUrl=%2Fapi%2FTestBasic"}}

Hata kolunda 401 durumu aramak yerine, bunun nasıl ele alınacağını belirlemek için başlıktaki bu bilgileri kontrol etmek üzere istemci tarafındaki mantığınızı değiştirebilirsiniz.

OnAuthorization ve HandleUnauthorizedRequest yöntemlerinde yanıt durumunu ayarlayarak özel bir AuthorizeAttribute bu davranışı geçersiz kılmaya çalıştım .

actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized);

Ama bu işe yaramadı. Yeni ardışık düzen daha sonra bu yanıtı almalı ve daha önce aldığım yanıta göre değiştirmelidir. Bir HttpException, 500 hata durumuna değiştirildiği için çalışmadı.

Brock Allen'ın çözümünü test ettim ve jQuery ajax çağrısı kullanırken işe yaradı. Eğer sizin için işe yaramıyorsa, sanırım bunun nedeni açısal kullanmanızdır. Testinizi Fiddler ile yapın ve aşağıdakilerin başlığınızda olup olmadığını görün.

X-Requested-With: XMLHttpRequest

Değilse sorun budur. Açısal tanıdık değilim, ancak kendi başlık değerlerinizi girmenize izin veriyorsa, bunu ajax isteklerinize ekleyin ve muhtemelen çalışmaya başlayacaktır.

Brock Allen, Çerez kimlik doğrulaması ve OWIN kullanırken ajax çağrıları için 401'i nasıl iade edeceğiniz konusunda güzel bir blog yazısı var. http://brockallen.com/2013/10/27/using-cookie-authentication-middleware-with-web-api-and-401-response-codes/

Bunu Startup.Auth.cs dosyasındaki ConfigureAuth yöntemine ekleyin:

app.UseCookieAuthentication(new CookieAuthenticationOptions
{
  AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
  LoginPath = new PathString("/Account/Login"),
  Provider = new CookieAuthenticationProvider
  {
    OnApplyRedirect = ctx =>
    {
      if (!IsAjaxRequest(ctx.Request))
      {
        ctx.Response.Redirect(ctx.RedirectUri);
      }
    }
  }
});

private static bool IsAjaxRequest(IOwinRequest request)
{
  IReadableStringCollection query = request.Query;
  if ((query != null) && (query["X-Requested-With"] == "XMLHttpRequest"))
  {
     return true;
  }
  IHeaderDictionary headers = request.Headers;
  return ((headers != null) && (headers["X-Requested-With"] == "XMLHttpRequest"));
}

Asp.net MVC web sitesi içine asp.net WebApi ekliyorsanız, muhtemelen bazı isteklere yetkisiz yanıt vermek istersiniz. Ama sonra ASP.NET altyapısı devreye girer ve HttpStatusCode.Unhorized için yanıt durum kodu ayarlamaya çalıştığınızda, oturum açma sayfasına 302 yönlendirmesi alırsınız.

Burada asp.net kimliği ve owin tabanlı kimlik doğrulaması kullanıyorsanız, bu sorunu çözmeye yardımcı olabilecek bir kod:

public void ConfigureAuth(IAppBuilder app)
{
    app.UseCookieAuthentication(new CookieAuthenticationOptions
    {
        AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
        LoginPath = new PathString("/Account/Login"),
        Provider = new CookieAuthenticationProvider()
        {
            OnApplyRedirect = ctx =>
            {
                if (!IsApiRequest(ctx.Request))
                {
                    ctx.Response.Redirect(ctx.RedirectUri);
                }
            }
        }
    });

    app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
}


private static bool IsApiRequest(IOwinRequest request)
{
    string apiPath = VirtualPathUtility.ToAbsolute("~/api/");
    return request.Uri.LocalPath.StartsWith(apiPath);
}

OWIN her zaman WebApi'den Giriş sayfasına 401 yanıtını yeniden yönlendirdiğinde de aynı durumu aldım. Bu nedenle, isteğin ajax isteği olup olmadığını kontrol etme çözümü bizim durumumuz için gerçekten sıralanmamıştır.

Başka bir yaklaşım yeni başlık yanıtı enjekte etmek Suppress-Redirectiçin seçtim : yanıtlar webApi geliyorsa. Uygulama işleyicide:

public class SuppressRedirectHandler : DelegatingHandler
{
    /// <summary>
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        return base.SendAsync(request, cancellationToken).ContinueWith(task =>
        {
            var response = task.Result;
            response.Headers.Add("Suppress-Redirect", "True");
            return response;
        }, cancellationToken);
    }
}

Ve bu işleyiciyi WebApi'nin küresel düzeyinde kaydedin:

config.MessageHandlers.Add(new SuppressRedirectHandler());

Böylece, OWIN başlangıcında yanıt başlığının olup olmadığını kontrol edebilirsiniz Suppress-Redirect:

public void Configuration(IAppBuilder app)
{
    app.UseCookieAuthentication(new CookieAuthenticationOptions
    {
        AuthenticationMode = AuthenticationMode.Active,
        AuthenticationType = DefaultApplicationTypes.ApplicationCookie,
        ExpireTimeSpan = TimeSpan.FromMinutes(48),

        LoginPath = new PathString("/NewAccount/LogOn"),

        Provider = new CookieAuthenticationProvider()
        {
            OnApplyRedirect = ctx =>
            {
                var response = ctx.Response;
                if (!IsApiResponse(ctx.Response))
                {
                    response.Redirect(ctx.RedirectUri);
                }
            }
        }
    });
}

private static bool IsApiResponse(IOwinResponse response)
{
    var responseHeader = response.Headers;

    if (responseHeader == null) 
        return false;

    if (!responseHeader.ContainsKey("Suppress-Redirect"))
        return false;

    if (!bool.TryParse(responseHeader["Suppress-Redirect"], out bool suppressRedirect))
        return false;

    return suppressRedirect;
}

ASP.NET'in önceki sürümlerinde, bunu çalıştırmak için bir sürü şey yapmanız gerekiyordu .

ASP.NET 4.5 kullandığınız için iyi haber. yeni HttpResponse.SuppressFormsAuthenticationRedirect özelliğini kullanarak form kimlik doğrulaması yeniden yönlendirmesini devre dışı bırakabilirsiniz .

İçinde Global.asax:

protected void Application_EndRequest(Object sender, EventArgs e)
{
        HttpApplication context = (HttpApplication)sender;
        context.Response.SuppressFormsAuthenticationRedirect = true;
}

DÜZENLEME : Sergey Zwezdin'in yapmaya çalıştığınız şeyi gerçekleştirmenin daha zarif bir yoluna sahip bu makalesine de göz atmak isteyebilirsiniz .

Alakalı kod snippet'leri ve yazar anlatımı aşağıda yapıştırıldı. Orijinal kod ve anlatım yazarı - Sergey Zwezdin .

İlk olarak - geçerli HTTP isteğinin AJAX isteği olup olmadığını belirleyelim. Evetse, HTTP 401 yerine HTTP 302 kullanılmasını devre dışı bırakmalıyız:

public class ApplicationAuthorizeAttribute : AuthorizeAttribute
{
    protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
    {
        var httpContext = filterContext.HttpContext;
        var request = httpContext.Request;
        var response = httpContext.Response;

        if (request.IsAjaxRequest())
            response.SuppressFormsAuthenticationRedirect = true;

        base.HandleUnauthorizedRequest(filterContext);
    }
}

İkincisi - bir koşul ekleyelim :: kullanıcı kimliği doğrulanırsa, HTTP 403 göndeririz; ve aksi takdirde HTTP 401.

public class ApplicationAuthorizeAttribute : AuthorizeAttribute
{
    protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
    {
        var httpContext = filterContext.HttpContext;
        var request = httpContext.Request;
        var response = httpContext.Response;
        var user = httpContext.User;

        if (request.IsAjaxRequest())
        {
            if (user.Identity.IsAuthenticated == false)
                response.StatusCode = (int)HttpStatusCode.Unauthorized;
            else
                response.StatusCode = (int)HttpStatusCode.Forbidden;

            response.SuppressFormsAuthenticationRedirect = true;
            response.End();
        }

        base.HandleUnauthorizedRequest(filterContext);
    }
}

Aferin. Şimdi standart AuthorizeAttribute'ın tüm kullanımlarını bu yeni filtreyle değiştirmeliyiz. Kod estetiği olan sime adamlar için geçerli olmayabilir. Ama başka bir yol bilmiyorum. Eğer varsa, lütfen yorumlara gidelim.

Sonuncusu, ne yapmalıyız - istemci tarafına HTTP 401/403 işleme eklemek için. Kod çoğaltmasını önlemek için jQuery'de ajaxError öğesini kullanabiliriz:

$(document).ajaxError(function (e, xhr) {
    if (xhr.status == 401)
        window.location = "/Account/Login";
    else if (xhr.status == 403)
        alert("You have no enough permissions to request this resource.");
});

Sonuç -

• Kullanıcı kimliği doğrulanmazsa, herhangi bir AJAX çağrısından sonra bir giriş sayfasına yönlendirilir.
• Kullanıcının kimliği doğrulanır ancak yeterli izne sahip değilse, kullanıcı dostu erorr mesajı görür.
• Kullanıcının kimliği doğrulanırsa ve yeterli izinlere sahipse, hata yoktur ve HTTP isteği her zamanki gibi devam eder.

Projenizi Web APIiçinden çalıştırıyorsanız , yöntemlerinize uygulamak için MVCbir özel oluşturmanız gerekir . İçinde yeniden yönlendirmeyi önlemek için akımı tutmanız gerekir , şöyle:AuthorizeAttributeAPIIsAuthorized overrideHttpContext

    protected override bool IsAuthorized(HttpActionContext actionContext)
    {
        if (string.IsNullOrWhiteSpace(Thread.CurrentPrincipal.Identity.Name))
        {
            var response = HttpContext.Current.Response;
            response.SuppressFormsAuthenticationRedirect = true;
            response.StatusCode = (int)System.Net.HttpStatusCode.Forbidden;
            response.End();
        }

        return base.IsAuthorized(actionContext);
    }

Azure Active Directory entegrasyonunu kendim kullanarak, CookieAuthenticationkatman yazılımını kullanan yaklaşım benim için işe yaramadı. Aşağıdakileri yapmak zorunda kaldım:

app.UseOpenIdConnectAuthentication(
    new OpenIdConnectAuthenticationOptions
    {
        ...
        Notifications = new OpenIdConnectAuthenticationNotifications
        {   
            ...         
            RedirectToIdentityProvider = async context =>
            {
                if (!context.Request.Accept.Contains("html"))
                {
                    context.HandleResponse();
                }
            },
            ...
        }
    });

İstek tarayıcının kendisinden geliyorsa (örneğin bir AJAX çağrısı değil), Kabul üstbilgisi dizeyi bir htmlyerde içerecektir . Yalnızca istemci HTML'yi kabul ettiğinde, yeniden yönlendirmeyi yararlı bir şey olarak değerlendireceğim.

İstemci uygulamam, 401'i, uygulamanın daha fazla erişiminin olmadığını ve tekrar oturum açmak için yeniden yüklemesi gerektiğini kullanıcıya bildirebilir.

Ayrıca WebApi (OWIN kullanarak) ile bir MVC5 uygulaması (System.Web) vardı ve sadece WebApi gelen 401 yanıt 302 yanıt değiştirilmesini önlemek istedim.

Benim için işe yarayan WebApi AuthorizeAttribute'un özelleştirilmiş bir sürümünü oluşturmaktı:

public class MyAuthorizeAttribute : System.Web.Http.AuthorizeAttribute
{
    protected override void HandleUnauthorizedRequest(HttpActionContext actionContext)
    {
        base.HandleUnauthorizedRequest(actionContext);
        HttpContext.Current.Response.SuppressFormsAuthenticationRedirect = true;
    }
}

Ve standart WebApi AuthorizeAttribute yerine kullanmak için. MVC davranışını değiştirmeden tutmak için standart MVC AuthorizeAttribute kullandım.

Sadece aşağıdaki NeGet Paketini kurun

Yükleme Paketi Microsoft.AspNet.WebApi.Owin

WebApiConfig dosyasına aşağıdaki kodu yazın.

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        //Web API configuration and services
        //Configure Web API to use only bearer token authentication.
        config.SuppressDefaultHostAuthentication();
        config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{action}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
        config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
        config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/form-data"));
    }
}

Content-Type == application / json'ı yakalamak istiyorsanız bu kodu kullanabilirsiniz:

private static bool IsAjaxRequest(IOwinRequest request)
    {
        IReadableStringCollection queryXML = request.Query;
        if ((queryXML != null) && (queryXML["X-Requested-With"] == "XMLHttpRequest"))
        {
            return true;
        }

        IReadableStringCollection queryJSON = request.Query;
        if ((queryJSON != null) && (queryJSON["Content-Type"] == "application/json"))
        {
            return true;
        }

        IHeaderDictionary headersXML = request.Headers;
        var isAjax = ((headersXML != null) && (headersXML["X-Requested-With"] == "XMLHttpRequest"));

        IHeaderDictionary headers = request.Headers;
        var isJson = ((headers != null) && (headers["Content-Type"] == "application/json"));

        return isAjax || isJson;

    }

Saygılarımızla!!

Durum kodu ve OnAuthorization / HandleUnauthorizedRequest yöntemlerinde çalışan bir metin yanıtı almak zor bir zaman geçirdim. Bunun benim için en iyi çözüm olduğu ortaya çıktı:

    actionContext.Response = new HttpResponseMessage()
    {
        StatusCode = HttpStatusCode.Forbidden,
        Content = new StringContent(unauthorizedMessage)
    };

Giriş sayfasına yeniden yönlendirmelerden kaçınmaya çalışırken, bunun aslında Yetkilendirme özelliği için oldukça uygun olduğunu fark ettim. Git ve Yetki al demek. Yetkili olmayan Api çağrıları yerine, hacker olabilecek herhangi bir bilgiyi açıklamak istemedim. Bu hedefe, içeriği 404 hatası olarak gizleyen Authorize'den türetilen yeni bir özellik ekleyerek doğrudan elde etmek daha kolaydı:

public class HideFromAnonymousUsersAttribute : AuthorizeAttribute
{
    protected override void HandleUnauthorizedRequest(HttpActionContext actionContext)
    {
         actionContext.Response = ActionContext.Request.CreateErrorResponse(HttpStatusCode.NotFound, "Access Restricted");
    }
}

MVC ve WebAPI karıştırıldığında, istek yetkisiz ise WebAPI isteğinde bile giriş sayfasına yönlendirilir. Bunun için, mobil uygulamaya yanıt göndermek için aşağıdaki kodu ekleyebiliriz

protected override void HandleUnauthorizedRequest(HttpActionContext actionContext)
{
    var httpContext = HttpContext.Current;
    if (httpContext == null)
    {
        base.HandleUnauthorizedRequest(actionContext);
        return;
    }

    actionContext.Response = httpContext.User.Identity.IsAuthenticated == false ?
        actionContext.Request.CreateErrorResponse(
      System.Net.HttpStatusCode.Unauthorized, "Unauthorized") :
       actionContext.Request.CreateErrorResponse(
      System.Net.HttpStatusCode.Forbidden, "Forbidden");

    httpContext.Response.SuppressFormsAuthenticationRedirect = true;
    httpContext.Response.End();
}

Teşekkürler beyler!

Benim durumumda, cuongle & Shiva'nın cevaplarını birleştirdim ve şöyle bir şey aldım:

API İstisnaları için Controller's OnException () işleyicisinde:

filterContext.ExceptionHandled = true;
//...
var response = filterContext.HttpContext.Response;
response.Headers.Add("Suppress-Redirect", "true");
response.SuppressFormsAuthenticationRedirect = true;

Uygulama başlangıç ​​yapılandırma kodunda:

app.UseCookieAuthentication(new CookieAuthenticationOptions {
        AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
        LoginPath = new PathString("/Account/Login"),
        Provider = new CookieAuthenticationProvider {
            OnValidateIdentity = ctx => {
                return validateFn.Invoke(ctx);
            },
            OnApplyRedirect = ctx =>
            {
                bool enableRedir = true;
                if (ctx.Response != null)
                {
                    string respType = ctx.Response.ContentType;
                    string suppress = ctx.Response.Headers["Suppress-Redirect"];
                    if (respType != null)
                    {
                        Regex rx = new Regex("^application\\/json(;(.*))?$",
                            RegexOptions.IgnoreCase);
                        if (rx.IsMatch(respType))
                        {
                            enableRedir = false;
                        }  
                    }
                    if ((!String.IsNullOrEmpty(suppress)) && (Boolean.Parse(suppress)))
                    {
                        enableRedir = false;
                    }
                }
                if (enableRedir)
                {
                    ctx.Response.Redirect(ctx.RedirectUri);
                }
            }
        }
    });

Dot Net Framework 4.5.2 ile MVC 5'te "Accept" başlığı altında "application / json, plaint text .." alıyoruz Aşağıdaki gibi kullanmak güzel olacaktır:

isJson = headers["Content-Type"] == "application/json" || headers["Accept"].IndexOf("application/json", System.StringComparison.CurrentCultureIgnoreCase) >= 0;