Comment : créer une stratégie d'autorisation personnalisée

Article
02/27/2011

L'infrastructure de modèle d'identité dans Windows Communication Foundation (WCF) prend en charge un modèle d'autorisation basé sur les revendications. Les revendications, une fois extraites des jetons, sont traitées par une stratégie d'autorisation personnalisée lorsqu'une telle stratégie a été définie, puis placées dans un AuthorizationContext, lequel peut ensuite être examiné afin de délivrer ou non les autorisations. Il est possible d'utiliser une stratégie personnalisée afin de transformer les revendications émanant des jetons entrants en revendications escomptées par l'application. De cette façon, les détails des différentes revendications provenant des différents types de jetons pris en charge par WCF sont épargnés à l'application. Cette rubrique contient des instructions permettant d'implémenter une stratégie d'autorisation personnalisée et d'ajouter celle-ci à la collection de stratégies utilisées par un service donné.

Pour implémenter une stratégie d'autorisation personnalisée

Définissez une nouvelle classe dérivée de IAuthorizationPolicy.
Implémentez la propriété Id en lecture seule en générant une chaîne unique dans le constructeur de la classe et en faisant en sorte que cette chaîne soit retournée à chaque accès à la propriété.
Implémentez la propriété Issuer en lecture seule en retournant un ClaimSet qui représente l'émetteur de la stratégie. Il peut s'agir d'un ClaimSet qui représente l'application ou d'un ClaimSet intégré (par exemple, le ClaimSet retourné par la propriété System statique).
Implémentez la méthode Evaluate comme décrit dans la procédure suivante.

Pour implémenter la méthode d'évaluation

Deux paramètres sont passés à cette méthode : une instance de la classe EvaluationContext ainsi qu'une référence d'objet.
Si la stratégie d'autorisation personnalisée ajoute des instances ClaimSet indépendamment du contenu actuel du EvaluationContext, ajoutez alors chaque ClaimSet en appelant la méthode AddClaimSet, puis retournez la valeur true depuis la méthode Evaluate. Le renvoi de la valeur true indique à l'infrastructure d'autorisation que la stratégie d'autorisation a terminé son travail et qu'il n'est plus nécessaire de l'appeler.
Si la stratégie d'autorisation personnalisée ajoute des ensembles de revendications uniquement lorsque des revendications sont déjà présentes dans le EvaluationContext, recherchez ces revendications en examinant les instances ClaimSet retournées par la propriété ClaimSets. Si des revendications sont déjà présentes, ajoutez les nouveaux ensembles de revendications en appelant la méthode AddClaimSet, puis, lorsqu'il n'y a plus d'ensembles de revendications à ajouter, retournez la valeur true afin d'indiquer à l'infrastructure d'autorisation que la stratégie d'autorisation a terminé son travail. En l'absence de revendications, retournez la valeur false afin d'indiquer que la stratégie d'autorisation doit encore être appelée lorsque d'autres stratégies d'autorisation souhaitent ajouter de nouveaux ensembles de revendications au EvaluationContext.
Lorsque les autorisations nécessitent un traitement plus complexe, notamment une évaluation particulière, le second paramètre de la méthode Evaluate est utilisé pour stocker une variable d'état que l'infrastructure d'autorisation repasse à chaque nouvel appel de la méthode Evaluate.

Pour spécifier une stratégie d'autorisation personnalisée dans le fichier de configuration

Spécifiez le type de la stratégie d'autorisation personnalisée dans l'attribut policyType de l'élément add de l'élément authorizationPolicies de l'élément serviceAuthorization.

<configuration>
 <system.serviceModel>
  <behaviors>
    <serviceAuthorization serviceAuthorizationManagerType=
              "Samples.MyServiceAuthorizationManager" >
      <authorizationPolicies>       
        <add policyType="Samples.MyAuthorizationPolicy"
      </authorizationPolicies>
    </serviceAuthorization>
  </behaviors>
 </system.serviceModel>
</configuration>

Pour spécifier une stratégie d'autorisation personnalisée dans le code

Créez une liste List de IAuthorizationPolicy.
Créez une instance de la stratégie d'autorisation personnalisée.
Ajoutez l'instance de la stratégie d'autorisation à la liste.
Répétez les étapes 2 et 3 pour chaque stratégie d'autorisation personnalisée à ajouter.

Assignez une version en lecture seule de la liste à la propriété ExternalAuthorizationPolicies.

' Add custom authorization policy to service authorization behavior.
Dim policies As List(Of IAuthorizationPolicy) = New List(Of IAuthorizationPolicy)()
policies.Add(New MyAuthorizationPolicy())
serviceHost.Authorization.ExternalAuthorizationPolicies = policies.AsReadOnly()

// Add a custom authorization policy to the service authorization behavior.
List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>();
policies.Add(new MyAuthorizationPolicy());
serviceHost.Authorization.ExternalAuthorizationPolicies = policies.AsReadOnly();

Exemple

Dans l'exemple suivant, la stratégie IAuthorizationPolicy est implémentée de manière exhaustive.

Public Class MyAuthorizationPolicy
    Implements IAuthorizationPolicy
    Private id_Value As String
    
    
    Public Sub New() 
        id_Value = Guid.NewGuid().ToString()
    
    End Sub 
    
    
    Public Function Evaluate(ByVal evaluationContext As EvaluationContext, ByRef state As Object) As Boolean _
        Implements IAuthorizationPolicy.Evaluate
        Dim bRet As Boolean = False
        Dim customstate As CustomAuthState = Nothing
        
        ' If the state is null, then this has not been called before, so set up
        ' our custom state.
        If state Is Nothing Then
            customstate = New CustomAuthState()
            state = customstate
        Else
            customstate = CType(state, CustomAuthState)
        End If 
        ' If claims have not been added yet...
        If Not customstate.ClaimsAdded Then
            ' Create an empty list of Claims.
            Dim claims as IList (Of Claim) = New List(Of Claim)()
            
            ' Iterate through each of the claimsets in the evaluation context.
            Dim cs As ClaimSet
            For Each cs In  evaluationContext.ClaimSets
                ' Look for Name claims in the current claimset...
                Dim c As Claim
                For Each c In  cs.FindClaims(ClaimTypes.Name, Rights.PossessProperty)
                    ' Get the list of operations that the given username is allowed to call.
                    Dim s As String
                    For Each s In  GetAllowedOpList(c.Resource.ToString())
                        ' Add claims to the list.
                        claims.Add(New Claim("http://example.org/claims/allowedoperation", s, Rights.PossessProperty))
                        Console.WriteLine("Claim added {0}", s)
                    Next s
                Next c 
            Next cs ' Add claims to the evaluation context.    
            evaluationContext.AddClaimSet(Me, New DefaultClaimSet(Me.Issuer, claims))
            
            ' Record that claims were added.
            customstate.ClaimsAdded = True
            
            ' Return true, indicating that this does not need to be called again.
            bRet = True
        Else
            ' Should never get here, but just in case...
            bRet = True
        End If
        
        
        Return bRet
    
    End Function
    
    Public ReadOnly Property Issuer() As ClaimSet Implements IAuthorizationPolicy.Issuer
        Get
            Return ClaimSet.System
        End Get
    End Property 
    
    Public ReadOnly Property Id() As String Implements IAuthorizationPolicy.Id
        Get
            Return id_Value
        End Get
    End Property 
    ' This method returns a collection of action strings thet indicate the 
    ' operations the specified username is allowed to call.
    
        ' Operations the specified username is allowed to call.
    Private Function GetAllowedOpList(ByVal userName As String) As IEnumerable(Of String)
            Dim ret As IList(Of String) = new List(Of String)()
        If username = "test1" Then
            ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Add")
            ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Multiply")
            ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Subtract")
        ElseIf username = "test2" Then
            ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Add")
            ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Subtract")
        End If
        Return ret
     End Function
    
    ' internal class for keeping track of state
    
    Class CustomAuthState
        Private bClaimsAdded As Boolean
        
        
        Public Sub New() 
            bClaimsAdded = False
        
        End Sub 'New
        
        
        Public Property ClaimsAdded() As Boolean 
            Get
                Return bClaimsAdded
            End Get
            Set
                bClaimsAdded = value
            End Set
        End Property 
    End Class 
End Class

public class MyAuthorizationPolicy : IAuthorizationPolicy
{
  string id;
  
  public MyAuthorizationPolicy()
  {
    id =  Guid.NewGuid().ToString();
  }

  public bool Evaluate(EvaluationContext evaluationContext, ref object state)
  {
    bool bRet = false;
    CustomAuthState customstate = null;

    // If the state is null, then this has not been called before so 
    // set up a custom state.
    if (state == null)
    {
      customstate = new CustomAuthState();
      state = customstate;
    }
    else
      customstate = (CustomAuthState)state;

    // If claims have not been added yet...
    if (!customstate.ClaimsAdded)
    {
      // Create an empty list of claims.
      IList<Claim> claims = new List<Claim>();

      // Iterate through each of the claim sets in the evaluation context.
      foreach (ClaimSet cs in evaluationContext.ClaimSets)
        // Look for Name claims in the current claimset.
        foreach (Claim c in cs.FindClaims(ClaimTypes.Name, Rights.PossessProperty))
          // Get the list of operations the given username is allowed to call.
          foreach (string s in GetAllowedOpList(c.Resource.ToString()))
          {
            // Add claims to the list.
            claims.Add(new Claim("http://example.org/claims/allowedoperation", s, Rights.PossessProperty));
            Console.WriteLine("Claim added {0}", s);
          }
      
      // Add claims to the evaluation context.
      evaluationContext.AddClaimSet(this, new DefaultClaimSet(this.Issuer,claims));
      
      // Record that claims were added.
      customstate.ClaimsAdded = true;
      
      // Return true, indicating that this method does not need to be called again.
      bRet = true;
    }
    else
    {
      // Should never get here, but just in case, return true.
      bRet = true;
    }
    
    
    return bRet;
  }

  public ClaimSet Issuer
  {
    get { return ClaimSet.System; }
  }
  
  public string Id
  {
    get { return id; }
  }

  // This method returns a collection of action strings that indicate the 
  // operations the specified username is allowed to call.
  private IEnumerable<string> GetAllowedOpList(string username)
  {
    IList<string> ret = new List<string>();
    
    if (username == "test1")
    {
      ret.Add ( "http://Microsoft.ServiceModel.Samples/ICalculator/Add");
      ret.Add ("http://Microsoft.ServiceModel.Samples/ICalculator/Multiply");
      ret.Add("http://Microsoft.ServiceModel.Samples/ICalculator/Subtract");
    }
    else if (username == "test2")
    {
      ret.Add ( "http://Microsoft.ServiceModel.Samples/ICalculator/Add");
      ret.Add ("http://Microsoft.ServiceModel.Samples/ICalculator/Subtract");
    }
    return ret;
  }

  // Internal class for keeping track of state.
  class CustomAuthState
  {
    bool bClaimsAdded;
    
    public CustomAuthState()
    {
      bClaimsAdded = false;
    }
    
    public bool ClaimsAdded { get { return bClaimsAdded; } 
    set {  bClaimsAdded = value; } }
  }
}

Voir aussi

Tâches

Comment : comparer des revendications
Comment : créer un gestionnaire d'autorisations personnalisé pour un service
Authorization Policy

Référence

ServiceAuthorizationManager

Partager via