ClaimsAuthorizationManager Klasse

Definition

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

Vererbung

Object

ClaimsAuthorizationManager

Implementiert

ICustomIdentityConfiguration

Beispiele

Die Codebeispiele, die in den ClaimsAuthorizationManager Themen verwendet werden, stammen aus dem Claims Based Authorization Beispiel. Dieses Beispiel stellt einen benutzerdefinierten Anspruchsautorisierungs-Manager bereit, der Subjekte basierend auf einer richtlinie autorisieren kann, die in der Konfiguration angegeben ist. Der Autorisierungs-Manager für benutzerdefinierte Ansprüche besteht aus drei grundlegenden Komponenten: einer von ClaimsAuthorizationManager abgeleiteten Klasse, die den Manager implementiert, der Klasse, die ResourceAction eine Ressource und eine Aktion koppelt, und einem Richtlinienleser, der die in der Konfigurationsdatei angegebene Richtlinie liest und kompiliert. Diese kompilierte Richtlinie kann dann vom Anspruchsautorisierungs-Manager verwendet werden, um einen Prinzipal auszuwerten, um den Zugriff auf Ressourcen zu autorisieren. Nicht alle Elemente werden der Kürze halber angezeigt. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen und zu deren Downloadmöglichkeiten finden Sie unter WIF-Codebeispielindex.

Der folgende Code zeigt die Implementierung des benutzerdefinierten Anspruchsautorisierungs-Managers. Die LoadCustomConfiguration -Methode liest und kompiliert die Richtlinie aus der Konfiguration mithilfe der Hilfsklasse des Richtlinienlesers (nicht angezeigt), und die CheckAccess Methode gewährt oder verweigert den Zugriff basierend auf dieser Richtlinie.

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

Der folgende Code zeigt die klasse, die ResourceAction vom benutzerdefinierten Anspruchs-Manager verwendet wird.

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

Der folgende XML-Code zeigt, wie der oben gezeigte Anspruchsautorisierungs-Manager für eine in IIS 7.5 gehostete Webanwendung konfiguriert wird. Es werden nur die elemente angezeigt, die für die Konfiguration des Anspruchsautorisierungs-Managers spezifisch sind. Beachten Sie, dass der Pipeline unter dem -Element ein Verweis auf ClaimsAuthorizationModule die <system.Webserver> -Klasse hinzugefügt werden muss. Für Websites und Anwendungen, die in IIS-Versionen vor IIS 7 gehostet werden, können die Module der Pipeline unter dem <system.Web> -Element hinzugefügt werden. Diese Konfiguration wird angezeigt, aber auskommentiert.

Die vom Anspruchsautorisierungs-Manager verwendete Richtlinie wird von benutzerdefinierten <policy> Elementen unter dem <claimsAuthorizationManager-Element> angegeben. In der ersten Richtlinie muss der Prinzipal über einen der angegebenen Ansprüche verfügen, um die angegebene Aktion für die angegebene Ressource auszuführen. In der zweiten Richtlinie muss der Prinzipal über beide Ansprüche verfügen, um die angegebene Aktion für die angegebene Ressource ausführen zu können. In allen anderen wird dem Prinzipal automatisch der Zugriff gewährt, unabhängig von den Ansprüchen, die er besitzt.

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

Hinweise

Die ClaimsAuthorizationManager -Klasse stellt die Basisimplementierung für einen Anspruchsautorisierungs-Manager bereit. Ein Anspruchsautorisierungs-Manager kann in den folgenden zwei Szenarien verwendet werden:

• In webbasierten Anwendungen und Diensten kann der Verarbeitungspipeline ein Anspruchsautorisierungs-Manager hinzugefügt werden, um einen Erweiterbarkeitspunkt bereitzustellen, von dem aus Sie den Zugriff auf eine Ressource gemäß dem Wert eingehender Ansprüche autorisieren können, bevor der Anwendungscode aufgerufen wird, der die angeforderte Ressource tatsächlich implementiert.

• Wenn Sie die ClaimsPrincipalPermission -Klasse oder die ClaimsPrincipalPermissionAttribute -Klasse verwenden, um entweder imperative oder deklarative anspruchsbasierte Zugriffsüberprüfungen in Ihrem Code durchzuführen, wird der für Ihre Anwendung konfigurierte Anspruchsautorisierungs-Manager vom System aufgerufen, um die Überprüfung durchzuführen. Anspruchsbasierte Zugriffsüberprüfungen können sowohl in webbasierten Anwendungen als auch in Desktopanwendungen durchgeführt werden.

Die von der -Klasse bereitgestellte Standardimplementierung autorisiert den ClaimsAuthorizationManager Zugriff für jeden dargestellten Anspruch. Sie können jedoch von dieser Klasse ableiten und die CheckAccess -Methode überschreiben, um Ihre eigene Autorisierungslogik bereitzustellen.

Die Verwendung eines Anspruchsautorisierungs-Managers ist optional. Sie können Ihre Anwendung so konfigurieren, dass sie einen Anspruchsautorisierungs-Manager entweder programmgesteuert mithilfe der IdentityConfiguration -Klasse oder deklarativ verwendet, indem Sie das <claimsAuthorizationManager-Element> angeben, das ein untergeordnetes Element des <identityConfiguration-Elements in Ihrer Anwendungskonfigurationsdatei> ist. Wenn Es sich bei Ihrer Anwendung um eine Website oder eine Webanwendung handelt, die in Internetinformationsdiensten (IIS) gehostet wird, müssen Sie auch die ClaimsAuthorizationModule in der sammlung ASP.NET HTTP-Module hinzufügen.

Die ClaimsAuthorizationManager Basisklasse nimmt keine zusätzliche Konfiguration an. Sie können jedoch in abgeleiteten Klassen außer Kraft setzen, um die LoadCustomConfiguration Initialisierung Ihres Anspruchsautorisierungs-Managers aus untergeordneten Elementen des <claimsAuthorizationElement>bereitzustellen. Das typische Szenario besteht darin, diese untergeordneten Elemente zu verwenden, um Autorisierungsrichtlinien anzugeben, die bestimmen, welche Anspruchstypen und Werte erforderlich sind, um Zugriff auf welche Ressource zu erhalten. Dies ist keine harte Anforderung, obwohl Sie die Verwendung und Syntax definieren können, die für Ihre Implementierung sinnvoll ist.

Konstruktoren

Methoden

Gilt für: