SecurityTokenService Klasse

Referenz

Definition

Namespace:: System.IdentityModel

Assembly:: System.IdentityModel.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Die abstrakte Basis-Klasse, die die Eigenschaften und Methoden eines Sicherheitstokendiensts (STS) definiert.

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Vererbung: Object
SecurityTokenService

Beispiele

Die Codebeispiele, die in den SecurityTokenService Themen verwendet werden, stammen aus dem Custom Token Beispiel. Dieses Beispiel stellt benutzerdefinierte Klassen bereit, die die Verarbeitung von Einfachen Webtoken (SWT) ermöglichen, und enthält eine Implementierung eines passiven STS, das ein SWT-Token bereitstellen kann. Ein Beispiel für die Implementierung eines aktiven STS finden Sie im Federation Metadata Beispiel. Informationen zu diesen Beispielen und anderen Beispielen, die für WIF verfügbar sind, sowie informationen dazu, wo sie heruntergeladen werden können, finden Sie unter WIF-Codebeispielindex. Der folgende Code zeigt die Implementierung eines passiven STS mithilfe der SecurityTokenService -Klasse.

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

    }
}

Der folgende Code zeigt, wie Sie einen benutzerdefinierten passiven STS aufrufen, um eine WS-Federation-Anforderung zu verarbeiten, indem Sie die FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) -Methode aus dem Code Behind in der default.aspx.cs Datei aufrufen.

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

Hinweise

Um einen STS zu erstellen, müssen Sie von der SecurityTokenService -Klasse abgeleitet werden. In Ihrer benutzerdefinierten Klasse müssen Sie mindestens die GetScope Methoden und GetOutputClaimsIdentity außer Kraft setzen. Mit diesen Überschreibungen kann der STS, der mit der Standardimplementierung aller anderen in der -Klasse definierten Methoden erstellt wurde, Sicherheitstoken als Reaktion auf Sicherheitstokenanforderungen (Security Token Requests, RST) ausgeben. Das heißt, die in der WS-Trust Spezifikation definierte Issue-Bindung wird implementiert. Diese Bindung wird in der Issue -Methode implementiert. Keine der anderen WS-Trust Bindungen (Renew, Cancel und Validate) wird im Standardfall implementiert, und ein entsprechender Fehler wird an den Aufrufer zurückgegeben, wenn eine RST gefunden wird, die einer dieser Bindungen entspricht. Sie können natürlich die entsprechenden Methoden (Renew, und Validate) außer Kraft setzen, Cancelum diese Bindungen in Ihrem STS zu implementieren.

Wichtig

Die Implementierung eines produktionsfähigen STS erfordert eine sorgfältige Planung und erhebliche Ressourcen, um die potenziellen Sicherheitsrisiken zu minimieren, die mit der Offenlegung eines solchen Diensts verbunden sind. Die meisten Entwickler, die Windows Identity Foundation (WIF) verwenden, entwickeln Anwendungen, die die Identitätsverwaltung an einen STS auslagern, anstatt selbst einen STS zu entwickeln. WIF bietet eine Visual Studio-Erweiterung, das Identitäts- und Zugriffstool für Visual Studio 2012, um Entwicklern beim Testen von Lösungen in der Entwicklungsumgebung zu helfen. Dieses Tool enthält einen STS, den Sie konfigurieren können, LocalSTSum bestimmte Ansprüche für die Anwendung zu erfüllen, die Sie entwickeln. Weitere Informationen zum Identitäts- und Zugriffstool finden Sie unter Identitäts- und Zugriffstool für Visual Studio 2012. In einigen Szenarios kann es sein, dass nicht die Funktionalität bereitgestellt wird, LocalSTS die zum adäquaten Testen der Anwendung erforderlich ist, z. B. in einem Szenario, das die Entwicklung eines benutzerdefinierten Tokenhandlers für die Verwendung durch eine Anwendung umfasst. In diesen Fällen können Sie von SecurityTokenService ableiten, um eine oder mehrere einfache STS zu erstellen, die in Ihrer Entwicklungsumgebung bereitgestellt und zum Testen solcher Features in Ihrer Anwendung verwendet werden können. Der Rest dieses Abschnitts konzentriert sich auf die Von der -Klasse verfügbar gemachten Methoden, mit denen SecurityTokenService Sie eine einfache STS implementieren und die Tokenausstellungspipeline erweitern können.

Die folgende Liste bietet einen kurzen Überblick über die Methoden, die für den Entwickler von vorrangiger Bedeutung für die Verwendung in einer Test- oder Entwicklungsumgebung sind.

Die GetScope -Methode. Diese Methode gibt ein Scope -Objekt zurück, das Informationen zum RP enthält. Dieses Objekt wird im Rest der Tokenausstellungspipeline verwendet und enthält Informationen zu den Anmeldeinformationen für das Signieren und Verschlüsseln, die in der Antwort verwendet werden sollen, sowie die AppliesTo Adressen und ReplyTo (falls erforderlich). Sie müssen diese Methode überschreiben.
Die GetOutputClaimsIdentity -Methode. Diese Methode gibt ein ClaimsIdentity Objekt zurück, das die Ansprüche enthält, die an den RP zurückgegeben werden sollen. Sie müssen diese Methode überschreiben.
Die Issue -Methode. Diese Methode implementiert die Tokenanforderungspipeline, die eine eingehende Sicherheitstokenanforderung (RST) verarbeitet und eine Antwort (RSTR) an den Aufrufer zurückgibt, der ein Token enthält, das zur Authentifizierung mit einem RP verwendet werden kann. Viele der anderen in der SecurityTokenService -Klasse definierten Methoden werden von dieser Methode aufgerufen, einschließlich der GetScope Methoden und GetOutputClaimsIdentity . Sie müssen diese Methode nicht überschreiben, aber ein Verständnis der implementierten Tokenanforderungspipeline kann hilfreich sein.

Ein STS wird über die SecurityTokenServiceConfiguration -Klasse konfiguriert.

Hinweise für Ausführende

Sie müssen sowohl die GetScope(ClaimsPrincipal, RequestSecurityToken) -Methode als auch die GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) -Methode außer Kraft setzen.

Konstruktoren

SecurityTokenService(SecurityTokenServiceConfiguration)

Aufgerufen von abgeleiteten Klassen, um die SecurityTokenService-Klasse mit der angegebenen Konfigurationseinstellungen zu initialisieren.

Eigenschaften

Principal	Übernimmt oder bestimmt den Prinzipal, der der aktuellen Instanz zugeordnet ist.
Request	Übernimmt oder bestimmt die Sicherheitstokenanforderung (RST), die der aktuellen Instanz zugeordnet ist.
Scope	Übernimmt oder bestimmt den Scope, der der aktuellen Instanz zugeordnet ist.
SecurityTokenDescriptor	Übernimmt oder bestimmt den SecurityTokenDescriptor, der mit der aktuellen Instanz verknüpft ist.
SecurityTokenServiceConfiguration	Ruft die Besitzerkonfigurationsinstanz ab.

Methoden

BeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Beginnt beim Überschreiben in einer abgeleiteten Klasse eine asynchrone WS-Trust-Cancel-Anforderung.
BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)	Leitet beim Überschreiben in einer abgeleiteten Klasse einen asynchronen Aufruf der GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)-Methode ein.
BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Leitet beim Überschreiben in einer abgeleiteten Klasse einen asynchronen Aufruf für die GetScope(ClaimsPrincipal, RequestSecurityToken)-Methode ein.
BeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Beginnt beim Überschreiben in einer abgeleiteten Klasse eine asynchrone WS-Trust-Issue-Anforderung.
BeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Beginnt beim Überschreiben in einer abgeleiteten Klasse eine asynchrone WS-Trust-Renew-Anforderung.
BeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Beginnt beim Überschreiben in einer abgeleiteten Klasse eine asynchrone WS-Trust-Validate-Anforderung.
Cancel(ClaimsPrincipal, RequestSecurityToken)	Verarbeitet beim Überschreiben in einer abgeleiteten Klasse eine WS-Trust-Cancel-Anforderung.
CreateSecurityTokenDescriptor(RequestSecurityToken, Scope)	Erstellt eine Instanz eines SecurityTokenDescriptor.
EndCancel(IAsyncResult)	Schließt beim Überschreiben in einer abgeleiteten Klasse die asynchrone WS-Trust-Cancel-Anforderung ab.
EndGetOutputClaimsIdentity(IAsyncResult)	Schließt beim Überschreiben in einer abgeleiteten Klasse einen asynchronen Aufruf der BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)-Methode ab.
EndGetScope(IAsyncResult)	Schließt beim Überschreiben in einer abgeleiteten Klasse einen asynchronen Aufruf der BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)-Methode ab.
EndIssue(IAsyncResult)	Schließt beim Überschreiben in einer abgeleiteten Klasse die asynchrone WS-Trust-Issue-Anforderung ab.
EndRenew(IAsyncResult)	Schließt beim Überschreiben in einer abgeleiteten Klasse die asynchrone WS-Trust-Renew-Anforderung ab.
EndValidate(IAsyncResult)	Schließt beim Überschreiben in einer abgeleiteten Klasse die asynchrone WS-Trust-Validate-Anforderung ab.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetIssuerName()	Ruft den Namen des Sicherheitstokendienst (STS) ab.
GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, gibt diese Methode eine Auflistung von Ausgabebetreffs zurück, die in das ausgestellte Token eingeschlossen werden sollen.
GetProofToken(RequestSecurityToken, Scope)	Ruft das Prüftoken ab, das in der Antwort enthalten sein soll (RSTR).
GetRequestorProofEncryptingCredentials(RequestSecurityToken)	Ruft den Beweis der Verschlüsselungsanmeldeinformationen des Anfordernden ab.
GetResponse(RequestSecurityToken, SecurityTokenDescriptor)	Erstellt die Antwort (RSTR) die das ausgestelltes Token enthält, indem der angegebene Deskriptor der Anforderung (RST) und des Sicherheitstoken verwendet wird.
GetScope(ClaimsPrincipal, RequestSecurityToken)	Ruft ein Scope-Objekt ab, das Informationen über die vertrauende Seite enthält, die der angegebenen Anforderung zugeordnet ist. In Ihrer Implementierung der SecurityTokenService-Klasse müssen Sie diese Methode überschreiben.
GetSecurityTokenHandler(String)	Ruft den entsprechenden Sicherheitstokenhandler zum Ausgeben eines Sicherheitstoken des angegebenen Typs ab.
GetTokenLifetime(Lifetime)	Ruft die Lebensdauer für das ausgestellte Token ab.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
Issue(ClaimsPrincipal, RequestSecurityToken)	Erstellt ein Sicherheitstoken.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Renew(ClaimsPrincipal, RequestSecurityToken)	Verarbeitet beim Überschreiben in einer abgeleiteten Klasse eine WS-Trust-Renew-Anforderung.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
Validate(ClaimsPrincipal, RequestSecurityToken)	Verarbeitet beim Überschreiben in einer abgeleiteten Klasse eine WS-Trust-Validate-Anforderung.
ValidateRequest(RequestSecurityToken)	Überprüft die von dieser Instanz gekapselten Sicherheitstokenanforderungen (RST).

Gilt für: