SecurityTokenService Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System.IdentityModel

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.

Abstrakcyjna klasa bazowa, która definiuje właściwości i metody usługi tokenu zabezpieczającego (STS).

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Dziedziczenie: Object
SecurityTokenService

Przykłady

Przykłady kodu używane w tematach SecurityTokenService pochodzą z przykładu Custom Token . Ten przykład zawiera niestandardowe klasy, które umożliwiają przetwarzanie prostych tokenów sieci Web (SWT) i obejmują implementację pasywnej usługi STS, która może obsługiwać token SWT. Przykład implementacji aktywnej usługi STS można znaleźć w przykładzie Federation Metadata . Aby uzyskać informacje o tych przykładach 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ę pasywnej usługi STS przy użyciu SecurityTokenService klasy .

using System;
using System.IdentityModel;
using System.IdentityModel.Configuration;
using System.IdentityModel.Protocols.WSTrust;
using System.IdentityModel.Tokens;
using System.Security.Claims;
using System.Security.Cryptography.X509Certificates;

namespace PassiveSTS
{
    /// <summary>
    /// Overrides the SecurityTokenService class to provide
    /// the relying party related information, such as encryption credentials to encrypt the issued
    /// token, signing credentials to sign the issued token, claims that the STS wants to issue for a 
    /// certain token request, as well as the claim types that this STS is capable
    /// of issuing.
    /// </summary>
    public class CustomSecurityTokenService : SecurityTokenService
    {
        // Certificate Constants
        private const string SIGNING_CERTIFICATE_NAME = "CN=localhost";
        private const string ENCRYPTING_CERTIFICATE_NAME = "CN=localhost";

        private SigningCredentials _signingCreds;
        private EncryptingCredentials _encryptingCreds;
        // Used for validating applies to address, set to URI used in RP app of application, could also have been done via config
        private string _addressExpected = "http://localhost:19851/";
        public CustomSecurityTokenService(SecurityTokenServiceConfiguration configuration)
            : base(configuration)
        {
            // Setup the certificate our STS is going to use to sign the issued tokens
            _signingCreds = new X509SigningCredentials(CertificateUtil.GetCertificate(StoreName.My, StoreLocation.LocalMachine, SIGNING_CERTIFICATE_NAME));

            // Note: In this sample app only a si   ngle RP identity is shown, which is localhost, and the certificate of that RP is 
            // populated as _encryptingCreds
            // If you have multiple RPs for the STS you would select the certificate that is specific to 
            // the RP that requests the token and then use that for _encryptingCreds
            _encryptingCreds = new X509EncryptingCredentials(CertificateUtil.GetCertificate(StoreName.My, StoreLocation.LocalMachine, ENCRYPTING_CERTIFICATE_NAME));
        }

        /// <summary>
        /// This method returns the configuration for the token issuance request. The configuration
        /// is represented by the Scope class. In our case, we are only capable of issuing a token to a
        /// single RP identity represented by the _encryptingCreds field.
        /// </summary>
        /// <param name="principal">The caller's principal</param>
        /// <param name="request">The incoming RST</param>
        /// <returns></returns>
        protected override Scope GetScope(ClaimsPrincipal principal, RequestSecurityToken request)
        {
            // Validate the AppliesTo address
            ValidateAppliesTo( request.AppliesTo );

            // Create the scope using the request AppliesTo address and the RP identity
            Scope scope = new Scope( request.AppliesTo.Uri.AbsoluteUri, _signingCreds );

            if (Uri.IsWellFormedUriString(request.ReplyTo, UriKind.Absolute))
            {
                if (request.AppliesTo.Uri.Host != new Uri(request.ReplyTo).Host)
                    scope.ReplyToAddress = request.AppliesTo.Uri.AbsoluteUri;
                else
                    scope.ReplyToAddress = request.ReplyTo;
            }
            else
            {
                Uri resultUri = null;
                if (Uri.TryCreate(request.AppliesTo.Uri, request.ReplyTo, out resultUri))
                    scope.ReplyToAddress = resultUri.AbsoluteUri;
                else
                    scope.ReplyToAddress = request.AppliesTo.Uri.ToString() ;
            }

            // Note: In this sample app only a single RP identity is shown, which is localhost, and the certificate of that RP is 
            // populated as _encryptingCreds
            // If you have multiple RPs for the STS you would select the certificate that is specific to 
            // the RP that requests the token and then use that for _encryptingCreds
            scope.EncryptingCredentials = _encryptingCreds;

            return scope;
        }
        /// <summary>
        /// This method returns the content of the issued token. The content is represented as a set of
        /// IClaimIdentity intances, each instance corresponds to a single issued token. Currently, the Windows Identity Foundation only
        /// supports a single token issuance, so the returned collection must always contain only a single instance.
        /// </summary>
        /// <param name="scope">The scope that was previously returned by GetScope method</param>
        /// <param name="principal">The caller's principal</param>
        /// <param name="request">The incoming RST, we don't use this in our implementation</param>
        /// <returns></returns>
        protected override ClaimsIdentity GetOutputClaimsIdentity( ClaimsPrincipal principal, RequestSecurityToken request, Scope scope )
        {
            //
            // Return a default claim set which contains a custom decision claim
            // Here you can actually examine the user by looking at the IClaimsPrincipal and 
            // return the right decision based on that. 
            //
            ClaimsIdentity outgoingIdentity = new ClaimsIdentity();
            outgoingIdentity.AddClaims(principal.Claims);

            return outgoingIdentity;
        }
        /// <summary>
        /// Validates the appliesTo and throws an exception if the appliesTo is null or appliesTo contains some unexpected address.
        /// </summary>
        /// <param name="appliesTo">The AppliesTo parameter in the request that came in (RST)</param>
        /// <returns></returns>
        void ValidateAppliesTo(EndpointReference appliesTo)
        {
            if (appliesTo == null)
            {
                throw new InvalidRequestException("The appliesTo is null.");
            }

            if (!appliesTo.Uri.Equals(new Uri(_addressExpected)))
            {
                throw new InvalidRequestException(String.Format("The relying party address is not valid. Expected value is {0}, the actual value is {1}.", _addressExpected, appliesTo.Uri.AbsoluteUri));
            }
        }

    }
}

Poniższy kod pokazuje, jak wywołać niestandardową pasywną usługę STS w celu przetworzenia żądania WS-Federation przez wywołanie FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) metody z kodu w default.aspx.cs pliku.

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

namespace PassiveSTS
{
    public partial class _Default : System.Web.UI.Page
    {
        /// <summary>
        /// We perform the WS-Federation Passive Protocol processing in this method. 
        /// </summary>
        protected void Page_PreRender( object sender, EventArgs e ) 
        {
            FederatedPassiveSecurityTokenServiceOperations.ProcessRequest( Request, User as ClaimsPrincipal, CustomSecurityTokenServiceConfiguration.Current.CreateSecurityTokenService(), Response );
        }
    }
}

Uwagi

Aby utworzyć usługę STS, musisz pochodzić z SecurityTokenService klasy . W klasie niestandardowej należy co najmniej zastąpić GetScope metody i GetOutputClaimsIdentity . W przypadku tych przesłonięć usługa STS utworzona przy użyciu domyślnej implementacji wszystkich innych metod zdefiniowanych w klasie może wystawiać tokeny zabezpieczające w odpowiedzi na żądania tokenu zabezpieczającego (RST). Oznacza to, że powiązanie problemu zdefiniowane w specyfikacji WS-Trust jest implementowane. To powiązanie jest implementowane w metodzie Issue . Żadne z innych powiązań WS-Trust (Odnów, Anuluj i Weryfikuj) są implementowane w przypadku domyślnym, a odpowiedni błąd jest zwracany do obiektu wywołującego, jeśli wystąpi błąd RST odpowiadający jednemu z tych powiązań. Można oczywiście zastąpić odpowiednie metody (Renew, Canceli Validate) w celu zaimplementowania tych powiązań w usłudze STS.

Ważne

Wdrożenie produkcyjnej usługi STS wiąże się z ostrożnym planowaniem i znacznymi zasobami w celu ograniczenia potencjalnych zagrożeń bezpieczeństwa związanych z ujawnieniem takiej usługi. Większość deweloperów korzystających z programu Windows Identity Foundation (WIF) będzie opracowywać aplikacje, które przesuną zarządzanie tożsamościami do usługi STS, zamiast samodzielnie opracowywać usługi STS. Program WIF udostępnia rozszerzenie programu Visual Studio, narzędzie Identity and Access Tool for Visual Studio 2012, aby ułatwić deweloperom testowanie rozwiązań w środowisku deweloperów. To narzędzie zawiera usługę STS, LocalSTS, którą można skonfigurować pod kątem obsługi określonych oświadczeń dla tworzonej aplikacji. Aby uzyskać więcej informacji na temat narzędzia Identity and Access, zobacz Identity and Access Tool for Visual Studio 2012 (Narzędzie tożsamości i dostępu dla programu Visual Studio 2012). W niektórych scenariuszach LocalSTS może nie zapewnić funkcjonalności niezbędnej do odpowiedniego przetestowania aplikacji, na przykład w scenariuszu obejmującym opracowanie niestandardowej procedury obsługi tokenów do użycia przez aplikację. W takich przypadkach można utworzyć SecurityTokenService jeden lub więcej prostych usług STS, które można wdrożyć w środowisku projektowym i które mogą służyć do testowania takich funkcji w aplikacji. W pozostałej części tej sekcji skupiono się na metodach uwidocznionych przez SecurityTokenService klasę, które umożliwiają zaimplementowanie prostej usługi STS i rozszerzenie potoku wystawiania tokenów.

Poniższa lista zawiera krótkie omówienie metod podstawowego znaczenia dla dewelopera do użycia w środowisku testowym lub programistycznym.

Metoda GetScope . Ta metoda zwraca Scope obiekt zawierający informacje o żądaniu jednostki domeny. Ten obiekt jest używany w pozostałej części potoku wystawiania tokenów i zawiera informacje na temat podpisywania i szyfrowania poświadczeń do użycia w odpowiedzi, a także AppliesTo adresów i ReplyTo (jeśli jest to wymagane). Tę metodę należy zastąpić.
Metoda GetOutputClaimsIdentity . Ta metoda zwraca ClaimsIdentity obiekt, który zawiera oświadczenia, które mają wrócić do dostawcy usług. Tę metodę należy zastąpić.
Metoda Issue . Ta metoda implementuje potok żądania tokenu, który przetwarza przychodzące żądanie tokenu zabezpieczającego (RST) i zwraca odpowiedź (RSTR) do obiektu wywołującego, który zawiera token, który może służyć do uwierzytelniania za pomocą dostawcy zasobów. Wiele innych metod zdefiniowanych w SecurityTokenService klasie jest wywoływanych z tej metody, w tym GetScope metod i GetOutputClaimsIdentity . Nie trzeba zastąpić tej metody, ale przydatne może być zrozumienie potoku żądania tokenu, który implementuje.

Usługa STS jest konfigurowana za pośrednictwem SecurityTokenServiceConfiguration klasy .

Uwagi dotyczące implementowania

Należy zastąpić zarówno metody, jak GetScope(ClaimsPrincipal, RequestSecurityToken) i GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) .

Konstruktory

SecurityTokenService(SecurityTokenServiceConfiguration)

Wywoływane z klas pochodnych w celu zainicjowania SecurityTokenService klasy przy użyciu określonych ustawień konfiguracji.

Właściwości

Principal	Pobiera lub ustawia podmiot zabezpieczeń skojarzony z bieżącym wystąpieniem.
Request	Pobiera lub ustawia żądanie tokenu zabezpieczającego skojarzone z bieżącym wystąpieniem.
Scope	Pobiera lub ustawia zakres skojarzony z bieżącym wystąpieniem.
SecurityTokenDescriptor	Pobiera lub ustawia SecurityTokenDescriptor skojarzone z bieżącym wystąpieniem.
SecurityTokenServiceConfiguration	Pobiera wystąpienie konfiguracji właściciela.

Metody

BeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Po zastąpieniu w klasie pochodnej rozpoczyna się asynchroniczne żądanie WS-Trust Anuluj.
BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)	Po zastąpieniu klasy pochodnej rozpoczyna asynchroniczne wywołanie GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) metody .
BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Po zastąpieniu klasy pochodnej rozpoczyna asynchroniczne wywołanie GetScope(ClaimsPrincipal, RequestSecurityToken) metody .
BeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Po zastąpieniu w klasie pochodnej rozpoczyna się asynchroniczne żądanie problemu WS-Trust.
BeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Po zastąpieniu w klasie pochodnej rozpoczyna się asynchroniczne żądanie WS-Trust Odnów.
BeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Po zastąpieniu w klasie pochodnej rozpoczyna się asynchroniczne żądanie WS-Trust Validate.
Cancel(ClaimsPrincipal, RequestSecurityToken)	Gdy zastąpisz klasę pochodną, przetwarza żądanie WS-Trust Anuluj.
CreateSecurityTokenDescriptor(RequestSecurityToken, Scope)	Tworzy wystąpienie obiektu SecurityTokenDescriptor.
EndCancel(IAsyncResult)	Po zastąpieniu w klasie pochodnej program kończy asynchroniczne żądanie WS-Trust Anuluj.
EndGetOutputClaimsIdentity(IAsyncResult)	Po zastąpieniu w klasie pochodnej wykonuje asynchroniczne wywołanie BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object) metody .
EndGetScope(IAsyncResult)	Po zastąpieniu w klasie pochodnej wykonuje asynchroniczne wywołanie BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) metody .
EndIssue(IAsyncResult)	Po zastąpieniu w klasie pochodnej kończy asynchroniczne żądanie problemu WS-Trust.
EndRenew(IAsyncResult)	Po zastąpieniu w klasie pochodnej wykonuje asynchroniczne żądanie WS-Trust Odnów.
EndValidate(IAsyncResult)	Po przesłonięciu w klasie pochodnej wykonuje asynchroniczne żądanie WS-Trust Validate.
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)
GetIssuerName()	Pobiera nazwę usługi tokenu zabezpieczającego (STS).
GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)	W przypadku zastąpienia w klasie pochodnej ta metoda zwraca kolekcję podmiotów wyjściowych, które mają zostać uwzględnione w wystawionym tokenie.
GetProofToken(RequestSecurityToken, Scope)	Pobiera token dowodowy, który ma zostać uwzględniony w odpowiedzi (RSTR).
GetRequestorProofEncryptingCredentials(RequestSecurityToken)	Pobiera dowód szyfrowania poświadczeń osoby żądającej.
GetResponse(RequestSecurityToken, SecurityTokenDescriptor)	Tworzy odpowiedź (RSTR), która zawiera wystawiony token przy użyciu określonego żądania (RST) i deskryptora tokenu zabezpieczającego.
GetScope(ClaimsPrincipal, RequestSecurityToken)	Scope Pobiera obiekt zawierający informacje o jednostki uzależnionej skojarzonej z określonym żądaniem (RST). Tę metodę należy zastąpić w implementacji SecurityTokenService klasy .
GetSecurityTokenHandler(String)	Pobiera odpowiednią procedurę obsługi tokenów zabezpieczających na potrzeby wystawiania tokenu zabezpieczającego określonego typu.
GetTokenLifetime(Lifetime)	Pobiera okres istnienia wystawionego tokenu.
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
Issue(ClaimsPrincipal, RequestSecurityToken)	Wystawia token zabezpieczający.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Renew(ClaimsPrincipal, RequestSecurityToken)	Gdy zastąpisz klasę pochodną, przetwarza żądanie WS-Trust Odnów.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
Validate(ClaimsPrincipal, RequestSecurityToken)	Po przesłonięciu w klasie pochodnej przetwarza żądanie WS-Trust Validate.
ValidateRequest(RequestSecurityToken)	Weryfikuje żądanie tokenu zabezpieczającego (RST) hermetyzowane przez to wystąpienie.

Dotyczy

Udostępnij za pośrednictwem