SecurityToken Clase

Definición

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Herencia

Object

SecurityToken

Derivado

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Más…

Ejemplos

Los ejemplos de código que se usan en los SecurityToken temas se toman del Custom Token ejemplo. En este ejemplo se proporcionan clases personalizadas que permiten el procesamiento de tokens web simples (SWT). Incluye una implementación de una SimpleWebToken clase y una SimpleWebTokenHandler clase, así como otras clases que admiten tokens SWT. 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. En el código siguiente se muestra la implementación de la SimpleWebToken clase . Esta clase extiende 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.

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 asunto. Todos los tokens de seguridad derivan de la SecurityToken clase .

A partir de .NET 4.5, Windows Identity Foundation (WIF) se ha integrado completamente en .NET Framework y las clases expuestas por WIF son el método preferido para controlar los tokens de seguridad en el código. 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. Validar un token implica no solo asegurarse de que el token es válido, sino también devolver una ClaimsIdentity instancia del token que se puede usar para tomar decisiones de autenticación y autorización. ClaimsIdentity se construye mediante la implementación del controlador de tokens del método a partir de ValidateToken las notificaciones contenidas en el token, así como de las notificaciones intrínsecas al propio tipo de token.

WIF incluye compatibilidad con los siguientes tipos de tokens de seguridad:

• Saml2SecurityToken: representa un token de seguridad basado en una aserción de SAML 2.0. Este tipo de token normalmente lo emite un servicio de token de seguridad en respuesta a una solicitud de token de seguridad (RST) WS-Trust o WS-Federation.

• SamlSecurityToken: representa un token de seguridad basado en una aserción de SAML 1.1. Este tipo de token normalmente lo emite un servicio de token de seguridad en respuesta a una solicitud de token de seguridad (RST) WS-Trust o WS-Federation.

• KerberosRequestorSecurityToken y KerberosReceiverSecurityToken: representa un token de seguridad basado en un vale kerberos que se recibe o envía en un mensaje SOAP.

• RsaSecurityToken: representa un token de seguridad basado en la clave que se crea mediante el algoritmo RSA.

• SessionSecurityToken: representa un token de seguridad que contiene información sobre una sesión.

• UserNameSecurityToken: representa un token de seguridad basado en un nombre de usuario y una contraseña.

• WindowsSecurityToken: representa un token de seguridad basado en la identidad de un dominio de Windows o una cuenta de usuario.

• X509SecurityToken: representa un token de seguridad basado en un certificado X.509.

• X509WindowsSecurityToken: representa un token de seguridad basado en un certificado X.509 asignado a un usuario de dominio de Windows o a una cuenta de usuario de equipo local.

Se pueden usar otras dos clases de token de seguridad y GenericXmlSecurityTokenEncryptedSecurityToken, para ayudar a controlar los casos generales.

En términos generales, los tokens de seguridad se dividen en tres categorías principales:

• Tokens que llevan o hacen referencia al material de clave criptográfica. Por ejemplo, los RsaSecurityToken tipos y X509SecurityToken se usan a menudo para este propósito.

• Tokens que representan credenciales para los usuarios que ya se han autenticado. Por ejemplo, , UserNameSecurityTokenWindowsSecurityTokeny, en el caso de un usuario autenticado mediante un certificado, los X509SecurityToken tipos .

• 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. Normalmente se devuelven en un wst:RequestSecurityTokenResponse fragmento XML. Los Saml2SecurityToken tipos y SamlSecurityToken se usan con más frecuencia para representar estos tokens.

Un tipo de token especial, , SessionSecurityTokencontiene información necesaria para volver a crear una entidad de seguridad cuando se usan sesiones en escenarios activos o pasivos.

Para agregar funcionalidad a los tipos de token existentes, puede derivar del tipo específico y su controlador de tokens asociado para admitir los nuevos elementos que agregue al token. Para agregar compatibilidad con nuevos tipos de token, puede derivar directamente de la SecurityToken clase . Al hacerlo, también tendrá que crear una clase de controlador de tokens derivando de la SecurityTokenHandler clase . En función de cómo se use el token, es posible que también tenga que crear un solucionador de tokens personalizado derivando de la IssuerTokenResolver clase, así como uno o varios tipos de cláusulas de identificador de clave personalizadas derivando de la SecurityKeyIdentifierClause clase .

Notas a los implementadores

Debe invalidar las Idpropiedades , SecurityKeys, ValidFromy ValidTo . Todos CanCreateKeyIdentifierClause<T>()los métodos , CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)y ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) admiten identificadores clave de tipo LocalIdKeyIdentifierClause. Debe invalidar estos métodos para admitir otros tipos de identificador de clave en la clase derivada.

Constructores

Propiedades

Métodos

Se aplica a

Consulte también

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause