ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Methode

Referenz

Definition

Namespace:: System.Security.Claims

Assembly:: System.IdentityModel.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Überprüft beim Implementieren in einer abgeleiteten Klasse die Autorisierung für den Antragsteller im angegebenen Kontext, 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, die für die Autorisierung überprüft werden sollen.

Gibt zurück

Boolean

true, wenn das Subjekt berechtigt ist, die angegebene Ressource für die angegebene Aktion auszuführen; andernfalls false.

Beispiele

Die Codebeispiele, die in den ClaimsAuthorizationManager Themen verwendet werden, werden aus dem Claims Based Authorization Beispiel entnommen. In diesem Beispiel wird ein benutzerdefinierter Anspruchsautorisierungs-Manager bereitgestellt, der Themen basierend auf einer Richtlinie autorisieren kann, die in der Konfiguration angegeben ist. Der benutzerdefinierte Anspruchsautorisierungs-Manager besteht aus drei grundlegenden Komponenten: eine Klasse, die vom ClaimsAuthorizationManager Manager abgeleitet wird, die Klasse, die ResourceAction eine Ressource und eine Aktion koppelt, und einen Richtlinienleser, der richtlinien liest 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 Gründen der Kürze angezeigt. Informationen zu diesem Beispiel und anderen Beispielen, die für WIF verfügbar sind und wo sie heruntergeladen werden sollen, finden Sie unter WIF-Codebeispielindex.

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

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 einen der angegebenen Ansprüche besitzen, um die angegebene Aktion für die angegebene Ressource auszuführen. In der zweiten Richtlinie muss der Prinzipal beide Ansprüche besitzen, um die angegebene Aktion für die angegebene Ressource auszuführen. In allen anderen Wird der 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 zurückgibt, gibt falseWindows Identity Foundation (WIF) einen nicht autorisierten Fehler an den Aufrufer zurück. Andernfalls wird die Ausführung an die RP-Anwendung übergeben.

Gilt für