ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Metoda

Definicja

Przestrzeń nazw:

System.Security.Claims

Zestaw:

System.IdentityModel.dll

Po zaimplementowaniu w klasie pochodnej sprawdza autoryzację podmiotu w określonym kontekście, aby wykonać określoną akcję dla określonego zasobu.

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

Parametry

context

AuthorizationContext

Kontekst autoryzacji, który zawiera temat, zasób i akcję, dla której ma zostać sprawdzona autoryzacja.

Zwraca

Boolean

true jeśli podmiot jest autoryzowany do wykonywania określonej akcji na określonym zasobie; w przeciwnym razie , false.

Przykłady

Przykłady kodu używane w tematach ClaimsAuthorizationManager pochodzą z przykładu Claims Based Authorization . Ten przykład zawiera niestandardowego menedżera autoryzacji oświadczeń, który może autoryzować podmioty na podstawie zasad określonych w konfiguracji. Menedżer autoryzacji oświadczeń niestandardowych składa się z trzech podstawowych składników: klasy pochodnej z ClaimsAuthorizationManager niej, która implementuje menedżera, ResourceAction klasę, która łączy zasób i akcję, oraz czytnik zasad, który odczytuje i kompiluje zasady określone w pliku konfiguracji. Te skompilowane zasady mogą być następnie używane przez menedżera autoryzacji oświadczeń do oceny podmiotu zabezpieczeń w celu autoryzowania dostępu do zasobów. Nie wszystkie elementy są wyświetlane ze względu na zwięzłość. Aby uzyskać informacje o tym przykładzie i innych przykładach dostępnych dla programu WIF oraz o tym, gdzie je pobrać, zobacz Przykładowy indeks kodu programu WIF.

Poniższy kod przedstawia zastąpienie CheckAccess metody . Ta metoda udziela lub odmawia dostępu na podstawie zasad odczytanych i skompilowanych z pliku konfiguracji.

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

Poniższy kod przedstawia klasę ResourceAction używaną przez menedżera oświadczeń niestandardowych.

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

Zasady używane przez menedżera autoryzacji oświadczeń są określane przez elementy niestandardowe <policy> w <ramach elementu claimsAuthorizationManager> . Te zasady są odczytywane i kompilowane przez metodę LoadCustomConfiguration . W pierwszych zasadach podmiot zabezpieczeń musi posiadać jedno z określonych oświadczeń, aby wykonać określoną akcję dla określonego zasobu. W drugiej zasadach podmiot zabezpieczeń musi posiadać oba oświadczenia, aby móc wykonać określoną akcję dla określonego zasobu. We wszystkich innych podmiotach podmiot zabezpieczeń jest automatycznie udzielany dostępu niezależnie od posiadanych przez nią roszczeń.

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

Uwagi

Implementacja podstawowa zawsze zwraca wartość true, która autoryzuje dostęp. Tę metodę można zastąpić w klasie pochodnej, aby autoryzować dostęp na podstawie wymagań aplikacji rp. Jeśli ta metoda zwróci metodę false, Windows Identity Foundation (WIF) zwraca nieautoryzowany błąd do elementu wywołującego. W przeciwnym razie wykonanie jest przekazywane do aplikacji rp.