private static PrivateKey getRSAPrivateKeyFrom(String content) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException { PemReader reader = new PemReader(new StringReader(content)); PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(reader.readPemObject().getContent()); return KeyFactory.getInstance("RSA").generatePrivate(spec); }
private static PublicKey getRSAPublicKeyFrom(String content) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException { PemReader reader = new PemReader(new StringReader(content)); EncodedKeySpec spec = new X509EncodedKeySpec(reader.readPemObject().getContent()); return KeyFactory.getInstance("RSA").generatePublic(spec); }
public static Registration fromJson(String json) { Map map = GSON.fromJson(json, Map.class); if (map.isEmpty()) { return Registration.createNullPrivateKeyEntry(); } List<X509Certificate> chain = new ArrayList<>(); try { PemReader reader = new PemReader(new StringReader((String) map.get("agentPrivateKey"))); KeyFactory kf = KeyFactory.getInstance("RSA"); PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(reader.readPemObject().getContent()); PrivateKey privateKey = kf.generatePrivate(spec); String agentCertificate = (String) map.get("agentCertificate"); PemReader certReader = new PemReader(new StringReader(agentCertificate)); while (true) { PemObject obj = certReader.readPemObject(); if (obj == null) { break; } chain.add((X509Certificate) CertificateFactory.getInstance("X.509").generateCertificate(new ByteArrayInputStream(obj.getContent()))); } return new Registration(privateKey, chain.toArray(new X509Certificate[0])); } catch (IOException | NoSuchAlgorithmException | CertificateException | InvalidKeySpecException e) { throw bomb(e); } }
InvalidKeySpecException try ( PemReader r = new PemReader( new FileReader( privateKeyFile ) ) )
public X509Certificate[] loadCertificates( File certFile ) throws CertificateException, IOException { CertificateFactory certFactory = CertificateFactory.getInstance( CERTIFICATE_TYPE ); Collection<X509Certificate> certificates = new LinkedList<>(); try ( PemReader r = new PemReader( new FileReader( certFile ) ) ) { for ( PemObject pemObject = r.readPemObject(); pemObject != null; pemObject = r.readPemObject() ) { byte[] encodedCert = pemObject.getContent(); Collection<? extends X509Certificate> loadedCertificates = (Collection<X509Certificate>) certFactory.generateCertificates( new ByteArrayInputStream( encodedCert ) ); certificates.addAll( loadedCertificates ); } } if ( certificates.size() == 0 ) { // Ok, failed to read as PEM file, try and read it as raw binary certificate try ( FileInputStream in = new FileInputStream( certFile ) ) { certificates = (Collection<X509Certificate>) certFactory.generateCertificates( in ); } } return certificates.toArray( new X509Certificate[certificates.size()] ); }
private static byte[] parsePEMFile(File pemFile) throws IOException { if (!pemFile.isFile() || !pemFile.exists()) { throw new FileNotFoundException(String.format("The file '%s' doesn't exist.", pemFile.getAbsolutePath())); } PemReader reader = new PemReader(new FileReader(pemFile)); PemObject pemObject = reader.readPemObject(); byte[] content = pemObject.getContent(); reader.close(); return content; }
PemReader pemReader = new PemReader(new StringReader(encodedKey)); PemObject pem = pemReader.readPemObject(); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pem.getContent());
public PrivateKey parsePrivateKey(final String key) throws IOException { Preconditions.checkArgument(!Strings.isNullOrEmpty(key)); try (final PemReader pemReader = new PemReader(new StringReader(key));) { final PemObject pemObject = pemReader.readPemObject(); final byte[] content = pemObject.getContent(); final PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(content); final KeyFactory factory = KeyFactory.getInstance("RSA", "BC"); return factory.generatePrivate(privKeySpec); } catch (NoSuchAlgorithmException | NoSuchProviderException e) { throw new IOException("No encryption provider available.", e); } catch (final InvalidKeySpecException e) { throw new IOException("Invalid Key format.", e); } }
private byte[] convertPemToDer(String pem) throws IOException { PemReader pemReader = new PemReader(new StringReader(pem)); return pemReader.readPemObject().getContent(); }
public byte[] certificateToDER(String certificatePEM) { byte[] content = null; try (PemReader pemReader = new PemReader(new StringReader(certificatePEM))) { final PemObject pemObject = pemReader.readPemObject(); content = pemObject.getContent(); } catch (IOException e) { // best attempt } return content; }
@Override public Certificate parseCertificate(final String cert) { Preconditions.checkArgument(!Strings.isNullOrEmpty(cert)); final PemReader certPem = new PemReader(new StringReader(cert)); try { return readCertificateFromPemObject(certPem.readPemObject()); } catch (final CertificateException | IOException e) { throw new InvalidParameterValueException("Invalid Certificate format. Expected X509 certificate. Failed due to " + e.getMessage()); } finally { IOUtils.closeQuietly(certPem); } }
public static PrivateKey pemToPrivateKey(final String pem) throws InvalidKeySpecException, IOException { final PemReader pr = new PemReader(new StringReader(pem)); final PemObject pemObject = pr.readPemObject(); final KeyFactory keyFactory = getKeyFactory(); return keyFactory.generatePrivate(new PKCS8EncodedKeySpec(pemObject.getContent())); }
public static PublicKey pemToPublicKey(final String pem) throws InvalidKeySpecException, IOException { final PemReader pr = new PemReader(new StringReader(pem)); final PemObject pemObject = pr.readPemObject(); final KeyFactory keyFactory = getKeyFactory(); return keyFactory.generatePublic(new X509EncodedKeySpec(pemObject.getContent())); }
public static List<Certificate> parseChain(final String chain) throws IOException, CertificateException { Preconditions.checkNotNull(chain); final List<Certificate> certs = new ArrayList<Certificate>(); try(final PemReader pemReader = new PemReader(new StringReader(chain));) { final PemObject pemObject = pemReader.readPemObject(); final CertificateFactory certificateFactory = CertificateFactory.getInstance("X509"); final ByteArrayInputStream bais = new ByteArrayInputStream(pemObject.getContent()); for (final Certificate cert : certificateFactory.generateCertificates(bais)) { if (cert instanceof X509Certificate) { certs.add(cert); } } if (certs.isEmpty()) { throw new IllegalStateException("Unable to decode certificate chain"); } } return certs; }
/*** * Creates a TLSCertificateKeyPair out of the given {@link X509Certificate} and {@link KeyPair} * encoded in PEM and also in DER for the certificate * @param x509Cert the certificate to process * @param keyPair the key pair to process * @return a TLSCertificateKeyPair * @throws IOException upon failure */ static TLSCertificateKeyPair fromX509CertKeyPair(X509Certificate x509Cert, KeyPair keyPair) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); PrintWriter writer = new PrintWriter(baos); JcaPEMWriter w = new JcaPEMWriter(writer); w.writeObject(x509Cert); w.flush(); w.close(); byte[] pemBytes = baos.toByteArray(); InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(pemBytes)); PemReader pr = new PemReader(isr); PemObject pem = pr.readPemObject(); byte[] derBytes = pem.getContent(); baos = new ByteArrayOutputStream(); PrintWriter wr = new PrintWriter(baos); wr.println("-----BEGIN PRIVATE KEY-----"); wr.println(new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()))); wr.println("-----END PRIVATE KEY-----"); wr.flush(); wr.close(); byte[] keyBytes = baos.toByteArray(); return new TLSCertificateKeyPair(pemBytes, derBytes, keyBytes); }
/** * Return PrivateKey from pem bytes. * * @param pemKey pem-encoded private key * @return */ public PrivateKey bytesToPrivateKey(byte[] pemKey) throws CryptoException { PrivateKey pk = null; CryptoException ce = null; try { PemReader pr = new PemReader(new StringReader(new String(pemKey))); PemObject po = pr.readPemObject(); PEMParser pem = new PEMParser(new StringReader(new String(pemKey))); if (po.getType().equals("PRIVATE KEY")) { pk = new JcaPEMKeyConverter().getPrivateKey((PrivateKeyInfo) pem.readObject()); } else { logger.trace("Found private key with type " + po.getType()); PEMKeyPair kp = (PEMKeyPair) pem.readObject(); pk = new JcaPEMKeyConverter().getPrivateKey(kp.getPrivateKeyInfo()); } } catch (Exception e) { throw new CryptoException("Failed to convert private key bytes", e); } return pk; }
final PemReader pemReader = new PemReader(new StringReader(csr)); pemObject = pemReader.readPemObject(); } catch (IOException e) {
Optional<PublicKey> fromPEM(Optional<String> pemKey) { return pemKey .map(k -> new PEMParser(new PemReader(new StringReader(k)))) .flatMap(this::publicKeyFrom); }
static PemObject loadPemResource(String resource) throws IOException { InputStream s = new FileInputStream(resource); try (PemReader p = new PemReader(new InputStreamReader(s))) { PemObject o = p.readPemObject(); return o; } }
private byte[] convertPemToDer(String pem) throws IOException { PemReader pemReader = new PemReader(new StringReader(pem)); return pemReader.readPemObject().getContent(); }