How to: Use Separate X.509 Certificates for Signing and Encryption

Article
08/07/2009

This topic shows how to configure Windows Communication Foundation (WCF) to use different certificates for message signing and encryption on both the client and service.

To enable separate certificates to be used for signing and encryption, a custom client or service credentials (or both) must be created because WCF does not provide an API to set multiple client or service certificates. Additionally, a security token manager must be provided to leverage the multiple certificates' information and to create an appropriate security token provider for specified key usage and message direction.

The following diagram shows the main classes used, the classes they inherit from (shown by an upward-pointing arrow), and the return types of certain methods and properties.

MyClientCredentials is a custom implementation of ClientCredentials.
- Its properties shown in the diagram all return instances of X509Certificate2.
- Its method CreateSecurityTokenManager returns an instance of MyClientCredentialsSecurityTokenManager.
MyClientCredentialsSecurityTokenManager is a custom implementation of ClientCredentialsSecurityTokenManager.
- Its method CreateSecurityTokenProvider returns an instance of X509SecurityTokenProvider.

ms729856.e4971edd-a59f-4571-b36f-7e6b2f0d610f(en-us,VS.85).gif

For more information about custom credentials, see How to: Create Custom Client and Service Credentials.

In addition, you must create a custom identity verifier, and link it to a security binding element in a custom binding. You must also use the custom credentials instead of the default credentials.

The following diagram shows the classes involved in the custom binding, and how the custom identity verifier is linked. There are several binding elements involved, all of which inherit from BindingElement. The AsymmetricSecurityBindingElement has the LocalClientSecuritySettings property, which returns an instance of IdentityVerifier, from which MyIdentityVerifier is customized.

ms729856.dddea4a2-0bb4-4921-9bf4-20d4d82c3da5(en-us,VS.85).gif

For more information about creating a custom identity verifier, see How to: How to: Create a Custom Client Identity Verifier.

To use separate certificates for signing and encryption

Define a new client credentials class that inherits from the ClientCredentials class. Implement four new properties to allow multiple certificates specification: ClientSigningCertificate, ClientEncryptingCertificate, ServiceSigningCertificate, and ServiceEncryptingCertificate. Also override the CreateSecurityTokenManager method to return an instance of the customized ClientCredentialsSecurityTokenManager class that is defined in the next step.

public class MyClientCredentials : ClientCredentials
{
    X509Certificate2 clientSigningCert;
    X509Certificate2 clientEncryptingCert;
    X509Certificate2 serviceSigningCert;
    X509Certificate2 serviceEncryptingCert;

    public MyClientCredentials()
    {
    }

    protected MyClientCredentials(MyClientCredentials other)
        : base(other)
    {
        this.clientEncryptingCert = other.clientEncryptingCert;
        this.clientSigningCert = other.clientSigningCert;
        this.serviceEncryptingCert = other.serviceEncryptingCert;
        this.serviceSigningCert = other.serviceSigningCert;
    }

    public X509Certificate2 ClientSigningCertificate
    {
        get
        {
            return this.clientSigningCert;
        }
        set
        {
            this.clientSigningCert = value;
        }
    }

    public X509Certificate2 ClientEncryptingCertificate
    {
        get
        {
            return this.clientEncryptingCert;
        }
        set
        {
            this.clientEncryptingCert = value;
        }
    }

    public X509Certificate2 ServiceSigningCertificate
    {
        get
        {
            return this.serviceSigningCert;
        }
        set
        {
            this.serviceSigningCert = value;
        }
    }

    public X509Certificate2 ServiceEncryptingCertificate
    {
        get
        {
            return this.serviceEncryptingCert;
        }
        set
        {
            this.serviceEncryptingCert = value;
        }
    }

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

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

Define a new client security token manager that inherits from the ClientCredentialsSecurityTokenManager class. Override the CreateSecurityTokenProvider method to create an appropriate security token provider. The requirement parameter (a SecurityTokenRequirement) provides the message direction and key usage.

internal class MyClientCredentialsSecurityTokenManager : 
    ClientCredentialsSecurityTokenManager
{
    MyClientCredentials credentials;

    public MyClientCredentialsSecurityTokenManager(
        MyClientCredentials credentials): base(credentials)
    {
        this.credentials = credentials;
    }

    public override SecurityTokenProvider CreateSecurityTokenProvider(
        SecurityTokenRequirement requirement)
    {
        SecurityTokenProvider result = null;
        if (requirement.TokenType == SecurityTokenTypes.X509Certificate)
        {
            MessageDirection direction = requirement.GetProperty
                <MessageDirection>(ServiceModelSecurityTokenRequirement.
                MessageDirectionProperty);
            if (direction == MessageDirection.Output)
            {
                if (requirement.KeyUsage == SecurityKeyUsage.Signature)
                {
                    result = new X509SecurityTokenProvider(
                        this.credentials.ClientSigningCertificate);
                }
                else
                {
                    result = new X509SecurityTokenProvider(this.credentials.
                        ServiceEncryptingCertificate);
                }
            }
            else
            {
                if (requirement.KeyUsage == SecurityKeyUsage.Signature)
                {
                    result = new X509SecurityTokenProvider(this.
                        credentials.ServiceSigningCertificate);
                }
                else
                {
                    result = new X509SecurityTokenProvider(credentials.
                        ClientEncryptingCertificate);
                }
            }
        }
        else
        {
            result = base.CreateSecurityTokenProvider(requirement);
        }

        return result;
    }

    public override SecurityTokenAuthenticator 
        CreateSecurityTokenAuthenticator(SecurityTokenRequirement 
        tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
    {
        return base.CreateSecurityTokenAuthenticator(tokenRequirement, 
            out outOfBandTokenResolver);
    }
}

Define a new service credentials class that inherits from the ServiceCredentials class. Implement four new properties to allow multiple certificates specification: ClientSigningCertificate, ClientEncryptingCertificate, ServiceSigningCertificate, and ServiceEncryptingCertificate. Also override the CreateSecurityTokenManager method to return an instance of the customized ServiceCredentialsSecurityTokenManager class that is defined in the next step.

public class MyServiceCredentials : ServiceCredentials
{
    X509Certificate2 clientSigningCert;
    X509Certificate2 clientEncryptingCert;
    X509Certificate2 serviceSigningCert;
    X509Certificate2 serviceEncryptingCert;

    public MyServiceCredentials()
    {
    }

    protected MyServiceCredentials(MyServiceCredentials other)
        : base(other)
    {
        this.clientEncryptingCert = other.clientEncryptingCert;
        this.clientSigningCert = other.clientSigningCert;
        this.serviceEncryptingCert = other.serviceEncryptingCert;
        this.serviceSigningCert = other.serviceSigningCert;
    }

    public X509Certificate2 ClientSigningCertificate
    {
        get
        {
            return this.clientSigningCert;
        }
        set
        {
            this.clientSigningCert = value;
        }
    }

    public X509Certificate2 ClientEncryptingCertificate
    {
        get
        {
            return this.clientEncryptingCert;
        }
        set
        {
            this.clientEncryptingCert = value;
        }
    }

    public X509Certificate2 ServiceSigningCertificate
    {
        get
        {
            return this.serviceSigningCert;
        }
        set
        {
            this.serviceSigningCert = value;
        }
    }

    public X509Certificate2 ServiceEncryptingCertificate
    {
        get
        {
            return this.serviceEncryptingCert;
        }
        set
        {
            this.serviceEncryptingCert = value;
        }
    }

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

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

Define a new service security token manager that inherits from the ServiceCredentialsSecurityTokenManager class. Override the CreateSecurityTokenProvider method to create an appropriate security token provider given the passed-in message direction and key usage.

internal class MyServiceCredentialsSecurityTokenManager : 
    ServiceCredentialsSecurityTokenManager
{
    MyServiceCredentials credentials;

    public MyServiceCredentialsSecurityTokenManager(
        MyServiceCredentials credentials)
        : base(credentials)
    {
        this.credentials = credentials;
    }

    public override SecurityTokenProvider CreateSecurityTokenProvider(
        SecurityTokenRequirement requirement)
    {
        SecurityTokenProvider result = null;
        if (requirement.TokenType == SecurityTokenTypes.X509Certificate)
        {
            MessageDirection direction = requirement.
                GetProperty<MessageDirection>(
                ServiceModelSecurityTokenRequirement.
                MessageDirectionProperty);
            if (direction == MessageDirection.Input)
            {
                if (requirement.KeyUsage == SecurityKeyUsage.Exchange)
                {
                    result = new X509SecurityTokenProvider(
                        credentials.ServiceEncryptingCertificate);
                }
                else
                {
                    result = new X509SecurityTokenProvider(
                        credentials.ClientSigningCertificate);
                }
            }
            else
            {
                if (requirement.KeyUsage == SecurityKeyUsage.Signature)
                {
                    result = new X509SecurityTokenProvider(
                        credentials.ServiceSigningCertificate);
                }
                else
                {
                    result = new X509SecurityTokenProvider(
                        credentials.ClientEncryptingCertificate);
                }
            }
        }
        else
        {
            result = base.CreateSecurityTokenProvider(requirement);
        }
        return result;
    }
}

To use multiple certificates on the client

Create a custom binding. The security binding element must operate in duplex mode to allow different security token providers to be present for requests and responses. One way to do this is to use a duplex-capable transport or to use the CompositeDuplexBindingElement as shown in the following code. Link the customized IdentityVerifier which is defined in the next step to the security binding element. Replace the default client credentials with the customized client credentials previously created.

            EndpointAddress serviceEndpoint = 
                new EndpointAddress(new Uri("https://localhost:6060/service"));

            CustomBinding binding = new CustomBinding();

            AsymmetricSecurityBindingElement securityBE = 
                SecurityBindingElement.CreateMutualCertificateDuplexBindingElement(
                MessageSecurityVersion.
WSSecurity10WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10);
            // Add a custom IdentityVerifier because the service uses two certificates 
            // (one for signing and one for encryption) and an endpoint identity that 
            // contains a single identity claim.
            securityBE.LocalClientSettings.IdentityVerifier = new MyIdentityVerifier();
            binding.Elements.Add(securityBE);

            CompositeDuplexBindingElement compositeDuplex = 
                new CompositeDuplexBindingElement();
            compositeDuplex.ClientBaseAddress = new Uri("https://localhost:6061/client");
            binding.Elements.Add(compositeDuplex);

            binding.Elements.Add(new OneWayBindingElement());

            binding.Elements.Add(new HttpTransportBindingElement());

            using (ChannelFactory<IMyServiceChannel> factory = 
                new ChannelFactory<IMyServiceChannel>(binding, serviceEndpoint))
            {
                MyClientCredentials credentials = new MyClientCredentials();
                SetupCertificates(credentials);
                factory.Endpoint.Behaviors.Remove(typeof(ClientCredentials));
                factory.Endpoint.Behaviors.Add(credentials);

                IMyServiceChannel channel = factory.CreateChannel();
                Console.WriteLine(channel.Hello("world"));
                channel.Close();
            }

Define a custom IdentityVerifier. The service has multiple identities because different certificates are used to encrypt the request and to sign the response.

Note:
In the following sample, the provided custom identity verifier does not perform any endpoint identity checking for demonstration purposes. This is not recommended practice for production code.

class MyIdentityVerifier : IdentityVerifier
{
    IdentityVerifier defaultVerifier;

    public MyIdentityVerifier()
    {
        this.defaultVerifier = IdentityVerifier.CreateDefault();
    }

    public override bool CheckAccess(EndpointIdentity identity, 
        AuthorizationContext authContext)
    {
        // The following implementation is for demonstration only, and
        // does not perform any checks regarding EndpointIdentity.
        // Do not use this for production code.
        return true;
    }

    public override bool TryGetIdentity(EndpointAddress reference, 
        out EndpointIdentity identity)
    {
        return this.defaultVerifier.TryGetIdentity(reference, out identity);
    }
}

To use multiple certificates on the service

Create a custom binding. The security binding element must operate in a duplex mode to allow different security token providers to be present for requests and responses. As with the client, use a duplex-capable transport or use CompositeDuplexBindingElement as shown in the following code. Replace the default service credentials with the customized service credentials previously created.

            Uri serviceEndpoint = new Uri("https://localhost:6060/service");
            using (ServiceHost host = new ServiceHost(typeof(Service), serviceEndpoint))
            {
                CustomBinding binding = new CustomBinding();
                binding.Elements.Add(SecurityBindingElement.
                    CreateMutualCertificateDuplexBindingElement(
MessageSecurityVersion.WSSecurity10WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10));
                binding.Elements.Add(new CompositeDuplexBindingElement());
                binding.Elements.Add(new OneWayBindingElement());
                binding.Elements.Add(new HttpTransportBindingElement());

                MyServiceCredentials credentials = new MyServiceCredentials();
                SetupCertificates(credentials);
                host.Description.Behaviors.Remove(typeof(ServiceCredentials));
                host.Description.Behaviors.Add(credentials);

                ServiceEndpoint endpoint = host.AddServiceEndpoint(
                    typeof(IMyService), binding, "");
                host.Open();

                Console.WriteLine("Service started, press ENTER to stop...");
                Console.ReadLine();
            }

Share via

How to: Use Separate X.509 Certificates for Signing and Encryption

To use separate certificates for signing and encryption

To use multiple certificates on the client

To use multiple certificates on the service

See Also

Reference

Concepts

Additional resources