SecurityToken Classe

Definizione

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Ereditarietà

Object

SecurityToken

Derivato

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Altro…

Esempio

Gli esempi di codice usati negli SecurityToken argomenti vengono acquisiti dall'esempio Custom Token . Questo esempio fornisce classi personalizzate che consentono l'elaborazione di token Web semplici (SWT). Include un'implementazione di una classe e una SimpleWebTokenSimpleWebTokenHandler classe, nonché altre classi che supportano i token SWT. Per informazioni su questo esempio e altri esempi disponibili per WIF e su dove scaricarli, vedere Indice di esempio di codice WIF. Il codice seguente mostra l'implementazione della SimpleWebToken classe. Questa classe estende 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 );
        } 
    }    
}

Commenti

Utilizzare un token di sicurezza per fornire credenziali di autenticazione o proteggere un messaggio.

Un token di sicurezza può essere usato per fornire credenziali di autenticazione, materiale della chiave crittografica o, nel caso di un token di sicurezza rilasciato da un servizio token di sicurezza (STS), una raccolta di attestazioni su un soggetto. Tutti i token di sicurezza derivano dalla SecurityToken classe .

A partire da .NET 4.5, Windows Identity Foundation (WIF) è stato completamente integrato in .NET Framework e le classi esposte da WIF sono il metodo preferito per gestire i token di sicurezza nel codice. In WIF, i token di sicurezza vengono serializzati e deserializzati da e verso la SecurityTokenHandler relativa rappresentazione XML e vengono convalidati usando classi derivate dalla classe base. La convalida di un token implica non solo garantire che il token sia valido, ma anche la restituzione di un'istanza ClaimsIdentity dal token che può essere usato per prendere decisioni di autenticazione e autorizzazione. Viene ClaimsIdentity costruito dall'implementazione del gestore del token del ValidateToken metodo dalle attestazioni contenute nel token e dalle attestazioni intrinseche al tipo di token stesso.

WIF viene fornito con supporto per i tipi seguenti di token di sicurezza:

• Saml2SecurityToken: rappresenta un token di sicurezza basato su un'asserzione SAML 2.0. Questo tipo di token viene in genere rilasciato da un servizio token di sicurezza in risposta a un WS-Trust o WS-Federation richiesta di token di sicurezza (RST).

• SamlSecurityToken: rappresenta un token di sicurezza basato su un'asserzione SAML 1.1. Questo tipo di token viene in genere rilasciato da un servizio token di sicurezza in risposta a un WS-Trust o WS-Federation richiesta di token di sicurezza (RST).

• KerberosRequestorSecurityToken e KerberosReceiverSecurityToken: rappresenta un token di sicurezza basato su un ticket Kerberos ricevuto o inviato in un messaggio SOAP

• RsaSecurityToken: rappresenta un token di sicurezza basato sulla chiave creata usando l'algoritmo RSA.

• SessionSecurityToken: rappresenta un token di sicurezza che contiene informazioni su una sessione.

• UserNameSecurityToken: rappresenta un token di sicurezza basato su un nome utente e una password.

• WindowsSecurityToken: rappresenta un token di sicurezza basato sull'identità di un dominio o di un account utente di Windows.

• X509SecurityToken: rappresenta un token di sicurezza basato su un certificato X.509.

• X509WindowsSecurityToken: rappresenta un token di sicurezza basato su un certificato X.509 mappato a un utente di dominio Windows o a un account utente del computer locale.

È possibile usare due altre classi GenericXmlSecurityToken di token di sicurezza e EncryptedSecurityToken, per gestire i casi generali.

In generale i token di sicurezza rientrano in tre categorie principali:

• Token che contengono o fanno riferimento al materiale della chiave crittografica. Ad esempio, i RsaSecurityToken tipi e X509SecurityToken vengono spesso usati per questo scopo.

• Token che rappresentano le credenziali per gli utenti che sono già stati autenticati. Ad esempio, , UserNameSecurityTokenWindowsSecurityTokene, nel caso di un utente autenticato usando un certificato, i X509SecurityToken tipi.

• Token rilasciati da un servizio token di sicurezza (STS) in risposta a una richiesta di token di sicurezza usando il protocollo WS-Trust o WS-Federation. Questi vengono in genere restituiti in un wst:RequestSecurityTokenResponse frammento XML. I Saml2SecurityToken tipi e SamlSecurityToken vengono spesso usati per rappresentare questi token.

Un tipo di token speciale, il , contiene informazioni necessarie per ricreare un'entità SessionSecurityTokenquando si usano sessioni in scenari attivi o passivi.

Per aggiungere funzionalità ai tipi di token esistenti, è possibile derivare dal tipo specifico e dal gestore token associato per supportare eventuali nuovi elementi aggiunti al token. Per aggiungere il supporto per i nuovi tipi di token, è possibile derivare direttamente dalla SecurityToken classe. A tale scopo, sarà anche necessario creare una classe del gestore token derivando dalla SecurityTokenHandler classe . A seconda del modo in cui deve essere usato il token, è anche necessario creare un resolver token personalizzato derivando dalla IssuerTokenResolver classe e da uno o più tipi di clausola identificatore di chiave personalizzata derivando dalla SecurityKeyIdentifierClause classe.

Note per gli implementatori

È necessario eseguire l'override delle Idproprietà , SecurityKeys, ValidFrome ValidTo . I CanCreateKeyIdentifierClause<T>()metodi , CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)e ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) supportano tutti gli identificatori di chiave di tipo LocalIdKeyIdentifierClause. È necessario eseguire l'override di questi metodi per supportare altri tipi di identificatore di chiave nella classe derivata.

Costruttori

Proprietà

Metodi

Si applica a

Vedi anche

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause