Como: Criar uma política de autorização personalizada

A infraestrutura do Modelo de Identidade no Windows Communication Foundation (WCF) oferece suporte a um modelo de autorização baseado em declarações. As declarações são extraídas de tokens, processadas opcionalmente pela política de autorização personalizada e, em seguida, colocadas num AuthorizationContext, que pode ser examinado para tomar decisões de autorização. Uma política personalizada pode ser usada para transformar declarações de tokens recebidos em declarações esperadas pela aplicação. Dessa forma, a camada de aplicativo pode ser isolada dos detalhes sobre as diferentes declarações servidas pelos diferentes tipos de token que o WCF suporta. Este tópico mostra como implementar uma política de autorização personalizada e como adicioná-la à coleção de políticas usadas por um serviço.

Para implementar uma política de autorização personalizada

1. Defina uma nova classe que deriva de IAuthorizationPolicy.

2. Implemente a propriedade Id somente leitura gerando uma cadeia de caracteres exclusiva no construtor para a classe e retornando essa cadeia de caracteres sempre que a propriedade for acessada.

3. Implemente a propriedade Issuer de leitura única retornando um ClaimSet que representa o emissor da política. Isso pode ser um ClaimSet que representa o aplicativo ou um ClaimSet interno (por exemplo, o ClaimSet retornado pela propriedade System estática.

4. Implemente o método Evaluate(EvaluationContext, Object) conforme descrito no procedimento a seguir.

Para implementar o método Evaluate

1. Dois parâmetros são passados para esse método: uma instância da classe EvaluationContext e uma referência de objeto.

2. Se a política de autorização personalizada adicionar instâncias ClaimSet sem considerar o conteúdo atual do EvaluationContext, adicione cada ClaimSet chamando o método AddClaimSet(IAuthorizationPolicy, ClaimSet) e retorne true do método Evaluate. O retorno true indica à infraestrutura de autorização que a política de autorização executou seu trabalho e não precisa ser chamada novamente.

3. Se a política de autorização personalizada adicionar conjuntos de reivindicações apenas se determinadas reivindicações já estiverem presentes no EvaluationContext, então procure essas reivindicações examinando as instâncias ClaimSet retornadas pela propriedade ClaimSets. Se as declarações estiverem presentes, adicione os novos conjuntos de declarações chamando o método AddClaimSet(IAuthorizationPolicy, ClaimSet) e, se não houver mais conjuntos de declarações a serem adicionados, retorne true, indicando à infraestrutura de autorização que a política de autorização concluiu seu trabalho. Se as declarações não estiverem presentes, retorne false, indicando que a política de autorização deve ser chamada novamente se outras políticas de autorização adicionarem mais conjuntos de declarações ao EvaluationContext.

4. Em cenários de processamento mais complexos, o segundo parâmetro do método Evaluate(EvaluationContext, Object) é usado para armazenar uma variável de estado que a infraestrutura de autorização passará de volta durante cada chamada subsequente para o método Evaluate(EvaluationContext, Object) para uma avaliação específica.

Para especificar uma política de autorização personalizada por meio da configuração

1. Especifique o tipo da política de autorização personalizada no atributo policyType no elemento add no elemento authorizationPolicies no elemento serviceAuthorization.

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

Para especificar uma política de autorização personalizada por meio de código

1. Crie uma List<T> de IAuthorizationPolicy.

2. Crie uma instância da política de autorização personalizada.

3. Adicione a instância da política de autorização à lista.

4. Repita as etapas 2 e 3 para cada política de autorização personalizada.

5. Atribua uma versão somente leitura da lista à propriedade ExternalAuthorizationPolicies.

   // 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();
   

   ' 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()
   

Exemplo

O exemplo a seguir mostra uma implementação IAuthorizationPolicy completa.

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 {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; }
        }
    }
}

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 that 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


        Public Property ClaimsAdded() As Boolean
            Get
                Return bClaimsAdded
            End Get
            Set
                bClaimsAdded = value
            End Set
        End Property
    End Class
End Class

Ver também

• ServiceAuthorizationManager
• Como Comparar Reivindicações
• Como: Criar um Gerenciador de Autorização Personalizado para um Serviço
• Política de Autorização