Refactor composite keys

peterdettman · peterdettman · commit ca7c312862d1 · 2026-01-20T23:17:17.000+07:00
diff --git a/prov/src/main/java/org/bouncycastle/jcajce/CompositePrivateKey.java b/prov/src/main/java/org/bouncycastle/jcajce/CompositePrivateKey.java
@@ -267,57 +267,67 @@ public String getFormat()
      */
     public byte[] getEncoded()
     {
-        if (this.algorithmIdentifier.getAlgorithm().on(IANAObjectIdentifiers.id_alg))
+        ASN1ObjectIdentifier algOid = algorithmIdentifier.getAlgorithm();
+
+        if (algOid.on(IANAObjectIdentifiers.id_alg))
         {
             try
             {
                 PrivateKey key0 = keys.get(0);
                 PrivateKey key1 = keys.get(1);
 
-                byte[] mldsaKey = ((MLDSAPrivateKey)key0).getSeed();
+                byte[] mldsaSeed = ((MLDSAPrivateKey)key0).getSeed();
 
-                byte[] key1Encoded = key1.getEncoded();
-                PrivateKeyInfo pki = PrivateKeyInfo.getInstance(key1Encoded);
+                PrivateKeyInfo pki = PrivateKeyInfo.getInstance(key1.getEncoded());
 
-                byte[] tradKey;
+                byte[] tradSK;
                 String key1Algorithm = key1.getAlgorithm();
                 if (key1Algorithm.contains("Ed"))
                 {
-                    tradKey = ASN1OctetString.getInstance(pki.parsePrivateKey()).getOctets();
+                    tradSK = ASN1OctetString.getInstance(pki.parsePrivateKey()).getOctets();
                 }
                 else if (key1Algorithm.contains("EC"))
                 {
                     ECPrivateKey ecPrivateKey = ECPrivateKey.getInstance(pki.parsePrivateKey());
 
-                    // TODO Do we also want to remove any parameters from the ECPrivateKey? 
+                    /*
+                     * TODO
+                     * - Confirm pki.privateKeyAlgorithm is id_ecPublicKey with X9.62 Parameters namedCurve OID.
+                     * - If ecPrivateKey.parameters are present, must match pki.privateKeyAlgorithm
+                     * The private key MUST be encoded as ECPrivateKey specified in [RFC5915] with the 'NamedCurve'
+                     * parameter set to the OID of the curve, but without the 'publicKey' field.
+                     */
+                    // TODO Also need to ensure that ECPrivateKey.parameters are present
                     ASN1BitString publicKey = ecPrivateKey.getPublicKey();
                     if (publicKey != null)
                     {
                         ecPrivateKey = new ECPrivateKey(ecPrivateKey.getPrivateKey(), ecPrivateKey.getParametersObject(), null);
                     }
 
-                    tradKey = ecPrivateKey.getEncoded();
+                    tradSK = ecPrivateKey.getEncoded(ASN1Encoding.DER);
                 }
                 else
                 {
-                    tradKey = pki.getPrivateKey().getOctets();
+                    tradSK = pki.getPrivateKey().getOctets();
                 }
 
-                return new PrivateKeyInfo(algorithmIdentifier, Arrays.concatenate(mldsaKey, tradKey)).getEncoded();
+                return new PrivateKeyInfo(algorithmIdentifier, Arrays.concatenate(mldsaSeed, tradSK)).getEncoded();
             }
             catch (IOException e)
             {
                 throw new IllegalStateException("unable to encode composite public key: " + e.getMessage());
             }
         }
+
         ASN1EncodableVector v = new ASN1EncodableVector();
 
-        if (algorithmIdentifier.getAlgorithm().equals(MiscObjectIdentifiers.id_composite_key))
+        if (MiscObjectIdentifiers.id_composite_key.equals(algOid))
         {
             for (int i = 0; i < keys.size(); i++)
             {
-                PrivateKeyInfo info = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());
-                v.add(info);
+                PrivateKeyInfo pki = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());
+
+                v.add(pki);
             }
 
             try
@@ -334,8 +344,9 @@ else if (key1Algorithm.contains("EC"))
             byte[] keyEncoding = null;
             for (int i = 0; i < keys.size(); i++)
             {
-                PrivateKeyInfo info = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());
-                keyEncoding = Arrays.concatenate(keyEncoding, info.getPrivateKey().getOctets());
+                PrivateKeyInfo pki = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());
+
+                keyEncoding = Arrays.concatenate(keyEncoding, pki.getPrivateKey().getOctets());
             }
 
             try
diff --git a/prov/src/main/java/org/bouncycastle/jcajce/CompositePublicKey.java b/prov/src/main/java/org/bouncycastle/jcajce/CompositePublicKey.java
@@ -246,13 +246,15 @@ public String getFormat()
     @Override
     public byte[] getEncoded()
     {
-        if (this.algorithmIdentifier.getAlgorithm().on(IANAObjectIdentifiers.id_alg))
+        ASN1ObjectIdentifier algOid = algorithmIdentifier.getAlgorithm();
+
+        if (algOid.on(IANAObjectIdentifiers.id_alg))
         {
             try
             {
-                byte[] mldsaKey = org.bouncycastle.pqc.crypto.util.SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(org.bouncycastle.pqc.crypto.util.PublicKeyFactory.createKey(keys.get(0).getEncoded())).getPublicKeyData().getBytes();
-                byte[] tradKey = SubjectPublicKeyInfo.getInstance(keys.get(1).getEncoded()).getPublicKeyData().getBytes();
-                return new SubjectPublicKeyInfo(getAlgorithmIdentifier(), Arrays.concatenate(mldsaKey, tradKey)).getEncoded();
+                byte[] mldsaPK = SubjectPublicKeyInfo.getInstance(keys.get(0).getEncoded()).getPublicKeyData().getOctets();
+                byte[] tradPK = SubjectPublicKeyInfo.getInstance(keys.get(1).getEncoded()).getPublicKeyData().getOctets();
+                return new SubjectPublicKeyInfo(algorithmIdentifier, Arrays.concatenate(mldsaPK, tradPK)).getEncoded(ASN1Encoding.DER);
             }
             catch (IOException e)
             {
@@ -264,18 +266,20 @@ public byte[] getEncoded()
 
         for (int i = 0; i < keys.size(); i++)
         {
-            if (this.algorithmIdentifier.getAlgorithm().equals(MiscObjectIdentifiers.id_composite_key))
+            SubjectPublicKeyInfo spki = SubjectPublicKeyInfo.getInstance(keys.get(i).getEncoded());
+
+            if (MiscObjectIdentifiers.id_composite_key.equals(algOid))
             {
                 //Legacy, component is the whole SubjectPublicKeyInfo
-                v.add(SubjectPublicKeyInfo.getInstance(keys.get(i).getEncoded()));
+                v.add(spki);
             }
             else
             {
                 //component is the value of subjectPublicKey from SubjectPublicKeyInfo
-                SubjectPublicKeyInfo keyInfo = SubjectPublicKeyInfo.getInstance(keys.get(i).getEncoded());
-                v.add(keyInfo.getPublicKeyData());
+                v.add(spki.getPublicKeyData());
             }
         }
+
         try
         {
             return new SubjectPublicKeyInfo(this.algorithmIdentifier, new DERSequence(v)).getEncoded(ASN1Encoding.DER);
@@ -286,31 +290,26 @@ public byte[] getEncoded()
         }
     }
 
-
     public int hashCode()
     {
-        return keys.hashCode();
+        return algorithmIdentifier.hashCode() ^ keys.hashCode();
     }
 
-    public boolean equals(Object o)
+    public boolean equals(Object obj)
     {
-        if (o == this)
+        if (obj == this)
         {
             return true;
         }
 
-        if (o instanceof CompositePublicKey)
+        if (!(obj instanceof CompositePublicKey))
         {
-            boolean isEqual = true;
-            CompositePublicKey comparedKey = (CompositePublicKey)o;
-            if (!comparedKey.getAlgorithmIdentifier().equals(this.algorithmIdentifier) || !this.keys.equals(comparedKey.keys))
-            {
-                isEqual = false;
-            }
-
-            return isEqual;
+            return false;
         }
 
-        return false;
+        CompositePublicKey that = (CompositePublicKey)obj;
+
+        return this.algorithmIdentifier.equals(that.algorithmIdentifier)
+            && this.keys.equals(that.keys);
     }
 }
diff --git a/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyFactorySpi.java b/prov/src/main/java/org/bouncycastle/jcajce/provider/asymmetric/compositesignatures/KeyFactorySpi.java
@@ -25,7 +25,6 @@
 import org.bouncycastle.asn1.DERBitString;
 import org.bouncycastle.asn1.DEROctetString;
 import org.bouncycastle.asn1.DERSequence;
-import org.bouncycastle.asn1.bc.BCObjectIdentifiers;
 import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
 import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
 import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
@@ -56,20 +55,24 @@ public class KeyFactorySpi
     extends BaseKeyFactorySpi
     implements AsymmetricKeyInfoConverter
 {
+    private static AlgorithmIdentifier createECAlgID(ASN1ObjectIdentifier curveOid)
+    {
+        return new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, new X962Parameters(curveOid));
+    }
 
     //Specific algorithm identifiers of all component signature algorithms for SubjectPublicKeyInfo. These do not need to be all initialized here but makes the code more readable IMHO.
     private static final AlgorithmIdentifier mlDsa44 = new AlgorithmIdentifier(NISTObjectIdentifiers.id_ml_dsa_44);
     private static final AlgorithmIdentifier mlDsa65 = new AlgorithmIdentifier(NISTObjectIdentifiers.id_ml_dsa_65);
     private static final AlgorithmIdentifier mlDsa87 = new AlgorithmIdentifier(NISTObjectIdentifiers.id_ml_dsa_87);
-    private static final AlgorithmIdentifier falcon512Identifier = new AlgorithmIdentifier(BCObjectIdentifiers.falcon_512);
+//    private static final AlgorithmIdentifier falcon512Identifier = new AlgorithmIdentifier(BCObjectIdentifiers.falcon_512);
     private static final AlgorithmIdentifier ed25519 = new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed25519);
-    private static final AlgorithmIdentifier ecDsaP256 = new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, new X962Parameters(SECObjectIdentifiers.secp256r1));
-    private static final AlgorithmIdentifier ecDsaBrainpoolP256r1 = new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, new X962Parameters(TeleTrusTObjectIdentifiers.brainpoolP256r1));
-    private static final AlgorithmIdentifier rsa = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption);
     private static final AlgorithmIdentifier ed448 = new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed448);
-    private static final AlgorithmIdentifier ecDsaP384 = new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, new X962Parameters(SECObjectIdentifiers.secp384r1));
-    private static final AlgorithmIdentifier ecDsaP521 = new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, new X962Parameters(SECObjectIdentifiers.secp521r1));
-    private static final AlgorithmIdentifier ecDsaBrainpoolP384r1 = new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, new X962Parameters(TeleTrusTObjectIdentifiers.brainpoolP384r1));
+    private static final AlgorithmIdentifier ecDsaP256 = createECAlgID(SECObjectIdentifiers.secp256r1);
+    private static final AlgorithmIdentifier ecDsaP384 = createECAlgID(SECObjectIdentifiers.secp384r1);
+    private static final AlgorithmIdentifier ecDsaP521 = createECAlgID(SECObjectIdentifiers.secp521r1);
+    private static final AlgorithmIdentifier ecDsaBrainpoolP256r1 = createECAlgID(TeleTrusTObjectIdentifiers.brainpoolP256r1);
+    private static final AlgorithmIdentifier ecDsaBrainpoolP384r1 = createECAlgID(TeleTrusTObjectIdentifiers.brainpoolP384r1);
+    private static final AlgorithmIdentifier rsa = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption);
 
     private static Map<ASN1ObjectIdentifier, AlgorithmIdentifier[]> pairings = new HashMap<ASN1ObjectIdentifier, AlgorithmIdentifier[]>();
     private static Map<ASN1ObjectIdentifier, int[]> componentKeySizes = new HashMap<ASN1ObjectIdentifier, int[]>();
@@ -289,7 +292,7 @@ public PublicKey generatePublic(SubjectPublicKeyInfo keyInfo)
 
         try
         {
-            seq = DERSequence.getInstance(keyInfo.getPublicKeyData().getBytes());
+            seq = ASN1Sequence.getInstance(keyInfo.getPublicKeyData().getOctets());
         }
         catch (Exception e)
         {
@@ -299,7 +302,8 @@ public PublicKey generatePublic(SubjectPublicKeyInfo keyInfo)
         if (MiscObjectIdentifiers.id_alg_composite.equals(keyIdentifier)
             || MiscObjectIdentifiers.id_composite_key.equals(keyIdentifier))
         {
-            ASN1Sequence keySeq = ASN1Sequence.getInstance(keyInfo.getPublicKeyData().getBytes());
+            // TODO This is redundant with 'seq' calculation above 
+            ASN1Sequence keySeq = ASN1Sequence.getInstance(keyInfo.getPublicKeyData().getOctets());
             PublicKey[] pubKeys = new PublicKey[keySeq.size()];
 
             for (int i = 0; i != keySeq.size(); i++)

Original file line number	Diff line number	Diff line change
`@@ -267,57 +267,67 @@ public String getFormat()`
`267`	`267`	`*/`
`268`	`268`	`public byte[] getEncoded()`
`269`	`269`	`{`
`270`		`- if (this.algorithmIdentifier.getAlgorithm().on(IANAObjectIdentifiers.id_alg))`
	`270`	`+ ASN1ObjectIdentifier algOid = algorithmIdentifier.getAlgorithm();`
	`271`	`+`
	`272`	`+ if (algOid.on(IANAObjectIdentifiers.id_alg))`
`271`	`273`	`{`
`272`	`274`	`try`
`273`	`275`	`{`
`274`	`276`	`PrivateKey key0 = keys.get(0);`
`275`	`277`	`PrivateKey key1 = keys.get(1);`
`276`	`278`
`277`		`- byte[] mldsaKey = ((MLDSAPrivateKey)key0).getSeed();`
	`279`	`+ byte[] mldsaSeed = ((MLDSAPrivateKey)key0).getSeed();`
`278`	`280`
`279`		`- byte[] key1Encoded = key1.getEncoded();`
`280`		`- PrivateKeyInfo pki = PrivateKeyInfo.getInstance(key1Encoded);`
	`281`	`+ PrivateKeyInfo pki = PrivateKeyInfo.getInstance(key1.getEncoded());`
`281`	`282`
`282`		`- byte[] tradKey;`
	`283`	`+ byte[] tradSK;`
`283`	`284`	`String key1Algorithm = key1.getAlgorithm();`
`284`	`285`	`if (key1Algorithm.contains("Ed"))`
`285`	`286`	`{`
`286`		`- tradKey = ASN1OctetString.getInstance(pki.parsePrivateKey()).getOctets();`
	`287`	`+ tradSK = ASN1OctetString.getInstance(pki.parsePrivateKey()).getOctets();`
`287`	`288`	`}`
`288`	`289`	`else if (key1Algorithm.contains("EC"))`
`289`	`290`	`{`
`290`	`291`	`ECPrivateKey ecPrivateKey = ECPrivateKey.getInstance(pki.parsePrivateKey());`
`291`	`292`
`292`		`- // TODO Do we also want to remove any parameters from the ECPrivateKey?`
	`293`	`+ /*`
	`294`	`+ * TODO`
	`295`	`+ * - Confirm pki.privateKeyAlgorithm is id_ecPublicKey with X9.62 Parameters namedCurve OID.`
	`296`	`+ * - If ecPrivateKey.parameters are present, must match pki.privateKeyAlgorithm`
	`297`	`+ * The private key MUST be encoded as ECPrivateKey specified in [RFC5915] with the 'NamedCurve'`
	`298`	`+ * parameter set to the OID of the curve, but without the 'publicKey' field.`
	`299`	`+ */`
	`300`	`+ // TODO Also need to ensure that ECPrivateKey.parameters are present`
`293`	`301`	`ASN1BitString publicKey = ecPrivateKey.getPublicKey();`
`294`	`302`	`if (publicKey != null)`
`295`	`303`	`{`
`296`	`304`	`ecPrivateKey = new ECPrivateKey(ecPrivateKey.getPrivateKey(), ecPrivateKey.getParametersObject(), null);`
`297`	`305`	`}`
`298`	`306`
`299`		`- tradKey = ecPrivateKey.getEncoded();`
	`307`	`+ tradSK = ecPrivateKey.getEncoded(ASN1Encoding.DER);`
`300`	`308`	`}`
`301`	`309`	`else`
`302`	`310`	`{`
`303`		`- tradKey = pki.getPrivateKey().getOctets();`
	`311`	`+ tradSK = pki.getPrivateKey().getOctets();`
`304`	`312`	`}`
`305`	`313`
`306`		`- return new PrivateKeyInfo(algorithmIdentifier, Arrays.concatenate(mldsaKey, tradKey)).getEncoded();`
	`314`	`+ return new PrivateKeyInfo(algorithmIdentifier, Arrays.concatenate(mldsaSeed, tradSK)).getEncoded();`
`307`	`315`	`}`
`308`	`316`	`catch (IOException e)`
`309`	`317`	`{`
`310`	`318`	`throw new IllegalStateException("unable to encode composite public key: " + e.getMessage());`
`311`	`319`	`}`
`312`	`320`	`}`
	`321`	`+`
`313`	`322`	`ASN1EncodableVector v = new ASN1EncodableVector();`
`314`	`323`
`315`		`- if (algorithmIdentifier.getAlgorithm().equals(MiscObjectIdentifiers.id_composite_key))`
	`324`	`+ if (MiscObjectIdentifiers.id_composite_key.equals(algOid))`
`316`	`325`	`{`
`317`	`326`	`for (int i = 0; i < keys.size(); i++)`
`318`	`327`	`{`
`319`		`- PrivateKeyInfo info = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());`
`320`		`- v.add(info);`
	`328`	`+ PrivateKeyInfo pki = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());`
	`329`	`+`
	`330`	`+ v.add(pki);`
`321`	`331`	`}`
`322`	`332`
`323`	`333`	`try`
`@@ -334,8 +344,9 @@ else if (key1Algorithm.contains("EC"))`
`334`	`344`	`byte[] keyEncoding = null;`
`335`	`345`	`for (int i = 0; i < keys.size(); i++)`
`336`	`346`	`{`
`337`		`- PrivateKeyInfo info = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());`
`338`		`- keyEncoding = Arrays.concatenate(keyEncoding, info.getPrivateKey().getOctets());`
	`347`	`+ PrivateKeyInfo pki = PrivateKeyInfo.getInstance(keys.get(i).getEncoded());`
	`348`	`+`
	`349`	`+ keyEncoding = Arrays.concatenate(keyEncoding, pki.getPrivateKey().getOctets());`
`339`	`350`	`}`
`340`	`351`
`341`	`352`	`try`
Original file line number	Diff line number	Diff line change
`@@ -246,13 +246,15 @@ public String getFormat()`
`246`	`246`	`@Override`
`247`	`247`	`public byte[] getEncoded()`
`248`	`248`	`{`
`249`		`- if (this.algorithmIdentifier.getAlgorithm().on(IANAObjectIdentifiers.id_alg))`
	`249`	`+ ASN1ObjectIdentifier algOid = algorithmIdentifier.getAlgorithm();`
	`250`	`+`
	`251`	`+ if (algOid.on(IANAObjectIdentifiers.id_alg))`
`250`	`252`	`{`
`251`	`253`	`try`
`252`	`254`	`{`
`253`		`- byte[] mldsaKey = org.bouncycastle.pqc.crypto.util.SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(org.bouncycastle.pqc.crypto.util.PublicKeyFactory.createKey(keys.get(0).getEncoded())).getPublicKeyData().getBytes();`
`254`		`- byte[] tradKey = SubjectPublicKeyInfo.getInstance(keys.get(1).getEncoded()).getPublicKeyData().getBytes();`
`255`		`- return new SubjectPublicKeyInfo(getAlgorithmIdentifier(), Arrays.concatenate(mldsaKey, tradKey)).getEncoded();`
	`255`	`+ byte[] mldsaPK = SubjectPublicKeyInfo.getInstance(keys.get(0).getEncoded()).getPublicKeyData().getOctets();`
	`256`	`+ byte[] tradPK = SubjectPublicKeyInfo.getInstance(keys.get(1).getEncoded()).getPublicKeyData().getOctets();`
	`257`	`+ return new SubjectPublicKeyInfo(algorithmIdentifier, Arrays.concatenate(mldsaPK, tradPK)).getEncoded(ASN1Encoding.DER);`
`256`	`258`	`}`
`257`	`259`	`catch (IOException e)`
`258`	`260`	`{`
`@@ -264,18 +266,20 @@ public byte[] getEncoded()`
`264`	`266`
`265`	`267`	`for (int i = 0; i < keys.size(); i++)`
`266`	`268`	`{`
`267`		`- if (this.algorithmIdentifier.getAlgorithm().equals(MiscObjectIdentifiers.id_composite_key))`
	`269`	`+ SubjectPublicKeyInfo spki = SubjectPublicKeyInfo.getInstance(keys.get(i).getEncoded());`
	`270`	`+`
	`271`	`+ if (MiscObjectIdentifiers.id_composite_key.equals(algOid))`
`268`	`272`	`{`
`269`	`273`	`//Legacy, component is the whole SubjectPublicKeyInfo`
`270`		`- v.add(SubjectPublicKeyInfo.getInstance(keys.get(i).getEncoded()));`
	`274`	`+ v.add(spki);`
`271`	`275`	`}`
`272`	`276`	`else`
`273`	`277`	`{`
`274`	`278`	`//component is the value of subjectPublicKey from SubjectPublicKeyInfo`
`275`		`- SubjectPublicKeyInfo keyInfo = SubjectPublicKeyInfo.getInstance(keys.get(i).getEncoded());`
`276`		`- v.add(keyInfo.getPublicKeyData());`
	`279`	`+ v.add(spki.getPublicKeyData());`
`277`	`280`	`}`
`278`	`281`	`}`
	`282`	`+`
`279`	`283`	`try`
`280`	`284`	`{`
`281`	`285`	`return new SubjectPublicKeyInfo(this.algorithmIdentifier, new DERSequence(v)).getEncoded(ASN1Encoding.DER);`
`@@ -286,31 +290,26 @@ public byte[] getEncoded()`
`286`	`290`	`}`
`287`	`291`	`}`
`288`	`292`
`289`		`-`
`290`	`293`	`public int hashCode()`
`291`	`294`	`{`
`292`		`- return keys.hashCode();`
	`295`	`+ return algorithmIdentifier.hashCode() ^ keys.hashCode();`
`293`	`296`	`}`
`294`	`297`
`295`		`- public boolean equals(Object o)`
	`298`	`+ public boolean equals(Object obj)`
`296`	`299`	`{`
`297`		`- if (o == this)`
	`300`	`+ if (obj == this)`
`298`	`301`	`{`
`299`	`302`	`return true;`
`300`	`303`	`}`
`301`	`304`
`302`		`- if (o instanceof CompositePublicKey)`
	`305`	`+ if (!(obj instanceof CompositePublicKey))`
`303`	`306`	`{`
`304`		`- boolean isEqual = true;`
`305`		`- CompositePublicKey comparedKey = (CompositePublicKey)o;`
`306`		`- if (!comparedKey.getAlgorithmIdentifier().equals(this.algorithmIdentifier) \|\| !this.keys.equals(comparedKey.keys))`
`307`		`- {`
`308`		`- isEqual = false;`
`309`		`- }`
`310`		`-`
`311`		`- return isEqual;`
	`307`	`+ return false;`
`312`	`308`	`}`
`313`	`309`
`314`		`- return false;`
	`310`	`+ CompositePublicKey that = (CompositePublicKey)obj;`
	`311`	`+`
	`312`	`+ return this.algorithmIdentifier.equals(that.algorithmIdentifier)`
	`313`	`+ && this.keys.equals(that.keys);`
`315`	`314`	`}`
`316`	`315`	`}`