try using thread-shared secure random gen (in PKey-s) where possible

Author: kares

src/main/java/org/jruby/ext/openssl/PKey.java

@@ -32,15 +32,7 @@
 import java.io.InputStreamReader;
 import java.io.StringReader;
 import java.math.BigInteger;
-import java.security.GeneralSecurityException;
-import java.security.InvalidKeyException;
-import java.security.KeyFactory;
-import java.security.KeyPair;
-import java.security.NoSuchAlgorithmException;
-import java.security.PrivateKey;
-import java.security.PublicKey;
-import java.security.Signature;
-import java.security.SignatureException;
+import java.security.*;
 import java.security.interfaces.DSAPrivateKey;
 import java.security.interfaces.DSAPublicKey;
 import java.security.interfaces.RSAPrivateCrtKey;
@@ -263,6 +255,26 @@ static boolean verify(final String signAlg, final PublicKey publicKey, final Byt
         return signature.verify(sign.getUnsafeBytes(), sign.getBegin(), sign.getRealSize());
     }
 
+    private static boolean tryContextSecureRandom = true;
+
+    static SecureRandom getSecureRandom(final Ruby runtime) {
+        if ( tryContextSecureRandom ) {
+            final ThreadContext context = runtime.getCurrentContext();
+            try {
+                SecureRandom random = context.secureRandom;
+                if (random == null) { // public SecureRandom getSecureRandom() on 9K
+                    random = (SecureRandom) context.getClass().getMethod("getSecureRandom").invoke(context);
+                }
+                return random;
+            }
+            catch (Throwable ex) {
+                tryContextSecureRandom = false;
+                debug(runtime, "PKey falling back to using new SecureRandom()", ex);
+            }
+        }
+        return new SecureRandom();
+    }
+
     // shared Helpers for PKeyRSA / PKEyDSA :
 
     protected PrivateKey tryPKCS8EncodedKey(final Ruby runtime, final KeyFactory keyFactory, final byte[] encodedKey) {

src/main/java/org/jruby/ext/openssl/PKeyDH.java

@@ -93,17 +93,6 @@ public static RaiseException newDHError(Ruby runtime, String message) {
         return Utils.newError(runtime, _PKey(runtime).getClass("DHError"), message);
     }
 
-    private static SecureRandom _secureRandom;
-
-    private static SecureRandom getSecureRandom() {
-        SecureRandom rand;
-        if ((rand = _secureRandom) != null) {
-            return rand;
-        }
-        // FIXME: do we want a particular algorithm / provider? BC?
-        return _secureRandom = new SecureRandom();
-    }
-
     // transient because: we do not want these value serialized (insecure)
     // volatile because: permits unsynchronized reads in some cases
     private transient volatile BigInteger dh_p;
@@ -201,7 +190,7 @@ public static BigInteger generateX(BigInteger p, int limit) {
         if (limit < 0) throw new IllegalArgumentException("invalid limit");
 
         BigInteger x;
-        SecureRandom secureRandom = getSecureRandom();
+        SecureRandom secureRandom = new SecureRandom();
         // adapting algorithm from org.bouncycastle.crypto.generators.DHKeyGeneratorHelper,
         // which seems a little stronger (?) than OpenSSL's (OSSL just generates a random,
         // while BC generates a random potential prime [for limit > 0], though it's not
@@ -252,11 +241,11 @@ public synchronized IRubyObject generate_key() {
     @JRubyMethod(name = "compute_key")
     public synchronized IRubyObject compute_key(IRubyObject other_pub_key) {
         BigInteger x, y, p;
-        if ((y = BN.getBigInteger(other_pub_key)) == null) {
+        if ((y = BN.asBigInteger(other_pub_key)) == null) {
             throw getRuntime().newArgumentError("invalid public key");
         }
         if ((x = this.dh_x) == null || (p = this.dh_p) == null) {
-            throw newDHError(getRuntime(), "can't compute key");
+            throw newDHError(getRuntime(), "incomplete DH");
         }
         int plen;
         if ((plen = p.bitLength()) == 0 || plen > OPENSSL_DH_MAX_MODULUS_BITS) {

src/main/java/org/jruby/ext/openssl/PKeyDSA.java

@@ -136,7 +136,7 @@ private static PKeyDSA dsaGenerate(final Ruby runtime,
         PKeyDSA dsa, int keySize) throws RaiseException {
         try {
             KeyPairGenerator gen = SecurityHelper.getKeyPairGenerator("DSA");
-            gen.initialize(keySize, new SecureRandom());
+            gen.initialize(keySize, getSecureRandom(runtime));
             KeyPair pair = gen.generateKeyPair();
             dsa.privateKey = (DSAPrivateKey) pair.getPrivate();
             dsa.publicKey = (DSAPublicKey) pair.getPublic();

src/main/java/org/jruby/ext/openssl/PKeyRSA.java

@@ -175,7 +175,7 @@ private static PKeyRSA rsaGenerate(final Ruby runtime,
             if ( "IBMJCEFIPS".equals( gen.getProvider().getName() ) ) {
                 gen.initialize(keySize); // IBMJCEFIPS does not support parameters
             } else {
-                gen.initialize(new RSAKeyGenParameterSpec(keySize, exp), new SecureRandom());
+                gen.initialize(new RSAKeyGenParameterSpec(keySize, exp), getSecureRandom(runtime));
             }
             KeyPair pair = gen.generateKeyPair();
             rsa.privateKey = (RSAPrivateCrtKey) pair.getPrivate();