ClaimsAuthorizationManager Clase

Referencia

Definición

Espacio de nombres:: System.Security.Claims

Ensamblado:: System.IdentityModel.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Define la implementación base de un administrador de autorización de notificaciones.

public ref class ClaimsAuthorizationManager : System::IdentityModel::Configuration::ICustomIdentityConfiguration

public class ClaimsAuthorizationManager : System.IdentityModel.Configuration.ICustomIdentityConfiguration

type ClaimsAuthorizationManager = class
    interface ICustomIdentityConfiguration

Public Class ClaimsAuthorizationManager
Implements ICustomIdentityConfiguration

Herencia: Object
ClaimsAuthorizationManager

Implementaciones: ICustomIdentityConfiguration

Ejemplos

Los ejemplos de código que se usan en los ClaimsAuthorizationManager temas se toman del Claims Based Authorization ejemplo. En este ejemplo se proporciona un administrador de autorización de notificaciones personalizado que puede autorizar a los sujetos en función de una directiva especificada en la configuración. El administrador de autorización de notificaciones personalizada consta de tres componentes básicos: una clase derivada de ClaimsAuthorizationManager que implementa el administrador, la ResourceAction clase que empareja un recurso y una acción, y un lector de directivas que lee y compila la directiva especificada en el archivo de configuración. A continuación, el administrador de autorización de notificaciones puede usar esta directiva compilada para evaluar una entidad de seguridad con el fin de autorizar el acceso a los recursos. No todos los elementos se muestran por motivos de brevedad. Para obtener información sobre este ejemplo y otros ejemplos disponibles para WIF y sobre dónde descargarlos, consulte Índice de ejemplo de código wiF.

En el código siguiente se muestra la implementación del administrador de autorización de notificaciones personalizado. El LoadCustomConfiguration método lee y compila la directiva a partir de la configuración mediante la clase auxiliar del lector de directivas (no se muestra) y el CheckAccess método concede o deniega el acceso en función de esta directiva.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Security.Claims;
using System.Xml;

namespace ClaimsAuthorizationLibrary
{
    /// <summary>
    /// Simple ClaimsAuthorizationManager implementation that reads policy information from the .config file
    /// </summary>
    public class MyClaimsAuthorizationManager : ClaimsAuthorizationManager
    {
        static Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>> _policies = new Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>>();
        PolicyReader _policyReader = new PolicyReader();

        /// <summary>
        /// Creates a new instance of the MyClaimsAuthorizationManager
        /// </summary>        
        public MyClaimsAuthorizationManager()
        {
        }

        /// <summary>
        /// Overloads  the base class method to load the custom policies from the config file
        /// </summary>
        /// <param name="nodelist">XmlNodeList containing the policy information read from the config file</param>
        public override void LoadCustomConfiguration(XmlNodeList nodelist)
        {
            Expression<Func<ClaimsPrincipal, bool>> policyExpression;

            foreach (XmlNode node in nodelist)
            {
                //
                // Initialize the policy cache
                //
                XmlDictionaryReader rdr = XmlDictionaryReader.CreateDictionaryReader(new XmlTextReader(new StringReader(node.OuterXml)));
                rdr.MoveToContent();

                string resource = rdr.GetAttribute("resource");
                string action = rdr.GetAttribute("action");

                policyExpression = _policyReader.ReadPolicy(rdr);

                //
                // Compile the policy expression into a function
                //
                Func<ClaimsPrincipal, bool> policy = policyExpression.Compile();

                //
                // Insert the policy function into the policy cache
                //
                _policies[new ResourceAction(resource, action)] = policy;
            }
        }

        /// <summary>
        /// Checks if the principal specified in the authorization context is authorized to perform action specified in the authorization context 
        /// on the specified resoure
        /// </summary>
        /// <param name="pec">Authorization context</param>
        /// <returns>true if authorized, false otherwise</returns>
        public override bool CheckAccess(AuthorizationContext pec)
        {
            //
            // Evaluate the policy against the claims of the 
            // principal to determine access
            //
            bool access = false;
            try
            {
                ResourceAction ra = new ResourceAction(pec.Resource.First<Claim>().Value, pec.Action.First<Claim>().Value);

                access = _policies[ra](pec.Principal);
            }
            catch (Exception)
            {
                access = false;
            }

            return access;
        }
    }
}

En el código siguiente se muestra la ResourceAction clase usada por el administrador de notificaciones personalizado.

using System;

namespace ClaimsAuthorizationLibrary
{
    /// <summary>
    /// Class to encapsulate resource/action pair
    /// </summary>
    public class ResourceAction
    {
        public string Resource;
        public string Action;

        /// <summary>
        /// Checks if the current instance is equal to the given object by comparing the resource and action values
        /// </summary>
        /// <param name="obj">object to compare to</param>
        /// <returns>True if equal, else false.</returns>
        public override bool Equals(object obj)
        {
            ResourceAction ra = obj as ResourceAction;
            if (ra != null)
            {
                return ((string.Compare(ra.Resource, Resource, true) == 0) && (string.Compare(ra.Action, Action, true) == 0));
            }

            return base.Equals(obj);
        }

        /// <summary>
        /// Gets the hash code.
        /// </summary>
        /// <returns>The hash code.</returns>
        public override int GetHashCode()
        {
            return (Resource + Action).ToLower().GetHashCode();
        }

        /// <summary>
        /// Creates an instance of ResourceAction class.
        /// </summary>
        /// <param name="resource">The resource name.</param>
        /// <param name="action">The action.</param>
        /// <exception cref="ArgumentNullException">when <paramref name="resource"/> is null</exception>
        public ResourceAction(string resource, string action)
        {
            if (string.IsNullOrEmpty(resource))
            {
                throw new ArgumentNullException("resource");
            }

            Resource = resource;
            Action = action;
        }
    }
}

El siguiente XML muestra cómo configurar el administrador de autorización de notificaciones mostrado anteriormente para una aplicación web hospedada en IIS 7.5. Solo se muestran los elementos específicos de la configuración del administrador de autorización de notificaciones. Tenga en cuenta que se debe agregar una referencia a la ClaimsAuthorizationModule clase a la canalización en el <system.Webserver> elemento . En el caso de sitios y aplicaciones hospedadas en versiones de IIS anteriores a IIS 7, los módulos se pueden agregar a la canalización en el <system.Web> elemento . Esta configuración se muestra pero se comenta.

La directiva usada por el administrador de autorización de notificaciones se especifica mediante elementos personalizados <policy> en el <elemento claimsAuthorizationManager> . En la primera directiva, la entidad de seguridad debe poseer una de las notificaciones especificadas para realizar la acción especificada en el recurso especificado. En la segunda directiva, la entidad de seguridad debe poseer ambas notificaciones para poder realizar la acción especificada en el recurso especificado. En todos los demás, la entidad de seguridad se concede automáticamente acceso independientemente de las reclamaciones que posee.

<configuration>
  <configSections>
    <!--WIF 4.5 sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    ...

  </configSections>

  ...

  <system.web>
    <httpModules>
      <!--WIF 4.5 modules -->
      <!--Not needed here for IIS >= 7 -->
      <!--<add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>-->
    </httpModules>
  </system.web>

  ...

  <system.webServer>
    <modules>
      <!--WIF 4.5 modules -->
      <add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </modules>
  </system.webServer>

  ...

  <!-- WIF 4.5 s.im section-->
  <system.identityModel>
    <identityConfiguration>
      <claimsAuthorizationManager type="ClaimsAuthorizationLibrary.MyClaimsAuthorizationManager, ClaimsAuthorizationLibrary">
        <policy resource="http://localhost:28491/Developers.aspx" action="GET">
          <or>
            <claim claimType="http://schemas.microsoft.com/ws/2008/06/identity/claims/role" claimValue="developer" />
            <claim claimType="http://schemas.xmlsoap.org/claims/Group" claimValue="Administrator" />
          </or>
        </policy>
        <policy resource="http://localhost:28491/Administrators.aspx" action="GET">
          <and>
            <claim claimType="http://schemas.xmlsoap.org/claims/Group" claimValue="Administrator" />
            <claim claimType="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/country" claimValue="USA" />
          </and>
        </policy>
        <policy resource="http://localhost:28491/Default.aspx" action="GET">
        </policy>
        <policy resource="http://localhost:28491/" action="GET">
        </policy>
        <policy resource="http://localhost:28491/Claims.aspx" action="GET">
        </policy>
      </claimsAuthorizationManager>

      ...

    </identityConfiguration>
  </system.identityModel>
  ...

</configuration><configuration>
  <configSections>
    <!--WIF 4.5 sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    ...

  </configSections>

  ...

  <system.web>
    <httpModules>
      <!--WIF 4.5 modules -->
      <!--Not needed here for IIS >= 7 -->
      <!--<add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>-->
    </httpModules>
  </system.web>

  ...

  <system.webServer>
    <modules>
      <!--WIF 4.5 modules -->
      <add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </modules>
  </system.webServer>

  ...

  <!-- WIF 4.5 s.im section-->
  <system.identityModel>
    <identityConfiguration>
      <claimsAuthorizationManager type="MyClaimsAuthorizationManager.SimpleClaimsAuthorizationManager, MyClaimsAuthorizationManager" />
      ...

  </system.identityModel>
  ...

</configuration>

Comentarios

La ClaimsAuthorizationManager clase proporciona la implementación base para un administrador de autorización de notificaciones. Un administrador de autorización de notificaciones se puede usar en los dos escenarios siguientes:

En los servicios y aplicaciones basados en web, se puede agregar un administrador de autorización de notificaciones a la canalización de procesamiento para proporcionar un punto de extensibilidad desde el que se puede autorizar el acceso a un recurso según el valor de las notificaciones entrantes antes de que se llame al código de aplicación que implementa realmente el recurso solicitado.
Cuando se usa la ClaimsPrincipalPermission clase o la ClaimsPrincipalPermissionAttribute clase para realizar comprobaciones de acceso basadas en notificaciones imperativas o declarativas en el código, el sistema llama al administrador de autorización de notificaciones configurado para la aplicación para realizar la comprobación. Las comprobaciones de acceso basadas en notificaciones se pueden realizar tanto en aplicaciones basadas en web como en aplicaciones de escritorio.

La implementación predeterminada proporcionada por la ClaimsAuthorizationManager clase autoriza el acceso para cada notificación presentada; sin embargo, puede derivar de esta clase e invalidar el CheckAccess método para proporcionar su propia lógica de autorización.

El uso de un administrador de autorización de notificaciones es opcional. Puede configurar la aplicación para que use un administrador de autorización de notificaciones mediante programación mediante la IdentityConfiguration clase o mediante declaración, especificando el <elemento claimsAuthorizationManager>, que es un elemento secundario del elemento identityConfiguration> en el< archivo de configuración de la aplicación. Si la aplicación es un sitio web o una aplicación web hospedada en Internet Information Services (IIS), también debe agregar en ClaimsAuthorizationModule la colección módulos HTTP de ASP.NET.

Importante

Cuando se usa la ClaimsPrincipalPermission clase o la ClaimsPrincipalPermissionAttribute clase , el administrador de autorización de notificaciones que se usa para realizar la comprobación de acceso es el que se especifica en la configuración de identidad en la FederatedAuthentication.FederationConfiguration propiedad . En un archivo de configuración, es la sección a la <identityConfiguration> que se hace referencia desde el elemento predeterminado <federationConfiguration> . Esto es cierto incluso para los servicios y aplicaciones de escritorio de Windows Communication Foundation (WCF).

La ClaimsAuthorizationManager clase base no toma ninguna configuración adicional; sin embargo, puede invalidar las LoadCustomConfiguration clases derivadas para proporcionar inicialización del administrador de autorización de notificaciones de los elementos secundarios de <claimsAuthorizationElement>. El escenario típico consiste en usar estos elementos secundarios para especificar directivas de autorización que determinan qué tipos y valores de notificación son necesarios para obtener acceso a qué recurso. Esto no es un requisito difícil, aunque es libre de definir cualquier uso y sintaxis que tenga sentido para la implementación.

Constructores

ClaimsAuthorizationManager()

Inicializa una nueva instancia de la clase ClaimsAuthorizationManager.

Métodos

CheckAccess(AuthorizationContext)	Cuando se implementa en una clase derivada, comprueba la autorización para el asunto en el contexto especificado para realizar la acción especificada en el recurso especificado.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
LoadCustomConfiguration(XmlNodeList)	Cuando se reemplaza en una clase derivada, carga la configuración personalizada de XML.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Se aplica a

Comparteix a través de