byte[] privateKeyBytes; byte[] publicKeyBytes; KeyFactory kf = KeyFactory.getInstance("RSA"); // or "EC" or whatever PrivateKey privateKey = kf.generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes)); PublicKey publicKey = kf.generatePublic(new X509EncodedKeySpec(publicKeyBytes));
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(clear); KeyFactory fact = KeyFactory.getInstance("DSA"); PrivateKey priv = fact.generatePrivate(keySpec); Arrays.fill(clear, (byte) 0); return priv; X509EncodedKeySpec spec = new X509EncodedKeySpec(data); KeyFactory fact = KeyFactory.getInstance("DSA"); return fact.generatePublic(spec); PKCS8EncodedKeySpec spec = fact.getKeySpec(priv, PKCS8EncodedKeySpec.class); byte[] packed = spec.getEncoded(); String key64 = base64Encode(packed); X509EncodedKeySpec spec = fact.getKeySpec(publ, X509EncodedKeySpec.class); return base64Encode(spec.getEncoded()); KeyPair pair = gen.generateKeyPair(); String pubKey = savePublicKey(pair.getPublic()); PublicKey pubSaved = loadPublicKey(pubKey); System.out.println(pair.getPublic()+"\n"+pubSaved); String privKey = savePrivateKey(pair.getPrivate()); PrivateKey privSaved = loadPrivateKey(privKey); System.out.println(pair.getPrivate()+"\n"+privSaved);
/** * Saves public and private keys to specified streams. * * @param keyPair the key pair * @param privateKeyOutput the private key output stream * @param publicKeyOutput the public key output stream * @throws IOException Signals that an I/O exception has occurred. */ public static void saveKeyPair( KeyPair keyPair, OutputStream privateKeyOutput, OutputStream publicKeyOutput) throws IOException { PrivateKey privateKey = keyPair.getPrivate(); PublicKey publicKey = keyPair.getPublic(); // Store Public Key. X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec( publicKey.getEncoded()); publicKeyOutput.write(x509EncodedKeySpec.getEncoded()); // Store Private Key. PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec( privateKey.getEncoded()); privateKeyOutput.write(pkcs8EncodedKeySpec.getEncoded()); }
/** * Gets the public part of the RSA key that represents the server identity. */ public PublicKey getIdentity() throws GeneralSecurityException { if (identity==null) return null; byte[] image = Base64.decodeBase64(identity); return KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(image)); } }
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(2048); KeyPair keyPair = kpg.generateKeyPair(); PublicKey pub = keyPair.getPublic(); PrivateKey prv = keyPair.getPrivate(); byte[] pubBytes = pub.getEncoded(); byte[] prvBytes = prv.getEncoded(); // now save pubBytes or prvBytes // to recover the key KeyFactory kf = KeyFactory.getInstance("RSA"); PrivateKey prv_recovered = kf.generatePrivate(new PKCS8EncodedKeySpec(prvBytes)); PublicKey pub_recovered = kf.generatePublic(new X509EncodedKeySpec(pubBytes)); System.out.println("Private Key: \n" + prv_recovered.toString()); System.out.println("Public Key: \n" + pub_recovered.toString());
/** * Generates an X509 formatted key used in authentication. * * @param base The key to use to generate a public key from its key spec. * @return The X509 formatted key. */ public static Key generateX509Key(Key base) { Key key = null; try { X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(base.getEncoded()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); key = keyFactory.generatePublic(encodedKeySpec); } catch (Exception ex) { GlowServer.logger.log(Level.SEVERE, "Unable to generate X509 encoded key", ex); } return key; } }
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");
registerKey(authorization.getIdentity(), keyPair.getPublic()); StringWriter writer = new StringWriter(); PemWriter pemWriter = new PemWriter(writer); pemWriter.writeObject(new PemObject("PUBLIC KEY", keyPair.getPublic().getEncoded())); pemWriter.flush(); pemWriter.close(); StringWriter writer = new StringWriter(); PemWriter pemWriter = new PemWriter(writer); pemWriter.writeObject(new PemObject("PRIVATE KEY", keyPair.getPrivate().getEncoded())); pemWriter.flush(); pemWriter.close(); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(encodedKey)); pub = (RSAPublicKey) KeyFactory.getInstance(algorithm).generatePublic(keySpec); } catch (Throwable e) { throw new APIException(400, "Public key not readable (DER)"); PemReader pemReader = new PemReader(new StringReader(encodedKey)); PemObject pem = pemReader.readPemObject(); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pem.getContent()); pub = (RSAPublicKey) KeyFactory.getInstance(algorithm).generatePublic(keySpec); } catch (Exception e) { throw new APIException(400, "Public key not readable (PEM)");
/** * Gets the public key from bytes. * * @param keyBytes the key bytes * @return the public * @throws InvalidKeyException invalid key exception */ public static PublicKey getPublic(byte[] keyBytes) throws InvalidKeyException { try { X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes); KeyFactory kf = KeyFactory.getInstance(RSA); return kf.generatePublic(spec); } catch (NoSuchAlgorithmException | InvalidKeySpecException ex) { throw new InvalidKeyException(ex); } }
} else if (credentialClass == PublicKeyCredential.class) { final PublicKey publicKey = credential.castAndApply(PublicKeyCredential.class, PublicKeyCredential::getPublicKey); final KeyFactory keyFactory = KeyFactory.getInstance(publicKey.getAlgorithm()); final X509EncodedKeySpec keySpec = keyFactory.getKeySpec(keyFactory.translateKey(publicKey), X509EncodedKeySpec.class); final byte[] encoded = keySpec.getEncoded(); entry = new KeyStore.SecretKeyEntry(new SecretKeySpec(encoded, DATA_OID)); } else if (credentialClass == KeyPairCredential.class) { final KeyPair keyPair = credential.castAndApply(KeyPairCredential.class, KeyPairCredential::getKeyPair); final PublicKey publicKey = keyPair.getPublic(); final PrivateKey privateKey = keyPair.getPrivate(); final KeyFactory keyFactory = KeyFactory.getInstance(publicKey.getAlgorithm()); final DEREncoder encoder = new DEREncoder(); encoder.startSequence(); encoder.writeEncoded(publicSpec.getEncoded()); encoder.writeEncoded(privateSpec.getEncoded()); encoder.endSequence(); entry = new KeyStore.SecretKeyEntry(new SecretKeySpec(encoder.getEncoded(), DATA_OID)); } else if (credentialClass == X509CertificateChainPublicCredential.class) { final X509Certificate[] x509Certificates = credential.castAndApply(X509CertificateChainPublicCredential.class, X509CertificateChainPublicCredential::getCertificateChain);
if (requireAuthentication) { X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFact = KeyFactory.getInstance("DH"); pubKey = keyFact.generatePublic(x509KeySpec); SecretKeySpec sks = new SecretKeySpec(sKeyBytes, 0, keysize, algoStr); IvParameterSpec ivps = new IvParameterSpec(sKeyBytes, keysize, blocksize);
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); }
// Use RSA/NONE/NoPadding as algorithm and BouncyCastle as crypto provider Cipher asymmetricCipher = Cipher.getInstance("RSA/NONE/NoPadding", "BC"); // asume, that publicKeyBytes contains a byte array representing // your public key X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes); KeyFactory keyFactory; keyFactory = KeyFactory.getInstance(publicKeySpec.getFormat()); Key key = keyFactory.generatePublic(publicKeySpec); // initialize your cipher asymmetricCipher.init(Cipher.DECRYPT_MODE, key); // asuming, cipherText is a byte array containing your encrypted message byte[] plainText = asymmetricCipher.doFinal(cipherText);
public PublicKey createPublicKey( String base64 ) { try { return this.keyFactory.generatePublic( new X509EncodedKeySpec( Base64.getDecoder().decode( base64 ) ) ); } catch ( InvalidKeySpecException e ) { e.printStackTrace(); return null; } }
public PublicKey getPublicKey() throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException { try { SubjectPublicKeyInfo subjectPublicKeyInfo = spkacSeq.getPublicKeyAndChallenge().getSubjectPublicKeyInfo(); X509EncodedKeySpec xspec = new X509EncodedKeySpec(subjectPublicKeyInfo.getEncoded()); AlgorithmIdentifier keyAlg = subjectPublicKeyInfo.getAlgorithm(); KeyFactory factory = helper.createKeyFactory(keyAlg.getAlgorithm().getId()); return factory.generatePublic(xspec); } catch (Exception e) { throw new InvalidKeyException("error encoding public key"); } } }
public void writePublicKey(String fileName) throws IOException { X509EncodedKeySpec keySpec = new X509EncodedKeySpec(this.keyPair .getPublic().getEncoded()); FileOutputStream fos = null; try { fos = new FileOutputStream(fileName); fos.write(keySpec.getEncoded()); } finally { fos.close(); } }
/** * 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; }
private static byte[] encodePublicKey(PublicKey publicKey) throws InvalidKeyException { byte[] encodedPublicKey = null; if ("X.509".equals(publicKey.getFormat())) { encodedPublicKey = publicKey.getEncoded(); } if (encodedPublicKey == null) { try { encodedPublicKey = KeyFactory.getInstance(publicKey.getAlgorithm()) .getKeySpec(publicKey, X509EncodedKeySpec.class) .getEncoded(); } catch (NoSuchAlgorithmException e) { throw new InvalidKeyException( "Failed to obtain X.509 encoded form of public key " + publicKey + " of class " + publicKey.getClass().getName(), e); } catch (InvalidKeySpecException e) { throw new InvalidKeyException( "Failed to obtain X.509 encoded form of public key " + publicKey + " of class " + publicKey.getClass().getName(), e); } } if ((encodedPublicKey == null) || (encodedPublicKey.length == 0)) { throw new InvalidKeyException( "Failed to obtain X.509 encoded form of public key " + publicKey + " of class " + publicKey.getClass().getName()); } return encodedPublicKey; }
private RSAPublicKey key() throws InvalidKeySpecException { byte[] decoded = Base64.getDecoder().decode(VERIFY_KEY.getBytes()); EncodedKeySpec spec = new X509EncodedKeySpec(decoded); return (RSAPublicKey) kf.generatePublic(spec); }
/** * Generate PEM content containing a {@link PublicKey}. * * @param target the target byte string builder (must not be {@code null}) * @param publicKey the {@link PublicKey} (must not be {@code null}) */ public static void generatePemPublicKey(ByteStringBuilder target, PublicKey publicKey) { Assert.checkNotNullParam("target", target); Assert.checkNotNullParam("publicKey", publicKey); try { KeyFactory instance = KeyFactory.getInstance(publicKey.getAlgorithm()); X509EncodedKeySpec keySpec = instance.getKeySpec(publicKey, X509EncodedKeySpec.class); generatePemContent(target, PUBLIC_KEY_FORMAT, ByteIterator.ofBytes(keySpec.getEncoded())); } catch (Exception e) { throw log.publicKeyParseError(e); } }