ClaimsPrincipalPermission Klass

Definition

public ref class ClaimsPrincipalPermission sealed : System::Security::IPermission, System::Security::Permissions::IUnrestrictedPermission

[System.Serializable]
public sealed class ClaimsPrincipalPermission : System.Security.IPermission, System.Security.Permissions.IUnrestrictedPermission

[<System.Serializable>]
type ClaimsPrincipalPermission = class
    interface IPermission
    interface ISecurityEncodable
    interface IUnrestrictedPermission

Public NotInheritable Class ClaimsPrincipalPermission
Implements IPermission, IUnrestrictedPermission

Arv

Object

ClaimsPrincipalPermission

Attribut

SerializableAttribute

Implementeringar

IPermission ISecurityEncodable IUnrestrictedPermission

Exempel

I följande exempel visas hur du skyddar en resurs med hjälp Demand av metoden, CheckAccess metoden eller en ClaimsPrincipalPermissionAttribute deklaration. I varje fall anropas den konfigurerade ClaimsAuthorizationManager för att utvärdera det aktuella huvudkontot mot den angivna resursen och åtgärden. Om det aktuella huvudkontot inte är auktoriserat för den angivna åtgärden på den angivna resursen genereras en SecurityException . Annars fortsätter körningen.

using System;
using System.IdentityModel.Services;
using System.Security.Claims;
using System.Security.Permissions;
using System.Threading;

namespace ClaimsBasedAuthorization
{
    /// <summary>
    /// Program illustrates using Claims-based authorization
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //
            // Method 1. Simple access check using static method. 
            // Expect this to be most common method.
            //
            ClaimsPrincipalPermission.CheckAccess("resource", "action");

            //
            // Method 2. Programmatic check using the permission class
            // Follows model found at http://msdn.microsoft.com/library/system.security.permissions.principalpermission.aspx
            //
            ClaimsPrincipalPermission cpp = new ClaimsPrincipalPermission("resource", "action");
            cpp.Demand();

            //
            // Method 3. Access check interacting directly with the authorization manager.
            //            
            ClaimsAuthorizationManager am = new ClaimsAuthorizationManager();
            am.CheckAccess(new AuthorizationContext((ClaimsPrincipal)Thread.CurrentPrincipal, "resource", "action"));

            //
            // Method 4. Call a method that is protected using the permission attribute class
            //
            ProtectedMethod();

            Console.WriteLine("Press [Enter] to continue.");
            Console.ReadLine();
        }

        //
        // Declarative access check using the permission class. The caller must satisfy both demands.
        //
        [ClaimsPrincipalPermission(SecurityAction.Demand, Resource = "resource", Operation = "action")]
        [ClaimsPrincipalPermission(SecurityAction.Demand, Resource = "resource1", Operation = "action1")]
        static void ProtectedMethod()
        {
        }
    }
}

Följande XML visar den minsta konfiguration som krävs för att använda en anpassad anspråksauktoriseringshanterare med ClaimsPrincipalPermission klassen. Du måste minst deklarera både avsnitten system.identityModelsystem.identityModel.services och i elementet <configSection> och sedan ange din auktoriseringshanterare i ett <claimsAuthorizationManager-element> under standardkonfigurationen för identitet. Detta säkerställer att auktoriseringshanteraren refereras från standardkonfigurationen för federation. Du kan också ange namnet på identitetskonfigurationen under vilken auktoriseringshanteraren anges i identityConfigurationName attributet <federationConfiguration-elementet> .

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <!-- WIF configuration sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    <section name="system.identityModel.services" type="System.IdentityModel.Services.Configuration.SystemIdentityModelServicesSection, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
  </configSections>

  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>

  <system.identityModel>
    <identityConfiguration>
      <claimsAuthorizationManager type ="MyClaimsAuthorizationManager.MyClaimsAuthorizationManager, MyClaimsAuthorizationManager"/>
    </identityConfiguration>
  </system.identityModel>

</configuration>

Kommentarer

Klassen ClaimsPrincipalPermission ger möjlighet att utföra imperativa åtkomstkontroller med hjälp ClaimsAuthorizationManager av det som har konfigurerats för ett program. Genom att Demand anropa metoden eller den statiska CheckAccess metoden kan du skydda resurser inifrån körningssökvägen för koden enligt den auktoriseringsprincip som definierats för din anspråksautentiseringshanterare. Deklarativa åtkomstkontroller kan utföras med hjälp ClaimsPrincipalPermissionAttribute av klassen .

På en nivå liknar funktionerna som tillhandahålls av ClaimsPrincipalPermission de rollbaserade åtkomstkontroller (RBAC) som tillhandahålls via PrincipalPermission klassen. Klassen utför dock ClaimsAuthorizationManager kontroller baserat på de anspråk som presenteras av det aktiva huvudkontot. Detta möjliggör mycket mer kornighet än vad som är tillgängligt via ren RBAC, där många behörigheter vanligtvis samlas in under en enda roll. Kanske, ännu viktigare, anspråksbaserad auktorisering möjliggör bättre uppdelning av affärslogik och auktoriseringsprincip eftersom behörighet kan begäras för en specifik åtgärd på en resurs i kod och serverdelsprincip kan användas för att konfigurera vilka anspråk den presenterande entiteten måste ha för att uppfylla efterfrågan. Precis som RBAC ClaimsPrincipalPermission utför en användarbaserad åtkomstkontroll, det vill säga, till skillnad från kodåtkomstsäkerhet som implementeras av klasser som härleds från CodeAccessPermission klassen och använder en stack-promenad för att säkerställa att alla anropare av koden har beviljats en behörighet, ClaimsPrincipalPermission utför sin kontroll endast på det aktuella huvudkontot.

Den statiska CheckAccess metoden kontrollerar åtkomsten för en angiven åtgärd på en angiven resurs. Resursen och åtgärden är båda strängarna och är vanligtvis URI:er. Du kan också initiera en instans av ClaimsPrincipalPermission med en åtgärd och en resurs och anropa Demand metoden. Konstruktorn tar bara en enda resurs och åtgärd, ClaimsPrincipalPermission men objekt kan kombineras med Union metoderna och Intersect . En behörighet som skapas med hjälp av dessa metoder kan innehålla flera resursåtgärdspar.

Båda metoderna avgör åtkomsten ClaimsAuthorizationManager.CheckAccess genom att anropa metoden för den konfigurerade anspråksauktoriseringshanteraren med ett AuthorizationContext bestående av det aktiva huvudkontot (Thread.CurrentPrincipal), resursen och åtgärden. De genererar en SecurityException om det aktuella huvudkontot inte har behörighet att utföra åtgärden på resursen. Annars fortsätter körningen.

När det gäller ett som innehåller flera resursåtgärdspar anropas ClaimsPrincipalPermission metoden för vart och ett ClaimsAuthorizationManager.CheckAccess av de resursåtgärdspar som ingår i behörigheten. För att anropet ska Demand lyckas måste det aktiva huvudkontot auktoriseras för alla resursåtgärdspar som ingår i behörigheten.

Se även

• ClaimsPrincipalPermissionAttribute
• FederationConfiguration
• ClaimsAuthorizationManager
• <federationConfiguration>