Autorisation sur mesure en Asp.net WebApi-quel gâchis?

je lis plusieurs ressources (livres et réponses) sur l'autorisation en WebApi.

supposons que je veuille ajouter un attribut personnalisé qui ne permet l'accès que pour certains utilisateurs:

affaire n ° 1

j'ai vu cette approche de overriding "1519160920 OnAuthorization , qui définit la réponse si quelque chose ne va pas

public class AllowOnlyCertainUsers : AuthorizeAttribute
{
 public override void OnAuthorization(HttpActionContext actionContext)
  {
   if ( /*check if user OK or not*/)
   {
     actionContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized);
   }
  }
}

affaire n ° 2

mais j'ai aussi vu cet exemple similaire qui surpasse aussi OnAuthorization mais avec l'appel à base :

public override void OnAuthorization(HttpActionContext actionContext) 
{ 
  base.OnAuthorization(actionContext);

    // If not authorized at all, don't bother

    if (actionContext.Response == null)  
     {
      //...
     }
}

ensuite, vous vérifiez si le HttpActionContext.Response est réglé ou pas. Si elle n'est pas ensemble, cela signifie que la demande est autorisée et que l'utilisateur est ok

cas n ° 3

mais j'ai aussi vu cette approche de "DOMINANT 151980920":

public class AllowOnlyCertainUsers : AuthorizeAttribute
{
 protected override bool IsAuthorized(HttpActionContext context)
  {
   if ( /*check if user OK or not*/)
   {
    return true;// or false
   }
  }
}

Cas n ° 4

et puis j'ai vu un exemple similaire, mais avec la base d'appel.IsAuthorized (context):

protected override bool IsAuthorized(HttpActionContext context)
{
 if (something1 && something2 && base.IsAuthorized(context)) //??
 return true;
 return false;
}

une chose de plus

et finalement Dominick a dit ici :

vous ne devriez pas outrepasser OnAuthorization-parce que vous manqueriez la gestion [AllowAnonymous].

Questions

  • 1) Quelles méthodes dois-je utiliser : IsAuthorized ou OnAuthorization ? ( ou quand utiliser)

  • 2) Quand dois-je appeler base.IsAuthorized or base.OnAuthorization` ?

  • 3) Est - ce ainsi qu'ils il construit ? que si la réponse est nulle alors tout va bien ? (affaire no 2)

NB

s'il vous Plaît notez , que j'utilise ( et que vous voulez utiliser ) seulement AuthorizeAttribute qui a déjà hérite de AuthorizationFilterAttribute

pourquoi ?

Parce que je suis à la première étape : http://www.asp.net/web-api/overview/security/authentication-and-authorization-in-aspnet-web-api

enter image description here

de toute façon je demande via l'attribut extending Authorize .

92
demandé sur Community 2014-10-20 15:41:42

3 réponses

quelles méthodes devrais-je utiliser : IsAuthorized ou OnAuthorization ? ( ou quand utiliser qui)

vous prolongerez AuthorizationFilterAttribute si votre logique d'autorisation ne dépend pas de l'identité établie et des rôles. Pour l'autorisation liée à l'utilisateur, vous étendrez et utiliserez AuthorizeAttribute . Dans le premier cas, vous annulerez OnAuthorization . Dans ce dernier cas, vous annulerez IsAuthorized . Comme vous pouvez le voir à partir du code source de ces attributs, OnAuthorization est marqué virtuel pour vous remplacer si vous dériver de AuthorizationFilterAttribute . D'autre part, la méthode IsAuthorized est marquée virtuelle dans AuthorizeAttribute . Je crois que c'est un bon pointeur à l'usage prévu.

Quand dois-je appeler la base?IsAuthorized ou de la base.OnAuthorization?

la réponse à cette question réside dans le fonctionnement général de OO. Si vous substituez une méthode, vous pouvez soit complètement fournir une nouvelle implémentation ou piggy back sur l'implémentation fournie par parent et améliorer le comportement. Prenons par exemple le cas de IsAuthorized(HttpActionContext) . Le comportement de la classe de base est de vérifier l'utilisateur / rôle par rapport à ce qui est spécifié dans le filtre par rapport à l'identité établie. Dire, vous voulez faire tout cela, mais en plus, vous voulez vérifier quelque chose d'autre, peut être basée sur un en-tête de requête ou de quelque chose. Dans ce cas, vous pouvez fournir un remplacement de ce genre.

protected override bool IsAuthorized(HttpActionContext actionContext)
{
    bool isAuthroized = base.IsAuthorized(actionContext);
    // Here you look at the header and do your additional stuff based on actionContext
    // and store the result in isRequestHeaderOk
    // Then, you can combine the results
    // return isAuthorized && isRequestHeaderOk;
}

je suis désolé mais je ne comprends pas votre Q3. BTW, filtre D'autorisation a été autour pendant une longue période et les gens l'utilisent pour toutes sortes de choses et parfois incorrectement aussi bien.

encore une chose. Et finalement, il y avait ce gars ici qui a dit: ne devrait pas outrepasser OnAuthorization-parce que vous seriez absent [AllowAnonymous] handling.

le type qui a dit que C'était le dieu du contrôle d'accès - Dominick. Évidemment, ce sera correct. Si vous regardez l'implémentation de OnAuthorization (copié ci-dessous),

public override void OnAuthorization(HttpActionContext actionContext)
{
    if (actionContext == null)
    {
        throw Error.ArgumentNull("actionContext");
    }

    if (SkipAuthorization(actionContext))
    {
        return;
    }

    if (!IsAuthorized(actionContext))
    {
        HandleUnauthorizedRequest(actionContext);
    }
}

l'appel à SkipAuthorization est la partie qui assure que les filtres AllowAnonymous sont appliqués, c'est-à-dire que l'autorisation est sautée. Si vous outrepassez cette méthode, vous perdez ce comportement. En fait, si vous décidez de baser votre autorisation sur les utilisateurs/rôles, à ce moment-là vous auriez décidé de dériver de AuthorizeAttribute . La seule option correcte qui reste pour vous à ce point sera d'outrepasser IsAuthorized et non le déjà dépassé OnAuthorization , bien qu'il soit techniquement possible de faire l'un ou l'autre.

PS. En ASP.NET API Web, il y a un autre filtre appelé authentification filter. L'idée est que vous utilisiez cela pour l'authentification et le filtre d'autorisation pour l'autorisation, comme le nom l'indique. Toutefois, il existe de nombreux exemples où cette limite est contournée. Beaucoup d'exemples de filtres authroization feront une sorte de Authentication. Quoi qu'il en soit, si vous avez le temps et que vous voulez comprendre un peu plus, jetez un oeil à ce MSDN article . Avertissement: Il a été écrit par moi.

84
répondu Badri 2014-10-20 16:49:26

Ok, ma suggestion est de faire ce qui suit en supposant que vous utilisez des tokens au porteur D'OAuth pour protéger votre API Web et que vous définissez allowedTime comme une réclamation pour l'utilisateur lorsque vous avez émis le token. Vous pouvez en savoir plus sur authentification par token ici

  1. Créer CustomAuthorizeAttribute qui dérive de AuthorizationFilterAttribute
  2. remplacer la méthode OnAuthorizationAsync et d'utiliser le exemple de code ci-dessous:

     public class CustomAuthorizeAttribute : AuthorizationFilterAttribute
    {
    
        public override Task OnAuthorizationAsync(HttpActionContext actionContext, System.Threading.CancellationToken cancellationToken)
        {
    
            var principal = actionContext.RequestContext.Principal as ClaimsPrincipal;
    
            if (!principal.Identity.IsAuthenticated)
            {
                return Task.FromResult<object>(null);
            }
    
            var userName = principal.FindFirst(ClaimTypes.Name).Value;
            var userAllowedTime = principal.FindFirst("userAllowedTime").Value;
    
            if (currentTime != userAllowedTime)
            {
                actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Unauthorized, "Not allowed to access...bla bla");
                return Task.FromResult<object>(null);
            }
    
            //User is Authorized, complete execution
            return Task.FromResult<object>(null);
    
        }
    }
    
  3. maintenant dans vos controllers vous utilisez l'attribut CustomAuthorize pour protéger vos controllers en utilisant cette logique d'autorisation.
16
répondu Taiseer Joudeh 2014-10-20 13:28:50

ASP.NET v5 a introduit un tout nouveau système D'autorisation. Pour ceux qui vont utiliser .NET 5, je suggère de passer à Microsoft.AspNet.Autorisation.

à peu près il conclut le désordre causé par garder les deux System.Web.Http.Authorize et System.Web.Mvc.Authorize et d'autres implémentations d'authentification plus anciennes.

il fournit une très bonne abstraction des types D'Action (Créer, Lire, mettre à jour, Supprimer), des ressources, des rôles, Des revendications, des Vues, des Exigences de personnalisation et permet de construire des Gestionnaires personnalisés, alliant tout ce qui précède. En outre, les gestionnaires peuvent être utilisés en combinaison.

In ASP.NET l'autorisation v5 fournit maintenant un rôle déclaratif simple et un modèle plus riche fondé sur les politiques où l'autorisation est exprimée en les exigences et les gestionnaires évaluent les réclamations des utilisateurs exigence. Les contrôles impératifs peuvent être basés sur des politiques simples ou politiques qui évaluent à la fois l'identité de l'utilisateur et les propriétés de la des ressources que l'utilisateur tente d'accéder.

3
répondu Anestis Kivranoglou 2017-02-07 23:14:55