ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Security.Claims

Assembly:: System.IdentityModel.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Una volta eseguita l'implementazione in una classe derivata, controlla l'autorizzazione per il soggetto nel contesto specificato per eseguire l'azione specificata nella risorsa specificata.

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

context: AuthorizationContext

Il contesto di autorizzazione che contiene l'oggetto, la risorsa e l'azione per cui deve essere controllata l'autorizzazione.

Restituisce

Boolean

true se il soggetto è autorizzato a eseguire l'azione specificata nella risorsa specificata; in caso contrario, false.

Esempio

Gli esempi di codice usati negli ClaimsAuthorizationManager argomenti vengono acquisiti dall'esempio Claims Based Authorization . In questo esempio viene fornito un gestore di autorizzazione 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 la gestione, la ResourceAction classe che associa una risorsa e un'azione 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 responsabile autorizzazioni attestazioni per valutare un'entità per autorizzare l'accesso alle risorse. Non tutti gli elementi vengono visualizzati per motivi di brevità. Per informazioni su questo esempio e altri esempi disponibili per WIF e su dove scaricarli, vedere Indice di esempio di codice WIF.

Il codice seguente mostra l'override CheckAccess del 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 mostra la ResourceAction classe usata dal gestore 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;
        }
    }
}

Il criterio usato dal gestore autorizzazioni attestazioni viene specificato dagli elementi personalizzati <policy> nell'elemento <claimsAuthorizationManager> . Questo criterio viene letto e compilato dal LoadCustomConfiguration metodo . Nel primo criterio, l'entità deve disporre di una delle attestazioni specificate per eseguire l'azione specificata nella risorsa specificata. Nel secondo criterio, l'entità deve disporre di entrambe le attestazioni per poter eseguire l'azione specificata nella risorsa specificata. In tutti gli altri, l'entità viene concessa 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.

Si applica a

Condividi tramite