private static PrivateKey loadPkcs1PrivateKey(String pkcs1KeyType, byte[] pkcs1Key) throws GeneralSecurityException { byte[] pkcs8Key; switch (pkcs1KeyType) { case "RSA": pkcs8Key = rsaPkcs1ToPkcs8(pkcs1Key); break; case "DSA": pkcs8Key = dsaPkcs1ToPkcs8(pkcs1Key); break; case "EC": pkcs8Key = ecPkcs1ToPkcs8(pkcs1Key); break; default: throw new InvalidKeySpecException("Key type must be one of " + SUPPORTED_KEY_TYPES); } try { KeyFactory keyFactory = KeyFactory.getInstance(pkcs1KeyType); return keyFactory.generatePrivate(new PKCS8EncodedKeySpec(pkcs8Key)); } catch (InvalidKeySpecException e) { throw new InvalidKeySpecException(format("Invalid PKCS 1 %s private key", pkcs1KeyType), e); } }
@Override public final InvalidKeySpecException insufficientDataToFormDigestAndSalt() { final InvalidKeySpecException result = new InvalidKeySpecException(String.format(getLoggingLocale(), insufficientDataToFormDigestAndSalt$str())); final StackTraceElement[] st = result.getStackTrace(); result.setStackTrace(Arrays.copyOfRange(st, 1, st.length)); return result; } private static final String invalidSalt2 = "ELY01054: Invalid salt \"%s%s\"";
return (T) (new PKCS8EncodedKeySpec(key.getEncoded())); throw new InvalidKeySpecException("'keySpec' is neither DSAPrivateKeySpec nor PKCS8EncodedKeySpec"); return (T) (new X509EncodedKeySpec(key.getEncoded())); throw new InvalidKeySpecException("'keySpec' is neither DSAPublicKeySpec nor X509EncodedKeySpec"); throw new InvalidKeySpecException("'key' is neither DSAPublicKey nor DSAPrivateKey");
protected SecretKey engineGenerateSecret( KeySpec keySpec) throws InvalidKeySpecException { if (keySpec instanceof TLSKeyMaterialSpec) { return new SecretKeySpec(PRF_legacy((TLSKeyMaterialSpec)keySpec), algName); } throw new InvalidKeySpecException("Invalid KeySpec"); } }
private static PrivateKey getPrivateKeyFromByteBuffer(ByteBuf encodedKeyBuf, String keyPassword) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeySpecException, InvalidAlgorithmParameterException, KeyException, IOException { byte[] encodedKey = new byte[encodedKeyBuf.readableBytes()]; encodedKeyBuf.readBytes(encodedKey).release(); PKCS8EncodedKeySpec encodedKeySpec = generateKeySpec( keyPassword == null ? null : keyPassword.toCharArray(), encodedKey); try { return KeyFactory.getInstance("RSA").generatePrivate(encodedKeySpec); } catch (InvalidKeySpecException ignore) { try { return KeyFactory.getInstance("DSA").generatePrivate(encodedKeySpec); } catch (InvalidKeySpecException ignore2) { try { return KeyFactory.getInstance("EC").generatePrivate(encodedKeySpec); } catch (InvalidKeySpecException e) { throw new InvalidKeySpecException("Neither RSA, DSA nor EC worked", e); } } } }
protected SecretKey engineGenerateSecret( KeySpec keySpec) throws InvalidKeySpecException { if (keySpec instanceof SecretKeySpec) { return new SecretKeySpec(((SecretKeySpec)keySpec).getEncoded(), algName); } throw new InvalidKeySpecException("Invalid KeySpec"); }
private static Key getEncKey(String encKey) { X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decodeBase64(encKey.getBytes(UTF8))); PublicKey publicKey = null; try { KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); publicKey = keyFactory.generatePublic(keySpec); } catch (NoSuchAlgorithmException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvalidKeySpecException e) { // TODO Auto-generated catch block e.printStackTrace(); } return publicKey; }
public KeyPair(byte[] privateKey, byte[] publicKey) { try { final KeyFactory keyFactory = KeyFactory.getInstance(ECDH_ALGORITHM_NAME, AeroGearCrypto.PROVIDER); final PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey); final X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey); this.publicKey = keyFactory.generatePublic(x509KeySpec); this.privateKey = keyFactory.generatePrivate(keySpec); } catch (InvalidKeySpecException e) { e.printStackTrace(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchProviderException e) { e.printStackTrace(); } }
@Override public PrivateKey load(Credentials in) { try { String privateKeyInPemFormat = checkNotNull(in.credential, "credential in PEM format"); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); return keyFactory.generatePrivate(privateKeySpec(ByteSource.wrap(privateKeyInPemFormat.getBytes(UTF_8)))); } catch (NoSuchAlgorithmException e) { throw new AssertionError(e); } catch (IOException e) { throw propagate(e); } catch (InvalidKeySpecException e) { throw new AuthorizationException("security exception loading credentials. " + e.getMessage(), e); // catch IAE that is thrown when parsing the pk fails } catch (IllegalArgumentException e) { throw new AuthorizationException("cannot parse pk. " + e.getMessage(), e); } } }
public static PublicKey loadPublicKey(String publicKey) throws GeneralSecurityException { Matcher matcher = PUBLIC_KEY_PATTERN.matcher(publicKey); if (!matcher.find()) { throw new KeyStoreException("did not find a public key"); } String data = matcher.group(1); byte[] encodedKey = base64Decode(data); X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(encodedKey); for (String algorithm : SUPPORTED_KEY_TYPES) { try { KeyFactory keyFactory = KeyFactory.getInstance(algorithm); return keyFactory.generatePublic(encodedKeySpec); } catch (InvalidKeySpecException ignore) { } } throw new InvalidKeySpecException("Key type must be one of " + SUPPORTED_KEY_TYPES); }
private static Key getDecKey(String decKey) { PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(decKey.getBytes(UTF8))); PrivateKey privateKey = null; try { KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); privateKey = keyFactory.generatePrivate(keySpec); } catch (NoSuchAlgorithmException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvalidKeySpecException e) { // TODO Auto-generated catch block e.printStackTrace(); } return privateKey; }
public PublicKey createPublicKey( String base64 ) { try { return this.keyFactory.generatePublic( new X509EncodedKeySpec( Base64.getDecoder().decode( base64 ) ) ); } catch ( InvalidKeySpecException e ) { e.printStackTrace(); return null; } }
factory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException s) { throw new IOException(s.getMessage(), s); factory.generatePublic(new RSAPublicKeySpec(n, e)), factory.generatePrivate(new RSAPrivateKeySpec(n, d)) ); } catch (InvalidKeySpecException i) { throw new IOException(i.getMessage(), i); ); } catch (InvalidKeySpecException e) { throw new IOException(e.getMessage(), e);
/** * @param publicKeyOpenSSH RSA public key in OpenSSH format * @return fingerprint ex. {@code 2b:a9:62:95:5b:8b:1d:61:e0:92:f7:03:10:e9:db:d9} */ public static String fingerprintPublicKey(String publicKeyOpenSSH) throws IOException { ECPublicKeySpec publicKeySpec = publicKeySpecFromOpenSSH(publicKeyOpenSSH); String fingerprint = null; try { ECPublicKey pk = (ECPublicKey) KeyFactory.getInstance("EC").generatePublic(publicKeySpec); fingerprint = fingerprint(pk); } catch (InvalidKeySpecException e) { e.printStackTrace(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return fingerprint; }
/** * Decodes base64 encoded private key to PrivateKey * @param privateKey encoded private key string * @return returns PrivateKey */ public static PrivateKey decodePrivateKey(String privateKey) { byte[] sigBytes = org.bouncycastle.util.encoders.Base64.decode(privateKey); PKCS8EncodedKeySpec pkscs8KeySpec = new PKCS8EncodedKeySpec(sigBytes); KeyFactory keyFactory = CertUtils.getKeyFactory(); if (keyFactory == null) return null; try { return keyFactory.generatePrivate(pkscs8KeySpec); } catch (InvalidKeySpecException e) { s_logger.error("Unable to create PrivateKey from privateKey string:" + e.getMessage()); } return null; }
/** * Decodes base64 encoded public key to PublicKey * @param publicKey encoded public key string * @return returns PublicKey */ public static PublicKey decodePublicKey(String publicKey) { byte[] sigBytes = org.bouncycastle.util.encoders.Base64.decode(publicKey); X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(sigBytes); KeyFactory keyFactory = CertUtils.getKeyFactory(); if (keyFactory == null) return null; try { return keyFactory.generatePublic(x509KeySpec); } catch (InvalidKeySpecException e) { s_logger.error("Unable to create PublicKey from PublicKey string:" + e.getMessage()); } return null; }
ASN1PrivateKeyInfo.verify(decryptedData); } catch (IOException e1) { throw new InvalidKeySpecException("Decrypted data does not represent valid PKCS#8 PrivateKeyInfo"); return new PKCS8EncodedKeySpec(decryptedData); } catch (IllegalStateException e) { throw new InvalidKeySpecException(e.getMessage()); } catch (IllegalBlockSizeException e) { throw new InvalidKeySpecException(e.getMessage()); } catch (BadPaddingException e) { throw new InvalidKeySpecException(e.getMessage());
private static Signature createSignature(PrivateKey privateKey, PublicKey publicKey) throws GeneralSecurityException { if (privateKey instanceof RSAPrivateKey && publicKey instanceof RSAPublicKey) { return Signature.getInstance("NONEwithRSA"); } if (privateKey instanceof ECPrivateKey && publicKey instanceof ECPublicKey) { return Signature.getInstance("NONEwithECDSA"); } if (privateKey instanceof DSAKey && publicKey instanceof DSAKey) { return Signature.getInstance("NONEwithDSA"); } throw new InvalidKeySpecException("Key type must be one of " + SUPPORTED_KEY_TYPES); }
byte[] encoding = keySpec.getEncoded(); .decode(encoding); } catch (IOException e) { throw new InvalidKeySpecException("Failed to decode keySpec encoding: " + e); subjectPublicKeyInfo.getSubjectPublicKey())); } catch (IOException e) { throw new InvalidKeySpecException("Failed to decode parameters: " + e); .decode(ai.getParameters()); } catch (IOException e) { throw new InvalidKeySpecException("Failed to decode parameters: " + e);
byte[] encoding = keySpec.getEncoded(); .decode(encoding); } catch (IOException e) { throw new InvalidKeySpecException("Failed to decode keySpec encoding: " + e); privateKeyInfo.getPrivateKey())); } catch (IOException e) { throw new InvalidKeySpecException("Failed to decode parameters: " + e); .decode(ai.getParameters()); } catch (IOException e) { throw new InvalidKeySpecException("Failed to decode parameters: " + e);