ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Methode

Definition

Namespace:

System.Security.Claims

Assembly:

System.IdentityModel.dll

Überprüft bei der Implementierung in einer abgeleiteten Klasse die Autorisierung des Betreffs im angegebenen Kontext, um die angegebene Aktion für die angegebene Ressource auszuführen.

public:
 virtual bool CheckAccess(System::Security::Claims::AuthorizationContext ^ context);

public virtual bool CheckAccess(System.Security.Claims.AuthorizationContext context);

abstract member CheckAccess : System.Security.Claims.AuthorizationContext -> bool
override this.CheckAccess : System.Security.Claims.AuthorizationContext -> bool

Public Overridable Function CheckAccess (context As AuthorizationContext) As Boolean

Parameter

context

AuthorizationContext

Der Autorisierungskontext, der den Betreff, die Ressource und die Aktion enthält, für die die Autorisierung überprüft werden soll.

Gibt zurück

Boolean

truewenn der Betreff berechtigt ist, die angegebene Aktion für die angegebene Ressource auszuführen; andernfalls . false

Beispiele

Die Codebeispiele, die in den ClaimsAuthorizationManager Themen verwendet werden, stammen aus dem Claims Based Authorization Beispiel. Dieses Beispiel enthält einen benutzerdefinierten Anspruchsautorisierungs-Manager, der Subjekte basierend auf einer in der Konfiguration angegebenen Richtlinie autorisieren kann. Der benutzerdefinierte Anspruchsautorisierungs-Manager besteht aus drei grundlegenden Komponenten: einer Klasse, die vom ClaimsAuthorizationManager Manager abgeleitet wird, der Klasse, die ResourceAction eine Ressource und eine Aktion koppelt, und einen Richtlinienleser, der richtlinienleset und kompiliert, die in der Konfigurationsdatei angegeben ist. 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 aus Platzgründen angezeigt.

Der folgende Code zeigt die Außerkraftsetzung der CheckAccess Methode. Diese Methode gewährt oder verweigert den Zugriff basierend auf einer Richtlinie, die aus der Konfigurationsdatei gelesen und kompiliert wurde.

static Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>> _policies = new Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>>();
PolicyReader _policyReader = new PolicyReader();

    /// <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 ResourceAction Klasse, die 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;
        }
    }
}

Die vom Anspruchsautorisierungs-Manager verwendete Richtlinie wird durch benutzerdefinierte <policy> Elemente unter dem <ClaimsAuthorizationManager-Element> angegeben. Diese Richtlinie wird von der LoadCustomConfiguration Methode gelesen und kompiliert. 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 Zugriff gewährt, unabhängig von den ansprüchen, die er besitzt.

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

Hinweise

Die Basisimplementierung gibt immer zurück true, was den Zugriff autorisiert. Sie können diese Methode in einer abgeleiteten Klasse außer Kraft setzen, um den Zugriff basierend auf den Anforderungen Ihrer RP-Anwendung zu autorisieren. Wenn diese Methode false zurückgibt, gibt Windows Identity Foundation (WIF) einen nicht autorisierten Fehler an den Aufrufer zurück. Andernfalls wird die Ausführung an die RP-Anwendung übergeben.