How to: Change the Cryptographic Provider for an X.509 Certificate's Private Key

Artikkeli
09/15/2021

This topic shows how to change the cryptographic provider used to provide an X.509 certificate's private key and how to integrate the provider into the Windows Communication Foundation (WCF) security framework. For more information about using certificates, see Working with Certificates.

The WCF security framework provides a way to introduce new security token types as described in How to: Create a Custom Token. It is also possible to use a custom token to replace existing system-provided token types.

In this topic, the system-provided X.509 security token is replaced by a custom X.509 token that provides a different implementation for the certificate private key. This is useful in scenarios where the actual private key is provided by a different cryptographic provider than the default Windows cryptographic provider. One example of an alternative cryptographic provider is a hardware security module that performs all private key related cryptographic operations, and does not store the private keys in memory, thus improving security of the system.

The following example is for demonstration purposes only. It does not replace the default Windows cryptographic provider, but it shows where such a provider could be integrated.

Procedures

Every security token that has an associated security key or keys must implement the SecurityKeys property, which returns a collection of keys from the security token instance. If the token is an X.509 security token, the collection contains a single instance of the X509AsymmetricSecurityKey class that represents both public and private keys associated with the certificate. To replace the default cryptographic provider used to provide the certificate's keys, create a new implementation of this class.

To create a custom X.509 asymmetric key

Define a new class derived from the X509AsymmetricSecurityKey class.
Override the KeySize read-only property. This property returns the actual key size of the certificate's public/private key pair.
Override the DecryptKey method. This method is called by the WCF security framework to decrypt a symmetric key with the certificate's private key. (The key was previously encrypted with the certificate's public key.)
Override the GetAsymmetricAlgorithm method. This method is called by the WCF security framework to obtain an instance of the AsymmetricAlgorithm class that represents the cryptographic provider for either the certificate's private or public key, depending on the parameters passed to the method.
Optional. Override the GetHashAlgorithmForSignature method. Override this method if a different implementation of the HashAlgorithm class is required.
Override the GetSignatureFormatter method. This method returns an instance of the AsymmetricSignatureFormatter class that is associated with the certificate's private key.

Override the IsSupportedAlgorithm method. This method is used to indicate whether a particular cryptographic algorithm is supported by the security key implementation.

class CustomX509AsymmetricSecurityKey : X509AsymmetricSecurityKey
{
    X509Certificate2 certificate;
    object thisLock = new Object();
    bool privateKeyAvailabilityDetermined;
    AsymmetricAlgorithm privateKey;
    PublicKey publicKey;

    public CustomX509AsymmetricSecurityKey(X509Certificate2 certificate)
        : base(certificate)
    {
        this.certificate = certificate;
    }

    public override int KeySize
    {
        get { return this.PublicKey.Key.KeySize; }
    }

    AsymmetricAlgorithm PrivateKey
    {
        // You need to modify this to obtain the private key using a different cryptographic
        // provider if you do not want to use the default provider.
        get
        {
            if (!this.privateKeyAvailabilityDetermined)
            {
                lock (ThisLock)
                {
                    if (!this.privateKeyAvailabilityDetermined)
                    {
                        this.privateKey = this.certificate.PrivateKey;
                        this.privateKeyAvailabilityDetermined = true;
                    }
                }
            }
            return this.privateKey;
        }
    }

    PublicKey PublicKey
    {
        get
        {
            if (this.publicKey == null)
            {
                lock (ThisLock)
                {
                    this.publicKey ??= this.certificate.PublicKey;
                }
            }
            return this.publicKey;
        }
    }

    Object ThisLock
    {
        get
        {
            return thisLock;
        }
    }

    public override byte[] DecryptKey(string algorithm, byte[] keyData)
    {
        // You can decrypt the key only if you have the private key in the certificate.
        if (this.PrivateKey == null)
        {
            throw new NotSupportedException("Missing private key");
        }

        RSA rsa = this.PrivateKey as RSA;
        if (rsa == null)
        {
            throw new NotSupportedException("Private key cannot be used with RSA algorithm");
        }

        // Support exchange keySpec, AT_EXCHANGE ?
        if (rsa.KeyExchangeAlgorithm == null)
        {
            throw new NotSupportedException("Private key does not support key exchange");
        }

        switch (algorithm)
        {
            case EncryptedXml.XmlEncRSA15Url:
                return EncryptedXml.DecryptKey(keyData, rsa, false);

            case EncryptedXml.XmlEncRSAOAEPUrl:
                return EncryptedXml.DecryptKey(keyData, rsa, true);

            default:
                throw new NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm));
        }
    }

    public override AsymmetricAlgorithm GetAsymmetricAlgorithm(string algorithm, bool privateKey)
    {
        if (privateKey)
        {
            if (this.PrivateKey == null)
            {
                throw new NotSupportedException("Missing private key");
            }

            switch (algorithm)
            {
                case SignedXml.XmlDsigDSAUrl:
                    if ((this.PrivateKey as DSA) != null)
                    {
                        return (this.PrivateKey as DSA);
                    }
                    throw new NotSupportedException("Private key cannot be used with DSA");

                case SignedXml.XmlDsigRSASHA1Url:
                case EncryptedXml.XmlEncRSA15Url:
                case EncryptedXml.XmlEncRSAOAEPUrl:
                    if ((this.PrivateKey as RSA) != null)
                    {
                        return (this.PrivateKey as RSA);
                    }
                    throw new NotSupportedException("Private key cannot be used with RSA");
                default:
                    throw new NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm));
            }
        }
        else
        {
            switch (algorithm)
            {
                case SignedXml.XmlDsigDSAUrl:
                    if ((this.PublicKey.Key as DSA) != null)
                    {
                        return (this.PublicKey.Key as DSA);
                    }
                    throw new NotSupportedException("Public key cannot be used with DSA");
                case SignedXml.XmlDsigRSASHA1Url:
                case EncryptedXml.XmlEncRSA15Url:
                case EncryptedXml.XmlEncRSAOAEPUrl:
                    if ((this.PublicKey.Key as RSA) != null)
                    {
                        return (this.PublicKey.Key as RSA);
                    }
                    throw new NotSupportedException("Public key cannot be used with RSA");
                default:
                    throw new NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm));
            }
        }
    }

    public override HashAlgorithm GetHashAlgorithmForSignature(string algorithm)
    {
        if (!this.IsSupportedAlgorithm(algorithm))
        {
            throw new NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm));
        }

        switch (algorithm)
        {
            case SignedXml.XmlDsigDSAUrl:
            case SignedXml.XmlDsigRSASHA1Url:
                return new SHA1Managed();
            default:
                throw new NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm));
        }
    }

    public override AsymmetricSignatureFormatter GetSignatureFormatter(string algorithm)
    {
        // The signature can be created only if the private key is present.
        if (this.PrivateKey == null)
        {
            throw new NotSupportedException("Private key is missing");
        }

        // Only one of the two algorithms is supported, not both.
        //     XmlDsigDSAUrl = "http://www.w3.org/2000/09/xmldsig#dsa-sha1";
        //     XmlDsigRSASHA1Url = "http://www.w3.org/2000/09/xmldsig#rsa-sha1";
        switch (algorithm)
        {
            case SignedXml.XmlDsigDSAUrl:

                // Ensure that this is a DSA algorithm object.
                DSA dsa = (this.PrivateKey as DSA);
                if (dsa == null)
                {
                    throw new NotSupportedException("Private key cannot be used DSA");
                }

                return new DSASignatureFormatter(dsa);

            case SignedXml.XmlDsigRSASHA1Url:
                // Ensure that this is an RSA algorithm object.
                RSA rsa = (this.PrivateKey as RSA);
                if (rsa == null)
                {
                    throw new NotSupportedException("Private key cannot be used RSA");
                }

                return new RSAPKCS1SignatureFormatter(rsa);
            default:
                throw new NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm));
        }
    }

    public override bool IsSupportedAlgorithm(string algorithm)
    {
        switch (algorithm)
        {
            case SignedXml.XmlDsigDSAUrl:
                return (this.PublicKey.Key is DSA);

            case SignedXml.XmlDsigRSASHA1Url:
            case EncryptedXml.XmlEncRSA15Url:
            case EncryptedXml.XmlEncRSAOAEPUrl:
                return (this.PublicKey.Key is RSA);

            default:
                return false;
        }
    }
}

Friend Class CustomX509AsymmetricSecurityKey
    Inherits X509AsymmetricSecurityKey

    Private _certificate As X509Certificate2
    Private _thisLock As New Object()
    Private _privateKeyAvailabilityDetermined As Boolean
    Private _privateKey As AsymmetricAlgorithm
    Private _publicKey As PublicKey

    Public Sub New(ByVal certificate As X509Certificate2)
        MyBase.New(certificate)
        Me._certificate = certificate
    End Sub

    Public Overrides ReadOnly Property KeySize() As Integer
        Get
            Return Me.PublicKey.Key.KeySize
        End Get
    End Property

    Private Overloads ReadOnly Property PrivateKey() As AsymmetricAlgorithm
        ' You need to modify this to obtain the private key using a different cryptographic
        ' provider if you do not want to use the default provider.
        Get
            If Not Me._privateKeyAvailabilityDetermined Then
                SyncLock ThisLock
                    If Not Me._privateKeyAvailabilityDetermined Then
                        Me._privateKey = Me._certificate.PrivateKey
                        Me._privateKeyAvailabilityDetermined = True
                    End If
                End SyncLock
            End If
            Return Me._privateKey
        End Get
    End Property

    Private Overloads ReadOnly Property PublicKey() As PublicKey
        Get
            If Me._publicKey Is Nothing Then
                SyncLock ThisLock
                    If Me._publicKey Is Nothing Then
                        Me._publicKey = Me._certificate.PublicKey
                    End If
                End SyncLock
            End If
            Return Me._publicKey
        End Get
    End Property

    Private Overloads ReadOnly Property ThisLock() As Object
        Get
            Return _thisLock
        End Get
    End Property

    Public Overrides Function DecryptKey(ByVal algorithm As String, _
                                         ByVal keyData() As Byte) As Byte()
        ' You can decrypt the key only if you have the private key in the certificate.
        If Me.PrivateKey Is Nothing Then
            Throw New NotSupportedException("Missing private key")
        End If

        Dim rsa = TryCast(Me.PrivateKey, RSA)
        If rsa Is Nothing Then
            Throw New NotSupportedException("Private key cannot be used with RSA algorithm")
        End If

        ' Support exchange keySpec, AT_EXCHANGE ?
        If rsa.KeyExchangeAlgorithm Is Nothing Then
            Throw New NotSupportedException("Private key does not support key exchange")
        End If

        Select Case algorithm
            Case EncryptedXml.XmlEncRSA15Url
                Return EncryptedXml.DecryptKey(keyData, rsa, False)

            Case EncryptedXml.XmlEncRSAOAEPUrl
                Return EncryptedXml.DecryptKey(keyData, rsa, True)

            Case Else
                Throw New NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm))
        End Select
    End Function

    Public Overrides Function GetAsymmetricAlgorithm(ByVal algorithm As String, _
                                                     ByVal privateKey As Boolean) As AsymmetricAlgorithm
        If privateKey Then
            If Me.PrivateKey Is Nothing Then
                Throw New NotSupportedException("Missing private key")
            End If

            Select Case algorithm
                Case SignedXml.XmlDsigDSAUrl
                    If TryCast(Me.PrivateKey, DSA) IsNot Nothing Then
                        Return (TryCast(Me.PrivateKey, DSA))
                    End If
                    Throw New NotSupportedException("Private key cannot be used with DSA")

                Case SignedXml.XmlDsigRSASHA1Url, EncryptedXml.XmlEncRSA15Url, EncryptedXml.XmlEncRSAOAEPUrl
                    If TryCast(Me.PrivateKey, RSA) IsNot Nothing Then
                        Return (TryCast(Me.PrivateKey, RSA))
                    End If
                    Throw New NotSupportedException("Private key cannot be used with RSA")
                Case Else
                    Throw New NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm))
            End Select
        Else
            Select Case algorithm
                Case SignedXml.XmlDsigDSAUrl
                    If TryCast(Me.PublicKey.Key, DSA) IsNot Nothing Then
                        Return (TryCast(Me.PublicKey.Key, DSA))
                    End If
                    Throw New NotSupportedException("Public key cannot be used with DSA")
                Case SignedXml.XmlDsigRSASHA1Url, EncryptedXml.XmlEncRSA15Url, EncryptedXml.XmlEncRSAOAEPUrl
                    If TryCast(Me.PublicKey.Key, RSA) IsNot Nothing Then
                        Return (TryCast(Me.PublicKey.Key, RSA))
                    End If
                    Throw New NotSupportedException("Public key cannot be used with RSA")
                Case Else
                    Throw New NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm))
            End Select
        End If
    End Function

    Public Overrides Function GetHashAlgorithmForSignature(ByVal algorithm As String) As HashAlgorithm
        If Not Me.IsSupportedAlgorithm(algorithm) Then
            Throw New NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm))
        End If

        Select Case algorithm
            Case SignedXml.XmlDsigDSAUrl, SignedXml.XmlDsigRSASHA1Url
                Return New SHA1Managed()
            Case Else
                Throw New NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm))
        End Select
    End Function

    Public Overrides Function GetSignatureFormatter(ByVal algorithm As String) As AsymmetricSignatureFormatter
        ' The signature can be created only if the private key is present.
        If Me.PrivateKey Is Nothing Then
            Throw New NotSupportedException("Private key is missing")
        End If

        ' Only one of the two algorithms is supported, not both.
        '     XmlDsigDSAUrl = "http://www.w3.org/2000/09/xmldsig#dsa-sha1";
        '     XmlDsigRSASHA1Url = "http://www.w3.org/2000/09/xmldsig#rsa-sha1";
        Select Case algorithm
            Case SignedXml.XmlDsigDSAUrl

                ' Ensure that this is a DSA algorithm object.
                Dim dsa = (TryCast(Me.PrivateKey, DSA))
                If dsa Is Nothing Then
                    Throw New NotSupportedException("Private key cannot be used DSA")
                End If

                Return New DSASignatureFormatter(dsa)

            Case SignedXml.XmlDsigRSASHA1Url
                ' Ensure that this is an RSA algorithm object.
                Dim rsa = (TryCast(Me.PrivateKey, RSA))
                If rsa Is Nothing Then
                    Throw New NotSupportedException("Private key cannot be used RSA")
                End If

                Return New RSAPKCS1SignatureFormatter(rsa)
            Case Else
                Throw New NotSupportedException(String.Format("Algorithm {0} is not supported", algorithm))
        End Select
    End Function

    Public Overrides Function IsSupportedAlgorithm(ByVal algorithm As String) As Boolean
        Select Case algorithm
            Case SignedXml.XmlDsigDSAUrl
                Return (TypeOf Me.PublicKey.Key Is DSA)

            Case SignedXml.XmlDsigRSASHA1Url, EncryptedXml.XmlEncRSA15Url, EncryptedXml.XmlEncRSAOAEPUrl
                Return (TypeOf Me.PublicKey.Key Is RSA)

            Case Else
                Return False
        End Select
    End Function

End Class

The following procedure shows how to integrate the custom X.509 asymmetric security key implementation created in the preceding procedure with the WCF security framework in order to replace the system-provided X.509 security token.

To replace the system-provided X.509 security token with a custom X.509 asymmetric security key token

Create a custom X.509 security token that returns the custom X.509 asymmetric security key instead of the system-provided security key, as shown in the following example. For more information about custom security tokens, see How to: Create a Custom Token.

class CustomX509SecurityToken : X509SecurityToken
{
    ReadOnlyCollection<SecurityKey> securityKeys;
    public CustomX509SecurityToken(X509Certificate2 certificate)
        : base(certificate)
    {
    }

    public override ReadOnlyCollection<SecurityKey> SecurityKeys
    {
        get
        {
            if (this.securityKeys == null)
            {
                List<SecurityKey> temp = new List<SecurityKey>(1);
                temp.Add(new CustomX509AsymmetricSecurityKey(this.Certificate));
                this.securityKeys = temp.AsReadOnly();
            }
            return this.securityKeys;
        }
    }
}

Friend Class CustomX509SecurityToken
    Inherits X509SecurityToken

    Private _securityKeys As ReadOnlyCollection(Of SecurityKey)

    Public Sub New(ByVal certificate As X509Certificate2)
        MyBase.New(certificate)
    End Sub

    Public Overrides ReadOnly Property SecurityKeys() As ReadOnlyCollection(Of SecurityKey)
        Get
            If Me._securityKeys Is Nothing Then
                Dim temp As New List(Of SecurityKey)(1)
                temp.Add(New CustomX509AsymmetricSecurityKey(Me.Certificate))
                Me._securityKeys = temp.AsReadOnly()
            End If
            Return Me._securityKeys
        End Get
    End Property

End Class

Create a custom security token provider that returns a custom X.509 security token, as shown in the example. For more information about custom security token providers, see How to: Create a Custom Security Token Provider.

class CustomX509SecurityTokenProvider : SecurityTokenProvider
{
    X509Certificate2 certificate;

    public CustomX509SecurityTokenProvider(X509Certificate2 certificate)
    {
        this.certificate = certificate;
    }

    protected override SecurityToken GetTokenCore(TimeSpan timeout)
    {
        return new CustomX509SecurityToken(certificate);
    }
}

Friend Class CustomX509SecurityTokenProvider
    Inherits SecurityTokenProvider

    Private _certificate As X509Certificate2

    Public Sub New(ByVal certificate As X509Certificate2)
        Me._certificate = certificate
    End Sub

    Protected Overrides Function GetTokenCore(ByVal timeout As TimeSpan) As SecurityToken
        Return New CustomX509SecurityToken(_certificate)
    End Function
End Class

If the custom security key needs to be used on the initiator side, create a custom client security token manager and custom client credentials classes, as shown in the following example. For more information about custom client credentials and client security token managers, see Walkthrough: Creating Custom Client and Service Credentials.

class CustomClientSecurityTokenManager : ClientCredentialsSecurityTokenManager
{
    CustomClientCredentials credentials;

    public CustomClientSecurityTokenManager(CustomClientCredentials credentials)
        : base(credentials)
    {
        this.credentials = credentials;
    }

    public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement)
    {
        SecurityTokenProvider result = null;

        if (tokenRequirement.TokenType == SecurityTokenTypes.X509Certificate)
        {
            MessageDirection direction = tokenRequirement.GetProperty<MessageDirection>(ServiceModelSecurityTokenRequirement.MessageDirectionProperty);
            if (direction == MessageDirection.Output)
            {
                if (tokenRequirement.KeyUsage == SecurityKeyUsage.Signature)
                {
                    result = new CustomX509SecurityTokenProvider(credentials.ClientCertificate.Certificate);
                }
            }
            else
            {
                if (tokenRequirement.KeyUsage == SecurityKeyUsage.Exchange)
                {
                    result = new CustomX509SecurityTokenProvider(credentials.ClientCertificate.Certificate);
                }
            }
        }

        result ??= base.CreateSecurityTokenProvider(tokenRequirement);
        return result;
    }
}

Friend Class CustomClientSecurityTokenManager
    Inherits ClientCredentialsSecurityTokenManager

    Private credentials As CustomClientCredentials

    Public Sub New(ByVal credentials As CustomClientCredentials)
        MyBase.New(credentials)
        Me.credentials = credentials
    End Sub

    Public Overrides Function CreateSecurityTokenProvider(ByVal tokenRequirement As SecurityTokenRequirement) _
    As SecurityTokenProvider
        Dim result As SecurityTokenProvider = Nothing

        If tokenRequirement.TokenType = SecurityTokenTypes.X509Certificate Then
            Dim direction = tokenRequirement.GetProperty(Of MessageDirection) _
            (ServiceModelSecurityTokenRequirement.MessageDirectionProperty)
            If direction = MessageDirection.Output Then
                If tokenRequirement.KeyUsage = SecurityKeyUsage.Signature Then
                    result = New CustomX509SecurityTokenProvider(credentials.ClientCertificate.Certificate)
                End If
            Else
                If tokenRequirement.KeyUsage = SecurityKeyUsage.Exchange Then
                    result = New CustomX509SecurityTokenProvider(credentials.ClientCertificate.Certificate)
                End If
            End If
        End If

        If result Is Nothing Then
            result = MyBase.CreateSecurityTokenProvider(tokenRequirement)
        End If
        Return result
    End Function
End Class

public class CustomClientCredentials : ClientCredentials
{
    public CustomClientCredentials()
    {
    }

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

    protected override ClientCredentials CloneCore()
    {
        return new CustomClientCredentials(this);
    }

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

Public Class CustomClientCredentials
    Inherits ClientCredentials

    Public Sub New()
    End Sub

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

    Protected Overrides Function CloneCore() As ClientCredentials
        Return New CustomClientCredentials(Me)
    End Function

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

If the custom security key needs to be used on the recipient side, create a custom service security token manager and custom service credentials, as shown in the following example. For more information about custom service credentials and service security token managers, see Walkthrough: Creating Custom Client and Service Credentials.

class CustomServiceSecurityTokenManager : ServiceCredentialsSecurityTokenManager
{
    CustomServiceCredentials credentials;

    public CustomServiceSecurityTokenManager(CustomServiceCredentials credentials)
        : base(credentials)
    {
        this.credentials = credentials;
    }

    public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement)
    {
        SecurityTokenProvider result = null;

        if (tokenRequirement.TokenType == SecurityTokenTypes.X509Certificate)
        {
            MessageDirection direction = tokenRequirement.GetProperty<MessageDirection>(ServiceModelSecurityTokenRequirement.MessageDirectionProperty);
            if (direction == MessageDirection.Input)
            {
                if (tokenRequirement.KeyUsage == SecurityKeyUsage.Exchange)
                {
                    result = new CustomX509SecurityTokenProvider(credentials.ServiceCertificate.Certificate);
                }
            }
            else
            {
                if (tokenRequirement.KeyUsage == SecurityKeyUsage.Signature)
                {
                    result = new CustomX509SecurityTokenProvider(credentials.ServiceCertificate.Certificate);
                }
            }
        }

        result ??= base.CreateSecurityTokenProvider(tokenRequirement);
        return result;
    }
}

Friend Class CustomServiceSecurityTokenManager
    Inherits ServiceCredentialsSecurityTokenManager

    Private credentials As CustomServiceCredentials

    Public Sub New(ByVal credentials As CustomServiceCredentials)
        MyBase.New(credentials)
        Me.credentials = credentials
    End Sub

    Public Overrides Function CreateSecurityTokenProvider(ByVal tokenRequirement As SecurityTokenRequirement) As SecurityTokenProvider
        Dim result As SecurityTokenProvider = Nothing

        If tokenRequirement.TokenType = SecurityTokenTypes.X509Certificate Then
            Dim direction = tokenRequirement.GetProperty(Of MessageDirection) _
            (ServiceModelSecurityTokenRequirement.MessageDirectionProperty)
            If direction = MessageDirection.Input Then
                If tokenRequirement.KeyUsage = SecurityKeyUsage.Exchange Then
                    result = New CustomX509SecurityTokenProvider(credentials.ServiceCertificate.Certificate)
                End If
            Else
                If tokenRequirement.KeyUsage = SecurityKeyUsage.Signature Then
                    result = New CustomX509SecurityTokenProvider(credentials.ServiceCertificate.Certificate)
                End If
            End If
        End If

        If result Is Nothing Then
            result = MyBase.CreateSecurityTokenProvider(tokenRequirement)
        End If
        Return result
    End Function
End Class

public class CustomServiceCredentials : ServiceCredentials
{
    public CustomServiceCredentials()
    {
    }

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

    protected override ServiceCredentials CloneCore()
    {
        return new CustomServiceCredentials(this);
    }

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

Public Class CustomServiceCredentials
    Inherits ServiceCredentials

    Public Sub New()
    End Sub

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

    Protected Overrides Function CloneCore() As ServiceCredentials
        Return New CustomServiceCredentials(Me)
    End Function

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

End Class

Jaa

How to: Change the Cryptographic Provider for an X.509 Certificate's Private Key

Procedures

To create a custom X.509 asymmetric key

To replace the system-provided X.509 security token with a custom X.509 asymmetric security key token

See also

Lisäresursseja