Java 类java.security.spec.EncodedKeySpec 实例源码

/**
 * Create a new PublicKey from encoded X.509 data
 */
public static PublicKey decodePublicKey(byte[] encodedKey)
{
    try
    {
        EncodedKeySpec encodedkeyspec = new X509EncodedKeySpec(encodedKey);
        KeyFactory keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(encodedkeyspec);
    }
    catch (NoSuchAlgorithmException var3)
    {
        ;
    }
    catch (InvalidKeySpecException var4)
    {
        ;
    }

    LOGGER.error("Public key reconstitute failed!");
    return null;
}

/**
 * Create a new PublicKey from encoded X.509 data
 */
public static PublicKey decodePublicKey(byte[] encodedKey)
{
    try
    {
        EncodedKeySpec encodedkeyspec = new X509EncodedKeySpec(encodedKey);
        KeyFactory keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(encodedkeyspec);
    }
    catch (NoSuchAlgorithmException var3)
    {
        ;
    }
    catch (InvalidKeySpecException var4)
    {
        ;
    }

    LOGGER.error("Public key reconstitute failed!");
    return null;
}

/**
 * Create a new PublicKey from encoded X.509 data
 */
public static PublicKey decodePublicKey(byte[] encodedKey)
{
    try
    {
        EncodedKeySpec encodedkeyspec = new X509EncodedKeySpec(encodedKey);
        KeyFactory keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(encodedkeyspec);
    }
    catch (NoSuchAlgorithmException var3)
    {
        ;
    }
    catch (InvalidKeySpecException var4)
    {
        ;
    }

    LOGGER.error("Public key reconstitute failed!");
    return null;
}

/**
 * Create a new PublicKey from encoded X.509 data
 */
public static PublicKey decodePublicKey(byte[] encodedKey)
{
    try
    {
        EncodedKeySpec encodedkeyspec = new X509EncodedKeySpec(encodedKey);
        KeyFactory keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(encodedkeyspec);
    }
    catch (NoSuchAlgorithmException var3)
    {
        ;
    }
    catch (InvalidKeySpecException var4)
    {
        ;
    }

    LOGGER.error("Public key reconstitute failed!");
    return null;
}

private static PublicKey generatePublicKeyFromString(String key, String algorithm) {
    PublicKey publicKey = null;
    if(key.length()>1){
        key = key.replace("-----BEGIN PUBLIC KEY-----", "").replace("-----END PUBLIC KEY-----", "")
                .replaceAll("\\s+", "").replaceAll("\\r+", "").replaceAll("\\n+", "");
        byte[] keyByteArray = java.util.Base64.getDecoder().decode(key);
        try {
            KeyFactory kf = KeyFactory.getInstance(algorithm);
            EncodedKeySpec keySpec = new X509EncodedKeySpec(keyByteArray);
            publicKey = kf.generatePublic(keySpec);
        } catch (Exception e) {
            ConsoleOut.output(e.getMessage());
        }
    }
    return publicKey;
}

private static PrivateKey generatePrivateKeyFromString(String key, String algorithm) {
    PrivateKey privateKey = null;
    if(key.length()>1){
        key = key.replace("-----BEGIN PRIVATE KEY-----", "").replace("-----END PRIVATE KEY-----", "")
             .replaceAll("\\s+", "").replaceAll("\\r+", "").replaceAll("\\n+", "");
        byte[] keyByteArray = Base64.decode(key);
        try {
            KeyFactory kf = KeyFactory.getInstance(algorithm);
            EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyByteArray);
            privateKey = kf.generatePrivate(keySpec);
        } catch (Exception e) {
            ConsoleOut.output(e.getMessage());
        }
    }
    return privateKey;
}

/**
 * Create a new PublicKey from encoded X.509 data
 */
public static PublicKey decodePublicKey(byte[] encodedKey)
{
    try
    {
        EncodedKeySpec encodedkeyspec = new X509EncodedKeySpec(encodedKey);
        KeyFactory keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(encodedkeyspec);
    }
    catch (NoSuchAlgorithmException var3)
    {
        ;
    }
    catch (InvalidKeySpecException var4)
    {
        ;
    }

    LOGGER.error("Public key reconstitute failed!");
    return null;
}

/**
 * Create a new PublicKey from encoded X.509 data
 */
public static PublicKey decodePublicKey(byte[] encodedKey)
{
    try
    {
        EncodedKeySpec encodedkeyspec = new X509EncodedKeySpec(encodedKey);
        KeyFactory keyfactory = KeyFactory.getInstance("RSA");
        return keyfactory.generatePublic(encodedkeyspec);
    }
    catch (NoSuchAlgorithmException var3)
    {
        ;
    }
    catch (InvalidKeySpecException var4)
    {
        ;
    }

    LOGGER.error("Public key reconstitute failed!");
    return null;
}

/**
 * Method convertes the bytes arrays back to private and public key objects
 */
public static Key[] bytesToPrivatePublicKeys( String algorithm, byte[] privKeyBytes, byte[] pubKeyBytes) throws Exception{
   PrivateKey privKey = null;
   PublicKey pubKey = null;
   KeyFactory keyFactory = KeyFactory.getInstance(algorithm);

   if (privKeyBytes != null) {
      EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privKeyBytes);
      privKey = keyFactory.generatePrivate(privateKeySpec);
   }

   if (pubKeyBytes != null) {
      EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(pubKeyBytes);
      pubKey = keyFactory.generatePublic(publicKeySpec);
   }

   return new Key[] { privKey, pubKey };
}

@Override
public String sign(HttpRequest request, HttpParameters requestParams) throws OAuthMessageSignerException {
    byte[] decodedPrivateKey;
    try {
        decodedPrivateKey = Base64.decode(getConsumerSecret());
        String baseString = new SignatureBaseString(request, requestParams).generate();
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_TYPE);
        EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedPrivateKey);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        signature.initSign(privateKey);
        signature.update(baseString.getBytes());
        byte[] rsasha1 = signature.sign();
        return Base64.encode(rsasha1);
    } catch (IOException | NoSuchAlgorithmException | InvalidKeyException | InvalidKeySpecException | SignatureException e) {
        throw new OAuthMessageSignerException(e);
    }
}

/**
 * Generates the RSA-SHA1 signature of OAuth request elements.
 *
 * @param baseString the combined OAuth elements to sign.
 * @param secrets    the secrets object containing the private key for generating the signature.
 * @return the OAuth signature, in base64-encoded form.
 * @throws InvalidSecretException if the supplied secret is not valid.
 */
@Override
public String sign(final String baseString, final OAuth1Secrets secrets) throws InvalidSecretException {

    byte[] decodedPrivateKey;
    try {
        decodedPrivateKey = Base64.decode(secrets.getConsumerSecret());
    } catch (IOException ioe) {
        throw new InvalidSecretException(LocalizationMessages.ERROR_INVALID_CONSUMER_SECRET(ioe));
    }

    try {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_TYPE);
        EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedPrivateKey);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        signature.initSign(privateKey);
        signature.update(baseString.getBytes());
        byte[] rsasha1 = signature.sign();
        return Base64.encode(rsasha1);
    } catch (NoSuchAlgorithmException | InvalidKeyException | InvalidKeySpecException | SignatureException e) {
        throw new IllegalStateException(e);
    }
}

/**
 * Tests that <code>getEncoded()</code> method returns valid byte array
 */
public final void testGetEncoded() {

    byte[] encodedKey = new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 4 };
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check returned array */
    boolean result = true;
    for (int i = 0; i < encodedKey.length; i++) {
        if (encodedKey[i] != ek[i]) {
            /* indicate failure */
            result = false;
        }
    }
    /* passed */
    assertTrue(result);
}

/**
 * Tests that internal state of the object can not be modified by modifying
 * initial array value
 */
public final void testIsStatePreserved1() {
    /* Create initial byte array */
    byte[] encodedKey = new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 4 };

    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Modify initial array's value */
    encodedKey[3] = (byte) 5;

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek[3] == (byte) 4);
}

/**
 * Tests that internal state of the object can not be modified using
 * returned value of <code>getEncoded()</code> method
 */
public final void testIsStatePreserved2() {

    byte[] encodedKey = new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 4 };
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();
    /* Modify returned value */
    ek[3] = (byte) 5;
    /* Get encoded key again */
    byte[] ek1 = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek1[3] == (byte) 4);
}

/**
 * Tests that <code>getEncoded()</code> method returns valid byte array
 */
@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "",
    method = "getEncoded",
    args = {}
)
public final void testGetEncoded() {

    byte[] encodedKey = new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 4 };
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check returned array */
    boolean result = true;
    for (int i = 0; i < encodedKey.length; i++) {
        if (encodedKey[i] != ek[i]) {
            /* indicate failure */
            result = false;
        }
    }
    /* passed */
    assertTrue(result);
}

/**
 * Tests that internal state of the object can not be modified by modifying
 * initial array value
 */
@TestTargetNew(
    level = TestLevel.PARTIAL_COMPLETE,
    notes = "",
    method = "getEncoded",
    args = {}
)
public final void testIsStatePreserved1() {
    /* Create initial byte array */
    byte[] encodedKey = new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 4 };

    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Modify initial array's value */
    encodedKey[3] = (byte) 5;

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek[3] == (byte) 4);
}

/**
 * Tests that internal state of the object can not be modified using
 * returned value of <code>getEncoded()</code> method
 */
@TestTargetNew(
    level = TestLevel.PARTIAL_COMPLETE,
    notes = "",
    method = "getEncoded",
    args = {}
)
public final void testIsStatePreserved2() {

    byte[] encodedKey = new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 4 };
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();
    /* Modify returned value */
    ek[3] = (byte) 5;
    /* Get encoded key again */
    byte[] ek1 = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek1[3] == (byte) 4);
}

/**
 * Test for <code>PKCS8EncodedKeySpec</code> constructor<br>
 * Assertion: constructs new <code>PKCS8EncodedKeySpec</code>
 * object using valid parameter
 */
@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "",
    method = "PKCS8EncodedKeySpec",
    args = {byte[].class}
)
public final void testPKCS8EncodedKeySpec() {
    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};

    EncodedKeySpec eks = new PKCS8EncodedKeySpec(encodedKey);

    assertTrue(eks instanceof PKCS8EncodedKeySpec);
    try {
        eks = new PKCS8EncodedKeySpec(null);
        fail("expected NullPointerException");
    } catch (NullPointerException e) {
        // ok
    }
}

/**
 * Test for <code>X509EncodedKeySpec</code> constructor<br>
 * Assertion: constructs new <code>X509EncodedKeySpec</code>
 * object using valid parameter
 */
@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "",
    method = "X509EncodedKeySpec",
    args = {byte[].class}
)
public final void testX509EncodedKeySpec() {
    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};

    EncodedKeySpec eks = new X509EncodedKeySpec(encodedKey);

    assertTrue(eks instanceof X509EncodedKeySpec);
    try {
        eks = new X509EncodedKeySpec(null);
        fail("expected NullPointerException");
    } catch (NullPointerException e) {
        // ok
    }
}

/**
 * @return an RSA decryption cipher
 */
protected synchronized AsymmetricBlockCipher getRSADecryptCipher()
{
    if (decodeCipher == null)
    {
        try
        {
            byte[] bytes = getEncoder().decode(privateKey);
            EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(bytes);

            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PrivateKey key = keyFactory.generatePrivate(privateKeySpec);

            this.decodeCipher = new PKCS1Encoding(new RSABlindedEngine());
            decodeCipher.init(false, generatePrivateKeyParameter((RSAPrivateKey) key));
        }
        catch (Exception e)
        {
            throw new RuntimeException("Error constructing Cipher: ", e);
        }
    }

    return decodeCipher;
}

/**
 * @return
 */
protected synchronized AsymmetricBlockCipher getRSAEncryptCipher()
{
    if (encodeCipher == null)
    {
        try
        {
            byte[] bytes = getEncoder().decode(publicKey);
            EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(bytes);

            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PublicKey key = keyFactory.generatePublic(publicKeySpec);

            this.encodeCipher = new PKCS1Encoding(new RSABlindedEngine());
            encodeCipher.init(true, generatePublicKeyParameter((RSAPublicKey) key));
        }
        catch (Exception e)
        {
            throw new RuntimeException("Error constructing Cipher: ", e);
        }
    }

    return encodeCipher;
}

/**
 * Tests that <code>getEncoded()</code> method
 * returns valid byte array
 */
public final void testGetEncoded() {

    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check returned array */
    boolean result = true;
    for (int i=0; i<encodedKey.length; i++) {
        if (encodedKey[i] != ek[i]) {
            /* indicate failure */
            result = false;
        }
    }
    /* passed */
    assertTrue(result);
}

/**
 * Tests that internal state of the object
 * can not be modified by modifying initial array value
 */
public final void testIsStatePreserved1() {
    /* Create initial byte array */
    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};

    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Modify initial array's value */
    encodedKey[3] = (byte)5;

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek[3] == (byte)4);
}

/**
 * Tests that internal state of the object
 * can not be modified using returned value
 * of <code>getEncoded()</code> method 
*/
public final void testIsStatePreserved2() {

    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();        
    /* Modify returned value */
    ek[3] = (byte)5;
    /* Get encoded key again */
    byte[] ek1 = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek1[3] == (byte)4);
}

public static Validator getPrivateKey (byte[] encodedPrivateKey){
    Validator vKey = new Validator();

    try {
        EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
                encodedPrivateKey);
        KeyFactory generator = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = generator.generatePrivate(privateKeySpec);

        vKey.setVerified(true);
        vKey.setObject(privateKey);
    } catch (Exception e) {
        vKey.setVerified(false);
        vKey.setStatus("Convertion of bytes to private key failed");
    }

    return vKey;
}

/**
 * Tests that <code>getEncoded()</code> method
 * returns valid byte array
 */
public final void testGetEncoded() {

    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check returned array */
    boolean result = true;
    for (int i=0; i<encodedKey.length; i++) {
        if (encodedKey[i] != ek[i]) {
            /* indicate failure */
            result = false;
        }
    }
    /* passed */
    assertTrue(result);
}

/**
 * Tests that internal state of the object
 * can not be modified by modifying initial array value
 */
public final void testIsStatePreserved1() {
    /* Create initial byte array */
    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};

    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Modify initial array's value */
    encodedKey[3] = (byte)5;

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek[3] == (byte)4);
}

/**
 * Tests that internal state of the object
 * can not be modified using returned value
 * of <code>getEncoded()</code> method 
*/
public final void testIsStatePreserved2() {

    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();        
    /* Modify returned value */
    ek[3] = (byte)5;
    /* Get encoded key again */
    byte[] ek1 = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek1[3] == (byte)4);
}

/**
 * Tests that <code>getEncoded()</code> method
 * returns valid byte array
 */
public final void testGetEncoded() {

    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check returned array */
    boolean result = true;
    for (int i=0; i<encodedKey.length; i++) {
        if (encodedKey[i] != ek[i]) {
            /* indicate failure */
            result = false;
        }
    }
    /* passed */
    assertTrue(result);
}

/**
 * Tests that internal state of the object
 * can not be modified by modifying initial array value
 */
public final void testIsStatePreserved1() {
    /* Create initial byte array */
    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};

    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Modify initial array's value */
    encodedKey[3] = (byte)5;

    /* Get encoded key */
    byte[] ek = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek[3] == (byte)4);
}

/**
 * Tests that internal state of the object
 * can not be modified using returned value
 * of <code>getEncoded()</code> method 
*/
public final void testIsStatePreserved2() {

    byte[] encodedKey = new byte[] {(byte)1,(byte)2,(byte)3,(byte)4};
    EncodedKeySpec meks = new MyEncodedKeySpec(encodedKey);

    /* Get encoded key */
    byte[] ek = meks.getEncoded();        
    /* Modify returned value */
    ek[3] = (byte)5;
    /* Get encoded key again */
    byte[] ek1 = meks.getEncoded();

    /* Check that byte value has not been changed */
    assertTrue(ek1[3] == (byte)4);
}

/**
 * @return the peer's public contained in its certificate.
 */
public PublicKey getPublicKey() {
    PublicKey publicKey = null;

    if (rawPublicKeyBytes == null) {
        publicKey = certificateChain[0].getPublicKey();
    } else {
        // get server's public key from Raw Public Key
        EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(rawPublicKeyBytes);
        try {
            // TODO make instance variable
            publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
        } catch (Exception e) {
            LOG.severe("Could not reconstruct the server's public key.");
            e.printStackTrace();
        }
    }
    return publicKey;

}

@Test public void shouldValidateTheSHA1WithRSASignature() throws Exception {
    // create a public/private key pair
    KeyFactory keyFactory   = KeyFactory.getInstance("RSA");
    KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
    KeyPair pair = keyGen.generateKeyPair();
    EncodedKeySpec encoded = new X509EncodedKeySpec(pair.getPublic().getEncoded());
    PublicKey encodedPublic = keyFactory.generatePublic(encoded);
    String encodePublicBase64 = Base64.encodeToString(encodedPublic.getEncoded(), Base64.DEFAULT);

    // and sign some data with it
    Signature sig = Signature.getInstance("SHA1WithRSA");
    sig.initSign(pair.getPrivate());
    String data = "some sample data";
    sig.update(data.getBytes());

    String signature = Base64.encodeToString(sig.sign(), Base64.DEFAULT);

    SignatureValidator validator = new DefaultSignatureValidator(encodePublicBase64);
    assertThat(validator.validate(data, signature)).isTrue();
    assertThat(validator.validate(data+"extraData", signature)).isFalse();
}

@Override
public byte[] getDhResult(byte[] aMsg, int offset , boolean isLegacyClient) throws ZrtpException {
    try {
        int PV_LENGTH = keyType.pvLengthInWords * 4;
        byte[] encodedKey = new byte[keyType.pvLengthInWords * 4 + 1];
        encodedKey[0] = 4;
        System.arraycopy(aMsg, offset, encodedKey, 1, encodedKey.length - 1);
        EncodedKeySpec keySpec = getSpec(encodedKey, keyPair.getPublic());
        PublicKey pub = keyFactory.generatePublic(keySpec);
        KeyAgreement agreement = KeyAgreement.getInstance(algorithm, "ZBC");
        agreement.init(keyPair.getPrivate());
        agreement.doPhase(pub, true);
        byte[] secret = agreement.generateSecret();
        byte[] iDHResult = null;
        if(!isLegacyClient) {
            iDHResult = new byte[secret.length];
            System.arraycopy(secret, 0, iDHResult, 0, secret.length);    
        } else {
            iDHResult = new byte[PV_LENGTH];
            System.arraycopy(secret, 0, iDHResult, iDHResult.length - secret.length, secret.length);    
        }
        return iDHResult;
    } catch (Exception e) {
        throw new ZrtpException(e);
    }
}

/**
 * Transforms the private key, encoded as a base 64 string, into a private
 * key instance.
 *
 * @param key private key as a base64 encoded string
 * @return the private key
 * @throws DeltaClientException on error creating private key from string
 */
public PrivateKey getPrivateKey(String key) throws DeltaClientException {
    try {
        byte[] byteKey = BaseEncoding.base64().decode(key);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(byteKey);
        return keyFactory.generatePrivate(privateKeySpec);
    } catch (InvalidKeySpecException | NoSuchAlgorithmException | IllegalArgumentException e) {
        throw new DeltaClientException("Error creating private key from string", e);
    }
}

/**
 * Creates a new AdbCrypto object from a key pair loaded from files.
 *
 * @param base64     Implementation of base 64 conversion interface required by ADB
 * @param privateKey File containing the RSA private key
 * @param publicKey  File containing the RSA public key
 * @return New AdbCrypto object
 * @throws IOException              If the files cannot be read
 * @throws NoSuchAlgorithmException If an RSA key factory cannot be found
 * @throws InvalidKeySpecException  If a PKCS8 or X509 key spec cannot be found
 */
public static AdbCrypto loadAdbKeyPair(AdbBase64 base64, File privateKey, File publicKey) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
    AdbCrypto crypto = new AdbCrypto();

    int privKeyLength = (int) privateKey.length();
    int pubKeyLength = (int) publicKey.length();
    byte[] privKeyBytes = new byte[privKeyLength];
    byte[] pubKeyBytes = new byte[pubKeyLength];

    FileInputStream privIn = new FileInputStream(privateKey);
    FileInputStream pubIn = new FileInputStream(publicKey);

    privIn.read(privKeyBytes);
    pubIn.read(pubKeyBytes);

    privIn.close();
    pubIn.close();

    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privKeyBytes);
    EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(pubKeyBytes);

    crypto.keyPair = new KeyPair(keyFactory.generatePublic(publicKeySpec),
            keyFactory.generatePrivate(privateKeySpec));
    crypto.base64 = base64;

    return crypto;
}

/**
 * Creates a new AdbCrypto object from a key pair loaded from files.
 * @param base64 Implementation of base 64 conversion interface required by ADB 
 * @param privateKey File containing the RSA private key
 * @param publicKey File containing the RSA public key
 * @return New AdbCrypto object
 * @throws IOException If the files cannot be read
 * @throws NoSuchAlgorithmException If an RSA key factory cannot be found
 * @throws InvalidKeySpecException If a PKCS8 or X509 key spec cannot be found
 */
public static AdbCrypto loadAdbKeyPair(AdbBase64 base64, File privateKey, File publicKey) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException
{
    AdbCrypto crypto = new AdbCrypto();

    int privKeyLength = (int)privateKey.length();
    int pubKeyLength = (int)publicKey.length();
    byte[] privKeyBytes = new byte[privKeyLength];
    byte[] pubKeyBytes = new byte[pubKeyLength];

    FileInputStream privIn = new FileInputStream(privateKey);
    FileInputStream pubIn = new FileInputStream(publicKey);

    privIn.read(privKeyBytes);
    pubIn.read(pubKeyBytes);

    privIn.close();
    pubIn.close();

    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privKeyBytes);
    EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(pubKeyBytes);

    crypto.keyPair = new KeyPair(keyFactory.generatePublic(publicKeySpec),
            keyFactory.generatePrivate(privateKeySpec));
    crypto.base64 = base64;

    return crypto;
}

/**
 * Creates a new AdbCrypto object from a key pair loaded from files.
 *
 * @param base64     Implementation of base 64 conversion interface required by ADB
 * @param privateKey File containing the RSA private key
 * @param publicKey  File containing the RSA public key
 * @return New AdbCrypto object
 * @throws IOException              If the files cannot be read
 * @throws NoSuchAlgorithmException If an RSA key factory cannot be found
 * @throws InvalidKeySpecException  If a PKCS8 or X509 key spec cannot be found
 */
public static AdbCrypto loadAdbKeyPair(AdbBase64 base64, File privateKey, File publicKey) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
    AdbCrypto crypto = new AdbCrypto();

    int privKeyLength = (int) privateKey.length();
    int pubKeyLength = (int) publicKey.length();
    byte[] privKeyBytes = new byte[privKeyLength];
    byte[] pubKeyBytes = new byte[pubKeyLength];

    FileInputStream privIn = new FileInputStream(privateKey);
    FileInputStream pubIn = new FileInputStream(publicKey);

    privIn.read(privKeyBytes);
    pubIn.read(pubKeyBytes);

    privIn.close();
    pubIn.close();

    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privKeyBytes);
    EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(pubKeyBytes);

    crypto.keyPair = new KeyPair(keyFactory.generatePublic(publicKeySpec),
            keyFactory.generatePrivate(privateKeySpec));
    crypto.base64 = base64;

    return crypto;
}

private static void testPublicPrivateKeys(){
   try {
      String keyAlgorithm = "RSA";
      Key[] keys = CryptUtils.generatePrivatePublicKeys(keyAlgorithm, 1024);
      Key kPriv = keys[0];
      Key kPub = keys[1];
      byte[] kPubBytes = kPub.getEncoded();
      byte[] kPrivBytes = kPriv.getEncoded();
      System.out.println("--------------PublicKey----------------");
      System.out.println(kPub);
      System.out.println(kPub.getAlgorithm());
      System.out.println(kPub.getEncoded());
      System.out.println("--------------PrivateKey----------------");
      System.out.println(kPriv);
      System.out.println(kPriv.getAlgorithm());
      System.out.println(kPriv.getEncoded());

      // The bytes can be converted back to public and private key objects
      KeyFactory keyFactory = KeyFactory.getInstance(keyAlgorithm);
      EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(kPrivBytes);
      PrivateKey privateKey2 = keyFactory.generatePrivate(privateKeySpec);

      EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(kPubBytes);
      PublicKey publicKey2 = keyFactory.generatePublic(publicKeySpec);

      // The original and new keys are the same
      System.out.println("  Are both private keys equal? " + kPriv.equals(privateKey2));

      System.out.println("  Are both public keys equal? " + kPub.equals(publicKey2));
   } catch (Exception e) {
      e.printStackTrace();
   }
}

/**
 * Generates Public Key from BASE64 encoded string
 * 
 * @param key
 *            BASE64 encoded string which represents the key
 * @return The PublicKey
 * @throws java.lang.Exception
 */
public static PublicKey getPublicKeyFromBase64String(String base64PublicKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("Rsa");

        EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(Base64.decode(base64PublicKey));
        PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
        return publicKey;
    } catch (Exception ex) {
        Log.e(LOGTAG,ex.getMessage());
        return null;
    }
}