Procedura: Creare criteri di autorizzazione personalizzati

L'infrastruttura del modello di identità in Windows Communication Foundation (WCF) supporta un modello di autorizzazione basato su attestazioni. Le attestazioni vengono estratte dai token, elaborate facoltativamente dai criteri di autorizzazione personalizzati e quindi inserite in un AuthorizationContext che può quindi essere esaminato per prendere decisioni di autorizzazione. Un criterio personalizzato può essere usato per trasformare le attestazioni da token in ingresso in attestazioni previste dall'applicazione. In questo modo, il livello applicativo può essere isolato dai dettagli sulle attestazioni diverse offerte dai diversi tipi di token supportati da WCF. Questo argomento illustra come implementare criteri di autorizzazione personalizzati e come aggiungere tale criterio alla raccolta di criteri usati da un servizio.

Per implementare criteri di autorizzazione personalizzati

1. Definire una nuova classe che deriva da IAuthorizationPolicy.

2. Implementare la proprietà Id di sola lettura generando una stringa univoca nel costruttore per la classe e restituendo tale stringa ogni volta che si accede alla proprietà.

3. Implementare la proprietà Issuer di sola lettura restituendo un ClaimSet che rappresenta l'emittente della politica. Può trattarsi di un ClaimSet che rappresenta l'applicazione o un ClaimSet predefinito, ad esempio il ClaimSet restituito dalla proprietà System statica.

4. Implementare il metodo Evaluate(EvaluationContext, Object) come descritto nella procedura seguente.

Per implementare il metodo Evaluate

1. A questo metodo vengono passati due parametri: un'istanza della classe EvaluationContext e un riferimento all'oggetto.

2. Se i criteri di autorizzazione personalizzati aggiungono istanze di ClaimSet senza considerare il contenuto corrente del EvaluationContext, aggiungere ogni ClaimSet chiamando il metodo AddClaimSet(IAuthorizationPolicy, ClaimSet) e restituire true dal metodo Evaluate. La restituzione di true indica all'infrastruttura di autorizzazione che il criterio di autorizzazione ha eseguito il proprio lavoro e non deve essere chiamato di nuovo.

3. Se la politica di autorizzazione personalizzata aggiunge insiemi di attestazioni solo se determinate attestazioni sono già presenti nella EvaluationContext, individuare tali attestazioni esaminando le istanze di ClaimSet restituite dalla proprietà ClaimSets. Se le attestazioni sono presenti, aggiungere i nuovi set di attestazioni chiamando il metodo AddClaimSet(IAuthorizationPolicy, ClaimSet) e, se non devono essere aggiunti altri set di attestazioni, restituire true, a indicare all'infrastruttura di autorizzazione che i criteri di autorizzazione hanno completato il proprio lavoro. Se le attestazioni non sono presenti, restituire false, a indicare che il criterio di autorizzazione deve essere chiamato di nuovo se altri criteri di autorizzazione aggiungono altri set di attestazioni al EvaluationContext.

4. Negli scenari di elaborazione più complessi, il secondo parametro del metodo Evaluate(EvaluationContext, Object) viene usato per archiviare una variabile di stato che l'infrastruttura di autorizzazione passerà di nuovo durante ogni chiamata successiva al metodo Evaluate(EvaluationContext, Object) per una particolare valutazione.

Per specificare criteri di autorizzazione personalizzati tramite la configurazione

1. Specificare il tipo dei criteri di autorizzazione personalizzati nell'attributo policyType nell'elemento add nell'elemento authorizationPolicies nell'elemento serviceAuthorization.

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

Per specificare un criterio di autorizzazione personalizzato tramite codice

1. Creare una List<T> di IAuthorizationPolicy.

2. Creare un'istanza dei criteri di autorizzazione personalizzati.

3. Aggiungere l'istanza dei criteri di autorizzazione all'elenco.

4. Ripetere i passaggi 2 e 3 per ogni criterio di autorizzazione personalizzato.

5. Assegnare una versione di sola lettura dell'elenco alla proprietà 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()
   

Esempio

Nell'esempio seguente viene illustrata un'implementazione completa IAuthorizationPolicy.

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

Vedere anche

• ServiceAuthorizationManager
• Procedura: Confrontare le attestazioni
• Procedura: Creare un gestore autorizzazioni personalizzato per un servizio
• Politica di autorizzazione