Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Interfaz IAuthorizationPolicy

 

Publicado: noviembre de 2016

Define un conjunto de reglas para autorizar a un usuario, según un conjunto de demandas.

Espacio de nombres:   System.IdentityModel.Policy
Ensamblado:  System.IdentityModel (en System.IdentityModel.dll)

public interface IAuthorizationPolicy : IAuthorizationComponent

NombreDescripción
System_CAPS_pubpropertyId

Obtiene una cadena que identifica este componente de autorización.(Heredado de IAuthorizationComponent).

System_CAPS_pubpropertyIssuer

Obtiene un conjunto de demandas que representa al emisor de la directiva de autorización.

NombreDescripción
System_CAPS_pubmethodEvaluate(EvaluationContext, Object)

Evalúa si un usuario cumple los requisitos para esta directiva de autorización.

Implemente la interfaz IAuthorizationPolicy para agregar o asignar un conjunto de demandas a otro. Una directiva de autorización examina un conjunto de demandas y agrega demandas adicionales según el conjunto actual. Por ejemplo, una directiva de autorización podría evaluar una demanda que contenga la fecha de nacimiento y agregar una demanda que valide que el usuario es mayor de 21 años y agregar una demanda de edad superior a 21 a la EvaluationContext.

Las clases que implementan la interfaz IAuthorizationPolicy no autorizan a los usuarios, pero sí se lo permiten a la clase ServiceAuthorizationManager. ServiceAuthorizationManager llama al método Evaluate para cada directiva de autorización. El método Evaluate determina si las demandas adicionales se deberían agregar para el usuario, según el contexto actual. Se puede llamar al método Evaluate de una directiva de autorización varias veces, cuando las demandas se agregan a EvaluationContext a través de otras directivas de autorización. Cuando se realizan todas las directivas de autorización, la clase ServiceAuthorizationManager toma decisiones de autorización basadas en el conjunto final de demandas. La clase ServiceAuthorizationManager crea a continuación una AuthorizationContext que contiene un conjunto inmutable de demandas que refleja estas decisiones de autorización.

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 state is null, then this method has not been called before, so 
        // set up a custom state.
        if (state == null)
        {
            customstate = new CustomAuthState();
            state = customstate;
        }
        else
            customstate = (CustomAuthState)state;

        Console.WriteLine("Inside MyAuthorizationPolicy::Evaluate");

        // 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 claim set.
                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 have been added.
            customstate.ClaimsAdded = true;

            // Return true, which indicates this need not be called again.
            bRet = true;
        }
        else
        {
            // This point should not be reached, but just in case...
            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 that 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 state
    class CustomAuthState
    {
        bool bClaimsAdded;

        public CustomAuthState()
        {
            bClaimsAdded = false;
        }

        public bool ClaimsAdded { get { return bClaimsAdded; } 
                                  set {  bClaimsAdded = value; } }
    }
}

.NET Framework
Disponible desde 3.0
Volver al principio
Mostrar: