SecurityToken Clase

Definición

Representa una clase base utilizada para implementar todos los tokens de seguridad.Represents a base class used to implement all security tokens.

public ref class SecurityToken abstract
public abstract class SecurityToken
type SecurityToken = class
Public MustInherit Class SecurityToken
Herencia
SecurityToken
Derivado

Ejemplos

Los ejemplos de código que se usan en los SecurityToken temas se toman del Custom Token ejemplo.The code examples that are used in the SecurityToken topics are taken from the Custom Token sample. Este ejemplo proporciona clases personalizadas que permiten el procesamiento de tokens web simples (SWT).This sample provides custom classes that enable processing of Simple Web Tokens (SWT). Incluye una implementación de una SimpleWebToken clase y una SimpleWebTokenHandler clase, así como otras clases que admiten tokens de SWT.It includes an implementation of a SimpleWebToken class and a SimpleWebTokenHandler class, as well as other classes that support SWT tokens. Para obtener información sobre este ejemplo y otros ejemplos disponibles para WIF y sobre dónde descargarlos, consulte Índice de ejemplo de código WIF.For information about this sample and other samples available for WIF and about where to download them, see WIF Code Sample Index. En el código siguiente se muestra la implementación de la SimpleWebToken clase.The following code shows the implementation of the SimpleWebToken class. Esta clase extiende SecurityToken .This class extends 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 );
        } 
    }    
}

Comentarios

Utilice un token de seguridad para proporcionar las credenciales de autenticación o para proteger un mensaje.Use a security token to provide authentication credentials or to protect a message.

Un token de seguridad se puede usar para proporcionar credenciales de autenticación, material de clave criptográfica o, en el caso de un token de seguridad emitido por un servicio de token de seguridad (STS), una colección de notificaciones sobre un sujeto.A security token can be used to provide authentication credentials, cryptographic key material, or, in the case of a security token issued by a security token service (STS), a collection of claims about a subject. Todos los tokens de seguridad se derivan de la SecurityToken clase.All security tokens derive from the SecurityToken class.

A partir de .NET 4,5, Windows Identity Foundation (WIF) se ha integrado totalmente en el .NET Framework y las clases expuestas por WIF son el método preferido para controlar los tokens de seguridad en el código.Beginning with .NET 4.5, Windows Identity Foundation (WIF) has been fully integrated into the .NET Framework and the classes exposed by WIF are the preferred method of handling security tokens in your code. En WIF, los tokens de seguridad se serializan y deserializan hacia y desde su representación XML y se validan mediante clases derivadas de la SecurityTokenHandler clase base.In WIF, security tokens are serialized and deserialized to and from their XML representation and are validated by using classes derived from the SecurityTokenHandler base class. La validación de un token implica no solo garantizar que el token sea válido, sino también devolver una ClaimsIdentity instancia del token que se puede usar para tomar decisiones de autenticación y autorización.Validating a token involves not just ensuring that the token is valid, but also returning a ClaimsIdentity instance from the token that can be used in making authentication and authorization decisions. ClaimsIdentitySe construye mediante la implementación del controlador de tokens del ValidateToken método a partir de las notificaciones contenidas en el token, así como de las notificaciones que son intrínsecas al propio tipo de token.The ClaimsIdentity is constructed by the token handler's implementation of the ValidateToken method from the claims contained in the token as well as from claims that are intrinsic to the token type itself.

WIF incluye compatibilidad con los siguientes tipos de tokens de seguridad:WIF ships with support for the following types of security tokens:

  • Saml2SecurityToken: Representa un token de seguridad basado en una aserción SAML 2,0.Saml2SecurityToken: Represents a security token that is based upon a SAML 2.0 Assertion. Este tipo de token normalmente lo emite un servicio de token de seguridad en respuesta a una solicitud de token de seguridad de WS-Trust o WS-Federation (RST).This token type is typically issued by a security token service in response to a WS-Trust or WS-Federation security token request (RST).

  • SamlSecurityToken: Representa un token de seguridad basado en una aserción SAML 1,1.SamlSecurityToken: Represents a security token that is based upon a SAML 1.1 Assertion. Este tipo de token normalmente lo emite un servicio de token de seguridad en respuesta a una solicitud de token de seguridad de WS-Trust o WS-Federation (RST).This token type is typically issued by a security token service in response to a WS-Trust or WS-Federation security token request (RST).

  • KerberosRequestorSecurityToken and KerberosReceiverSecurityToken : representa un token de seguridad que se basa en un vale de Kerberos que se recibe o se envía en un mensaje SOAP.KerberosRequestorSecurityToken and KerberosReceiverSecurityToken: Represents a security token that is based upon a Kerberos ticket that is received or sent in a SOAP message

  • RsaSecurityToken: Representa un token de seguridad que se basa en la clave que se crea utilizando el algoritmo de RSA.RsaSecurityToken: Represents a security token that is based upon key that is created using the RSA algorithm.

  • SessionSecurityToken: Representa un token de seguridad que contiene información sobre una sesión.SessionSecurityToken: Represents a security token that contains information about a session.

  • UserNameSecurityToken: Representa un token de seguridad basado en un nombre de usuario y una contraseña.UserNameSecurityToken: Represents a security token that is based on a username and password.

  • WindowsSecurityToken: Representa un token de seguridad que se basa en la identidad de un dominio o cuenta de usuario de Windows.WindowsSecurityToken: Represents a security token that is based on the identity of a Windows domain or user account.

  • X509SecurityToken: Representa un token de seguridad basado en un certificado X. 509.X509SecurityToken: Represents a security token that is based on an X.509 certificate.

  • X509WindowsSecurityToken: Representa un token de seguridad que se basa en un certificado X. 509 que se asigna a una cuenta de usuario de dominio de Windows o de equipo local.X509WindowsSecurityToken: Represents a security token that is based upon an X.509 certificate that is mapped to a Windows domain user or local computer user account.

Otras dos clases de tokens de seguridad, GenericXmlSecurityToken y EncryptedSecurityToken , se pueden utilizar para ayudar a controlar los casos generales.Two other security token classes, GenericXmlSecurityToken and EncryptedSecurityToken, can be used to help handle general cases.

Los tokens de seguridad de ámbito general se dividen en tres categorías principales:Broadly speaking security tokens fall into three major categories:

  • Tokens que incluyen o hacen referencia a material de clave criptográfica.Tokens that carry or reference cryptographic key material. Por ejemplo RsaSecurityToken , los X509SecurityToken tipos y suelen usarse para este fin.For example the RsaSecurityToken and X509SecurityToken types are often used for this purpose.

  • Tokens que representan las credenciales para los usuarios que ya se han autenticado.Tokens that represent credentials for users that have already been authenticated. Por ejemplo,, UserNameSecurityToken WindowsSecurityToken y, en el caso de un usuario autenticado mediante un certificado, los X509SecurityToken tipos.For example, the UserNameSecurityToken, WindowsSecurityToken, and, in the case of a user authenticated using a certificate, the X509SecurityToken types.

  • Tokens emitidos por un servicio de token de seguridad (STS) en respuesta a una solicitud de token de seguridad mediante el protocolo WS-Trust o WS-Federation.Tokens that are issued by a security token service (STS) in response to a security token request using either the WS-Trust or WS-Federation protocol. Normalmente se devuelven en un wst:RequestSecurityTokenResponse fragmento XML.These are typically returned in a wst:RequestSecurityTokenResponse XML fragment. Los Saml2SecurityToken tipos y suelen SamlSecurityToken usarse para representar estos tokens.The Saml2SecurityToken and SamlSecurityToken types are most often used to represent these tokens.

Un tipo de token especial, SessionSecurityToken , contiene información necesaria para volver a crear una entidad de seguridad cuando se usan sesiones en escenarios activos o pasivos.A special token type, the SessionSecurityToken, contains information necessary to recreate a principal when using sessions in active or passive scenarios.

Para agregar funcionalidad a los tipos de token existentes, puede derivar del tipo específico y su controlador de token asociado para admitir los nuevos elementos que agregue al token.To add functionality to existing token types you can derive from the specific type and its associated token handler to support any new elements that you add to the token. Para agregar compatibilidad con los nuevos tipos de token, puede derivar directamente de la SecurityToken clase.To add support for new token types, you can derive directly from the SecurityToken class. Al hacerlo, también tendrá que crear una clase de controlador de tokens mediante la derivación de la SecurityTokenHandler clase.When you do this, you will also need to create a token handler class by deriving from the SecurityTokenHandler class. Dependiendo de cómo se use el token, puede que también tenga que crear una resolución de tokens personalizada mediante la derivación de la clase, así IssuerTokenResolver como uno o varios tipos de cláusula de identificador de clave personalizada mediante la derivación de la SecurityKeyIdentifierClause clase.Depending on how your token is to be used, you may also need to create a custom token resolver by deriving from the IssuerTokenResolver class as well as one or more custom key identifier clause types by deriving from the SecurityKeyIdentifierClause class.

Notas a los implementadores

Debe reemplazar las Id propiedades, SecurityKeys , ValidFrom y ValidTo .You must override the Id, SecurityKeys, ValidFrom, and ValidTo properties. Los CanCreateKeyIdentifierClause<T>() CreateKeyIdentifierClause<T>() métodos,, MatchesKeyIdentifierClause(SecurityKeyIdentifierClause) y ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) admiten los identificadores de clave de tipo LocalIdKeyIdentifierClause .The CanCreateKeyIdentifierClause<T>(), CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause), and ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) methods all support key identifiers of type LocalIdKeyIdentifierClause. Debe invalidar estos métodos para admitir otros tipos de identificador de clave en la clase derivada.You must override these methods to support other key identifier types in your derived class.

Constructores

SecurityToken()

Se le llama desde los constructores en las clases derivadas para inicializar la clase SecurityToken.Called by constructors in derived classes to initialize the SecurityToken class.

Propiedades

Id

Obtiene un identificador único del token de seguridad.Gets a unique identifier of the security token.

SecurityKeys

Obtiene las claves criptográficas asociadas al token de seguridad.Gets the cryptographic keys associated with the security token.

ValidFrom

Obtiene a tiempo el primer momento en el que este token de seguridad es válido.Gets the first instant in time at which this security token is valid.

ValidTo

Obtiene a tiempo el último momento en el que este token de seguridad es válido.Gets the last instant in time at which this security token is valid.

Métodos

CanCreateKeyIdentifierClause<T>()

Obtiene un valor que indica si este token de seguridad es capaz de crear el identificador clave especificado.Gets a value that indicates whether this security token is capable of creating the specified key identifier.

CreateKeyIdentifierClause<T>()

Crea la cláusula de identificador de clave especificada.Creates the specified key identifier clause.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)

Devuelve un valor que indica si el identificador clave para esta instancia puede resolverse en el identificador de clave especificado.Returns a value that indicates whether the key identifier for this instance can be resolved to the specified key identifier.

MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ResolveKeyIdentifierClause(SecurityKeyIdentifierClause)

Obtiene la clave para la cláusula de identificador de clave especificada.Gets the key for the specified key identifier clause.

ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Se aplica a

Consulte también