Procedimiento para crear un token personalizado

  • Artículo

Este tema muestra cómo crear un token de seguridad personalizado mediante la clase SecurityToken y cómo integrarlo en un autenticador y en un proveedor de token de seguridad personalizado. Para ver un ejemplo completo de código, consulte el ejemplo Token personalizado.

Un token de seguridad es esencialmente un elemento XML que el marco de seguridad de Windows Communication Foundation (WCF) emplea para representar notificaciones sobre un remitente dentro del mensaje SOAP. La seguridad de WCF proporciona varios tokens para los modos de autenticación facilitados por el sistema. En los ejemplos se incluye un token de seguridad de certificado X.509 representado por la clase X509SecurityToken o un token de seguridad Username representado por la clase UserNameSecurityToken.

A veces los tipos proporcionados no admiten un modo de autenticación o credencial. En ese caso, es necesario para crear un token de seguridad personalizado para proporcionar una representación XML de la credencial personalizada dentro del mensaje SOAP.

Los siguientes procedimientos muestran cómo crear un token de seguridad personalizado y cómo integrarlo en la infraestructura de seguridad de WCF. En este tema se crea un token de tarjeta de crédito que se utiliza para pasar información sobre la tarjeta de crédito del cliente al servidor.

Para más información sobre las credenciales personalizadas y el administrador de tokens de seguridad, consulte Tutorial: Creación de credenciales de cliente y servicio personalizadas.

Vea el espacio de nombres System.IdentityModel.Tokens para obtener más clases que representen tokens de seguridad.

Procedimientos

Es necesario proporcionar a una aplicación cliente una manera de especificar información de la tarjeta de crédito para la infraestructura de seguridad. Una clase de credenciales de cliente personalizada pone esta información a disposición de la aplicación. El primer paso es crear una clase para que represente la información de la tarjeta de crédito para las credenciales de cliente personalizadas.

Para crear una clase que represente información de la tarjeta de crédito dentro de las credenciales de cliente

  1. Defina una nueva clase que represente la información de la tarjeta de crédito para la aplicación. En el siguiente ejemplo se nombra la clase CreditCardInfo.

  2. Agregue las propiedades adecuadas a la clase para permitir que una aplicación establezca la información necesaria para el token personalizado. En este ejemplo, la clase tiene tres propiedades: CardNumber, CardIssuery ExpirationDate.

    public class CreditCardInfo
{
    string cardNumber;
    string cardIssuer;
    DateTime expirationDate;

    public CreditCardInfo(string cardNumber, string cardIssuer, DateTime expirationDate)
    {
        this.cardNumber = cardNumber;
        this.cardIssuer = cardIssuer;
        this.expirationDate = expirationDate;
    }

    public string CardNumber
    {
        get { return this.cardNumber; }
    }

    public string CardIssuer
    {
        get { return this.cardIssuer; }
    }

    public DateTime ExpirationDate
    {
        get { return this.expirationDate; }
    }
}

    Public Class CreditCardInfo

    Private _cardNumber As String
    Private _cardIssuer As String
    Private _expirationDate As DateTime

    Public Sub New(ByVal cardNumber As String, ByVal cardIssuer As String, _
                   ByVal expirationDate As DateTime)
        Me._cardNumber = cardNumber
        Me._cardIssuer = cardIssuer
        Me._expirationDate = expirationDate
    End Sub

    Public ReadOnly Property CardNumber() As String
        Get
            Return Me._cardNumber
        End Get
    End Property

    Public ReadOnly Property CardIssuer() As String
        Get
            Return Me._cardIssuer
        End Get
    End Property

    Public ReadOnly Property ExpirationDate() As DateTime
        Get
            Return Me._expirationDate
        End Get
    End Property

End Class

A continuación, se ha de crear una clase que represente el token de seguridad personalizado. El proveedor de tokens de seguridad, el autenticador y las clases del serializador usan esta clase para pasar información sobre el token de seguridad a la infraestructura de seguridad de WCF y desde allí.

Para crear una clase de token de seguridad personalizada

  1. Defina una clase nueva derivada de la clase SecurityToken. En este ejemplo se crea una clase denominada CreditCardToken.

  2. Invalide la propiedad Id. Esta propiedad se utiliza para obtener el identificador local del token de seguridad que se utiliza para señalar a la representación XML del token de seguridad desde otros elementos dentro del mensaje SOAP. En este ejemplo, se le puede pasar un identificador de token como parámetro de constructor o se puede generar uno nuevo aleatorio cada vez que se cree una instancia de token de seguridad.

  3. Implemente la propiedad SecurityKeys. Esta propiedad devuelve una colección de claves de seguridad que representa la instancia del token de seguridad. WCF puede usar este tipo de claves para firmar o cifrar partes del mensaje SOAP. En este ejemplo, el token de seguridad de la tarjeta de crédito no puede contener ninguna clave de seguridad; por consiguiente, la implementación siempre devuelve una colección vacía.

  4. Invalide las propiedades ValidFrom y ValidTo. WCF usa estas propiedades para determinar la validez de la instancia del token de seguridad. En este ejemplo, el token de seguridad de la tarjeta de crédito solo tiene una fecha de expiración, por lo que la propiedad ValidFrom devuelve DateTime que representa la fecha y hora de creación de la instancia.

    class CreditCardToken : SecurityToken
{
    CreditCardInfo cardInfo;
    DateTime effectiveTime = DateTime.UtcNow;
    string id;
    ReadOnlyCollection<SecurityKey> securityKeys;

    public CreditCardToken(CreditCardInfo cardInfo) : this(cardInfo, Guid.NewGuid().ToString()) { }

    public CreditCardToken(CreditCardInfo cardInfo, string id)
    {
        if (cardInfo == null)
        {
            throw new ArgumentNullException("cardInfo");
        }
        if (id == null)
        {
            throw new ArgumentNullException("id");
        }

        this.cardInfo = cardInfo;
        this.id = id;
        // The credit card token is not capable of any cryptography.
        this.securityKeys = new ReadOnlyCollection<SecurityKey>(new List<SecurityKey>());
    }

    public CreditCardInfo CardInfo
    {
        get { return this.cardInfo; }
    }

    public override ReadOnlyCollection<SecurityKey> SecurityKeys
    {
        get { return this.securityKeys; }
    }

    public override DateTime ValidFrom
    {
        get { return this.effectiveTime; }
    }

    public override DateTime ValidTo
    {
        get { return this.cardInfo.ExpirationDate; }
    }

    public override string Id
    {
        get { return this.id; }
    }
}

    Friend Class CreditCardToken
    Inherits SecurityToken

    Private _cardInfo As CreditCardInfo
    Private _effectiveTime As DateTime = DateTime.UtcNow
    Private _id As String
    Private _securityKeys As ReadOnlyCollection(Of SecurityKey)

    Public Sub New(ByVal cardInfo As CreditCardInfo)
        Me.New(cardInfo, Guid.NewGuid().ToString())
    End Sub

    Public Sub New(ByVal cardInfo As CreditCardInfo, _
                   ByVal id As String)
        If cardInfo Is Nothing Then
            Throw New ArgumentNullException("cardInfo")
        End If
        If id Is Nothing Then
            Throw New ArgumentNullException("id")
        End If

        Me._cardInfo = cardInfo
        Me._id = id
        ' The credit card token is not capable of any cryptography.
        Me._securityKeys = New ReadOnlyCollection(Of SecurityKey)(New List(Of SecurityKey)())
    End Sub

    Public ReadOnly Property CardInfo() As CreditCardInfo
        Get
            Return Me._cardInfo
        End Get
    End Property

    Public Overrides ReadOnly Property SecurityKeys() As ReadOnlyCollection(Of SecurityKey)
        Get
            Return Me._securityKeys
        End Get
    End Property

    Public Overrides ReadOnly Property ValidFrom() As DateTime
        Get
            Return Me._effectiveTime
        End Get
    End Property

    Public Overrides ReadOnly Property ValidTo() As DateTime
        Get
            Return Me._cardInfo.ExpirationDate
        End Get
    End Property

    Public Overrides ReadOnly Property Id() As String
        Get
            Return Me._id
        End Get
    End Property
End Class

Cuando se crea un nuevo tipo de token de seguridad, requiere una implementación de la clase SecurityTokenParameters. La implementación se utiliza en la configuración del elemento de enlace de seguridad para representar el nuevo tipo de token. La clase de los parámetros de token de seguridad sirve como plantilla que se emplea para igualar a la instancia del token de seguridad real cuando se procesa un mensaje. La plantilla proporciona propiedades adicionales que una aplicación puede utilizar para especificar los criterios a los que debe ajustarse el token de seguridad para que pueda usarse o autenticarse. En el siguiente ejemplo no se agrega ninguna propiedad, de modo que solo se busca la coincidencia del tipo de token de seguridad cuando la infraestructura de WCF busca una instancia del token de seguridad que debe utilizar o validar.

Para crear una clase de parámetros de token de seguridad personalizada

  1. Defina una clase nueva derivada de la clase SecurityTokenParameters.

  2. Implemente el método CloneCore. Copie todos los campos internos definidos en su clase, si hubiese alguno. Este ejemplo no define ningún campo adicional.

  3. Implemente la propiedad de solo lectura SupportsClientAuthentication. Esta propiedad devuelve true si el tipo de token de seguridad representado por esta clase se puede utilizar para autenticar un cliente a un servicio. En este ejemplo, el token de seguridad de la tarjeta de crédito se puede utilizar para autenticar un cliente a un servicio.

  4. Implemente la propiedad de solo lectura SupportsServerAuthentication. Esta propiedad devuelve true si el tipo de token de seguridad representado por esta clase se puede utilizar para autenticar un servicio a un cliente. En este ejemplo, el token de seguridad de la tarjeta de crédito no se puede utilizar para autenticar un servicio a un cliente.

  5. Implemente la propiedad de solo lectura SupportsClientWindowsIdentity. Esta propiedad devuelve true si el tipo de token de seguridad representado por esta clase puede asignarse a una cuenta de Windows. En ese caso, el resultado de la autenticación se representa mediante una instancia de la clase WindowsIdentity. En este ejemplo, el token no se puede asignar a una cuenta de Windows.

  6. Implemente el método CreateKeyIdentifierClause(SecurityToken, SecurityTokenReferenceStyle). El marco de seguridad de WCF llama a este método cuando necesita una referencia a la instancia del token de seguridad representada por esta clase de parámetros de token de seguridad. Tanto la instancia del token de seguridad real como el SecurityTokenReferenceStyle que especifica el tipo de la referencia que se solicita se pasan a este método como argumentos. En este ejemplo el token de seguridad de la tarjeta de crédito solo admite referencias internas. La clase SecurityToken tiene funcionalidad para crear referencias internas, por lo que la implementación no precisa código adicional.

  7. Implemente el método InitializeSecurityTokenRequirement(SecurityTokenRequirement). WCF llama a este método para convertir la instancia de la clase de parámetros de token de seguridad en una instancia de la clase SecurityTokenRequirement. Los proveedores de tokens de seguridad utilizan el resultado para crear la instancia del token de seguridad adecuada.

    public class CreditCardTokenParameters : SecurityTokenParameters
{
    public CreditCardTokenParameters()
    {
    }

    protected CreditCardTokenParameters(CreditCardTokenParameters other)
        : base(other)
    {
    }

    protected override SecurityTokenParameters CloneCore()
    {
        return new CreditCardTokenParameters(this);
    }

    protected override void InitializeSecurityTokenRequirement(SecurityTokenRequirement requirement)
    {
        requirement.TokenType = Constants.CreditCardTokenType;
        return;
    }

    // A credit card token has no cryptography, no windows identity, and supports only client authentication.
    protected override bool HasAsymmetricKey
    {
        get { return false; }
    }

    protected override bool SupportsClientAuthentication
    {
        get { return true; }
    }

    protected override bool SupportsClientWindowsIdentity
    {
        get { return false; }
    }

    protected override bool SupportsServerAuthentication
    {
        get { return false; }
    }

    protected override SecurityKeyIdentifierClause CreateKeyIdentifierClause(SecurityToken token, SecurityTokenReferenceStyle referenceStyle)
    {
        if (referenceStyle == SecurityTokenReferenceStyle.Internal)
        {
            return token.CreateKeyIdentifierClause<LocalIdKeyIdentifierClause>();
        }
        else
        {
            throw new NotSupportedException("External references are not supported for credit card tokens");
        }
    }
}

    Public Class CreditCardTokenParameters
    Inherits SecurityTokenParameters

    Public Sub New()
    End Sub

    Protected Sub New(ByVal other As CreditCardTokenParameters)
        MyBase.New(other)
    End Sub

    Protected Overrides Function CloneCore() As SecurityTokenParameters
        Return New CreditCardTokenParameters(Me)
    End Function

    Protected Overrides Sub InitializeSecurityTokenRequirement(ByVal requirement As SecurityTokenRequirement)
        requirement.TokenType = Constants.CreditCardTokenType
        Return
    End Sub

    ' A credit card token has no cryptography, no windows identity, and supports only client authentication.
    Protected Overrides ReadOnly Property HasAsymmetricKey() As Boolean
        Get
            Return False
        End Get
    End Property

    Protected Overrides ReadOnly Property SupportsClientAuthentication() As Boolean
        Get
            Return True
        End Get
    End Property

    Protected Overrides ReadOnly Property SupportsClientWindowsIdentity() As Boolean
        Get
            Return False
        End Get
    End Property

    Protected Overrides ReadOnly Property SupportsServerAuthentication() As Boolean
        Get
            Return False
        End Get
    End Property

    Protected Overrides Function CreateKeyIdentifierClause(ByVal token As SecurityToken, _
                                                           ByVal referenceStyle As SecurityTokenReferenceStyle) As SecurityKeyIdentifierClause
        If referenceStyle = SecurityTokenReferenceStyle.Internal Then
            Return token.CreateKeyIdentifierClause(Of LocalIdKeyIdentifierClause)()
        Else
            Throw New NotSupportedException("External references are not supported for credit card tokens")
        End If
    End Function

End Class

Los tokens de seguridad se transmiten dentro de los mensajes SOAP, lo que necesita un mecanismo de traducción entre la representación del token de seguridad en memoria y la representación en tránsito. Para realizar esta tarea, WCF usa un serializador de tokens de seguridad. Todos los tokens personalizados deben estar acompañados de un serializador de tokens de seguridad personalizado que pueda serializar y deserializar el token de seguridad personalizado del mensaje SOAP.

Nota

Las claves derivadas están habilitadas de forma predeterminada. Si crea un token de seguridad personalizado y lo utiliza como token principal, WCF obtiene una clave de él. En este proceso, llama al serializador del token de seguridad personalizado para escribir la SecurityKeyIdentifierClause para el token de seguridad personalizado durante la serialización de DerivedKeyToken en la conexión. En el extremo receptor, al deserializar el token fuera de la conexión, el serializador DerivedKeyToken espera un elemento SecurityTokenReference como elemento secundario de nivel superior bajo sí mismo. Si el serializador del token de seguridad personalizado no agregó un elemento SecurityTokenReference durante la serialización de su tipo de cláusula, se produce una excepción.

Para crear un serializador de tokens de seguridad personalizado

  1. Defina una clase nueva derivada de la clase WSSecurityTokenSerializer.

  2. Invalide el método CanReadTokenCore(XmlReader), que se basa en un XmlReader para leer la secuencia XML. El método devuelve true si la implementación del serializador puede deserializar el token de seguridad dado su elemento actual. En este ejemplo, este método comprueba si el elemento XML actual del lector XML tiene el nombre de elemento y espacio de nombres correctos. Si no es así, llama a la implementación de la clase base de este método para controlar el elemento XML.

  3. Invalide el método ReadTokenCore(XmlReader, SecurityTokenResolver) . Este método lee el contenido XML del token de seguridad y construye la representación en memoria adecuada para el mismo. Si no reconoce el elemento XML sobre el que se alza el lector XML pasado, llama a la implementación de la clase base para procesar los tipos de token proporcionados por el sistema.

  4. Invalide el método CanWriteTokenCore(SecurityToken) . Este método devuelve true si puede convertir la representación del token en memoria (pasado como argumento) en la representación XML. Si no puede convertirlo, llama a la implementación de la clase base.

  5. Invalide el método WriteTokenCore(XmlWriter, SecurityToken) . Este método convierte una representación de tokens de seguridad en memoria en una representación XML. Si el método no puede convertirlo, llama a la implementación de la clase base.

    public class CreditCardSecurityTokenSerializer : WSSecurityTokenSerializer
{
    public CreditCardSecurityTokenSerializer(SecurityTokenVersion version) : base() { }

    protected override bool CanReadTokenCore(XmlReader reader)
    {
        XmlDictionaryReader localReader = XmlDictionaryReader.CreateDictionaryReader(reader);
        if (reader == null)
        {
            throw new ArgumentNullException("reader");
        }
        if (reader.IsStartElement(Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace))
        {
            return true;
        }
        return base.CanReadTokenCore(reader);
    }

    protected override SecurityToken ReadTokenCore(XmlReader reader, SecurityTokenResolver tokenResolver)
    {
        if (reader == null)
        {
            throw new ArgumentNullException("reader");
        }
        if (reader.IsStartElement(Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace))
        {
            string id = reader.GetAttribute(Constants.Id, Constants.WsUtilityNamespace);

            reader.ReadStartElement();

            // Read the credit card number.
            string creditCardNumber = reader.ReadElementString(Constants.CreditCardNumberElementName, Constants.CreditCardTokenNamespace);

            // Read the expiration date.
            string expirationTimeString = reader.ReadElementString(Constants.CreditCardExpirationElementName, Constants.CreditCardTokenNamespace);
            DateTime expirationTime = XmlConvert.ToDateTime(expirationTimeString, XmlDateTimeSerializationMode.Utc);

            // Read the issuer of the credit card.
            string creditCardIssuer = reader.ReadElementString(Constants.CreditCardIssuerElementName, Constants.CreditCardTokenNamespace);
            reader.ReadEndElement();

            CreditCardInfo cardInfo = new CreditCardInfo(creditCardNumber, creditCardIssuer, expirationTime);

            return new CreditCardToken(cardInfo, id);
        }
        else
        {
            return WSSecurityTokenSerializer.DefaultInstance.ReadToken(reader, tokenResolver);
        }
    }

    protected override bool CanWriteTokenCore(SecurityToken token)
    {
        if (token is CreditCardToken)
        {
            return true;
        }
        else
        {
            return base.CanWriteTokenCore(token);
        }
    }

    protected override void WriteTokenCore(XmlWriter writer, SecurityToken token)
    {
        if (writer == null)
        {
            throw new ArgumentNullException("writer");
        }
        if (token == null)
        {
            throw new ArgumentNullException("token");
        }

        CreditCardToken c = token as CreditCardToken;
        if (c != null)
        {
            writer.WriteStartElement(Constants.CreditCardTokenPrefix, Constants.CreditCardTokenName, Constants.CreditCardTokenNamespace);
            writer.WriteAttributeString(Constants.WsUtilityPrefix, Constants.Id, Constants.WsUtilityNamespace, token.Id);
            writer.WriteElementString(Constants.CreditCardNumberElementName, Constants.CreditCardTokenNamespace, c.CardInfo.CardNumber);
            writer.WriteElementString(Constants.CreditCardExpirationElementName, Constants.CreditCardTokenNamespace, XmlConvert.ToString(c.CardInfo.ExpirationDate, XmlDateTimeSerializationMode.Utc));
            writer.WriteElementString(Constants.CreditCardIssuerElementName, Constants.CreditCardTokenNamespace, c.CardInfo.CardIssuer);
            writer.WriteEndElement();
            writer.Flush();
        }
        else
        {
            base.WriteTokenCore(writer, token);
        }
    }
}

    Public Class CreditCardSecurityTokenSerializer
    Inherits WSSecurityTokenSerializer

    Public Sub New(ByVal version As SecurityTokenVersion)
        MyBase.New()
    End Sub

    Protected Overrides Function CanReadTokenCore(ByVal reader As XmlReader) As Boolean
        Dim localReader = XmlDictionaryReader.CreateDictionaryReader(reader)
        If reader Is Nothing Then
            Throw New ArgumentNullException("reader")
        End If
        If reader.IsStartElement(Constants.CreditCardTokenName, _
                                 Constants.CreditCardTokenNamespace) Then
            Return True
        End If
        Return MyBase.CanReadTokenCore(reader)
    End Function

    Protected Overrides Function ReadTokenCore(ByVal reader As XmlReader, _
                                               ByVal tokenResolver As SecurityTokenResolver) As SecurityToken
        If reader Is Nothing Then
            Throw New ArgumentNullException("reader")
        End If
        If reader.IsStartElement(Constants.CreditCardTokenName, _
                                 Constants.CreditCardTokenNamespace) Then

            Dim id = reader.GetAttribute(Constants.Id, _
                                         Constants.WsUtilityNamespace)
            reader.ReadStartElement()

            ' Read the credit card number.
            Dim creditCardNumber = reader.ReadElementString(Constants.CreditCardNumberElementName, _
                                                            Constants.CreditCardTokenNamespace)

            ' Read the expiration date.
            Dim expirationTimeString = reader.ReadElementString(Constants.CreditCardExpirationElementName, _
                                                                Constants.CreditCardTokenNamespace)
            Dim expirationTime As DateTime = XmlConvert.ToDateTime(expirationTimeString, _
                                                                   XmlDateTimeSerializationMode.Utc)

            ' Read the issuer of the credit card.
            Dim creditCardIssuer = reader.ReadElementString(Constants.CreditCardIssuerElementName, _
                                                            Constants.CreditCardTokenNamespace)
            reader.ReadEndElement()

            Dim cardInfo As New CreditCardInfo(creditCardNumber, _
                                               creditCardIssuer, _
                                               expirationTime)

            Return New CreditCardToken(cardInfo, id)
        Else
            Return WSSecurityTokenSerializer.DefaultInstance.ReadToken(reader, _
                                                                       tokenResolver)
        End If
    End Function

    Protected Overrides Function CanWriteTokenCore(ByVal token As SecurityToken) As Boolean
        If TypeOf token Is CreditCardToken Then
            Return True
        Else
            Return MyBase.CanWriteTokenCore(token)
        End If
    End Function

    Protected Overrides Sub WriteTokenCore(ByVal writer As XmlWriter, _
                                           ByVal token As SecurityToken)
        If writer Is Nothing Then
            Throw New ArgumentNullException("writer")
        End If
        If token Is Nothing Then
            Throw New ArgumentNullException("token")
        End If

        Dim c = TryCast(token, CreditCardToken)
        If c IsNot Nothing Then
            With writer
                .WriteStartElement(Constants.CreditCardTokenPrefix, _
                                   Constants.CreditCardTokenName, _
                                   Constants.CreditCardTokenNamespace)
                .WriteAttributeString(Constants.WsUtilityPrefix, _
                                      Constants.Id, _
                                      Constants.WsUtilityNamespace, _
                                      token.Id)
                .WriteElementString(Constants.CreditCardNumberElementName, _
                                    Constants.CreditCardTokenNamespace, _
                                    c.CardInfo.CardNumber)
                .WriteElementString(Constants.CreditCardExpirationElementName, _
                                    Constants.CreditCardTokenNamespace, _
                                    XmlConvert.ToString(c.CardInfo.ExpirationDate, _
                                                        XmlDateTimeSerializationMode.Utc))
                .WriteElementString(Constants.CreditCardIssuerElementName, _
                                    Constants.CreditCardTokenNamespace, _
                                    c.CardInfo.CardIssuer)
                .WriteEndElement()
                .Flush()
            End With
        Else
            MyBase.WriteTokenCore(writer, token)
        End If
    End Sub

End Class

Después de completar los cuatro procedimientos anteriores, integre el token de seguridad personalizado con el proveedor de tokens de seguridad, autenticador, administrador y credenciales de cliente y servicio.

Para integrar el token de seguridad personalizado con un proveedor de tokens de seguridad

  1. El proveedor de tokens de seguridad crea, modifica (si es necesario) y devuelve una instancia del token. Para crear un proveedor personalizado para el token de seguridad personalizado, cree una clase que herede de la clase SecurityTokenProvider. En el ejemplo siguiente se invalida el método GetTokenCore para devolver una instancia de CreditCardToken. Para más información sobre los proveedores de tokens de seguridad personalizados, consulte Creación de un proveedor de tokens de seguridad personalizados.

    class CreditCardTokenProvider : SecurityTokenProvider
{
    CreditCardInfo creditCardInfo;

    public CreditCardTokenProvider(CreditCardInfo creditCardInfo)
        : base()
    {
        if (creditCardInfo == null)
        {
            throw new ArgumentNullException("creditCardInfo");
        }
        this.creditCardInfo = creditCardInfo;
    }

    protected override SecurityToken GetTokenCore(TimeSpan timeout)
    {
        SecurityToken result = new CreditCardToken(this.creditCardInfo);
        return result;
    }
}

    Friend Class CreditCardTokenProvider
    Inherits SecurityTokenProvider

    Private creditCardInfo As CreditCardInfo

    Public Sub New(ByVal creditCardInfo As CreditCardInfo)
        MyBase.New()
        If creditCardInfo Is Nothing Then
            Throw New ArgumentNullException("creditCardInfo")
        End If
        Me.creditCardInfo = creditCardInfo
    End Sub

    Protected Overrides Function GetTokenCore(ByVal timeout As TimeSpan) As SecurityToken
        Return TryCast(New CreditCardToken(Me.creditCardInfo), SecurityToken)
    End Function

End Class

Para integrar el token de seguridad personalizado con un autenticador de tokens de seguridad

  1. El autenticador de tokens de seguridad valida el contenido del token de seguridad cuando se extrae del mensaje. Para crear un autenticador personalizado para el token de seguridad personalizado, cree una clase que herede de la clase SecurityTokenAuthenticator. En el siguiente ejemplo se reemplaza el método ValidateTokenCore. Para más información sobre los autenticadores de tokens de seguridad personalizados, consulte Creación de un autenticador de tokens de seguridad personalizados.

    class CreditCardTokenAuthenticator : SecurityTokenAuthenticator
{
    string creditCardsFile;
    public CreditCardTokenAuthenticator(string creditCardsFile)
    {
        this.creditCardsFile = creditCardsFile;
    }

    protected override bool CanValidateTokenCore(SecurityToken token)
    {
        return (token is CreditCardToken);
    }

    protected override ReadOnlyCollection<IAuthorizationPolicy> ValidateTokenCore(SecurityToken token)
    {
        CreditCardToken creditCardToken = token as CreditCardToken;

        if (creditCardToken.CardInfo.ExpirationDate < DateTime.UtcNow)
        {
            throw new SecurityTokenValidationException("The credit card has expired");
        }
        if (!IsCardNumberAndExpirationValid(creditCardToken.CardInfo))
        {
            throw new SecurityTokenValidationException("Unknown or invalid credit card");
        }

        // The credit card token has only 1 claim: the card number. The issuer for the claim is the
        // credit card issuer.
        DefaultClaimSet cardIssuerClaimSet = new DefaultClaimSet(new Claim(ClaimTypes.Name, creditCardToken.CardInfo.CardIssuer, Rights.PossessProperty));
        DefaultClaimSet cardClaimSet = new DefaultClaimSet(cardIssuerClaimSet, new Claim(Constants.CreditCardNumberClaim, creditCardToken.CardInfo.CardNumber, Rights.PossessProperty));
        List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>(1);
        policies.Add(new CreditCardTokenAuthorizationPolicy(cardClaimSet));
        return policies.AsReadOnly();
    }

    // This helper method checks whether a given credit card entry is present in the user database.
    private bool IsCardNumberAndExpirationValid(CreditCardInfo cardInfo)
    {
        try
        {
            using (StreamReader myStreamReader = new StreamReader(this.creditCardsFile))
            {
                string line = "";
                while ((line = myStreamReader.ReadLine()) != null)
                {
                    string[] splitEntry = line.Split('#');
                    if (splitEntry[0] == cardInfo.CardNumber)
                    {
                        string expirationDateString = splitEntry[1].Trim();
                        DateTime expirationDateOnFile = DateTime.Parse(expirationDateString, System.Globalization.DateTimeFormatInfo.InvariantInfo, System.Globalization.DateTimeStyles.AdjustToUniversal);
                        if (cardInfo.ExpirationDate == expirationDateOnFile)
                        {
                            string issuer = splitEntry[2];
                            return issuer.Equals(cardInfo.CardIssuer, StringComparison.InvariantCultureIgnoreCase);
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                return false;
            }
        }
        catch (Exception e)
        {
            throw new Exception("BookStoreService: Error while retrieving credit card information from User DB " + e.ToString());
        }
    }
}

    Friend Class CreditCardTokenAuthenticator
    Inherits SecurityTokenAuthenticator

    Private creditCardsFile As String

    Public Sub New(ByVal creditCardsFile As String)
        Me.creditCardsFile = creditCardsFile
    End Sub

    Protected Overrides Function CanValidateTokenCore(ByVal token As SecurityToken) As Boolean
        Return (TypeOf token Is CreditCardToken)
    End Function

    Protected Overrides Function ValidateTokenCore(ByVal token As SecurityToken) As ReadOnlyCollection(Of IAuthorizationPolicy)

        Dim creditCardToken = TryCast(token, CreditCardToken)

        If creditCardToken.CardInfo.ExpirationDate < DateTime.UtcNow Then
            Throw New SecurityTokenValidationException("The credit card has expired")
        End If
        If Not IsCardNumberAndExpirationValid(creditCardToken.CardInfo) Then
            Throw New SecurityTokenValidationException("Unknown or invalid credit card")
        End If

        ' The credit card token has only 1 claim: the card number. The issuer for the claim is the
        ' credit card issuer.
        Dim cardIssuerClaimSet As New DefaultClaimSet(New Claim(ClaimTypes.Name, _
                                                                creditCardToken.CardInfo.CardIssuer, _
                                                                Rights.PossessProperty))
        Dim cardClaimSet As New DefaultClaimSet(cardIssuerClaimSet, _
                                                New Claim(Constants.CreditCardNumberClaim, _
                                                          creditCardToken.CardInfo.CardNumber, _
                                                          Rights.PossessProperty))
        Dim policies As New List(Of IAuthorizationPolicy)(1)
        policies.Add(New CreditCardTokenAuthorizationPolicy(cardClaimSet))
        Return policies.AsReadOnly()
    End Function

    ' This helper method checks whether a given credit card entry is present in the user database.
    Private Function IsCardNumberAndExpirationValid(ByVal cardInfo As CreditCardInfo) As Boolean
        Try
            Using myStreamReader As New StreamReader(Me.creditCardsFile)
                Dim line = String.Empty
                line = myStreamReader.ReadLine()
                Do While line IsNot Nothing
                    Dim splitEntry() = line.Split("#"c)
                    If splitEntry(0) = cardInfo.CardNumber Then
                        Dim expirationDateString = splitEntry(1).Trim()
                        Dim expirationDateOnFile As DateTime = DateTime.Parse(expirationDateString, _
                                                                              System.Globalization.DateTimeFormatInfo.InvariantInfo, _
                                                                              System.Globalization.DateTimeStyles.AdjustToUniversal)
                        If cardInfo.ExpirationDate = expirationDateOnFile Then
                            Dim issuer = splitEntry(2)
                            Return issuer.Equals(cardInfo.CardIssuer, _
                                                 StringComparison.InvariantCultureIgnoreCase)
                        Else
                            Return False
                        End If
                    End If
                    line = myStreamReader.ReadLine()
                Loop
                Return False
            End Using
        Catch e As Exception
            Throw New Exception("BookStoreService: Error while retrieving credit card information from User DB " & e.ToString())
        End Try
    End Function

End Class

    public class CreditCardTokenAuthorizationPolicy : IAuthorizationPolicy
{
    string id;
    ClaimSet issuer;
    IEnumerable<ClaimSet> issuedClaimSets;

    public CreditCardTokenAuthorizationPolicy(ClaimSet issuedClaims)
    {
        if (issuedClaims == null)
            throw new ArgumentNullException("issuedClaims");
        this.issuer = issuedClaims.Issuer;
        this.issuedClaimSets = new ClaimSet[] { issuedClaims };
        this.id = Guid.NewGuid().ToString();
    }

    public ClaimSet Issuer { get { return this.issuer; } }

    public string Id { get { return this.id; } }

    public bool Evaluate(EvaluationContext context, ref object state)
    {
        foreach (ClaimSet issuance in this.issuedClaimSets)
        {
            context.AddClaimSet(this, issuance);
        }

        return true;
    }
}

    Public Class CreditCardTokenAuthorizationPolicy
    Implements IAuthorizationPolicy

    Private _id As String
    Private _issuer As ClaimSet
    Private _issuedClaimSets As IEnumerable(Of ClaimSet)

    Public Sub New(ByVal issuedClaims As ClaimSet)
        If issuedClaims Is Nothing Then
            Throw New ArgumentNullException("issuedClaims")
        End If
        Me._issuer = issuedClaims.Issuer
        Me._issuedClaimSets = New ClaimSet() {issuedClaims}
        Me._id = Guid.NewGuid().ToString()
    End Sub

    Public ReadOnly Property Issuer() As ClaimSet Implements IAuthorizationPolicy.Issuer
        Get
            Return Me._issuer
        End Get
    End Property

    Public ReadOnly Property Id() As String Implements System.IdentityModel.Policy.IAuthorizationComponent.Id
        Get
            Return Me._id
        End Get
    End Property

    Public Function Evaluate(ByVal context As EvaluationContext, _
                             ByRef state As Object) As Boolean Implements IAuthorizationPolicy.Evaluate
        For Each issuance In Me._issuedClaimSets
            context.AddClaimSet(Me, issuance)
        Next issuance

        Return True
    End Function

End Class

Para integrar el token de seguridad personalizado con un administrador de tokens de seguridad

  1. El administrador de tokens de seguridad crea el proveedor de tokens, el autenticador de seguridad y las instancias del serializador de tokens adecuados. Para crear un administrador de tokens personalizado, cree una clase que herede de la clase ClientCredentialsSecurityTokenManager. Los métodos principales de la clase usan un SecurityTokenRequirement para crear el proveedor y las credenciales de cliente o servicio adecuados. Para más información sobre los administradores de tokens de seguridad personalizados, consulte Tutorial: Creación de credenciales de cliente y servicio personalizadas.

    public class CreditCardClientCredentialsSecurityTokenManager : ClientCredentialsSecurityTokenManager
{
    CreditCardClientCredentials creditCardClientCredentials;

    public CreditCardClientCredentialsSecurityTokenManager(CreditCardClientCredentials creditCardClientCredentials)
        : base(creditCardClientCredentials)
    {
        this.creditCardClientCredentials = creditCardClientCredentials;
    }

    public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement)
    {
        if (tokenRequirement.TokenType == Constants.CreditCardTokenType)
        {
            // Handle this token for Custom.
            return new CreditCardTokenProvider(this.creditCardClientCredentials.CreditCardInfo);
        }
        else if (tokenRequirement is InitiatorServiceModelSecurityTokenRequirement)
        {
            // Return server certificate.
            if (tokenRequirement.TokenType == SecurityTokenTypes.X509Certificate)
            {
                return new X509SecurityTokenProvider(creditCardClientCredentials.ServiceCertificate.DefaultCertificate);
            }
        }
        return base.CreateSecurityTokenProvider(tokenRequirement);
    }

    public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
    {
        return new CreditCardSecurityTokenSerializer(version);
    }
}

    Public Class CreditCardClientCredentialsSecurityTokenManager
    Inherits ClientCredentialsSecurityTokenManager

    Private creditCardClientCredentials As CreditCardClientCredentials

    Public Sub New(ByVal creditCardClientCredentials As CreditCardClientCredentials)
        MyBase.New(creditCardClientCredentials)
        Me.creditCardClientCredentials = creditCardClientCredentials
    End Sub

    Public Overrides Function CreateSecurityTokenProvider(ByVal tokenRequirement As SecurityTokenRequirement) As SecurityTokenProvider

        If tokenRequirement.TokenType = Constants.CreditCardTokenType Then
            ' Handle this token for Custom.
            Return New CreditCardTokenProvider(Me.creditCardClientCredentials.CreditCardInfo)
        ElseIf TypeOf tokenRequirement Is InitiatorServiceModelSecurityTokenRequirement Then
            ' Return server certificate.
            If tokenRequirement.TokenType = SecurityTokenTypes.X509Certificate Then
                Return New X509SecurityTokenProvider(creditCardClientCredentials.ServiceCertificate.DefaultCertificate)
            End If
        End If
        Return MyBase.CreateSecurityTokenProvider(tokenRequirement)
    End Function

    Public Overloads Overrides Function CreateSecurityTokenSerializer(ByVal version As SecurityTokenVersion) As SecurityTokenSerializer
        Return New CreditCardSecurityTokenSerializer(version)
    End Function

End Class

    public class CreditCardServiceCredentialsSecurityTokenManager : ServiceCredentialsSecurityTokenManager
{
    CreditCardServiceCredentials creditCardServiceCredentials;

    public CreditCardServiceCredentialsSecurityTokenManager(CreditCardServiceCredentials creditCardServiceCredentials)
        : base(creditCardServiceCredentials)
    {
        this.creditCardServiceCredentials = creditCardServiceCredentials;
    }

    public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
    {
        if (tokenRequirement.TokenType == Constants.CreditCardTokenType)
        {
            outOfBandTokenResolver = null;
            return new CreditCardTokenAuthenticator(creditCardServiceCredentials.CreditCardDataFile);
        }
        return base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver);
    }

    public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
    {
        return new CreditCardSecurityTokenSerializer(version);
    }
}

    Public Class CreditCardServiceCredentialsSecurityTokenManager
    Inherits ServiceCredentialsSecurityTokenManager

    Private creditCardServiceCredentials As CreditCardServiceCredentials

    Public Sub New(ByVal creditCardServiceCredentials As CreditCardServiceCredentials)
        MyBase.New(creditCardServiceCredentials)
        Me.creditCardServiceCredentials = creditCardServiceCredentials
    End Sub

    Public Overrides Function CreateSecurityTokenAuthenticator(ByVal tokenRequirement As SecurityTokenRequirement, _
                                                               <System.Runtime.InteropServices.Out()> ByRef outOfBandTokenResolver As SecurityTokenResolver) As SecurityTokenAuthenticator
        If tokenRequirement.TokenType = Constants.CreditCardTokenType Then
            outOfBandTokenResolver = Nothing
            Return New CreditCardTokenAuthenticator(creditCardServiceCredentials.CreditCardDataFile)
        End If
        Return MyBase.CreateSecurityTokenAuthenticator(tokenRequirement, outOfBandTokenResolver)
    End Function

    Public Overrides Function CreateSecurityTokenSerializer(ByVal version As SecurityTokenVersion) As SecurityTokenSerializer
        Return New CreditCardSecurityTokenSerializer(version)
    End Function

End Class

Para integrar el token de seguridad personalizado con credenciales de cliente y servicio personalizadas

  1. Es necesario agregar credenciales de cliente y servicio personalizadas para proporcionar una API de manera que la aplicación permita especificar la información de tokens personalizados que utiliza la infraestructura de tokens de seguridad personalizados antes creada para proporcionar y autenticar el contenido del token de seguridad personalizado. Los ejemplos siguientes muestran cómo hacerlo. Para más información sobre las credenciales de cliente y servicio personalizadas, consulte Tutorial: Creación de credenciales de cliente y servicio personalizadas.

    public class CreditCardClientCredentials : ClientCredentials
{
    CreditCardInfo creditCardInfo;

    public CreditCardClientCredentials(CreditCardInfo creditCardInfo)
        : base()
    {
        if (creditCardInfo == null)
        {
            throw new ArgumentNullException("creditCardInfo");
        }

        this.creditCardInfo = creditCardInfo;
    }

    public CreditCardInfo CreditCardInfo
    {
        get { return this.creditCardInfo; }
    }

    protected override ClientCredentials CloneCore()
    {
        return new CreditCardClientCredentials(this.creditCardInfo);
    }

    public override SecurityTokenManager CreateSecurityTokenManager()
    {
        return new CreditCardClientCredentialsSecurityTokenManager(this);
    }
}

    Public Class CreditCardClientCredentials
    Inherits ClientCredentials

    Private _creditCardInfo As CreditCardInfo

    Public Sub New(ByVal creditCardInfo As CreditCardInfo)
        MyBase.New()
        If creditCardInfo Is Nothing Then
            Throw New ArgumentNullException("creditCardInfo")
        End If

        Me._creditCardInfo = creditCardInfo
    End Sub

    Public ReadOnly Property CreditCardInfo() As CreditCardInfo
        Get
            Return Me._creditCardInfo
        End Get
    End Property

    Protected Overrides Function CloneCore() As ClientCredentials
        Return New CreditCardClientCredentials(Me._creditCardInfo)
    End Function

    Public Overrides Function CreateSecurityTokenManager() As SecurityTokenManager
        Return New CreditCardClientCredentialsSecurityTokenManager(Me)
    End Function

End Class

    public class CreditCardServiceCredentials : ServiceCredentials
{
    string creditCardFile;

    public CreditCardServiceCredentials(string creditCardFile)
        : base()
    {
        if (creditCardFile == null)
        {
            throw new ArgumentNullException("creditCardFile");
        }

        this.creditCardFile = creditCardFile;
    }

    public string CreditCardDataFile
    {
        get { return this.creditCardFile; }
    }

    protected override ServiceCredentials CloneCore()
    {
        return new CreditCardServiceCredentials(this.creditCardFile);
    }

    public override SecurityTokenManager CreateSecurityTokenManager()
    {
        return new CreditCardServiceCredentialsSecurityTokenManager(this);
    }
}

    Public Class CreditCardServiceCredentials
    Inherits ServiceCredentials

    Private creditCardFile As String

    Public Sub New(ByVal creditCardFile As String)
        MyBase.New()
        If creditCardFile Is Nothing Then
            Throw New ArgumentNullException("creditCardFile")
        End If

        Me.creditCardFile = creditCardFile
    End Sub

    Public ReadOnly Property CreditCardDataFile() As String
        Get
            Return Me.creditCardFile
        End Get
    End Property

    Protected Overrides Function CloneCore() As ServiceCredentials
        Return New CreditCardServiceCredentials(Me.creditCardFile)
    End Function

    Public Overrides Function CreateSecurityTokenManager() As SecurityTokenManager
        Return New CreditCardServiceCredentialsSecurityTokenManager(Me)
    End Function

End Class

La clase de parámetros de tokens de seguridad personalizados creada anteriormente se utiliza para indicar al marco de seguridad de WCF que se ha de utilizar un token de seguridad personalizado al comunicarse con un servicio. En el siguiente procedimiento se muestra cómo hacerlo:

Para integrar el token de seguridad personalizado con el enlace

  1. La clase de parámetros de tokens de seguridad personalizados ha de especificarse en una de las colecciones de parámetros de tokens que se exponen en la clase SecurityBindingElement. El siguiente ejemplo usa la colección devuelta por SignedEncrypted. El código agrega el token personalizado de la tarjeta de crédito a cada mensaje enviado desde el cliente al servicio con su contenido firmado y cifrado automáticamente.

    public static class BindingHelper
{
    public static Binding CreateCreditCardBinding()
    {
        HttpTransportBindingElement httpTransport = new HttpTransportBindingElement();

        // The message security binding element is configured to require a credit card
        // token that is encrypted with the service's certificate.
        SymmetricSecurityBindingElement messageSecurity = new SymmetricSecurityBindingElement();
        messageSecurity.EndpointSupportingTokenParameters.SignedEncrypted.Add(new CreditCardTokenParameters());
        X509SecurityTokenParameters x509ProtectionParameters = new X509SecurityTokenParameters();
        x509ProtectionParameters.InclusionMode = SecurityTokenInclusionMode.Never;
        messageSecurity.ProtectionTokenParameters = x509ProtectionParameters;
        return new CustomBinding(messageSecurity, httpTransport);
    }
}

    Public NotInheritable Class BindingHelper

    Private Sub New()
    End Sub

    Public Shared Function CreateCreditCardBinding() As Binding
        Dim httpTransport As New HttpTransportBindingElement()

        ' The message security binding element is configured to require a credit card
        ' token that is encrypted with the service's certificate. 
        Dim messageSecurity As New SymmetricSecurityBindingElement()
        messageSecurity.EndpointSupportingTokenParameters.SignedEncrypted.Add(New CreditCardTokenParameters())
        Dim x509ProtectionParameters As New X509SecurityTokenParameters()
        x509ProtectionParameters.InclusionMode = SecurityTokenInclusionMode.Never
        messageSecurity.ProtectionTokenParameters = x509ProtectionParameters
        Return New CustomBinding(messageSecurity, httpTransport)
    End Function

End Class

En este tema se muestran los distintos elementos de código necesarios para implementar y usar un token personalizado. Para ver un ejemplo completo de cómo encajan todos estos fragmentos de código consulte Token personalizado.

Consulte también