SecurityToken Classe

Définition

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Héritage

Object

SecurityToken

Dérivé

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Plus…

Exemples

Les exemples de code utilisés dans les SecurityToken rubriques sont extraits de l’exemple Custom Token . Cet exemple fournit des classes personnalisées qui permettent le traitement de jetons web simples (SWT). Il inclut une implémentation d’une SimpleWebToken classe et d’une SimpleWebTokenHandler classe, ainsi que d’autres classes qui prennent en charge les jetons SWT. Pour plus d’informations sur cet exemple et d’autres exemples disponibles pour WIF et sur l’emplacement où les télécharger, consultez l’index d’exemple de code WIF. Le code suivant montre l’implémentation de la SimpleWebToken classe. Cette classe s’étend 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 );
        } 
    }    
}

Remarques

Utilisez un jeton de sécurité pour fournir des informations d’identification d’authentification ou pour protéger un message.

Un jeton de sécurité peut être utilisé pour fournir des informations d’identification d’authentification, des documents de clé de chiffrement ou, dans le cas d’un jeton de sécurité émis par un service de jeton de sécurité (STS), une collection de revendications sur un sujet. Tous les jetons de sécurité dérivent de la SecurityToken classe.

À compter de .NET 4.5, Windows Identity Foundation (WIF) a été entièrement intégré au .NET Framework et les classes exposées par WIF sont la méthode préférée de gestion des jetons de sécurité dans votre code. Dans WIF, les jetons de sécurité sont sérialisés et désérialisés vers et à partir de leur représentation XML et sont validés à l’aide de classes dérivées de la SecurityTokenHandler classe de base. La validation d’un jeton implique non seulement de s’assurer que le jeton est valide, mais également de renvoyer une ClaimsIdentity instance à partir du jeton qui peut être utilisée pour prendre des décisions d’authentification et d’autorisation. Il ClaimsIdentity est construit par l’implémentation du gestionnaire de jetons de la ValidateToken méthode à partir des revendications contenues dans le jeton, ainsi que des revendications intrinsèques au type de jeton lui-même.

WIF est fourni avec prise en charge des types de jetons de sécurité suivants :

• Saml2SecurityToken: représente un jeton de sécurité basé sur une assertion SAML 2.0. Ce type de jeton est généralement émis par un service de jeton de sécurité en réponse à une demande de jeton de sécurité (RST) WS-Trust ou WS-Federation.

• SamlSecurityToken: représente un jeton de sécurité basé sur une assertion SAML 1.1. Ce type de jeton est généralement émis par un service de jeton de sécurité en réponse à une demande de jeton de sécurité (RST) WS-Trust ou WS-Federation.

• KerberosRequestorSecurityToken et KerberosReceiverSecurityToken: représente un jeton de sécurité basé sur un ticket Kerberos reçu ou envoyé dans un message SOAP

• RsaSecurityToken: représente un jeton de sécurité basé sur la clé créée à l’aide de l’algorithme RSA.

• SessionSecurityToken: représente un jeton de sécurité qui contient des informations sur une session.

• UserNameSecurityToken: représente un jeton de sécurité basé sur un nom d’utilisateur et un mot de passe.

• WindowsSecurityToken : représente un jeton de sécurité basé sur l’identité d’un domaine ou d’un compte d’utilisateur Windows.

• X509SecurityToken: représente un jeton de sécurité basé sur un certificat X.509.

• X509WindowsSecurityToken : représente un jeton de sécurité basé sur un certificat X.509 mappé à un utilisateur de domaine Windows ou un compte d’utilisateur d’ordinateur local.

Deux autres classes de jeton de sécurité, GenericXmlSecurityToken et EncryptedSecurityToken, peuvent être utilisées pour aider à gérer les cas généraux.

À l’échelle générale, les jetons de sécurité appartiennent à trois catégories principales :

• Jetons qui contiennent ou référencent des documents de clé de chiffrement. Par exemple, les RsaSecurityToken types sont X509SecurityToken souvent utilisés à cet effet.

• Jetons qui représentent les informations d’identification des utilisateurs qui ont déjà été authentifiés. Par exemple, le UserNameSecurityToken, WindowsSecurityTokenet, dans le cas d’un utilisateur authentifié à l’aide d’un certificat, les X509SecurityToken types.

• Jetons émis par un service de jeton de sécurité (STS) en réponse à une demande de jeton de sécurité à l’aide du protocole WS-Trust ou WS-Federation. Elles sont généralement retournées dans un wst:RequestSecurityTokenResponse fragment XML. Les Saml2SecurityToken types et SamlSecurityToken les types sont les plus souvent utilisés pour représenter ces jetons.

Un type de jeton spécial, le SessionSecurityToken, contient des informations nécessaires pour recréer un principal lors de l’utilisation de sessions dans des scénarios actifs ou passifs.

Pour ajouter des fonctionnalités aux types de jetons existants, vous pouvez dériver du type spécifique et de son gestionnaire de jetons associé pour prendre en charge les nouveaux éléments que vous ajoutez au jeton. Pour ajouter la prise en charge des nouveaux types de jetons, vous pouvez dériver directement de la SecurityToken classe. Lorsque vous effectuez cette opération, vous devez également créer une classe de gestionnaire de jetons en dérivant de la SecurityTokenHandler classe. Selon la façon dont votre jeton doit être utilisé, vous devrez peut-être également créer un programme de résolution de jeton personnalisé en dérivant de la IssuerTokenResolver classe ainsi qu’un ou plusieurs types de clauses d’identificateur de clé personnalisées en dérivant de la SecurityKeyIdentifierClause classe.

Notes pour les responsables de l’implémentation

Vous devez remplacer les propriétés, les IdSecurityKeyspropriétés et ValidFrom les ValidTopropriétés. Les CanCreateKeyIdentifierClause<T>()méthodes , et CreateKeyIdentifierClause<T>()MatchesKeyIdentifierClause(SecurityKeyIdentifierClause) les méthodes ResolveKeyIdentifierClause(SecurityKeyIdentifierClause)prennent tous en charge les identificateurs de clé de type LocalIdKeyIdentifierClause. Vous devez remplacer ces méthodes pour prendre en charge d’autres types d’identificateurs de clé dans votre classe dérivée.

Voir aussi

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause