static Collection<? extends Certificate> readCertificates(InputStream in) { try { CertificateFactory cf = CertificateFactory.getInstance(CERTIFICATE_TYPE_NAME); return cf.generateCertificates(in); } catch (Exception e) { LOG.error("Certificate read error", e); } return Collections.emptyList(); }
public static Collection<? extends Certificate> loadCertificates(Path certificatePath) throws CertificateException, IOException { final CertificateFactory cf = CertificateFactory.getInstance("X.509"); try (InputStream inputStream = Files.newInputStream(certificatePath)) { return cf.generateCertificates(inputStream); } }
public static X509Certificate[] loadCertificatesFromStream(InputStream in) throws Exception { if(in == null) { return null; } CertificateFactory fact = CertificateFactory.getInstance("X.509"); Collection<? extends Certificate> certs = fact.generateCertificates(in); X509Certificate[] x509Certs = new X509Certificate[certs.size()]; int i=0; for(Certificate cert: certs) { x509Certs[i++] = (X509Certificate) cert; } return x509Certs; }
private List<Certificate> readCertificates(Path file) throws CertificateException, IOException { try (InputStream inputStream = Files.newInputStream(file)) { final CertificateFactory cf = CertificateFactory.getInstance("X.509"); return new ArrayList<>(cf.generateCertificates(inputStream)); } }
public List<X509Certificate> certificates(File certFile) throws IOException, CertificateException { ArrayList<X509Certificate> certs = new ArrayList<>(); if (certFile != null && certFile.exists() && certFile.canRead()) { try (FileInputStream fis = new FileInputStream(certFile)) { CertificateFactory cf = CertificateFactory.getInstance("X.509"); Collection<? extends Certificate> certificates = cf.generateCertificates(fis); for (Certificate cert : certificates) { if (cert instanceof X509Certificate) { certs.add((X509Certificate) cert); } } } } return certs; } }
public static X509Certificate[] loadCertificatesFromFile(String file) throws Exception { if(file == null) { return null; } CertificateFactory fact = CertificateFactory.getInstance("X.509"); try(FileInputStream is = new FileInputStream(file)) { Collection<? extends Certificate> certs = fact.generateCertificates(is); X509Certificate[] x509Certs = new X509Certificate[certs.size()]; int i=0; for(Certificate cert: certs) { x509Certs[i++] = (X509Certificate) cert; } return x509Certs; } }
/** * Parses a certificate chain from a PEM representation. * * @param pemRepresentation a PEM representation of a certificate or certificate chain (cannot be null or empty) * @return A collection of certificates (possibly empty, but never null). */ @SuppressWarnings("unchecked") public static Collection<X509Certificate> parseCertificates(InputStream pemRepresentation) throws IOException, CertificateException { CertificateFactory certificateFactory; try { certificateFactory = CertificateFactory.getInstance("X509", "BC"); } catch (NoSuchProviderException e) { certificateFactory = CertificateFactory.getInstance("X509"); } return (Collection<X509Certificate>) certificateFactory.generateCertificates(pemRepresentation); }
private static Certificate[] loadCertificates(String certPath) throws IOException, CertificateException { try (InputStream is = new FileInputStream(certPath)) { CertificateFactory certificateFactory = CertificateFactory.getInstance("X509"); Collection<? extends Certificate> certs = certificateFactory.generateCertificates(is); return certs.toArray(new Certificate[certs.size()]); } } }
throws GeneralSecurityException { CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509"); Collection<? extends Certificate> certificates = certificateFactory.generateCertificates(in); if (certificates.isEmpty()) { throw new IllegalArgumentException("expected non-empty set of trusted certificates");
public static X509Certificate[] loadCertificatesFromPemFile(String certFilePath) throws KeyManagementException { X509Certificate[] certificates = null; if (certFilePath == null || certFilePath.isEmpty()) { return certificates; } try (FileInputStream input = new FileInputStream(certFilePath)) { CertificateFactory cf = CertificateFactory.getInstance("X.509"); Collection<X509Certificate> collection = (Collection<X509Certificate>) cf.generateCertificates(input); certificates = collection.toArray(new X509Certificate[collection.size()]); } catch (GeneralSecurityException | IOException e) { throw new KeyManagementException("Certificate loading error", e); } return certificates; }
private static X509Certificate[] loadCerts(Buffer buffer) throws Exception { if (buffer == null) { throw new RuntimeException("Missing X.509 certificate path"); } CertificateFactory certFactory = CertificateFactory.getInstance("X.509"); List<X509Certificate> certs = loadPems(buffer, (delimiter, content) -> { try { switch (delimiter) { case "CERTIFICATE": return (Collection<X509Certificate>) certFactory.generateCertificates(new ByteArrayInputStream(content)); default: return Collections.emptyList(); } } catch (CertificateException e) { throw new VertxException(e); } }); if (certs.isEmpty()) { throw new RuntimeException("Missing -----BEGIN CERTIFICATE----- delimiter"); } return certs.toArray(new X509Certificate[certs.size()]); }
private static X509Certificate[] getPemCertificateChain(HttpURLConnection connection) throws AcmeException { try { CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509"); Collection<? extends Certificate> reply; try (InputStream inputStream = new BufferedInputStream(getConvertedInputStream(connection.getInputStream()))) { reply = certificateFactory.generateCertificates(inputStream); } return X500.asX509CertificateArray(reply.toArray(new Certificate[reply.size()])); } catch (CertificateException | IOException e) { throw acme.unableToDownloadCertificateChainFromAcmeServer(e); } }
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()] ); }
/** * * @param sessionId The SSL session ID * @param cypherSuite The cypher suite name * @param certificate A string representation of the client certificate * @throws java.security.cert.CertificateException If the client cert could not be decoded * @throws CertificateException If the client cert could not be decoded */ public BasicSSLSessionInfo(byte[] sessionId, String cypherSuite, String certificate) throws java.security.cert.CertificateException, CertificateException { this.sessionId = sessionId; this.cypherSuite = cypherSuite; if (certificate != null) { java.security.cert.CertificateFactory cf = java.security.cert.CertificateFactory.getInstance("X.509"); byte[] certificateBytes = certificate.getBytes(StandardCharsets.US_ASCII); ByteArrayInputStream stream = new ByteArrayInputStream(certificateBytes); Collection<? extends java.security.cert.Certificate> certCol = cf.generateCertificates(stream); this.peerCertificate = new java.security.cert.Certificate[certCol.size()]; this.certificate = new X509Certificate[certCol.size()]; int i=0; for(java.security.cert.Certificate cert : certCol) { this.peerCertificate[i] = cert; this.certificate[i++] = X509Certificate.getInstance(cert.getEncoded()); } } else { this.peerCertificate = null; this.certificate = null; } } /**
@Override public Certificate[] engineGetCertificateChain(String alias) { Attributes attributes = obtainAliasOrCertificateAttributes(alias, null, new String[]{certificateChainAttribute}); if (attributes == null) { log.tracef("Alias [%s] does not exist", alias); return null; } try { Attribute attribute = LdapUtil.getBinaryAttribute(attributes, certificateChainAttribute); if (attribute == null) return null; byte[] bytes = (byte[]) attribute.get(); if (bytes == null) return null; InputStream is = new ByteArrayInputStream(bytes); CertificateFactory certFactory = CertificateFactory.getInstance(certificateType); Collection<? extends Certificate> chain = certFactory.generateCertificates(is); return chain.toArray(new Certificate[chain.size()]); } catch (CertificateException | NamingException e) { throw log.ldapKeyStoreFailedToObtainCertificateChain(alias, e); } }
public X509Certificate[] getTrustedX509CertificatesForTrustManager() { try { CertificateFactory certificateFactory = CertificateFactory .getInstance("X.509"); ArrayList<Certificate> allCerts = new ArrayList<>(); for (String trustedCert : ssl.getTrustedX509Certificates()) { try { URL url = ResourceUtils.getURL(trustedCert); Collection<? extends Certificate> certs = certificateFactory .generateCertificates(url.openStream()); allCerts.addAll(certs); } catch (IOException e) { throw new WebServerException( "Could not load certificate '" + trustedCert + "'", e); } } return allCerts.toArray(new X509Certificate[allCerts.size()]); } catch (CertificateException e1) { throw new WebServerException("Could not load CertificateFactory X.509", e1); } }
certs = cf.generateCertificates(new FileInputStream(certfile)); } catch (FileNotFoundException ioex) { if (!defaultfile) { // It is not an error if there is no file at the default location
Object[] certs = cf.generateCertificates(fis).toArray(new Certificate[]{}); ks.load(null, null); for (int i = 0; i < certs.length; i++) {
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; }
/** * addCACertificatesToTrustStore adds a CA certs in a stream to the trust store used for signature validation * * @param bis an X.509 certificate stream in PEM format in bytes * @throws CryptoException * @throws InvalidArgumentException */ public void addCACertificatesToTrustStore(BufferedInputStream bis) throws CryptoException, InvalidArgumentException { if (bis == null) { throw new InvalidArgumentException("The certificate stream bis cannot be null"); } try { final Collection<? extends Certificate> certificates = cf.generateCertificates(bis); for (Certificate certificate : certificates) { addCACertificateToTrustStore(certificate); } } catch (CertificateException e) { throw new CryptoException("Unable to add CA certificate to trust store. Error: " + e.getMessage(), e); } }