ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Méthode

Référence

Définition

Espace de noms:: System.Security.Claims

Assembly:: System.IdentityModel.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

En cas d'implémentation dans une classe dérivée, vérifie l'autorisation du sujet dans le contexte spécifié pour effectuer l'action spécifiée sur la ressource spécifiée.

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

Paramètres

context: AuthorizationContext

Contexte d'autorisation contenant le sujet, la ressource et l'action pour laquelle l'autorisation doit être vérifiée.

Retours

Boolean

true si le sujet est autorisé à exécuter l'action spécifiée dans la ressource spécifiée ; sinon, false.

Exemples

Les exemples de code utilisés dans les rubriques sont extraits de l’exemple ClaimsAuthorizationManager Claims Based Authorization . Cet exemple fournit un gestionnaire d’autorisation de revendications personnalisé qui peut autoriser des sujets basés sur une stratégie spécifiée dans la configuration. Le gestionnaire d’autorisation des revendications personnalisées se compose de trois composants de base : une classe dérivée qui ClaimsAuthorizationManager implémente le gestionnaire, la ResourceAction classe qui associe une ressource et une action, et un lecteur de stratégie qui lit et compile la stratégie spécifiée dans le fichier de configuration. Cette stratégie compilée peut ensuite être utilisée par le gestionnaire d’autorisations de revendications pour évaluer un principal afin d’autoriser l’accès aux ressources. Tous les éléments ne sont pas affichés pour la concision. Pour plus d’informations sur cet exemple et d’autres exemples disponibles pour WIF et sur l’emplacement de téléchargement, consultez l’exemple de code WIF.

Le code suivant montre le remplacement de la CheckAccess méthode. Cette méthode accorde ou refuse l’accès en fonction d’une stratégie lue et compilée à partir du fichier de configuration.

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

Le code suivant montre la ResourceAction classe utilisée par le gestionnaire de revendications personnalisées.


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

La stratégie utilisée par le gestionnaire d’autorisation des revendications est spécifiée par des éléments personnalisés <policy> sous l’élément <claimsAuthorizationManager> . Cette stratégie est lue et compilée par la LoadCustomConfiguration méthode. Dans la première stratégie, le principal doit posséder l’une des revendications spécifiées pour effectuer l’action spécifiée sur la ressource spécifiée. Dans la deuxième stratégie, le principal doit posséder les deux revendications pour pouvoir effectuer l’action spécifiée sur la ressource spécifiée. Dans tous les autres, le principal est automatiquement autorisé à accéder, quelle que soit la revendication qu’il possède.

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

Remarques

L’implémentation de base retourne truetoujours, ce qui autorise l’accès. Vous pouvez remplacer cette méthode dans une classe dérivée pour autoriser l’accès en fonction des exigences de votre application rp. Si cette méthode retourne false, Windows Identity Foundation (WIF) retourne une erreur non autorisée à l’appelant ; sinon, l’exécution est transmise à l’application rp.

S’applique à