Add support for multiple server certificates

Introduce support for multiple certificates in the server SSL configuration.

Tomcat configuration support multiple `Certificate` elements in `SSLHostConfig` of different type [1].
This functionality is supported by NSS which will select the most
appropriate certificate as result of the negotiation.

1. https://tomcat.apache.org/tomcat-9.0-doc/config/http.html#SSL_Support_-_SSLHostConfig

Author: fmarco76

base/src/main/java/org/mozilla/jss/ssl/javax/JSSEngine.java

@@ -4,13 +4,16 @@
 import java.util.Collection;
 import java.util.EventListener;
 import java.util.HashMap;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.net.ssl.SSLEngineResult;
 import javax.net.ssl.SSLException;
 import javax.net.ssl.SSLParameters;
 import javax.net.ssl.X509KeyManager;
 import javax.net.ssl.X509TrustManager;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
 
 import org.mozilla.jss.crypto.Policy;
 import org.mozilla.jss.nss.PR;
@@ -76,21 +79,16 @@ public abstract class JSSEngine extends javax.net.ssl.SSLEngine {
     /**
      * Certificate alias used by the JSSEngine instance.
      */
-    protected String certAlias;
+    protected List<String> certAliases;
 
     /**
-     * Certificate used by this JSSEngine instance.
+     * Collection of certificates and related keys used by this JSSEngine instance.
      *
      * Selected and inferred from the KeyManagers passed, when not passed
      * explicitly (either during construction or with a call to
      * setKeyMaterials(...)).
      */
-    protected PK11Cert cert;
-
-    /**
-     * Key corresponding to the local certificate.
-     */
-    protected PK11PrivKey key;
+    protected List<Pair<PK11Cert, PK11PrivKey>> certs;
 
     /**
      * A list of all KeyManagers available to this JSSEngine instance.
@@ -197,7 +195,7 @@ public abstract class JSSEngine extends javax.net.ssl.SSLEngine {
      * Set of cached server sockets based on the PK11Cert they were
      * initialized with.
      */
-    protected static HashMap<PK11Cert, SSLFDProxy> serverTemplates = new HashMap<>();
+    protected static HashMap<List<Pair<PK11Cert, PK11PrivKey>>, SSLFDProxy> serverTemplates = new HashMap<>();
 
     /**
      * Whether or not the session cache has been initialized already.
@@ -255,9 +253,8 @@ public JSSEngine(String peerHost, int peerPort,
                      org.mozilla.jss.crypto.X509Certificate localCert,
                      org.mozilla.jss.crypto.PrivateKey localKey) {
         super(peerHost, peerPort);
-
-        cert = (PK11Cert) localCert;
-        key = (PK11PrivKey) localKey;
+        certs = new ArrayList<>();
+        certs.add(ImmutablePair.of((PK11Cert) localCert, (PK11PrivKey) localKey));
 
         session = new JSSSession(this, BUFFER_SIZE);
         session.setPeerHost(peerHost);
@@ -338,7 +335,7 @@ public JSSParameters getSSLParameters() {
             ret.setWantClientAuth(true);
         }
 
-        ret.setAlias(certAlias);
+        ret.setAliases(certAliases);
         ret.setHostname(hostname);
         ret.setListeners(listeners);
 
@@ -405,8 +402,9 @@ public void setSSLParameters(SSLParameters params) {
         // them from the alias specified... We assume that when the SSLEngine
         // has a certificate already, we want to use them, even if parsed has
         // a null certificate.
-        if (parsed.getAlias() != null && key_managers != null && key_managers.length > 0 && cert == null && key == null) {
-            setCertFromAlias(parsed.getAlias());
+        if (parsed.getAliases() != null && !parsed.getAliases().isEmpty() && key_managers != null && key_managers.length > 0
+                && (certs == null || certs.isEmpty())) {
+            setCertFromAliases(parsed.getAliases());
         }
 
         // When we have a value for the peer hostname, we should try and use
@@ -452,54 +450,64 @@ public void setHostname(String name) {
      *
      */
     public void setCertFromAlias(String alias) throws IllegalArgumentException {
-        if (alias == null) {
+        List<String> aliases = new ArrayList<>();
+        if (alias != null) { 
+            aliases.add(alias);
+        }
+        setCertFromAliases(aliases);
+    }
+    
+    public void setCertFromAliases(List<String> aliases) throws IllegalArgumentException {
+        if (aliases == null || aliases.isEmpty()) {
             // Per calling, semantics, get rid of any existing cert/key we
             // might have.
-            certAlias = null;
-            cert = null;
-            key = null;
+            certAliases = null;
+            certs = null;
             return;
         }
 
-        certAlias = alias;
+        certAliases = aliases;
+        certs = new ArrayList<>();
 
         if (key_managers == null || key_managers.length == 0) {
             String msg = "Missing or null KeyManagers; refusing to search ";
             msg += "for cert";
             throw new IllegalArgumentException(msg);
         }
 
-        for (X509KeyManager key_manager : key_managers) {
-            if (key_manager == null) {
-                // Skip this key_manager. This case could occur when
-                // setKeyManagers(...) is passed an array containing the value
-                // null, but otherwise shouldn't happen.
-                continue;
-            }
+        for (String alias: certAliases) {
+            for (X509KeyManager key_manager : key_managers) {
+                if (key_manager == null) {
+                    // Skip this key_manager. This case could occur when
+                    // setKeyManagers(...) is passed an array containing the value
+                    // null, but otherwise shouldn't happen.
+                    continue;
+                }
 
-            if (!(key_manager instanceof JSSKeyManager)) {
-                // We're explicitly looking for a JSSKeyManager; skip this if
-                // it doesn't match.
-                continue;
-            }
+                if (!(key_manager instanceof JSSKeyManager)) {
+                    // We're explicitly looking for a JSSKeyManager; skip this if
+                    // it doesn't match.
+                    continue;
+                }
 
-            JSSKeyManager jkm = (JSSKeyManager) key_manager;
+                JSSKeyManager jkm = (JSSKeyManager) key_manager;
 
-            // While the return type of CryptoManager.findCertByNickname is
-            // technically org.mozilla.jss.crypto.X509Certificate, in practice
-            // they are always PK11Cert instances. We're going to need an
-            // instance of PK11Cert anyways, in order to correctly pass it to
-            // the native layer.
-            cert = (PK11Cert) jkm.getCertificate(alias);
-            key = (PK11PrivKey) jkm.getPrivateKey(alias);
+                // While the return type of CryptoManager.findCertByNickname is
+                // technically org.mozilla.jss.crypto.X509Certificate, in practice
+                // they are always PK11Cert instances. We're going to need an
+                // instance of PK11Cert anyways, in order to correctly pass it to
+                // the native layer.
+                PK11Cert cert = (PK11Cert) jkm.getCertificate(alias);
+                PK11PrivKey key = (PK11PrivKey) jkm.getPrivateKey(alias);
 
-            if (cert != null && key != null) {
-                // Found a cert and key matching our alias; exit.
-                break;
+                if (cert != null && key != null) {
+                    // Found a cert and key matching our alias; exit.
+                    certs.add(ImmutablePair.of(cert, key));
+                    break;
+                }
             }
         }
-
-        if (cert == null && key == null) {
+        if (certs.isEmpty()) {
             String msg = "JSSEngine.setCertFromAlias: Unable to find ";
             msg += "certificate and key for specified alias!";
             throw new IllegalArgumentException(msg);
@@ -771,8 +779,10 @@ public void setKeyMaterials(PK11Cert our_cert, PK11PrivKey our_key) throws Illeg
             throw new IllegalArgumentException("JSSEngine.setKeyMaterials(): Either both cert and key must be null or both must be not-null");
         }
 
-        cert = our_cert;
-        key = our_key;
+        if (certs == null) {
+            certs = new ArrayList<>();
+        }
+        certs.add(ImmutablePair.of(our_cert, our_key));
     }
 
     /**
@@ -1093,23 +1103,25 @@ public void setConfiguration(HashMap<Integer, Integer> config) {
     /**
      * Returns the templated server certificate, if one exists.
      */
-    protected static SSLFDProxy getServerTemplate(PK11Cert cert, PK11PrivKey key) {
-        if (cert == null || key == null) {
+    protected static SSLFDProxy getServerTemplate(List<Pair<PK11Cert, PK11PrivKey>> lstCerts) {
+        if (lstCerts == null || lstCerts.isEmpty()) {
             return null;
         }
 
-        SSLFDProxy fd = serverTemplates.get(cert);
+        SSLFDProxy fd = serverTemplates.get(lstCerts);
         if (fd == null) {
             PRFDProxy base = PR.NewTCPSocket();
             fd = SSL.ImportFD(null, base);
-            if (SSL.ConfigServerCert(fd, cert, key) != SSL.SECSuccess) {
-                String msg = "Unable to configure certificate and key on ";
-                msg += "model SSL PRFileDesc proxy: ";
-                msg += errorText(PR.GetError());
-                throw new RuntimeException(msg);
+            for(Pair<PK11Cert, PK11PrivKey> pairKey: lstCerts) {
+                if (SSL.ConfigServerCert(fd, pairKey.getLeft(), pairKey.getRight()) != SSL.SECSuccess) {
+                    String msg = "Unable to configure certificate and key on ";
+                    msg += "model SSL PRFileDesc proxy: ";
+                    msg += errorText(PR.GetError());
+                    throw new RuntimeException(msg);
+                }
             }
-
-            serverTemplates.put(cert, fd);
+ 
+            serverTemplates.put(lstCerts, fd);
         }
 
         return fd;

base/src/main/java/org/mozilla/jss/ssl/javax/JSSEngineReferenceImpl.java

@@ -9,13 +9,16 @@
 import java.nio.channels.WritableByteChannel;
 import java.security.PublicKey;
 import java.security.cert.CertificateException;
+import java.util.ArrayList;
+import java.util.List;
 
 import javax.net.ssl.SSLEngineResult;
 import javax.net.ssl.SSLException;
 import javax.net.ssl.SSLHandshakeException;
 import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.X509ExtendedTrustManager;
 import javax.net.ssl.X509TrustManager;
+import org.apache.commons.lang3.tuple.Pair;
 
 import org.mozilla.jss.nss.BadCertHandler;
 import org.mozilla.jss.nss.Buffer;
@@ -31,6 +34,7 @@
 import org.mozilla.jss.nss.SSLPreliminaryChannelInfo;
 import org.mozilla.jss.nss.SecurityStatusResult;
 import org.mozilla.jss.pkcs11.PK11Cert;
+import org.mozilla.jss.pkcs11.PK11PrivKey;
 import org.mozilla.jss.provider.javax.crypto.JSSNativeTrustManager;
 import org.mozilla.jss.ssl.SSLAlertDescription;
 import org.mozilla.jss.ssl.SSLAlertEvent;
@@ -331,7 +335,7 @@ private void createBufferFD() throws SSLException {
             // re-creating it from scratch. This saves a significant amount of
             // time during construction. The implementation lives in JSSEngine,
             // to be shared by all other JSSEngine implementations.
-            model = getServerTemplate(cert, key);
+            model = getServerTemplate(certs);
         }
 
         // Initialize ssl_fd from the model Buffer-backed PRFileDesc.
@@ -366,13 +370,17 @@ private void createBufferFD() throws SSLException {
     private void initClient() throws SSLException {
         debug("JSSEngine: initClient()");
 
-        if (cert != null && key != null) {
+        if (certs != null && !certs.isEmpty()) {
             // NSS uses a callback to check for the client certificate; we
             // assume we have knowledge of it ahead of time and set it
             // directly on our SSLFDProxy instance.
             //
             // In the future, we could use a KeyManager for inquiring at
             // selection time which certificate to use.
+            
+            // For the clients only the first certificate is used.
+            // Multiple certificate could be configure if it is needed.
+            PK11Cert cert = certs.iterator().next().getLeft();
             debug("JSSEngine.initClient(): Enabling client auth: " + cert);
             ssl_fd.SetClientCert(cert);
             if (SSL.AttachClientCertCallback(ssl_fd) != SSL.SECSuccess) {
@@ -400,14 +408,18 @@ private void initServer() throws SSLException {
 
         // The only time cert and key are strictly required are when we're
         // creating a server SSLEngine.
-        if (cert == null || key == null) {
+        if (certs == null) {
             throw new IllegalArgumentException("JSSEngine: must be initialized with server certificate and key!");
         }
 
-        debug("JSSEngine.initServer(): " + cert);
-        debug("JSSEngine.initServer(): " + key);
+        debug("JSSEngine.initServer(): " + certs);
 
-        session.setLocalCertificates(new PK11Cert[]{ cert } );
+        List<PK11Cert> lstCerts = new ArrayList<>();
+        for (Pair<PK11Cert, PK11PrivKey> pairKeys: certs) {
+            lstCerts.add(pairKeys.getLeft());
+        }
+        
+        session.setLocalCertificates(lstCerts.toArray(new PK11Cert[0]));
 
         // Create a small server session cache.
         //

base/src/main/java/org/mozilla/jss/ssl/javax/JSSParameters.java

@@ -1,9 +1,13 @@
 package org.mozilla.jss.ssl.javax;
 
-import javax.net.ssl.*;
-import java.util.*;
-
-import org.mozilla.jss.ssl.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EventListener;
+import java.util.List;
+import javax.net.ssl.SSLParameters;
+import org.mozilla.jss.ssl.SSLCipher;
+import org.mozilla.jss.ssl.SSLVersion;
+import org.mozilla.jss.ssl.SSLVersionRange;
 
 /**
  * JSSParameters is an implementation of SSLParameters to interoperate
@@ -24,7 +28,7 @@
 public class JSSParameters extends SSLParameters {
     private SSLCipher[] suites;
     private SSLVersionRange range;
-    private String alias;
+    private List<String> aliases;
     private String hostname;
     private Collection<? extends EventListener> listeners;
 
@@ -180,20 +184,20 @@ public SSLVersionRange getSSLVersionRange() {
         return range;
     }
 
-    public String getAlias() {
-        return alias;
+    public List<String> getAliases() {
+        return aliases;
     }
 
-    public void setAlias(String cert_alias) {
-        alias = cert_alias;
+    public void setAliases(List<String> certAliases) {
+        aliases = certAliases;
     }
 
     public String getHostname() {
         return hostname;
     }
 
-    public void setHostname(String server_hostname) {
-        hostname = server_hostname;
+    public void setHostname(String serverHostname) {
+        hostname = serverHostname;
     }
 
     public Collection<? extends EventListener> getListeners() {

base/src/test/java/org/mozilla/jss/tests/TestSSLEngine.java

@@ -4,6 +4,7 @@
 import java.security.KeyStore;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 
 import javax.net.ssl.KeyManager;
 import javax.net.ssl.KeyManagerFactory;
@@ -166,7 +167,9 @@ public static JSSParameters createParameters() throws Exception {
     public static JSSParameters createParameters(String alias) throws Exception {
         JSSParameters params = new JSSParameters();
 
-        params.setAlias(alias);
+        String[] aliases = alias.split(",");
+        
+        params.setAliases(Arrays.asList(aliases));
         params.setHostname("localhost");
 
         return params;