Java RSAPrivateCrtKey.getPrimeQ方法代码示例

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
private static void generateTestVector(int rsaKeyBits, int suffix) throws Exception {
  KeyPair pair = generateKeyPair(rsaKeyBits);
  RSAPrivateCrtKey priv = (RSAPrivateCrtKey) pair.getPrivate();

  // The core RSA private key operation is doing the modPow for the two components.
  BigInteger p = priv.getPrimeP();
  BigInteger dp = priv.getPrimeExponentP();
  BigInteger q = priv.getPrimeQ();
  BigInteger dq = priv.getPrimeExponentQ();

  byte[] random = new byte[rsaKeyBits / 8];
  SECURE_RANDOM.nextBytes(random);
  // Clear the top bit to ensure it fits.
  random[0] &= 0x7F;
  BigInteger message = new BigInteger(1, random);
  BigInteger pResult = message.modPow(dp, p);
  BigInteger qResult = message.modPow(dq, q);

  System.out.println("public static final TestVector VECTOR" + suffix + " = ");
  new TestVector(message, p, dp, pResult, q, dq, qResult).printJavaConstructorFor();
  System.out.println();
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
/**
 * construct a private key from another RSAPrivateCrtKey.
 *
 * @param key the object implementing the RSAPrivateCrtKey interface.
 */
JCERSAPrivateCrtKey(
    RSAPrivateCrtKey key)
{
    this.modulus = key.getModulus();
    this.publicExponent = key.getPublicExponent();
    this.privateExponent = key.getPrivateExponent();
    this.primeP = key.getPrimeP();
    this.primeQ = key.getPrimeQ();
    this.primeExponentP = key.getPrimeExponentP();
    this.primeExponentQ = key.getPrimeExponentQ();
    this.crtCoefficient = key.getCrtCoefficient();
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
/**
 * construct a private key from another RSAPrivateCrtKey.
 *
 * @param key the object implementing the RSAPrivateCrtKey interface.
 */
BCRSAPrivateCrtKey(
    RSAPrivateCrtKey key)
{
    this.modulus = key.getModulus();
    this.publicExponent = key.getPublicExponent();
    this.privateExponent = key.getPrivateExponent();
    this.primeP = key.getPrimeP();
    this.primeQ = key.getPrimeQ();
    this.primeExponentP = key.getPrimeExponentP();
    this.primeExponentQ = key.getPrimeExponentQ();
    this.crtCoefficient = key.getCrtCoefficient();
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
public static RSAKeyParameters generateRSAPrivateKeyParameter(RSAPrivateKey key) {
    ParamUtil.requireNonNull("key", key);
    if (key instanceof RSAPrivateCrtKey) {
        RSAPrivateCrtKey rsaKey = (RSAPrivateCrtKey) key;

        return new RSAPrivateCrtKeyParameters(rsaKey.getModulus(), rsaKey.getPublicExponent(),
                rsaKey.getPrivateExponent(), rsaKey.getPrimeP(), rsaKey.getPrimeQ(),
                rsaKey.getPrimeExponentP(), rsaKey.getPrimeExponentQ(),
                rsaKey.getCrtCoefficient());
    } else {
        return new RSAKeyParameters(true, key.getModulus(), key.getPrivateExponent());
    }
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
/**
 * construct a private key from another RSAPrivateCrtKey.
 *
 * @param key the object implementing the RSAPrivateCrtKey interface.
 */
TempJCERSAPrivateCrtKey(
    RSAPrivateCrtKey key)
{
    this.modulus = key.getModulus();
    this.publicExponent = key.getPublicExponent();
    this.privateExponent = key.getPrivateExponent();
    this.primeP = key.getPrimeP();
    this.primeQ = key.getPrimeQ();
    this.primeExponentP = key.getPrimeExponentP();
    this.primeExponentQ = key.getPrimeExponentQ();
    this.crtCoefficient = key.getCrtCoefficient();
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
private void checkPrivateCrtKey(RSAPrivateCrtKey key, int expectedKeySize) throws Exception {
  BigInteger p = key.getPrimeP();
  BigInteger q = key.getPrimeQ();
  BigInteger n = key.getModulus();
  BigInteger e = key.getPublicExponent();
  BigInteger d = key.getPrivateExponent();
  BigInteger dp = key.getPrimeExponentP();
  BigInteger dq = key.getPrimeExponentQ();
  BigInteger crtCoeff = key.getCrtCoefficient();

  // Simple test that (n,d,e) is a valid RSA key.
  assertEquals(n, p.multiply(q));
  assertEquals(expectedKeySize, n.bitLength());
  int certainty = 80;
  assertTrue(p.isProbablePrime(certainty));
  assertTrue(q.isProbablePrime(certainty));
  // Very simple checks for weak random number generators.
  RandomUtil.checkPrime(p);
  RandomUtil.checkPrime(q);
  assertTrue(d.bitLength() > expectedKeySize / 2);
  // TODO(bleichen): Keys that are very imbalanced can be broken with elliptic curve factoring.
  //   Add other checks. E.g. for the size of dp and dq
  assertTrue(p.bitLength() > 256);
  assertTrue(q.bitLength() > 256);
  BigInteger p1 = p.subtract(BigInteger.ONE);
  BigInteger q1 = q.subtract(BigInteger.ONE);
  BigInteger phi = p1.multiply(q1);
  BigInteger order = phi.divide(p1.gcd(q1)); // maximal order of elements
  assertEquals(BigInteger.ONE, d.multiply(e).mod(order));
  assertEquals(d.mod(p1), dp.mod(p1));
  assertEquals(d.mod(q1), dq.mod(q1));
  assertEquals(q.multiply(crtCoeff).mod(p), BigInteger.ONE);
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
private RSAPrivateCrtKeyParameters getPrivateKeyParameters(RSAPrivateCrtKey privateCrtKey) {
    return new RSAPrivateCrtKeyParameters(privateCrtKey.getModulus(),
            privateCrtKey.getPublicExponent(),
            privateCrtKey.getPrivateExponent(),
            privateCrtKey.getPrimeP(), privateCrtKey.getPrimeQ(), privateCrtKey.getPrimeExponentP(),
            privateCrtKey.getPrimeExponentQ(),
            privateCrtKey.getCrtCoefficient());
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
private static PrivateKey convertPrivateKey(PrivateKey key) {
if (key instanceof RSAPrivateCrtKey) {
    RSAPrivateCrtKey rsaKey = (RSAPrivateCrtKey)key;
    RawRSAPrivateKey ck = new RawRSAPrivateKey(rsaKey.getPrivateExponent(),
					       rsaKey.getPrimeP(),
					       rsaKey.getPrimeQ(),
					       rsaKey.getCrtCoefficient());
    return new X509RSAPrivateKey(ck);
} else {
    throw new IllegalArgumentException();
}
   }
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
public static void main(String[] args) throws NoSuchAlgorithmException,
        NoSuchProviderException, InvalidKeySpecException {
    // Generate the first key.
    KeyPairGenerator generator
            = KeyPairGenerator.getInstance(KEYALG, PROVIDER_NAME);
    KeyPair keyPair = generator.generateKeyPair();
    RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
    if (!(rsaPrivateKey instanceof RSAPrivateCrtKey)) {
        System.err.println("rsaPrivateKey class : " + rsaPrivateKey.getClass().getName());
        throw new RuntimeException("rsaPrivateKey is not a RSAPrivateCrtKey instance");
    }

    // Generate the second key.
    KeyFactory factory = KeyFactory.getInstance(KEYALG, PROVIDER_NAME);
    RSAPrivateKeySpec rsaPrivateKeySpec = new RSAPrivateKeySpec(
            rsaPrivateKey.getModulus(), rsaPrivateKey.getPrivateExponent());
    RSAPrivateKey rsaPrivateKey2 = (RSAPrivateKey) factory.generatePrivate(
            rsaPrivateKeySpec);

    // Generate the third key.
    PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(
            rsaPrivateKey.getEncoded());
    RSAPrivateKey rsaPrivateKey3 = (RSAPrivateKey) factory.generatePrivate(
            encodedKeySpec);

    // Check for equality.
    if (rsaPrivateKey.equals(rsaPrivateKey2)) {
        throw new RuntimeException("rsaPrivateKey should not equal to rsaPrivateKey2");
    }
    if (!rsaPrivateKey3.equals(rsaPrivateKey)) {
        throw new RuntimeException("rsaPrivateKey3 should equal to rsaPrivateKey");
    }
    if (rsaPrivateKey3.equals(rsaPrivateKey2)) {
        throw new RuntimeException("rsaPrivateKey3 should not equal to rsaPrivateKey2");
    }
    if (rsaPrivateKey2.equals(rsaPrivateKey3)) {
        throw new RuntimeException("rsaPrivateKey2 should not equal to rsaPrivateKey3");
    }

    // Generate the fourth key.
    RSAPrivateCrtKey rsaPrivateCrtKey =  (RSAPrivateCrtKey)rsaPrivateKey;
    RSAPrivateCrtKeySpec rsaPrivateCrtKeySpec = new RSAPrivateCrtKeySpec(
            rsaPrivateCrtKey.getModulus(),
            rsaPrivateCrtKey.getPublicExponent(),
            rsaPrivateCrtKey.getPrivateExponent(),
            rsaPrivateCrtKey.getPrimeP(),
            rsaPrivateCrtKey.getPrimeQ(),
            rsaPrivateCrtKey.getPrimeExponentP(),
            rsaPrivateCrtKey.getPrimeExponentQ(),
            rsaPrivateCrtKey.getCrtCoefficient()
        );
    RSAPrivateCrtKey rsaPrivateKey4 = (RSAPrivateCrtKey) factory.generatePrivate(
            rsaPrivateCrtKeySpec);
    if (!rsaPrivateKey.equals(rsaPrivateKey4)) {
        throw new RuntimeException("rsaPrivateKey should equal to rsaPrivateKey4");
    }
}
 

import java.security.interfaces.RSAPrivateCrtKey; //导入方法依赖的package包/类
static OpenSSLKey getInstance(RSAPrivateCrtKey rsaPrivateKey) throws InvalidKeyException {
    /**
     * If the key is not encodable (PKCS11-like key), then wrap it and use
     * JNI upcalls to satisfy requests.
     */
    if (rsaPrivateKey.getFormat() == null) {
        return wrapPlatformKey(rsaPrivateKey);
    }

    BigInteger modulus = rsaPrivateKey.getModulus();
    BigInteger privateExponent = rsaPrivateKey.getPrivateExponent();

    if (modulus == null) {
        throw new InvalidKeyException("modulus == null");
    } else if (privateExponent == null) {
        throw new InvalidKeyException("privateExponent == null");
    }

    try {
        /*
         * OpenSSL uses the public modulus to do RSA blinding. If
         * the public modulus is not available, the call to
         * EVP_PKEY_new_RSA will turn off blinding for this key
         * instance.
         */
        final BigInteger publicExponent = rsaPrivateKey.getPublicExponent();
        final BigInteger primeP = rsaPrivateKey.getPrimeP();
        final BigInteger primeQ = rsaPrivateKey.getPrimeQ();
        final BigInteger primeExponentP = rsaPrivateKey.getPrimeExponentP();
        final BigInteger primeExponentQ = rsaPrivateKey.getPrimeExponentQ();
        final BigInteger crtCoefficient = rsaPrivateKey.getCrtCoefficient();

        return new OpenSSLKey(NativeCrypto.EVP_PKEY_new_RSA(
                modulus.toByteArray(),
                publicExponent == null ? null : publicExponent.toByteArray(),
                privateExponent.toByteArray(),
                primeP == null ? null : primeP.toByteArray(),
                primeQ == null ? null : primeQ.toByteArray(),
                primeExponentP == null ? null : primeExponentP.toByteArray(),
                primeExponentQ == null ? null : primeExponentQ.toByteArray(),
                crtCoefficient == null ? null : crtCoefficient.toByteArray()));
    } catch (Exception e) {
        throw new InvalidKeyException(e);
    }
}