Udostępnij za pośrednictwem


SecurityToken Klasa

Definicja

Reprezentuje klasę bazową używaną do implementowania wszystkich tokenów zabezpieczających.

public ref class SecurityToken abstract
public abstract class SecurityToken
type SecurityToken = class
Public MustInherit Class SecurityToken
Dziedziczenie
SecurityToken
Pochodne

Przykłady

Przykłady kodu używane w tematach SecurityToken pochodzą z przykładu Custom Token . Ten przykład zawiera niestandardowe klasy, które umożliwiają przetwarzanie prostych tokenów internetowych (SWT). Obejmuje ona implementację SimpleWebToken klasy i SimpleWebTokenHandler klasy, a także inne klasy, które obsługują tokeny SWT. 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ę SimpleWebToken klasy. Ta klasa rozszerza klasę 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 );
        } 
    }    
}

Uwagi

Użyj tokenu zabezpieczającego, aby podać poświadczenia uwierzytelniania lub chronić komunikat.

Token zabezpieczający może służyć do dostarczania poświadczeń uwierzytelniania, materiału klucza kryptograficznego lub w przypadku tokenu zabezpieczającego wystawionego przez usługę tokenu zabezpieczającego (STS), kolekcję oświadczeń dotyczących podmiotu. Wszystkie tokeny zabezpieczające pochodzą z SecurityToken klasy .

Począwszy od platformy .NET 4.5, program Windows Identity Foundation (WIF) został w pełni zintegrowany z .NET Framework, a klasy udostępniane przez program WIF są preferowaną metodą obsługi tokenów zabezpieczających w kodzie. W programie WIF tokeny zabezpieczające są serializowane i deserializowane do i z ich reprezentacji XML i są weryfikowane przy użyciu klas pochodnych od klasy bazowej SecurityTokenHandler . Weryfikowanie tokenu polega nie tylko na upewnieniu się, że token jest prawidłowy, ale także zwracanie ClaimsIdentity wystąpienia z tokenu, którego można użyć w podejmowaniu decyzji dotyczących uwierzytelniania i autoryzacji. Obiekt ClaimsIdentity jest skonstruowany przez implementację ValidateToken metody procedury obsługi tokenów z oświadczeń zawartych w tokenie, a także z oświadczeń, które są wewnętrzne dla samego typu tokenu.

Program WIF jest dostarczany z obsługą następujących typów tokenów zabezpieczających:

  • Saml2SecurityToken: reprezentuje token zabezpieczający oparty na asercji SAML 2.0. Ten typ tokenu jest zazwyczaj wystawiany przez usługę tokenu zabezpieczającego w odpowiedzi na żądanie WS-Trust lub WS-Federation tokenu zabezpieczającego (RST).

  • SamlSecurityToken: reprezentuje token zabezpieczający oparty na asercji SAML 1.1. Ten typ tokenu jest zazwyczaj wystawiany przez usługę tokenu zabezpieczającego w odpowiedzi na żądanie WS-Trust lub WS-Federation tokenu zabezpieczającego (RST).

  • KerberosRequestorSecurityToken i KerberosReceiverSecurityToken: reprezentuje token zabezpieczający oparty na bilecie protokołu Kerberos, który jest odbierany lub wysyłany w komunikacie PROTOKOŁU SOAP

  • RsaSecurityToken: reprezentuje token zabezpieczający oparty na kluczu utworzonym przy użyciu algorytmu RSA.

  • SessionSecurityToken: reprezentuje token zabezpieczający zawierający informacje o sesji.

  • UserNameSecurityToken: reprezentuje token zabezpieczający oparty na nazwie użytkownika i haśle.

  • WindowsSecurityToken: reprezentuje token zabezpieczający oparty na tożsamości domeny lub konta użytkownika systemu Windows.

  • X509SecurityToken: reprezentuje token zabezpieczający oparty na certyfikacie X.509.

  • X509WindowsSecurityToken: reprezentuje token zabezpieczający oparty na certyfikacie X.509 mapowanym na konto użytkownika domeny systemu Windows lub użytkownika komputera lokalnego.

Dwie inne klasy tokenów zabezpieczających GenericXmlSecurityToken i EncryptedSecurityToken, mogą służyć do obsługi ogólnych przypadków.

Ogólnie rzecz biorąc tokeny zabezpieczające należą do trzech głównych kategorii:

  • Tokeny, które niosą lub odwołują się do materiału klucza kryptograficznego. Na przykład typy RsaSecurityToken i X509SecurityToken są często używane w tym celu.

  • Tokeny reprezentujące poświadczenia dla użytkowników, którzy zostali już uwierzytelnieni. Na przykład , UserNameSecurityTokenWindowsSecurityTokeni, w przypadku użytkownika uwierzytelnionego przy użyciu certyfikatu, X509SecurityToken typy.

  • Tokeny wystawione przez usługę tokenu zabezpieczającego (STS) w odpowiedzi na żądanie tokenu zabezpieczającego przy użyciu protokołu WS-Trust lub WS-Federation. Są one zwykle zwracane w fragmentcie wst:RequestSecurityTokenResponse XML. Typy Saml2SecurityToken i SamlSecurityToken są najczęściej używane do reprezentowania tych tokenów.

Specjalny typ tokenu SessionSecurityToken, zawiera informacje niezbędne do odtworzenia podmiotu zabezpieczeń podczas korzystania z sesji w scenariuszach aktywnych lub pasywnych.

Aby dodać funkcje do istniejących typów tokenów, możesz pochodzących z określonego typu i skojarzonego programu obsługi tokenów obsługiwać wszystkie nowe elementy dodane do tokenu. Aby dodać obsługę nowych typów tokenów, możesz pochodzić bezpośrednio z SecurityToken klasy. W takim przypadku należy również utworzyć klasę procedury obsługi tokenów, wyprowadzając je z SecurityTokenHandler klasy. W zależności od sposobu użycia tokenu może być również konieczne utworzenie niestandardowego rozpoznawania tokenów przez wyprowadzenie z IssuerTokenResolver klasy, a także jednego lub kilku niestandardowych typów klauzul identyfikatora klucza przez wyprowadzenie z SecurityKeyIdentifierClause klasy.

Uwagi dotyczące implementowania

Należy zastąpić Idwłaściwości , SecurityKeys, ValidFromi ValidTo . Metody CanCreateKeyIdentifierClause<T>(), CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)i ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) obsługują identyfikatory kluczy typu LocalIdKeyIdentifierClause. Te metody należy zastąpić, aby obsługiwać inne typy identyfikatorów kluczy w klasie pochodnej.

Konstruktory

SecurityToken()

Wywoływane przez konstruktory w klasach pochodnych w celu zainicjowania SecurityToken klasy.

Właściwości

Id

Pobiera unikatowy identyfikator tokenu zabezpieczającego.

SecurityKeys

Pobiera klucze kryptograficzne skojarzone z tokenem zabezpieczającym.

ValidFrom

Pobiera pierwszą chwilę w czasie, w której ten token zabezpieczający jest prawidłowy.

ValidTo

Pobiera ostatnią chwilę w czasie, w którym ten token zabezpieczający jest prawidłowy.

Metody

CanCreateKeyIdentifierClause<T>()

Pobiera wartość wskazującą, czy ten token zabezpieczający może utworzyć określony identyfikator klucza.

CreateKeyIdentifierClause<T>()

Tworzy określoną klauzulę identyfikatora klucza.

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 bieżące wystąpienie.

(Odziedziczone po Object)
MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)

Zwraca wartość wskazującą, czy identyfikator klucza dla tego wystąpienia można rozpoznać dla określonego identyfikatora klucza.

MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ResolveKeyIdentifierClause(SecurityKeyIdentifierClause)

Pobiera klucz dla określonej klauzuli identyfikatora klucza.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Dotyczy

Zobacz też