ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Metodo

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

Parametri

Valori restituiti

true se l'oggetto è autorizzato a eseguire l'azione specificata sulla risorsa specificata; in caso contrario, false.

Esempio

Gli esempi di codice usati negli ClaimsAuthorizationManager argomenti sono tratti dall'esempio Claims Based Authorization . Questo esempio fornisce un gestore di autorizzazione delle attestazioni personalizzato che può autorizzare soggetti in base a un criterio specificato nella configurazione. Gestione autorizzazioni attestazioni personalizzate è costituita da tre componenti di base: una classe derivata da ClaimsAuthorizationManager che implementa il gestore, la ResourceAction classe che associa una risorsa e un'azione e un lettore di criteri che legge e compila i criteri specificati nel file di configurazione. Questo criterio compilato può quindi essere usato dal gestore autorizzazioni attestazioni per valutare un'entità per autorizzare l'accesso alle risorse. Non tutti gli elementi vengono visualizzati per brevità.

Il codice seguente illustra l'override del CheckAccess metodo . Questo metodo concede o nega l'accesso in base a un criterio letto e compilato dal file di configurazione.

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

Il codice seguente illustra la ResourceAction classe usata dal gestore di attestazioni personalizzate.

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

I criteri usati dal gestore autorizzazioni attestazioni vengono specificati da elementi personalizzati <policy> nell'elemento <claimsAuthorizationManager> . Questo criterio viene letto e compilato dal LoadCustomConfiguration metodo . Nel primo criterio, l'entità deve possedere una delle attestazioni specificate per eseguire l'azione specificata sulla risorsa specificata. Nel secondo criterio, l'entità deve possedere entrambe le attestazioni per poter eseguire l'azione specificata sulla risorsa specificata. In tutti gli altri, all'entità viene concesso automaticamente l'accesso indipendentemente dalle attestazioni che possiede.

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

Commenti

L'implementazione di base restituisce truesempre , che autorizza l'accesso. È possibile eseguire l'override di questo metodo in una classe derivata per autorizzare l'accesso in base ai requisiti dell'applicazione rp. Se questo metodo restituisce false, Windows Identity Foundation (WIF) restituisce un errore non autorizzato al chiamante; in caso contrario, l'esecuzione viene passata all'applicazione RP.