Merge remote-tracking branch 'origin/main'

royb · royb · commit eb9e2bd2bd64 · 2025-05-12T15:51:37.000-04:00
diff --git a/tls/src/main/java/org/bouncycastle/tls/crypto/impl/jcajce/JcaTlsCrypto.java b/tls/src/main/java/org/bouncycastle/tls/crypto/impl/jcajce/JcaTlsCrypto.java
@@ -113,7 +113,8 @@ protected JcaTlsCrypto(JcaJceHelper helper, SecureRandom entropySource, SecureRa
      * @param entropySource      primary entropy source, used for key generation.
      * @param nonceEntropySource secondary entropy source, used for nonce and IV generation.
      */
-    protected JcaTlsCrypto(JcaJceHelper helper, JcaJceHelper altHelper, SecureRandom entropySource, SecureRandom nonceEntropySource)
+    protected JcaTlsCrypto(JcaJceHelper helper, JcaJceHelper altHelper, SecureRandom entropySource,
+        SecureRandom nonceEntropySource)
     {
         this.helper = helper;
         this.altHelper = altHelper;
@@ -573,7 +574,7 @@ public boolean hasCryptoSignatureAlgorithm(int cryptoSignatureAlgorithm)
         case CryptoSignatureAlgorithm.gostr34102012_256:
         case CryptoSignatureAlgorithm.gostr34102012_512:
 
-            // TODO[RFC 8998]
+        // TODO[RFC 8998]
         case CryptoSignatureAlgorithm.sm2:
 
         default:
@@ -755,7 +756,7 @@ public boolean hasSignatureAlgorithm(short signatureAlgorithm)
         case SignatureAlgorithm.gostr34102012_256:
         case SignatureAlgorithm.gostr34102012_512:
 
-            // TODO[RFC 8998]
+        // TODO[RFC 8998]
 //        case SignatureAlgorithm.sm2:
 
         default:
@@ -784,7 +785,7 @@ public boolean hasSignatureScheme(int signatureScheme)
         switch (signatureScheme)
         {
         case SignatureScheme.sm2sig_sm3:
-            // TODO[tls] Implement before adding
+        // TODO[tls] Implement before adding
         case SignatureScheme.DRAFT_mldsa44:
         case SignatureScheme.DRAFT_mldsa65:
         case SignatureScheme.DRAFT_mldsa87:
@@ -903,8 +904,7 @@ protected TlsAEADCipherImpl createAEADCipher(String cipherName, String algorithm
      * @throws GeneralSecurityException in case of failure.
      */
     protected TlsBlockCipherImpl createBlockCipher(String cipherName, String algorithm, int keySize,
-                                                   boolean isEncrypting)
-        throws GeneralSecurityException
+        boolean isEncrypting) throws GeneralSecurityException
     {
         return new JceBlockCipherImpl(this, helper.createCipher(cipherName), algorithm, keySize, isEncrypting);
     }
@@ -920,8 +920,7 @@ protected TlsBlockCipherImpl createBlockCipher(String cipherName, String algorit
      * @throws GeneralSecurityException in case of failure.
      */
     protected TlsBlockCipherImpl createBlockCipherWithCBCImplicitIV(String cipherName, String algorithm, int keySize,
-                                                                    boolean isEncrypting)
-        throws GeneralSecurityException
+        boolean isEncrypting) throws GeneralSecurityException
     {
         return new JceBlockCipherWithCBCImplicitIVImpl(this, helper.createCipher(cipherName), algorithm, isEncrypting);
     }
@@ -955,17 +954,15 @@ protected TlsNullCipher createNullCipher(TlsCryptoParameters cryptoParams, int m
     }
 
     protected TlsStreamSigner createStreamSigner(SignatureAndHashAlgorithm algorithm, PrivateKey privateKey,
-                                                 boolean needsRandom)
-        throws IOException
+        boolean needsRandom) throws IOException
     {
         String algorithmName = JcaUtils.getJcaAlgorithmName(algorithm);
 
         return createStreamSigner(algorithmName, null, privateKey, needsRandom);
     }
 
     protected TlsStreamSigner createStreamSigner(String algorithmName, AlgorithmParameterSpec parameter,
-                                                 PrivateKey privateKey, boolean needsRandom)
-        throws IOException
+        PrivateKey privateKey, boolean needsRandom) throws IOException
     {
         SecureRandom random = needsRandom ? getSecureRandom() : null;
 
@@ -977,14 +974,13 @@ protected TlsStreamSigner createStreamSigner(String algorithmName, AlgorithmPara
             }
             catch (InvalidKeyException e)
             {
-                if (altHelper != null)
-                {
-                    return createStreamSigner(altHelper, algorithmName, parameter, privateKey, random);
-                }
-                else
+                JcaJceHelper altHelper = getAltHelper();
+                if (altHelper == null)
                 {
                     throw e;
                 }
+
+                return createStreamSigner(altHelper, algorithmName, parameter, privateKey, random);
             }
         }
         catch (GeneralSecurityException e)
@@ -993,38 +989,36 @@ protected TlsStreamSigner createStreamSigner(String algorithmName, AlgorithmPara
         }
     }
 
-    private TlsStreamSigner createStreamSigner(JcaJceHelper helper, String algorithmName, AlgorithmParameterSpec parameter,
-                                               PrivateKey privateKey, SecureRandom random)
-        throws GeneralSecurityException
+    protected TlsStreamSigner createStreamSigner(JcaJceHelper helper, String algorithmName,
+        AlgorithmParameterSpec parameter, PrivateKey privateKey, SecureRandom random) throws GeneralSecurityException
     {
         try
         {
             if (null != parameter)
             {
+                Signature dummySigner;                
                 try
                 {
-                    Signature dummySigner = helper.createSignature(algorithmName);
-                    dummySigner.initSign(privateKey, random);
-                    helper = new ProviderJcaJceHelper(dummySigner.getProvider());
+                    dummySigner = helper.createSignature(algorithmName);
                 }
                 catch (NoSuchAlgorithmException e)
                 {
                     // more PKCS#11 mischief
                     String upperAlg = Strings.toUpperCase(algorithmName);
-                    if (upperAlg.endsWith("MGF1"))
+                    if (upperAlg.endsWith("ANDMGF1"))
                     {
                         // ANDMGF1 has vanished from the Sun PKCS11 provider.
                         algorithmName = upperAlg.replace("ANDMGF1", "SSA-PSS");
-                        Signature dummySigner = helper.createSignature(algorithmName);
-
-                        dummySigner.initSign(privateKey, random);
-                        helper = new ProviderJcaJceHelper(dummySigner.getProvider());
+                        dummySigner = helper.createSignature(algorithmName);
                     }
                     else
                     {
                         throw e;
                     }
                 }
+
+                dummySigner.initSign(privateKey, random);
+                helper = new ProviderJcaJceHelper(dummySigner.getProvider());
             }
 
             Signature signer = helper.createSignature(algorithmName);
@@ -1038,7 +1032,7 @@ private TlsStreamSigner createStreamSigner(JcaJceHelper helper, String algorithm
         catch (InvalidKeyException e)
         {
             String upperAlg = Strings.toUpperCase(algorithmName);
-            if (upperAlg.endsWith("MGF1"))
+            if (upperAlg.endsWith("ANDMGF1"))
             {
                 // ANDMGF1 has vanished from the Sun PKCS11 provider.
                 algorithmName = upperAlg.replace("ANDMGF1", "SSA-PSS");
@@ -1060,8 +1054,7 @@ protected TlsStreamVerifier createStreamVerifier(DigitallySigned digitallySigned
     }
 
     protected TlsStreamVerifier createStreamVerifier(String algorithmName, AlgorithmParameterSpec parameter,
-                                                     byte[] signature, PublicKey publicKey)
-        throws IOException
+        byte[] signature, PublicKey publicKey) throws IOException
     {
         try
         {
@@ -1088,8 +1081,7 @@ protected TlsStreamVerifier createStreamVerifier(String algorithmName, Algorithm
     }
 
     protected Tls13Verifier createTls13Verifier(String algorithmName, AlgorithmParameterSpec parameter,
-                                                PublicKey publicKey)
-        throws IOException
+        PublicKey publicKey) throws IOException
     {
         try
         {
@@ -1269,8 +1261,7 @@ public JcaJceHelper getAltHelper()
     }
 
     protected TlsBlockCipherImpl createCBCBlockCipherImpl(TlsCryptoParameters cryptoParams, String algorithm,
-                                                          int cipherKeySize, boolean forEncryption)
-        throws GeneralSecurityException
+        int cipherKeySize, boolean forEncryption) throws GeneralSecurityException
     {
         String cipherName = algorithm + "/CBC/NoPadding";
 
@@ -1325,8 +1316,7 @@ private TlsAEADCipher createCipher_Camellia_GCM(TlsCryptoParameters cryptoParams
     }
 
     protected TlsCipher createCipher_CBC(TlsCryptoParameters cryptoParams, String algorithm, int cipherKeySize,
-                                         int macAlgorithm)
-        throws GeneralSecurityException, IOException
+        int macAlgorithm) throws GeneralSecurityException, IOException
     {
         TlsBlockCipherImpl encrypt = createCBCBlockCipherImpl(cryptoParams, algorithm, cipherKeySize, true);
         TlsBlockCipherImpl decrypt = createCBCBlockCipherImpl(cryptoParams, algorithm, cipherKeySize, false);
diff --git a/tls/src/main/java/org/bouncycastle/tls/crypto/impl/jcajce/JcaTlsCryptoProvider.java b/tls/src/main/java/org/bouncycastle/tls/crypto/impl/jcajce/JcaTlsCryptoProvider.java
@@ -20,7 +20,7 @@ public class JcaTlsCryptoProvider
     implements TlsCryptoProvider
 {
     private JcaJceHelper helper = new DefaultJcaJceHelper();
-    private JcaJceHelper altHelper = helper;
+    private JcaJceHelper altHelper = null;
 
     public JcaTlsCryptoProvider()
     {
@@ -34,7 +34,8 @@ public JcaTlsCryptoProvider()
      */
     public JcaTlsCryptoProvider setProvider(Provider provider)
     {
-        this.helper = this.altHelper = new ProviderJcaJceHelper(provider);
+        this.helper = new ProviderJcaJceHelper(provider);
+        this.altHelper = null;
 
         return this;
     }
@@ -61,7 +62,8 @@ public JcaTlsCryptoProvider setAlternateProvider(Provider provider)
      */
     public JcaTlsCryptoProvider setProvider(String providerName)
     {
-        this.helper = this.altHelper = new NamedJcaJceHelper(providerName);
+        this.helper = new NamedJcaJceHelper(providerName);
+        this.altHelper = null;
 
         return this;
     }
@@ -120,19 +122,19 @@ public JcaTlsCrypto create(SecureRandom random)
      */
     public JcaTlsCrypto create(SecureRandom keyRandom, SecureRandom nonceRandom)
     {
-        if (helper != altHelper)
-        {
-            return new JcaTlsCrypto(getHelper(), altHelper, keyRandom, nonceRandom);
-        }
-
-        return new JcaTlsCrypto(getHelper(), keyRandom, nonceRandom);
+        return new JcaTlsCrypto(getHelper(), getAltHelper(), keyRandom, nonceRandom);
     }
 
     public JcaJceHelper getHelper()
     {
         return helper;
     }
 
+    public JcaJceHelper getAltHelper()
+    {
+        return altHelper;
+    }
+
     @SuppressWarnings("serial")
     private static class NonceEntropySource
        extends SecureRandom
diff --git a/tls/src/main/java/org/bouncycastle/tls/crypto/impl/jcajce/JcaTlsECDSA13Signer.java b/tls/src/main/java/org/bouncycastle/tls/crypto/impl/jcajce/JcaTlsECDSA13Signer.java
@@ -4,8 +4,10 @@
 import java.security.GeneralSecurityException;
 import java.security.InvalidKeyException;
 import java.security.PrivateKey;
+import java.security.SecureRandom;
 import java.security.Signature;
 
+import org.bouncycastle.jcajce.util.JcaJceHelper;
 import org.bouncycastle.tls.AlertDescription;
 import org.bouncycastle.tls.SignatureAndHashAlgorithm;
 import org.bouncycastle.tls.SignatureScheme;
@@ -51,26 +53,24 @@ public byte[] generateRawSignature(SignatureAndHashAlgorithm algorithm, byte[] h
             throw new IllegalStateException("Invalid algorithm: " + algorithm);
         }
 
+        SecureRandom random = crypto.getSecureRandom();
+
         try
         {
-            Signature signer = crypto.getHelper().createSignature("NoneWithECDSA");
-            signer.initSign(privateKey, crypto.getSecureRandom());
-            signer.update(hash, 0, hash.length);
-            return signer.sign();
-        }
-        catch (InvalidKeyException e)
-        {
-            // try with PKCS#11 (usually) alternative provider
             try
             {
-                Signature signer = crypto.getAltHelper().createSignature("NoneWithECDSA");
-                signer.initSign(privateKey, crypto.getSecureRandom());
-                signer.update(hash, 0, hash.length);
-                return signer.sign();
+                return implGenerateRawSignature(crypto.getHelper(), privateKey, random, hash);
             }
-            catch (GeneralSecurityException ex)
+            catch (InvalidKeyException e)
             {
-                throw new TlsFatalAlert(AlertDescription.internal_error, ex);
+                // try with PKCS#11 (usually) alternative provider
+                JcaJceHelper altHelper = crypto.getAltHelper();
+                if (altHelper == null)
+                {
+                    throw e;
+                }
+
+                return implGenerateRawSignature(altHelper, privateKey, random, hash);
             }
         }
         catch (GeneralSecurityException e)
@@ -84,4 +84,13 @@ public TlsStreamSigner getStreamSigner(SignatureAndHashAlgorithm algorithm)
     {
         return null;
     }
+
+    private static byte[] implGenerateRawSignature(JcaJceHelper helper, PrivateKey privateKey, SecureRandom random,
+        byte[] hash) throws GeneralSecurityException
+    {
+        Signature signer = helper.createSignature("NoneWithECDSA");
+        signer.initSign(privateKey, random);
+        signer.update(hash, 0, hash.length);
+        return signer.sign();
+    }
 }
diff --git a/tls/src/test/java/org/bouncycastle/jsse/provider/test/FipsJcaTlsCrypto.java b/tls/src/test/java/org/bouncycastle/jsse/provider/test/FipsJcaTlsCrypto.java
@@ -14,6 +14,12 @@ public FipsJcaTlsCrypto(JcaJceHelper helper, SecureRandom entropySource, SecureR
         super(helper, entropySource, nonceEntropySource);
     }
 
+    public FipsJcaTlsCrypto(JcaJceHelper helper, JcaJceHelper altHelper, SecureRandom entropySource,
+        SecureRandom nonceEntropySource)
+    {
+        super(helper, altHelper, entropySource, nonceEntropySource);
+    }
+
     @Override
     public AEADNonceGeneratorFactory getFipsGCMNonceGeneratorFactory()
     {
diff --git a/tls/src/test/java/org/bouncycastle/jsse/provider/test/FipsJcaTlsCryptoProvider.java b/tls/src/test/java/org/bouncycastle/jsse/provider/test/FipsJcaTlsCryptoProvider.java
@@ -10,6 +10,6 @@ public class FipsJcaTlsCryptoProvider extends JcaTlsCryptoProvider
     @Override
     public JcaTlsCrypto create(SecureRandom keyRandom, SecureRandom nonceRandom)
     {
-        return new FipsJcaTlsCrypto(getHelper(), keyRandom, nonceRandom);
+        return new FipsJcaTlsCrypto(getHelper(), getAltHelper(), keyRandom, nonceRandom);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,8 @@ protected JcaTlsCrypto(JcaJceHelper helper, SecureRandom entropySource, SecureRa`
`113`	`113`	`* @param entropySource primary entropy source, used for key generation.`
`114`	`114`	`* @param nonceEntropySource secondary entropy source, used for nonce and IV generation.`
`115`	`115`	`*/`
`116`		`- protected JcaTlsCrypto(JcaJceHelper helper, JcaJceHelper altHelper, SecureRandom entropySource, SecureRandom nonceEntropySource)`
	`116`	`+ protected JcaTlsCrypto(JcaJceHelper helper, JcaJceHelper altHelper, SecureRandom entropySource,`
	`117`	`+ SecureRandom nonceEntropySource)`
`117`	`118`	`{`
`118`	`119`	`this.helper = helper;`
`119`	`120`	`this.altHelper = altHelper;`
`@@ -573,7 +574,7 @@ public boolean hasCryptoSignatureAlgorithm(int cryptoSignatureAlgorithm)`
`573`	`574`	`case CryptoSignatureAlgorithm.gostr34102012_256:`
`574`	`575`	`case CryptoSignatureAlgorithm.gostr34102012_512:`
`575`	`576`
`576`		`- // TODO[RFC 8998]`
	`577`	`+ // TODO[RFC 8998]`
`577`	`578`	`case CryptoSignatureAlgorithm.sm2:`
`578`	`579`
`579`	`580`	`default:`
`@@ -755,7 +756,7 @@ public boolean hasSignatureAlgorithm(short signatureAlgorithm)`
`755`	`756`	`case SignatureAlgorithm.gostr34102012_256:`
`756`	`757`	`case SignatureAlgorithm.gostr34102012_512:`
`757`	`758`
`758`		`- // TODO[RFC 8998]`
	`759`	`+ // TODO[RFC 8998]`
`759`	`760`	`// case SignatureAlgorithm.sm2:`
`760`	`761`
`761`	`762`	`default:`
`@@ -784,7 +785,7 @@ public boolean hasSignatureScheme(int signatureScheme)`
`784`	`785`	`switch (signatureScheme)`
`785`	`786`	`{`
`786`	`787`	`case SignatureScheme.sm2sig_sm3:`
`787`		`- // TODO[tls] Implement before adding`
	`788`	`+ // TODO[tls] Implement before adding`
`788`	`789`	`case SignatureScheme.DRAFT_mldsa44:`
`789`	`790`	`case SignatureScheme.DRAFT_mldsa65:`
`790`	`791`	`case SignatureScheme.DRAFT_mldsa87:`
`@@ -903,8 +904,7 @@ protected TlsAEADCipherImpl createAEADCipher(String cipherName, String algorithm`
`903`	`904`	`* @throws GeneralSecurityException in case of failure.`
`904`	`905`	`*/`
`905`	`906`	`protected TlsBlockCipherImpl createBlockCipher(String cipherName, String algorithm, int keySize,`
`906`		`- boolean isEncrypting)`
`907`		`- throws GeneralSecurityException`
	`907`	`+ boolean isEncrypting) throws GeneralSecurityException`
`908`	`908`	`{`
`909`	`909`	`return new JceBlockCipherImpl(this, helper.createCipher(cipherName), algorithm, keySize, isEncrypting);`
`910`	`910`	`}`
`@@ -920,8 +920,7 @@ protected TlsBlockCipherImpl createBlockCipher(String cipherName, String algorit`
`920`	`920`	`* @throws GeneralSecurityException in case of failure.`
`921`	`921`	`*/`
`922`	`922`	`protected TlsBlockCipherImpl createBlockCipherWithCBCImplicitIV(String cipherName, String algorithm, int keySize,`
`923`		`- boolean isEncrypting)`
`924`		`- throws GeneralSecurityException`
	`923`	`+ boolean isEncrypting) throws GeneralSecurityException`
`925`	`924`	`{`
`926`	`925`	`return new JceBlockCipherWithCBCImplicitIVImpl(this, helper.createCipher(cipherName), algorithm, isEncrypting);`
`927`	`926`	`}`
`@@ -955,17 +954,15 @@ protected TlsNullCipher createNullCipher(TlsCryptoParameters cryptoParams, int m`
`955`	`954`	`}`
`956`	`955`
`957`	`956`	`protected TlsStreamSigner createStreamSigner(SignatureAndHashAlgorithm algorithm, PrivateKey privateKey,`
`958`		`- boolean needsRandom)`
`959`		`- throws IOException`
	`957`	`+ boolean needsRandom) throws IOException`
`960`	`958`	`{`
`961`	`959`	`String algorithmName = JcaUtils.getJcaAlgorithmName(algorithm);`
`962`	`960`
`963`	`961`	`return createStreamSigner(algorithmName, null, privateKey, needsRandom);`
`964`	`962`	`}`
`965`	`963`
`966`	`964`	`protected TlsStreamSigner createStreamSigner(String algorithmName, AlgorithmParameterSpec parameter,`
`967`		`- PrivateKey privateKey, boolean needsRandom)`
`968`		`- throws IOException`
	`965`	`+ PrivateKey privateKey, boolean needsRandom) throws IOException`
`969`	`966`	`{`
`970`	`967`	`SecureRandom random = needsRandom ? getSecureRandom() : null;`
`971`	`968`
`@@ -977,14 +974,13 @@ protected TlsStreamSigner createStreamSigner(String algorithmName, AlgorithmPara`
`977`	`974`	`}`
`978`	`975`	`catch (InvalidKeyException e)`
`979`	`976`	`{`
`980`		`- if (altHelper != null)`
`981`		`- {`
`982`		`- return createStreamSigner(altHelper, algorithmName, parameter, privateKey, random);`
`983`		`- }`
`984`		`- else`
	`977`	`+ JcaJceHelper altHelper = getAltHelper();`
	`978`	`+ if (altHelper == null)`
`985`	`979`	`{`
`986`	`980`	`throw e;`
`987`	`981`	`}`
	`982`	`+`
	`983`	`+ return createStreamSigner(altHelper, algorithmName, parameter, privateKey, random);`
`988`	`984`	`}`
`989`	`985`	`}`
`990`	`986`	`catch (GeneralSecurityException e)`
`@@ -993,38 +989,36 @@ protected TlsStreamSigner createStreamSigner(String algorithmName, AlgorithmPara`
`993`	`989`	`}`
`994`	`990`	`}`
`995`	`991`
`996`		`- private TlsStreamSigner createStreamSigner(JcaJceHelper helper, String algorithmName, AlgorithmParameterSpec parameter,`
`997`		`- PrivateKey privateKey, SecureRandom random)`
`998`		`- throws GeneralSecurityException`
	`992`	`+ protected TlsStreamSigner createStreamSigner(JcaJceHelper helper, String algorithmName,`
	`993`	`+ AlgorithmParameterSpec parameter, PrivateKey privateKey, SecureRandom random) throws GeneralSecurityException`
`999`	`994`	`{`
`1000`	`995`	`try`
`1001`	`996`	`{`
`1002`	`997`	`if (null != parameter)`
`1003`	`998`	`{`
	`999`	`+ Signature dummySigner;`
`1004`	`1000`	`try`
`1005`	`1001`	`{`
`1006`		`- Signature dummySigner = helper.createSignature(algorithmName);`
`1007`		`- dummySigner.initSign(privateKey, random);`
`1008`		`- helper = new ProviderJcaJceHelper(dummySigner.getProvider());`
	`1002`	`+ dummySigner = helper.createSignature(algorithmName);`
`1009`	`1003`	`}`
`1010`	`1004`	`catch (NoSuchAlgorithmException e)`
`1011`	`1005`	`{`
`1012`	`1006`	`// more PKCS#11 mischief`
`1013`	`1007`	`String upperAlg = Strings.toUpperCase(algorithmName);`
`1014`		`- if (upperAlg.endsWith("MGF1"))`
	`1008`	`+ if (upperAlg.endsWith("ANDMGF1"))`
`1015`	`1009`	`{`
`1016`	`1010`	`// ANDMGF1 has vanished from the Sun PKCS11 provider.`
`1017`	`1011`	`algorithmName = upperAlg.replace("ANDMGF1", "SSA-PSS");`
`1018`		`- Signature dummySigner = helper.createSignature(algorithmName);`
`1019`		`-`
`1020`		`- dummySigner.initSign(privateKey, random);`
`1021`		`- helper = new ProviderJcaJceHelper(dummySigner.getProvider());`
	`1012`	`+ dummySigner = helper.createSignature(algorithmName);`
`1022`	`1013`	`}`
`1023`	`1014`	`else`
`1024`	`1015`	`{`
`1025`	`1016`	`throw e;`
`1026`	`1017`	`}`
`1027`	`1018`	`}`
	`1019`	`+`
	`1020`	`+ dummySigner.initSign(privateKey, random);`
	`1021`	`+ helper = new ProviderJcaJceHelper(dummySigner.getProvider());`
`1028`	`1022`	`}`
`1029`	`1023`
`1030`	`1024`	`Signature signer = helper.createSignature(algorithmName);`
`@@ -1038,7 +1032,7 @@ private TlsStreamSigner createStreamSigner(JcaJceHelper helper, String algorithm`
`1038`	`1032`	`catch (InvalidKeyException e)`
`1039`	`1033`	`{`
`1040`	`1034`	`String upperAlg = Strings.toUpperCase(algorithmName);`
`1041`		`- if (upperAlg.endsWith("MGF1"))`
	`1035`	`+ if (upperAlg.endsWith("ANDMGF1"))`
`1042`	`1036`	`{`
`1043`	`1037`	`// ANDMGF1 has vanished from the Sun PKCS11 provider.`
`1044`	`1038`	`algorithmName = upperAlg.replace("ANDMGF1", "SSA-PSS");`
`@@ -1060,8 +1054,7 @@ protected TlsStreamVerifier createStreamVerifier(DigitallySigned digitallySigned`
`1060`	`1054`	`}`
`1061`	`1055`
`1062`	`1056`	`protected TlsStreamVerifier createStreamVerifier(String algorithmName, AlgorithmParameterSpec parameter,`
`1063`		`- byte[] signature, PublicKey publicKey)`
`1064`		`- throws IOException`
	`1057`	`+ byte[] signature, PublicKey publicKey) throws IOException`
`1065`	`1058`	`{`
`1066`	`1059`	`try`
`1067`	`1060`	`{`
`@@ -1088,8 +1081,7 @@ protected TlsStreamVerifier createStreamVerifier(String algorithmName, Algorithm`
`1088`	`1081`	`}`
`1089`	`1082`
`1090`	`1083`	`protected Tls13Verifier createTls13Verifier(String algorithmName, AlgorithmParameterSpec parameter,`
`1091`		`- PublicKey publicKey)`
`1092`		`- throws IOException`
	`1084`	`+ PublicKey publicKey) throws IOException`
`1093`	`1085`	`{`
`1094`	`1086`	`try`
`1095`	`1087`	`{`
`@@ -1269,8 +1261,7 @@ public JcaJceHelper getAltHelper()`
`1269`	`1261`	`}`
`1270`	`1262`
`1271`	`1263`	`protected TlsBlockCipherImpl createCBCBlockCipherImpl(TlsCryptoParameters cryptoParams, String algorithm,`
`1272`		`- int cipherKeySize, boolean forEncryption)`
`1273`		`- throws GeneralSecurityException`
	`1264`	`+ int cipherKeySize, boolean forEncryption) throws GeneralSecurityException`
`1274`	`1265`	`{`
`1275`	`1266`	`String cipherName = algorithm + "/CBC/NoPadding";`
`1276`	`1267`
`@@ -1325,8 +1316,7 @@ private TlsAEADCipher createCipher_Camellia_GCM(TlsCryptoParameters cryptoParams`
`1325`	`1316`	`}`
`1326`	`1317`
`1327`	`1318`	`protected TlsCipher createCipher_CBC(TlsCryptoParameters cryptoParams, String algorithm, int cipherKeySize,`
`1328`		`- int macAlgorithm)`
`1329`		`- throws GeneralSecurityException, IOException`
	`1319`	`+ int macAlgorithm) throws GeneralSecurityException, IOException`
`1330`	`1320`	`{`
`1331`	`1321`	`TlsBlockCipherImpl encrypt = createCBCBlockCipherImpl(cryptoParams, algorithm, cipherKeySize, true);`
`1332`	`1322`	`TlsBlockCipherImpl decrypt = createCBCBlockCipherImpl(cryptoParams, algorithm, cipherKeySize, false);`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public class JcaTlsCryptoProvider`
`20`	`20`	`implements TlsCryptoProvider`
`21`	`21`	`{`
`22`	`22`	`private JcaJceHelper helper = new DefaultJcaJceHelper();`
`23`		`- private JcaJceHelper altHelper = helper;`
	`23`	`+ private JcaJceHelper altHelper = null;`
`24`	`24`
`25`	`25`	`public JcaTlsCryptoProvider()`
`26`	`26`	`{`
`@@ -34,7 +34,8 @@ public JcaTlsCryptoProvider()`
`34`	`34`	`*/`
`35`	`35`	`public JcaTlsCryptoProvider setProvider(Provider provider)`
`36`	`36`	`{`
`37`		`- this.helper = this.altHelper = new ProviderJcaJceHelper(provider);`
	`37`	`+ this.helper = new ProviderJcaJceHelper(provider);`
	`38`	`+ this.altHelper = null;`
`38`	`39`
`39`	`40`	`return this;`
`40`	`41`	`}`
`@@ -61,7 +62,8 @@ public JcaTlsCryptoProvider setAlternateProvider(Provider provider)`
`61`	`62`	`*/`
`62`	`63`	`public JcaTlsCryptoProvider setProvider(String providerName)`
`63`	`64`	`{`
`64`		`- this.helper = this.altHelper = new NamedJcaJceHelper(providerName);`
	`65`	`+ this.helper = new NamedJcaJceHelper(providerName);`
	`66`	`+ this.altHelper = null;`
`65`	`67`
`66`	`68`	`return this;`
`67`	`69`	`}`
`@@ -120,19 +122,19 @@ public JcaTlsCrypto create(SecureRandom random)`
`120`	`122`	`*/`
`121`	`123`	`public JcaTlsCrypto create(SecureRandom keyRandom, SecureRandom nonceRandom)`
`122`	`124`	`{`
`123`		`- if (helper != altHelper)`
`124`		`- {`
`125`		`- return new JcaTlsCrypto(getHelper(), altHelper, keyRandom, nonceRandom);`
`126`		`- }`
`127`		`-`
`128`		`- return new JcaTlsCrypto(getHelper(), keyRandom, nonceRandom);`
	`125`	`+ return new JcaTlsCrypto(getHelper(), getAltHelper(), keyRandom, nonceRandom);`
`129`	`126`	`}`
`130`	`127`
`131`	`128`	`public JcaJceHelper getHelper()`
`132`	`129`	`{`
`133`	`130`	`return helper;`
`134`	`131`	`}`
`135`	`132`
	`133`	`+ public JcaJceHelper getAltHelper()`
	`134`	`+ {`
	`135`	`+ return altHelper;`
	`136`	`+ }`
	`137`	`+`
`136`	`138`	`@SuppressWarnings("serial")`
`137`	`139`	`private static class NonceEntropySource`
`138`	`140`	`extends SecureRandom`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,12 @@ public FipsJcaTlsCrypto(JcaJceHelper helper, SecureRandom entropySource, SecureR`
`14`	`14`	`super(helper, entropySource, nonceEntropySource);`
`15`	`15`	`}`
`16`	`16`
	`17`	`+ public FipsJcaTlsCrypto(JcaJceHelper helper, JcaJceHelper altHelper, SecureRandom entropySource,`
	`18`	`+ SecureRandom nonceEntropySource)`
	`19`	`+ {`
	`20`	`+ super(helper, altHelper, entropySource, nonceEntropySource);`
	`21`	`+ }`
	`22`	`+`
`17`	`23`	`@Override`
`18`	`24`	`public AEADNonceGeneratorFactory getFipsGCMNonceGeneratorFactory()`
`19`	`25`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,6 @@ public class FipsJcaTlsCryptoProvider extends JcaTlsCryptoProvider`
`10`	`10`	`@Override`
`11`	`11`	`public JcaTlsCrypto create(SecureRandom keyRandom, SecureRandom nonceRandom)`
`12`	`12`	`{`
`13`		`- return new FipsJcaTlsCrypto(getHelper(), keyRandom, nonceRandom);`
	`13`	`+ return new FipsJcaTlsCrypto(getHelper(), getAltHelper(), keyRandom, nonceRandom);`
`14`	`14`	`}`
`15`	`15`	`}`