ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Metod

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

Parametrar

Returer

trueom ämnet har behörighet att utföra den angivna åtgärden på den angivna resursen; annars . false

Exempel

Kodexemplen som används i ämnena ClaimsAuthorizationManager tas från Claims Based Authorization exemplet. Det här exemplet innehåller en ansvarig för anpassad anspråksauktorisering som kan auktorisera ämnen baserat på en princip som anges i konfigurationen. Hanteraren för anpassade anspråksauktorisering består av tre grundläggande komponenter: en klass som härleds från ClaimsAuthorizationManager som implementerar chefen, ResourceAction klassen som parar ihop en resurs och en åtgärd samt en principläsare som läser och kompilerar en princip som anges i konfigurationsfilen. Den här kompilerade principen kan sedan användas av anspråksauktoriseringshanteraren för att utvärdera ett huvudnamn för att auktorisera åtkomst till resurser. Alla element visas inte för korthetens skull. Information om det här exemplet och andra exempel som är tillgängliga för WIF och var du kan ladda ned dem finns i WIF Code Sample Index.

Följande kod visar åsidosättningen av CheckAccess metoden. Den här metoden beviljar eller nekar åtkomst baserat på en principläsning och kompilering från konfigurationsfilen.

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

Följande kod visar klassen ResourceAction som används av den anpassade anspråkshanteraren.

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

Principen som används av anspråksauktoriseringshanteraren anges av anpassade <policy> element under elementet< claimsAuthorizationManager>. Den här principen läs- och kompileras av LoadCustomConfiguration metoden. I den första principen måste huvudkontot ha ett av de angivna anspråken för att kunna utföra den angivna åtgärden på den angivna resursen. I den andra principen måste huvudkontot ha båda anspråken för att kunna utföra den angivna åtgärden på den angivna resursen. I alla andra beviljas huvudmannen automatiskt åtkomst oavsett vilka anspråk det har.

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

Kommentarer

Basimplementeringen returnerar truealltid , vilket tillåter åtkomst. Du kan åsidosätta den här metoden i en härledd klass för att auktorisera åtkomst baserat på kraven i ditt RP-program. Om den här metoden returnerar false returnerar Windows Identity Foundation (WIF) ett otillåtet fel till anroparen. Annars skickas körningen till RP-programmet.