Déterminer si le jeton de support a expiré ou est juste autorisé

Mon angulaire de l'application est de rendre l'utilisation de porteur de jetons que décrites dans l'article de la série http://bitoftech.net/2014/06/01/token-based-authentication-asp-net-web-api-2-owin-asp-net-identity/. J'ai suivi la fourche exemple de manière transparente l'actualisation des jetons lorsque le jeton d'accès a expiré (via 401 code http).

Ma question est comment puis-je déterminer si le porteur du jeton est expiré ou tout simplement non autorisée sur la base du rôle déterminé?

Par exemple, mon api web méthode a l'attribut [Autoriser(Rôles="Admin")]. Quand je fais un appel pour que je récupère mon erreur 401, ce qui est prévu. Toutefois, lorsque mon jeton d'accès expire et que je fais un api web de l'appel de méthode, il renvoie également à une erreur 401. Heres mon responseError gestionnaire dans mon intercepteur:

        responseError: function (rejection) {
            var deferred = q.defer();
            if (rejection.status === 401) {
                var authService = $injector.get('authService');
                authService.refreshToken().then(function (response) {
                    _retryHttpRequest(rejection.config, deferred);
                }, function () {
                    authService.logOut();
                    $location.path('/dashboard');
                    deferred.reject(rejection);
                });
            } else {
                deferred.reject(rejection);
            }
            return deferred.promise;
        }

J'ai été jouer avec des choses différentes, mais en gros, je voudrais actualiser mon jeton et de le renvoyer ma demande, lorsque le jeton d'accès est expiré; cependant, je ne veux pas actualiser mon jeton si c'est vraiment une demande rejetée en raison du rôle spécifié.

Toutes les pensées?

source d'informationauteur mmoreno79

  1. 14

    Comme indiqué dans ma réponse à Cory Silva, du commentaire, de l'API du Web Autorise attribut retournera toujours 401 non autorisé pour l'authentification ET l'autorisation.

    Voir l'article et le thread ci-dessous:

    http://leastprivilege.com/2014/10/02/401-vs-403/

    Pourquoi ne AuthorizeAttribute rediriger vers la page de connexion pour l'authentification et l'autorisation des échecs?

    Il semble que il ya deux options:

    1. Quand je stocker le jeton (extrait de mon serveur d'autorisation dans le localStorage, j'ai également stocker le jeton de l'expiration. Dans l'intercepteur responseError fonction, je compare le jeton stocké expiration avec l'actuel datetime. S'il est déterminé à être expiré, l'actualisation de la symbolique et de renvoyer la demande.

      responseError: function (rejection) {
    var deferred = q.defer();

    if (rejection.status === 401) {
        var tokenExpired = false;
        var authData = localStorage.get('authorizationData');
        if (authData) {
            tokenExpired = moment().isAfter(authData.expiration);
        }

        if (tokenExpired) {
            var authService = auth;//$injector.get('authService');
            authService.refreshToken().then(function (response) {
                _retryHttpRequest(rejection.config, deferred);
            }, function () {
                authService.logOut();
                $state.go('error');
                deferred.reject(rejection);
            });
        }
        else {
            $state.go('error');
            deferred.reject(rejection);
        }
    } else {
        $state.go('error');
        deferred.reject(rejection);
    }
    return deferred.promise;
}

    2. Utiliser la accepté de répondre dans le stackoverflow thread, j'ai mentionné ci-dessus et de créer mon propre AuthorizeAttribute pour déterminer jeton expiration contre les accès non autorisés.

      [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
public class AuthorizeAttribute : System.Web.Http.AuthorizeAttribute
{
    protected override void HandleUnauthorizedRequest(HttpActionContext actionContext)
    {
        if (actionContext.RequestContext.Principal.Identity.IsAuthenticated)
        {
            actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Forbidden);
        }
        else
        {
            base.HandleUnauthorizedRequest(actionContext);
        }
    }
}

    Je pense que je vais utiliser l'option 2, de sorte que les codes d'erreur un peu plus clair pour le client.