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 obtidos do Custom Token exemplo. Este exemplo fornece classes personalizadas que permitem o processamento de SWT (Tokens Web Simples). Ele inclui uma implementação de uma SimpleWebToken classe e uma SimpleWebTokenHandler classe, bem como outras classes que dão suporte a tokens SWT. Para obter informações sobre este exemplo e outros exemplos disponíveis para WIF e sobre onde baixá-los, consulte Índice de exemplo de código WIF. O código a seguir mostra a implementação da SimpleWebToken classe . Essa 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 );
        } 
    }    
}

Comentários

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 STS (serviço de token de segurança), uma coleção de declarações sobre um assunto. Todos os tokens de segurança derivam da SecurityToken classe .

A partir do .NET 4.5, o WIF (Windows Identity Foundation) foi totalmente integrado ao .NET Framework e as classes expostas pelo WIF são o método preferencial de manipulação de tokens de segurança em seu código. No WIF, os tokens de segurança são serializados e desserializados de e para sua representação XML e são validados usando classes derivadas da SecurityTokenHandler classe base. Validar um token envolve não apenas garantir que o token seja válido, mas também retornar 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 do método do manipulador de token a ValidateToken partir das declarações contidas no token, bem como de declaraçõ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 em uma declaração SAML 2.0. Esse tipo de token normalmente é emitido por um serviço de token de segurança em resposta a um WS-Trust ou WS-Federation solicitação de token de segurança (RST).

• SamlSecurityToken: representa um token de segurança baseado em uma declaração SAML 1.1. Esse tipo de token normalmente é emitido por um serviço de token de segurança em resposta a um WS-Trust ou WS-Federation solicitação de token de segurança (RST).

• KerberosRequestorSecurityToken e KerberosReceiverSecurityToken: representa um token de segurança baseado em um tíquete Kerberos recebido ou enviado em uma mensagem SOAP

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

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

• UserNameSecurityToken: representa um token de segurança baseado em um nome de usuário e senha.

• WindowsSecurityToken: representa um token de segurança baseado na identidade de um domínio ou conta de usuário do Windows.

• X509SecurityToken: representa um token de segurança baseado em um certificado X.509.

• X509WindowsSecurityToken: representa um token de segurança baseado em um certificado X.509 mapeado para um usuário de domínio do Windows ou uma conta de usuário do computador local.

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

Em termos gerais, os tokens de segurança se enquadram em três categorias principais:

• Tokens que carregam ou referenciam material de chave criptográfica. Por exemplo, os RsaSecurityToken tipos e X509SecurityToken geralmente são usados para essa finalidade.

• Tokens que representam credenciais para usuários que já foram autenticados. Por exemplo, o UserNameSecurityToken, WindowsSecurityTokene, no caso de um usuário autenticado usando um certificado, os X509SecurityToken tipos .

• Tokens emitidos por um STS (serviço de token de segurança) em resposta a uma solicitação de token de segurança usando o protocolo WS-Trust ou WS-Federation. Normalmente, eles são retornados em um wst:RequestSecurityTokenResponse fragmento XML. Os Saml2SecurityToken tipos e SamlSecurityToken são usados com mais frequência para representar esses tokens.

Um tipo de token especial, o SessionSecurityToken, contém informações necessárias para recriar uma entidade de segurança ao usar sessões em cenários ativos ou passivos.

Para adicionar funcionalidade a tipos de token existentes, você pode derivar do tipo específico e seu manipulador de token associado para dar suporte a quaisquer novos elementos que você adicionar ao token. Para adicionar suporte para novos tipos de token, você pode derivar diretamente da SecurityToken classe . Ao fazer isso, você também precisará criar uma classe de manipulador de token derivando da SecurityTokenHandler classe . Dependendo de como seu token deve ser usado, talvez você também precise criar um resolvedor de token personalizado derivando da IssuerTokenResolver classe , bem como um ou mais tipos de cláusula de identificador de chave personalizada derivando da SecurityKeyIdentifierClause classe .

Notas aos Implementadores

Você deve substituir as Idpropriedades , SecurityKeysValidFrom, e ValidTo . Os CanCreateKeyIdentifierClause<T>()métodos , CreateKeyIdentifierClause<T>()MatchesKeyIdentifierClause(SecurityKeyIdentifierClause), e ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) dão suporte a identificadores de chave do tipo LocalIdKeyIdentifierClause. Você deve substituir esses métodos para dar suporte a outros tipos de identificador de chave em sua classe derivada.

Construtores

Propriedades

Métodos

Aplica-se a

Confira também

• SecurityTokenHandler
• SecurityKeyIdentifierClause
• IssuerTokenResolver
• LocalIdKeyIdentifierClause