SecurityToken Klasse

Definition

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Vererbung

Object

SecurityToken

Abgeleitet

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Mehr …

Beispiele

Die Codebeispiele, die in den SecurityToken Themen verwendet werden, stammen aus dem Custom Token Beispiel. Dieses Beispiel stellt benutzerdefinierte Klassen bereit, die die Verarbeitung von Einfachen Webtoken (SWT) ermöglichen. Es enthält eine Implementierung einer SimpleWebToken Klasse und einer SimpleWebTokenHandler Klasse sowie andere Klassen, die SWT-Token unterstützen. Informationen zu diesem Beispiel und anderen für WIF verfügbaren Beispielen sowie zu den Downloadmöglichkeiten finden Sie unter WIF-Codebeispielindex. Der folgende Code zeigt die Implementierung der SimpleWebToken -Klasse. Diese Klasse erweitert SecurityToken.

/// <summary>
/// Defines the set of constants for the Simple Web Token.
/// </summary>
public static class SimpleWebTokenConstants
{
    public const string Audience = "Audience";
    public const string ExpiresOn = "ExpiresOn";
    public const string Id = "Id";
    public const string Issuer = "Issuer";
    public const string Signature = "HMACSHA256";
    public const string ValidFrom = "ValidFrom";
    public const string ValueTypeUri = "http://schemas.xmlsoap.org/ws/2009/11/swt-token-profile-1.0";     
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.IdentityModel.Tokens;

namespace SimpleWebToken
{
    /// <summary>
    /// This class represents the token format for the SimpleWebToken.
    /// </summary>
    public class SimpleWebToken : SecurityToken
    {
        public static DateTime SwtBaseTime = new DateTime( 1970, 1, 1, 0, 0, 0, 0 ); // per SWT psec

        NameValueCollection _properties;
        string _serializedToken;

        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleWebToken"/> class.
        /// This is an internal constructor that is only called from the <see cref="SimpleWebTokenHandler"/> when reading a token received from the wire.
        /// </summary>
        /// <param name="properties">The collection representing all the key value pairs in the token.</param>
        /// <param name="serializedToken">The serialized form of the token.</param>
        internal SimpleWebToken( NameValueCollection properties, string serializedToken )
            : this(properties)
        {
            _serializedToken = serializedToken;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleWebToken"/> class.
        /// </summary>
        /// <param name="properties">The collection representing all the key value pairs in the token.</param>
        public SimpleWebToken( NameValueCollection properties )
        {
            if ( properties == null )
            {
                throw new ArgumentNullException( "properties" );
            }

            _properties = properties;
        }

        /// <summary>
        /// Gets the Id of the token.
        /// </summary>
        /// <value>The Id of the token.</value>
        public override string Id
        {
            get 
            {
                return _properties[SimpleWebTokenConstants.Id];
            }
        }

        /// <summary>
        /// Gets the keys associated with this token.
        /// </summary>
        /// <value>The keys associated with this token.</value>
        public override ReadOnlyCollection<SecurityKey> SecurityKeys
        {
            get 
            { 
                return new ReadOnlyCollection<SecurityKey>( new List<SecurityKey>() ); 
            }
        }

        /// <summary>
        /// Gets the time from when the token is valid.
        /// </summary>
        /// <value>The time from when the token is valid.</value>
        public override DateTime ValidFrom
        {
            get 
            {
                string validFrom = _properties[SimpleWebTokenConstants.ValidFrom];
                return GetTimeAsDateTime( String.IsNullOrEmpty( validFrom ) ? "0" : validFrom );
            }
        }

        /// <summary>
        /// Gets the time when the token expires.
        /// </summary>
        /// <value>The time up to which the token is valid.</value>
        public override DateTime ValidTo
        {
            get
            {
                string expiryTime = _properties[SimpleWebTokenConstants.ExpiresOn];
                return GetTimeAsDateTime( String.IsNullOrEmpty( expiryTime ) ? "0" : expiryTime );
            }
        }

        /// <summary>
        /// Gets the Audience for the token.
        /// </summary>
        /// <value>The audience of the token.</value>
        public string Audience
        {
            get 
            {
                return _properties[SimpleWebTokenConstants.Audience];
            }
        }

        /// <summary>
        /// Gets the Issuer for the token.
        /// </summary>
        /// <value>The issuer for the token.</value>
        public string Issuer
        {
            get 
            { 
                return _properties[SimpleWebTokenConstants.Issuer]; 
            }
        }

        /// <summary>
        /// Gets the signature for the token.
        /// </summary>
        /// <value>The signature for the token.</value>
        public string Signature
        {
            get 
            { 
                return _properties[SimpleWebTokenConstants.Signature]; 
            }
        }

        /// <summary>
        /// Gets the serialized form of the token if the token was created from its serialized form by the token handler.
        /// </summary>
        /// <value>The serialized form of the token.</value>
        public string SerializedToken
        {
            get
            {
                return _serializedToken;
            }
        }

        /// <summary>
        /// Creates a copy of all key value pairs of the token.
        /// </summary>
        /// <returns>A copy of all the key value pairs in the token.</returns>
        public NameValueCollection GetAllProperties()
        {
            return new NameValueCollection( _properties );
        }

        /// <summary>
        /// Converts the time in seconds to a <see cref="DateTime"/> object based on the base time 
        /// defined by the Simple Web Token.
        /// </summary>
        /// <param name="expiryTime">The time in seconds.</param>
        /// <returns>The time as a <see cref="DateTime"/> object.</returns>
        protected virtual DateTime GetTimeAsDateTime( string expiryTime )
        {
            long totalSeconds = 0;
            if ( !long.TryParse( expiryTime, out totalSeconds ) )
            {
                throw new SecurityTokenException("Invalid expiry time. Expected the time to be in seconds passed from 1 January 1970.");
            }

            long maxSeconds = (long)( DateTime.MaxValue - SwtBaseTime ).TotalSeconds - 1;
            if ( totalSeconds > maxSeconds )
            {
                totalSeconds = maxSeconds;
            }

            return SwtBaseTime.AddSeconds( totalSeconds );
        } 
    }    
}

Hinweise

Verwenden Sie ein Sicherheitstoken, um Authentifizierungsinformationen bereitzustellen oder eine Meldung zu schützen.

Ein Sicherheitstoken kann verwendet werden, um Authentifizierungsanmeldeinformationen, kryptografisches Schlüsselmaterial oder im Fall eines Sicherheitstokens, das von einem Sicherheitstokendienst (Security Token Service, STS) ausgestellt wird, eine Sammlung von Ansprüchen zu einem Antragsteller bereitzustellen. Alle Sicherheitstoken stammen von der SecurityToken -Klasse ab.

Ab .NET 4.5 wurde Windows Identity Foundation (WIF) vollständig in die .NET Framework integriert, und die von WIF verfügbar gemachten Klassen sind die bevorzugte Methode zum Verarbeiten von Sicherheitstoken in Ihrem Code. In WIF werden Sicherheitstoken serialisiert und in und aus ihrer XML-Darstellung deserialisiert und überprüft, indem von der SecurityTokenHandler Basisklasse abgeleitete Klassen verwendet werden. Die Überprüfung eines Tokens umfasst nicht nur die Sicherstellung, dass das Token gültig ist, sondern auch die Rückgabe einer ClaimsIdentity Instanz aus dem Token, die zum Treffen von Authentifizierungs- und Autorisierungsentscheidungen verwendet werden kann. Der ClaimsIdentity wird durch die Implementierung der Methode des Tokenhandlers aus den ValidateToken im Token enthaltenen Ansprüchen sowie aus Ansprüchen erstellt, die für den Tokentyp selbst intrinsisch sind.

WIF wird mit Unterstützung für die folgenden Arten von Sicherheitstoken geliefert:

• Saml2SecurityToken: Stellt ein Sicherheitstoken dar, das auf einer SAML 2.0-Assertion basiert. Dieser Tokentyp wird in der Regel von einem Sicherheitstokendienst als Reaktion auf eine WS-Trust- oder WS-Federation Sicherheitstokenanforderung (Security Token Request, RST) ausgegeben.

• SamlSecurityToken: Stellt ein Sicherheitstoken dar, das auf einer SAML 1.1-Assertion basiert. Dieser Tokentyp wird in der Regel von einem Sicherheitstokendienst als Reaktion auf eine WS-Trust- oder WS-Federation Sicherheitstokenanforderung (Security Token Request, RST) ausgegeben.

• KerberosRequestorSecurityToken und KerberosReceiverSecurityToken: Stellt ein Sicherheitstoken dar, das auf einem Kerberos-Ticket basiert, das in einer SOAP-Nachricht empfangen oder gesendet wird.

• RsaSecurityToken: Stellt ein Sicherheitstoken dar, das auf dem Schlüssel basiert, der mit dem RSA-Algorithmus erstellt wird.

• SessionSecurityToken: Stellt ein Sicherheitstoken dar, das Informationen zu einer Sitzung enthält.

• UserNameSecurityToken: Stellt ein Sicherheitstoken dar, das auf einem Benutzernamen und Kennwort basiert.

• WindowsSecurityToken: Stellt ein Sicherheitstoken dar, das auf der Identität einer Windows-Domäne oder eines Benutzerkontos basiert.

• X509SecurityToken: Stellt ein Sicherheitstoken dar, das auf einem X.509-Zertifikat basiert.

• X509WindowsSecurityToken: Stellt ein Sicherheitstoken dar, das auf einem X.509-Zertifikat basiert, das einem Windows-Domänenbenutzer oder einem lokalen Computerbenutzerkonto zugeordnet ist.

Zwei weitere Sicherheitstokenklassen und EncryptedSecurityTokenkönnen verwendet werden, GenericXmlSecurityToken um allgemeine Fälle zu behandeln.

Im Allgemeinen fallen Sicherheitstoken in drei Hauptkategorien:

• Token, die Kryptografieschlüsselmaterial enthalten oder auf diese verweisen. Für diesen Zweck werden z. B. häufig die RsaSecurityToken Typen und X509SecurityToken verwendet.

• Token, die Anmeldeinformationen für Benutzer darstellen, die bereits authentifiziert wurden. Beispiel: , UserNameSecurityTokenWindowsSecurityToken, und, im Fall eines Benutzers, der sich mit einem Zertifikat authentifiziert hat, die X509SecurityToken Typen.

• Token, die von einem Sicherheitstokendienst (Security Token Service, STS) als Reaktion auf eine Sicherheitstokenanforderung mithilfe des WS-Trust- oder WS-Federation-Protokolls ausgegeben werden. Diese werden in der Regel in einem wst:RequestSecurityTokenResponse XML-Fragment zurückgegeben. Die Saml2SecurityToken Typen und SamlSecurityToken werden am häufigsten verwendet, um diese Token darzustellen.

Ein spezieller Tokentyp, der , enthält Informationen, die SessionSecurityTokenerforderlich sind, um einen Prinzipal neu zu erstellen, wenn Sitzungen in aktiven oder passiven Szenarien verwendet werden.

Um vorhandenen Tokentypen Funktionen hinzuzufügen, können Sie vom spezifischen Typ und dem zugehörigen Tokenhandler ableiten, um alle neuen Elemente zu unterstützen, die Sie dem Token hinzufügen. Um Unterstützung für neue Tokentypen hinzuzufügen, können Sie direkt von der SecurityToken -Klasse abgeleitet werden. In diesem Fall müssen Sie auch eine Tokenhandlerklasse erstellen, indem Sie von der SecurityTokenHandler -Klasse abgeleitet werden. Je nachdem, wie Ihr Token verwendet werden soll, müssen Sie möglicherweise auch einen benutzerdefinierten Tokenlöser erstellen, indem Sie von der IssuerTokenResolver -Klasse abgeleitet werden, sowie einen oder mehrere benutzerdefinierte Schlüsselbezeichnerklauseltypen durch Ableiten von der SecurityKeyIdentifierClause -Klasse erstellen.

Hinweise für Ausführende

Sie müssen die IdEigenschaften , , SecurityKeysund ValidFromValidTo überschreiben. Die CanCreateKeyIdentifierClause<T>()Methoden , CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)und ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) unterstützen schlüsselbezeichner vom Typ LocalIdKeyIdentifierClause. Sie müssen diese Methoden überschreiben, um andere Schlüsselbezeichnertypen in Ihrer abgeleiteten Klasse zu unterstützen.

Konstruktoren

Eigenschaften

Methoden

Gilt für:

Weitere Informationen

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause