Added builder carrying provider names to CompositePrivateKey.

Author: dghgit

prov/src/main/java/org/bouncycastle/jcajce/CompositePrivateKey.java

@@ -2,6 +2,8 @@
 
 import java.io.IOException;
 import java.security.PrivateKey;
+import java.security.Provider;
+import java.security.Security;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -29,7 +31,50 @@
 public class CompositePrivateKey
     implements PrivateKey
 {
+    public static class Builder
+    {
+        private final AlgorithmIdentifier algorithmIdentifier;
+        private final PrivateKey[] keys = new PrivateKey[2];
+        private final Provider[] providers = new Provider[2];
+
+        private int count = 0;
+
+        private Builder(AlgorithmIdentifier algorithmIdentifier)
+        {
+            this.algorithmIdentifier = algorithmIdentifier;
+        }
+
+        public Builder addPrivateKey(PrivateKey key, String providerName)
+        {
+            return addPrivateKey(key, Security.getProvider(providerName));
+        }
+
+        public Builder addPrivateKey(PrivateKey key, Provider provider)
+        {
+            if (count == keys.length)
+            {
+                throw new IllegalStateException("only " + keys.length + " allowed in composite");
+            }
+
+            keys[count] = key;
+            providers[count++] = provider;
+
+            return this;
+        }
+
+        public CompositePrivateKey build()
+        {
+            return new CompositePrivateKey(algorithmIdentifier, keys, providers);
+        }
+    }
+
+    public static Builder builder(ASN1ObjectIdentifier compAlgOid)
+    {
+        return new Builder(new AlgorithmIdentifier(compAlgOid));
+    }
+
     private final List<PrivateKey> keys;
+    private final List<Provider> providers;
 
     private AlgorithmIdentifier algorithmIdentifier;
 
@@ -69,17 +114,44 @@ public CompositePrivateKey(AlgorithmIdentifier algorithmIdentifier, PrivateKey..
         List<PrivateKey> keyList = new ArrayList<PrivateKey>(keys.length);
         for (int i = 0; i < keys.length; i++)
         {
-            if (keys[i] instanceof MLDSAPrivateKey)
-            {
-                // TODO: we don't insist on seed but we try to accommodate it - the debate continues
-                keyList.add(((MLDSAPrivateKey)keys[i]).getPrivateKey(true));
-            }
-            else
-            {
-                keyList.add(keys[i]);
-            }
+            keyList.add(processKey(keys[i]));
         }
         this.keys = Collections.unmodifiableList(keyList);
+        this.providers = null;
+    }
+
+    private PrivateKey processKey(PrivateKey key)
+    {
+        // we assume this also means BCKey
+        if (key instanceof MLDSAPrivateKey)
+        {
+            // TODO: we don't insist on seed but we try to accommodate it - the debate continues
+            return ((MLDSAPrivateKey)key).getPrivateKey(true);
+        }
+        else
+        {
+            return key;
+        }
+    }
+
+    private CompositePrivateKey(AlgorithmIdentifier algorithmIdentifier, PrivateKey[] keys, Provider[] providers)
+    {
+        this.algorithmIdentifier = algorithmIdentifier;
+
+        if (keys.length != 2)
+        {
+            throw new IllegalArgumentException("two keys required for composite private key");
+        }
+
+        List<PrivateKey> keyList = new ArrayList<PrivateKey>(keys.length);
+        List<Provider> providerList = new ArrayList<Provider>(providers.length);
+        for (int i = 0; i < keys.length; i++)
+        {
+            providerList.add(providers[i]);
+            keyList.add(processKey(keys[i]));
+        }
+        this.keys = Collections.unmodifiableList(keyList);
+        this.providers = Collections.unmodifiableList(providerList);
     }
 
     /**
@@ -111,6 +183,7 @@ public CompositePrivateKey(PrivateKeyInfo keyInfo)
         }
 
         this.keys = privateKeyFromFactory.getPrivateKeys();
+        this.providers = null;
         this.algorithmIdentifier = privateKeyFromFactory.getAlgorithmIdentifier();
     }
 
@@ -124,6 +197,16 @@ public List<PrivateKey> getPrivateKeys()
         return keys;
     }
 
+    /**
+     * Return a list of the providers supporting the component private keys.
+     *
+     * @return an immutable list of Provider objects.
+     */
+    public List<Provider> getProviders()
+    {
+        return providers;
+    }
+
     public String getAlgorithm()
     {
         return CompositeIndex.getAlgorithmName(this.algorithmIdentifier.getAlgorithm());

prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/SignatureSpi.java

@@ -8,6 +8,7 @@
 import java.security.InvalidParameterException;
 import java.security.Key;
 import java.security.PrivateKey;
+import java.security.Provider;
 import java.security.PublicKey;
 import java.security.SecureRandom;
 import java.security.Signature;
@@ -133,7 +134,7 @@ protected void engineInitVerify(PublicKey publicKey)
         {
             throw new InvalidKeyException("Provided composite public key cannot be used with the composite signature algorithm.");
         }
-        createComponentSignatures(compositePublicKey.getPublicKeys());
+        createComponentSignatures(compositePublicKey.getPublicKeys(), null);
 
         sigInitVerify();
     }
@@ -164,24 +165,34 @@ protected void engineInitSign(PrivateKey privateKey)
         {
             throw new InvalidKeyException("Provided composite private key cannot be used with the composite signature algorithm.");
         }
-        createComponentSignatures(compositePrivateKey.getPrivateKeys());
+        createComponentSignatures(compositePrivateKey.getPrivateKeys(), compositePrivateKey.getProviders());
 
         sigInitSign();
     }
 
-    private void createComponentSignatures(List keys)
+    private void createComponentSignatures(List keys, List<Provider> providers)
     {
         try
         {
-            for (int i = 0; i != componentSignatures.length; i++)
+            if (providers == null)
             {
-                if (keys.get(i) instanceof BCKey)
+                for (int i = 0; i != componentSignatures.length; i++)
                 {
-                    componentSignatures[i] = Signature.getInstance(algs[i], "BC");
+                    if (keys.get(i) instanceof BCKey)
+                    {
+                        componentSignatures[i] = Signature.getInstance(algs[i], "BC");
+                    }
+                    else
+                    {
+                        componentSignatures[i] = Signature.getInstance(algs[i]);
+                    }
                 }
-                else
+            }
+            else
+            {
+                for (int i = 0; i != componentSignatures.length; i++)
                 {
-                    componentSignatures[i] = Signature.getInstance(algs[i]);
+                    componentSignatures[i] = Signature.getInstance(algs[i], providers.get(i));
                 }
             }
         }

prov/src/test/java/org/bouncycastle/jcajce/provider/test/CompositeSignaturesTest.java

@@ -333,7 +333,10 @@ public void testMixedComposition()
         KeyPair ecKp = ecKpGen.generateKeyPair();
 
         CompositePublicKey compPublicKey = new CompositePublicKey(BCObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256, mldsaKp.getPublic(), ecKp.getPublic());
-        CompositePrivateKey compPrivateKey = new CompositePrivateKey(BCObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256, mldsaKp.getPrivate(), ecKp.getPrivate());
+        CompositePrivateKey compPrivateKey = CompositePrivateKey.builder(BCObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256)
+                                                    .addPrivateKey(mldsaKp.getPrivate(), "BC")
+                                                    .addPrivateKey(ecKp.getPrivate(), "SunEC")
+                                                    .build();
 
         Signature signature = Signature.getInstance(BCObjectIdentifiers.id_MLDSA44_ECDSA_P256_SHA256.getId(), "BC");
         signature.initSign(compPrivateKey);