ClaimsAuthorizationManager Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System.Security.Claims

Zestaw:: System.IdentityModel.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Definiuje podstawową implementację menedżera autoryzacji oświadczeń.

public ref class ClaimsAuthorizationManager : System::IdentityModel::Configuration::ICustomIdentityConfiguration

public class ClaimsAuthorizationManager : System.IdentityModel.Configuration.ICustomIdentityConfiguration

type ClaimsAuthorizationManager = class
    interface ICustomIdentityConfiguration

Public Class ClaimsAuthorizationManager
Implements ICustomIdentityConfiguration

Dziedziczenie: Object
ClaimsAuthorizationManager

Implementuje: ICustomIdentityConfiguration

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 implementację niestandardowego menedżera autoryzacji oświadczeń. Metoda LoadCustomConfiguration odczytuje i kompiluje zasady z konfiguracji przy użyciu klasy pomocnika czytnika zasad (nie pokazano) oraz CheckAccess metody przyznaje lub odmawia dostępu na podstawie tych zasad.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Security.Claims;
using System.Xml;

namespace ClaimsAuthorizationLibrary
{
    /// <summary>
    /// Simple ClaimsAuthorizationManager implementation that reads policy information from the .config file
    /// </summary>
    public class MyClaimsAuthorizationManager : ClaimsAuthorizationManager
    {
        static Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>> _policies = new Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>>();
        PolicyReader _policyReader = new PolicyReader();

        /// <summary>
        /// Creates a new instance of the MyClaimsAuthorizationManager
        /// </summary>        
        public MyClaimsAuthorizationManager()
        {
        }

        /// <summary>
        /// Overloads  the base class method to load the custom policies from the config file
        /// </summary>
        /// <param name="nodelist">XmlNodeList containing the policy information read from the config file</param>
        public override void LoadCustomConfiguration(XmlNodeList nodelist)
        {
            Expression<Func<ClaimsPrincipal, bool>> policyExpression;

            foreach (XmlNode node in nodelist)
            {
                //
                // Initialize the policy cache
                //
                XmlDictionaryReader rdr = XmlDictionaryReader.CreateDictionaryReader(new XmlTextReader(new StringReader(node.OuterXml)));
                rdr.MoveToContent();

                string resource = rdr.GetAttribute("resource");
                string action = rdr.GetAttribute("action");

                policyExpression = _policyReader.ReadPolicy(rdr);

                //
                // Compile the policy expression into a function
                //
                Func<ClaimsPrincipal, bool> policy = policyExpression.Compile();

                //
                // Insert the policy function into the policy cache
                //
                _policies[new ResourceAction(resource, action)] = policy;
            }
        }

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

Poniższy kod XML przedstawia sposób konfigurowania menedżera autoryzacji oświadczeń pokazanego powyżej dla aplikacji internetowej hostowanej w usługach IIS 7.5. Wyświetlane są tylko elementy specyficzne dla konfiguracji menedżera autoryzacji oświadczeń. Należy pamiętać, że odwołanie do klasy musi zostać dodane do ClaimsAuthorizationModule potoku w elemencie <system.Webserver> . W przypadku witryn i aplikacji hostowanych w wersjach usług IIS przed usługami IIS 7 moduły można dodać do potoku pod elementem <system.Web> . Ta konfiguracja jest wyświetlana, ale oznaczona jako komentarz.

Zasady używane przez menedżera autoryzacji oświadczeń są określane przez elementy niestandardowe <policy> w <ramach elementu claimsAuthorizationManager> . 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ń.

<configuration>
  <configSections>
    <!--WIF 4.5 sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    ...

  </configSections>

  ...

  <system.web>
    <httpModules>
      <!--WIF 4.5 modules -->
      <!--Not needed here for IIS >= 7 -->
      <!--<add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>-->
    </httpModules>
  </system.web>

  ...

  <system.webServer>
    <modules>
      <!--WIF 4.5 modules -->
      <add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </modules>
  </system.webServer>

  ...

  <!-- WIF 4.5 s.im section-->
  <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>
  ...

</configuration><configuration>
  <configSections>
    <!--WIF 4.5 sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    ...

  </configSections>

  ...

  <system.web>
    <httpModules>
      <!--WIF 4.5 modules -->
      <!--Not needed here for IIS >= 7 -->
      <!--<add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>-->
    </httpModules>
  </system.web>

  ...

  <system.webServer>
    <modules>
      <!--WIF 4.5 modules -->
      <add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </modules>
  </system.webServer>

  ...

  <!-- WIF 4.5 s.im section-->
  <system.identityModel>
    <identityConfiguration>
      <claimsAuthorizationManager type="MyClaimsAuthorizationManager.SimpleClaimsAuthorizationManager, MyClaimsAuthorizationManager" />
      ...

  </system.identityModel>
  ...

</configuration>

Uwagi

Klasa ClaimsAuthorizationManager zapewnia podstawową implementację menedżera autoryzacji oświadczeń. Menedżer autoryzacji oświadczeń może być używany w następujących dwóch scenariuszach:

W aplikacjach i usługach internetowych menedżer autoryzacji oświadczeń można dodać do potoku przetwarzania w celu zapewnienia punktu rozszerzalności, z którego można autoryzować dostęp do zasobu zgodnie z wartością oświadczeń przychodzących przed wywołania kodu aplikacji, który faktycznie implementuje żądany zasób.
Jeśli używasz klasy lub ClaimsPrincipalPermissionAttribute klasy do przeprowadzania kontroli dostępu opartej ClaimsPrincipalPermission na oświadczeniach imperatywnych lub deklaratywnych w kodzie, menedżer autoryzacji oświadczeń skonfigurowany dla aplikacji jest wywoływany przez system w celu sprawdzenia. Kontrole dostępu oparte na oświadczeniach można przeprowadzić zarówno w aplikacjach internetowych, jak i aplikacjach klasycznych.

Domyślna implementacja zapewniana przez klasę ClaimsAuthorizationManager autoryzuje dostęp dla każdego przedstawionego oświadczenia. Jednak można pochodzić z tej klasy i zastąpić metodę CheckAccess w celu zapewnienia własnej logiki autoryzacji.

Użycie menedżera autoryzacji oświadczeń jest opcjonalne. Aplikację można skonfigurować tak, aby korzystała z menedżera autoryzacji oświadczeń programowo przy użyciu IdentityConfiguration klasy lub deklaratywnie, określając <element claimsAuthorizationManager> , który jest elementem <podrzędnym elementu identityConfiguration> w pliku konfiguracji aplikacji. Jeśli aplikacja jest witryną sieci Web lub aplikacją internetową hostowaną w usługach Internet Information Services (IIS), należy również dodać element ClaimsAuthorizationModule w kolekcji modułów HTTP ASP.NET.

Ważne

W przypadku korzystania z ClaimsPrincipalPermission klasy lub ClaimsPrincipalPermissionAttribute klasy menedżer autoryzacji oświadczeń używany do sprawdzania dostępu jest tym, który jest określony w konfiguracji tożsamości w FederatedAuthentication.FederationConfiguration ramach właściwości . W pliku konfiguracji jest <identityConfiguration> to sekcja, do którego odwołuje się element domyślny <federationConfiguration> . Dotyczy to nawet usług Windows Communication Foundation (WCF) i aplikacji klasycznych.

Klasa ClaimsAuthorizationManager bazowa nie ma żadnej dodatkowej konfiguracji, ale można zastąpić LoadCustomConfiguration klas pochodnych w celu zapewnienia inicjowania menedżera autoryzacji oświadczeń z elementów podrzędnych .<claimsAuthorizationElement> Typowym scenariuszem jest użycie tych elementów podrzędnych do określenia zasad autoryzacji, które określają, które typy i wartości oświadczeń są wymagane w celu uzyskania dostępu do którego zasobu. Nie jest to trudne wymaganie, chociaż możesz zdefiniować, jakie użycie i składnia mają sens w implementacji.

Konstruktory

ClaimsAuthorizationManager()

Inicjuje nowe wystąpienie klasy ClaimsAuthorizationManager.

Metody

CheckAccess(AuthorizationContext)	Po zaimplementowaniu w klasie pochodnej sprawdza autoryzację podmiotu w określonym kontekście, aby wykonać określoną akcję dla określonego zasobu.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
LoadCustomConfiguration(XmlNodeList)	Po zastąpieniu w klasie pochodnej ładuje konfigurację niestandardową z pliku XML.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Dotyczy