Service WCF autorisation modèles

Je suis en œuvre une sécurité de service WCF. L'authentification se fait à l'aide du nom d'utilisateur /mot de passe ou des informations d'identification Windows. Le service est hébergé dans un Service Windows processus. Maintenant, j'essaie de trouver la meilleure façon de mettre en œuvre autorisation pour chaque opération de service.

Considérons, par exemple, la méthode suivante:

public EntityInfo GetEntityInfo(string entityId);

Comme vous le savez peut-être, dans WCF, il y a un OperationContext objet à partir de laquelle vous pouvez récupérer les informations d'identification de sécurité passé par l'appelant/client. Maintenant,authentification aurait déjà terminé au moment où la première ligne de la méthode est appelée. Cependant, comment pouvons-nous mettre en œuvre l'autorisation si la décision repose sur les données d'entrée lui-même? Par exemple, dans le cas ci-dessus, dire 'admin' utilisateurs(dont les autorisations etc sont stockés dans une base de données), sont autorisés à obtenir des infos sur l'entité, et les autres utilisateurs ne devraient pas être autorisés... où allons-nous mettre les vérifications d'autorisation?

Dire que nous l'avons mis dans la première ligne de la méthode comme suit:

CheckAccessPermission(PermissionType.GetEntity, user, entityId) //user is pulled from the current OperationContext

Maintenant, il ya un couple de questions:

  1. Ne nous valider le entityId (par exemple vérifier null /valeur vide etc) AVANT que l'autorisation de chèque ou de l'INTÉRIEUR de l'autorisation de vérifier? En d'autres termes, si les contrôles d'autorisation doivent être inclus dans chaque méthode, est-ce un bon modèle? Ce qui devrait arriver premier argument de la validation ou de l'autorisation?

  2. Comment pouvons-nous l'unité de test d'un service WCF lorsque les contrôles d'autorisation sont tous sur la place de ce genre, et nous n'avons pas de OperationContext dans l'unité de test!? (En supposant que je suis tryin pour tester cette classe de service mise en œuvre directement, sans aucun de la FMC de l'installation).

Toutes les idées, les gars?

OriginalL'auteur | 

  1. 3

    Pour la question 1, absolument autorisation d'abord. Pas de code (à l'intérieur de votre contrôle) doit s'exécuter avant l'autorisation de maintenir l'étanchéité de la sécurité. L'exemple de Paul ci-dessus est excellent.

    Pour la question 2, vous pouvez gérer ce sous-classement par votre service concret de mise en œuvre. Faire un véritable logique d'entreprise la mise en œuvre d'une classe abstraite avec un résumé "CheckPermissions" la méthode que vous mentionnez ci-dessus. Puis créer 2 sous-classes, l'une pour les utiliser, et un (très isolé dans une position non déployée DLL) qui retourne vrai (ou ce que vous aimeriez faire dans votre unité de test).

    Exemple (à noter que ceux-ci ne devraient pas être dans le même fichier ou même DLL, si!):

    public abstract class MyServiceImpl
{
    public void MyMethod(string entityId)
    {
        CheckPermissions(entityId);
        //move along...
    }
    protected abstract bool CheckPermissions(string entityId);
}

public class MyServiceUnitTest
{
    private bool CheckPermissions(string entityId)
    {
        return true;
    }
}

public class MyServiceMyAuth
{
    private bool CheckPermissions(string entityId)
    {
        //do some custom authentication
        return true;
    }
}

    Alors votre WCF déploiement utilise la classe "MyServiceMyAuth", et vous faites vos tests unitaires contre l'autre.

    OriginalL'auteur TheSoftwareJedi

  2. 6

    Pour la question 1, il est préférable de procéder à l'autorisation d'abord. De cette façon, vous n'avez pas de fuite d'erreur de validation des messages à des utilisateurs non autorisés.

    BTW, au lieu d'utiliser un home-grown méthode d'authentification (qui je suppose est ce que votre CheckAccessPermission est), vous pourriez être en mesure de s'accrocher jusqu'à la WCF out-of-the-box " pour ASP.NET rôle des fournisseurs. Une fois cela fait, vous effectuez l'autorisation par le biais d'OperationContext.Actuel.ServiceSecurityContext.PrimaryIdentity.IsInRole(). Le PrimaryIdentity est un IPrincipal.

    Merci Paul. Le problème avec l'autorisation de la première, est la suivante: comment pouvons-nous autoriser un utilisateur si nous avons besoin de vérifier les autorisations sur la base des arguments d'entrée? N'avons-nous pas besoin de valider ces arguments, tout d'abord, avant de nous l'utilisons pour l'autorisation?
    L'autorisation ne devrait dépendre de l'identité de l'utilisateur. Si elle repose sur des arguments d'entrée, alors le visiteur peut envoyer tout ce que les valeurs qu'il a besoin d'obtenir l'autorisation qu'il veut, de sorte que votre demande d'autorisation est dénué de sens.
    Pas de. Dire que je veux accéder à un objet avec l'id 'abc1'. Je suis 'user1'. Autorisation décide si "utilisateur 1" peut accéder à l'objet "abc1'. donc, la première chose à faire sera de valider le paramètre qui contient l'id de l'objet string!

    OriginalL'auteur Paul Lalonde

  3. 6

    À propos de la question #2, je voudrais faire cela à l'aide de l'Injection de Dépendance et de configurer votre service de la mise en œuvre quelque chose comme ceci:

    class MyService : IMyService
{
    public MyService() : this(new UserAuthorization()) { }
    public MyService(IAuthorization auth) { _auth = auth; }

    private IAuthorization _auth;

    public EntityInfo GetEntityInfo(string entityId)
    {
            _auth.CheckAccessPermission(PermissionType.GetEntity, 
                    user, entityId);

            //Get the entity info
    }
}

    Noter que IAuthorization est une interface qui vous permettrait de définir.

    Parce que vous allez tester le type de service directement (c'est, sans l'exécuter à l'intérieur de la WCF hébergement cadre) il vous suffit de définir votre service pour utiliser un mannequin IAuthorization type qui permet à tous les appels. Cependant, même le MEILLEUR test est de se moquer de l'IAuthorization et tester qu'il est appelé quand et avec les paramètres que vous attendez. Cela vous permet de tester vos appels à l'autorisation de méthodes sont valables, ainsi que la méthode elle-même.

    Séparant l'autorisation, dans son propre type de contenu vous permet également de tester plus facilement qu'il est correct dans l'isolement. Dans mon (bien que limitée) de l'expérience, à l'aide de DI "modèles" de vous donner largement la meilleure séparation des préoccupations et de la testabilité dans votre types comme conduisant à une interface épurée (c'est évidemment ouvert au débat).

    Mon préféré moqueur cadre est RhinoMocks qui est gratuit et a une très belle interface fluide mais il y a beaucoup d'autres là-bas. Si vous souhaitez en savoir plus à propos de DI voici quelques bonnes amorces et .Net cadres:

    OriginalL'auteur