SecurityToken Classe

Definição

public ref class SecurityToken abstract

public abstract class SecurityToken

type SecurityToken = class

Public MustInherit Class SecurityToken

Herança

Object

SecurityToken

Derivado

System.IdentityModel.Tokens.EncryptedSecurityToken

System.IdentityModel.Tokens.GenericXmlSecurityToken

System.IdentityModel.Tokens.KerberosRequestorSecurityToken

System.IdentityModel.Tokens.RsaSecurityToken

System.IdentityModel.Tokens.Saml2SecurityToken

Mais…

Exemplos

Os exemplos de código usados nos SecurityToken tópicos são retirados da Custom Token amostra. Este exemplo fornece classes personalizadas que permitem o processamento de Simples Web Tokens (SWT). Inclui uma implementação de uma SimpleWebToken classe e uma SimpleWebTokenHandler classe, bem como outras classes que suportam tokens SWT. Para informações sobre esta amostra e outras amostras disponíveis para WIF e sobre onde as descarregar, consulte o Índice de Exemplos de Código WIF. O código seguinte mostra a implementação da SimpleWebToken classe. Esta classe estende-se SecurityTokena .

/// <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 );
        } 
    }    
}

Observações

Use um token de segurança para fornecer credenciais de autenticação ou para proteger uma mensagem.

Um token de segurança pode ser usado para fornecer credenciais de autenticação, material de chave criptográfica ou, no caso de um token de segurança emitido por um serviço de token de segurança (STS), uma coleção de afirmações sobre um sujeito. Todos os tokens de segurança derivam da SecurityToken classe.

A partir do .NET 4.5, o Windows Identity Foundation (WIF) foi totalmente integrado no .NET Framework e as classes expostas pelo WIF são o método preferido para gerir tokens de segurança no seu código. No WIF, os tokens de segurança são serializados e desserializados para e a partir da sua representação XML e são validados usando classes derivadas da SecurityTokenHandler classe base. Validar um token envolve não só garantir que o token é válido, mas também devolver uma ClaimsIdentity instância do token que pode ser usada para tomar decisões de autenticação e autorização. O ClaimsIdentity é construído pela implementação ValidateToken do método pelo manipulador do token a partir das reivindicações contidas no token, bem como a partir de reivindicações intrínsecas ao próprio tipo de token.

O WIF é fornecido com suporte para os seguintes tipos de tokens de segurança:

• Saml2SecurityToken: Representa um token de segurança baseado numa Asserção SAML 2.0. Este tipo de token é normalmente emitido por um serviço de token de segurança em resposta a um pedido de token de segurança (RST) WS-Trust ou WS-Federation.

• SamlSecurityToken: Representa um token de segurança baseado numa Asserção SAML 1.1. Este tipo de token é normalmente emitido por um serviço de token de segurança em resposta a um pedido de token de segurança (RST) WS-Trust ou WS-Federation.

• KerberosRequestorSecurityToken e KerberosReceiverSecurityToken: Representa um token de segurança baseado num bilhete Kerberos que é recebido ou enviado numa mensagem SOAP

• RsaSecurityToken: Representa um token de segurança baseado numa chave criada usando o algoritmo RSA.

• SessionSecurityToken: Representa um token de segurança que contém informação sobre uma sessão.

• UserNameSecurityToken: Representa um token de segurança baseado num nome de utilizador e palavra-passe.

• WindowsSecurityToken: Representa um token de segurança baseado na identidade de um domínio Windows ou conta de utilizador.

• X509SecurityToken: Representa um token de segurança baseado num certificado X.509.

• X509WindowsSecurityToken: Representa um token de segurança baseado num certificado X.509 que é mapeado para uma conta de utilizador de domínio Windows ou de um computador local.

Duas outras classes de tokens de segurança, GenericXmlSecurityToken e EncryptedSecurityToken, podem ser usadas para ajudar a lidar com casos gerais.

De um modo geral, os tokens de segurança dividem-se em três grandes categorias:

• Tokens que transportam ou referenciam material de chave criptográfica. Por exemplo, os RsaSecurityToken tipos e X509SecurityToken são frequentemente usados para este fim.

• Tokens que representam credenciais de utilizadores que já foram autenticados. Por exemplo, o UserNameSecurityToken, WindowsSecurityToken, e, no caso de um utilizador autenticado usando um certificado, os X509SecurityToken tipos.

• Tokens que são emitidos por um serviço de token de segurança (STS) em resposta a um pedido de token de segurança utilizando o protocolo WS-Trust ou WS-Federation. Estes são normalmente devolvidos num wst:RequestSecurityTokenResponse fragmento XML. Os Saml2SecurityToken tipos e SamlSecurityToken são mais frequentemente usados para representar estes tokens.

Um tipo especial de token, o SessionSecurityToken, contém informação necessária para recriar um princípio ao utilizar sessões em cenários ativos ou passivos.

Para adicionar funcionalidade aos tipos de tokens existentes, pode derivar a partir do tipo específico e do seu gestor de tokens associado para suportar quaisquer novos elementos que adicione ao token. Para adicionar suporte a novos tipos de tokens, podes derivar diretamente da SecurityToken classe. Ao fazer isto, também terá de criar uma classe handler de tokens derivando da SecurityTokenHandler classe. Dependendo de como o seu token for usado, poderá também ser necessário criar um resolvedor de token personalizado derivando da IssuerTokenResolver classe, bem como um ou mais tipos personalizados de cláusulas identificadoras de chave, derivando da SecurityKeyIdentifierClause classe.

Notas para Implementadores

Deve sobrepor as Idpropriedades , SecurityKeys, ValidFrom, e ValidTo . Os CanCreateKeyIdentifierClause<T>()métodos , CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause), e ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) suportam todos identificadores-chave do tipo LocalIdKeyIdentifierClause. Deve sobrescrever estes métodos para suportar outros tipos de identificadores-chave na sua classe derivada.

Ver também

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause