public static X509Certificate loadCertificateFromStream(InputStream in) throws Exception { if(in == null) { return null; } CertificateFactory fact = CertificateFactory.getInstance("X.509"); return (X509Certificate) fact.generateCertificate(in); }
public static X509Certificate loadCertificateFromFile(String file) throws Exception { if(file == null) { return null; } CertificateFactory fact = CertificateFactory.getInstance("X.509"); try(FileInputStream is = new FileInputStream(file)) { return (X509Certificate) fact.generateCertificate(is); } }
protected static X509Certificate generateCertFromDER(byte[] certBytes) throws CertificateException { CertificateFactory factory = CertificateFactory.getInstance("X.509"); return (X509Certificate)factory.generateCertificate(new ByteArrayInputStream(certBytes)); } }
InputStream is = new FileInputStream("cacert.crt"); // You could get a resource as a stream instead. CertificateFactory cf = CertificateFactory.getInstance("X.509"); X509Certificate caCert = (X509Certificate)cf.generateCertificate(is); TrustManagerFactory tmf = TrustManagerFactory .getInstance(TrustManagerFactory.getDefaultAlgorithm()); KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(null); // You don't need the KeyStore instance to come from a file. ks.setCertificateEntry("caCert", caCert); tmf.init(ks); SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, tmf.getTrustManagers(), null);
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()] ); }
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; } }
CertificateFactory certificateFactory = CertificateFactory.getInstance("X509"); Certificate certificate = certificateFactory.generateCertificate(new ByteArrayInputStream(publicKeyBytes)); PublicKey publicKey = certificate.getPublicKey(); try (FileInputStream in = new FileInputStream(file); FileChannel channel = in.getChannel()) { ByteArrayOutputStream out = new ByteArrayOutputStream();
/** * Deserializes a {@code CertPath} from a serialized {@code CertPathRep} * object. * * @return the deserialized {@code CertPath}. * @throws ObjectStreamException * if deserialization fails. */ protected Object readResolve() throws ObjectStreamException { try { CertificateFactory cf = CertificateFactory.getInstance(type); return cf.generateCertPath(new ByteArrayInputStream(data)); } catch (Throwable t) { throw new NotSerializableException("Could not resolve cert path: " + t); } } }
KeyStore ks; try { ks = KeyStore.getInstance("jks"); } catch (KeyStoreException e) { fis = new FileInputStream(sslrootcertfile); // NOSONAR } catch (FileNotFoundException ex) { throw new PSQLException( CertificateFactory cf = CertificateFactory.getInstance("X.509"); ks.load(null, null); for (int i = 0; i < certs.length; i++) { ks.setCertificateEntry("cert" + i, (Certificate) certs[i]);
useCRLs = false; try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); FileInputStream crlStream = new FileInputStream(crlFile); BufferedInputStream crlBuffer = new BufferedInputStream(crlStream);
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()]); }
/** * Update a keystore with a CA certificate * * @param pTrustStore the keystore to update * @param pCaCert CA cert as PEM used for the trust store */ public static void updateWithCaPem(KeyStore pTrustStore, File pCaCert) throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException { InputStream is = new FileInputStream(pCaCert); try { CertificateFactory certFactory = CertificateFactory.getInstance("X509"); X509Certificate cert = (X509Certificate) certFactory.generateCertificate(is); String alias = cert.getSubjectX500Principal().getName(); pTrustStore.setCertificateEntry(alias, cert); } finally { is.close(); } }
public static TrustManager[] initTrustStore(File tlsClientAuthCertFile) throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException { final KeyStore trustStore = KeyStore.getInstance("JKS"); trustStore.load(null, null); loadCertificates(trustStore, tlsClientAuthCertFile, CertificateFactory.getInstance("X.509")); if (LOG.isDebugEnabled()) { LOG.debug("Client authentication certificate file: {}", tlsClientAuthCertFile); LOG.debug("Aliases: {}", join(trustStore.aliases())); } final TrustManagerFactory instance = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); instance.init(trustStore); return instance.getTrustManagers(); }
import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; //VERY IMPORTANT. SOME OF THESE EXIST IN MORE THAN ONE PACKAGE! import java.security.GeneralSecurityException; import java.security.KeyStore; import java.security.cert.Certificate; import java.security.cert.CertificateFactory; //Put everything after here in your function. KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); trustStore.load(null);//Make an empty store InputStream fis = /* insert your file path here */; BufferedInputStream bis = new BufferedInputStream(fis); CertificateFactory cf = CertificateFactory.getInstance("X.509"); while (bis.available() > 0) { Certificate cert = cf.generateCertificate(bis); trustStore.setCertificateEntry("fiddler"+bis.available(), cert); }
private static X509Certificate readX509Certificate() throws IOException { try (InputStream fis = new FileInputStream(AcmeClient.DOMAIN_CHAIN_FILE)) { CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509"); return (X509Certificate) certificateFactory.generateCertificate(fis); } catch (CertificateException ex) { throw new IOException(ex); } }
public static List<X509Certificate> readCertificateChain(String certificateChain) throws CertificateException { Matcher matcher = CERT_PATTERN.matcher(certificateChain); CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509"); List<X509Certificate> certificates = new ArrayList<>(); int start = 0; while (matcher.find(start)) { byte[] buffer = base64Decode(matcher.group(1)); certificates.add((X509Certificate) certificateFactory.generateCertificate(new ByteArrayInputStream(buffer))); start = matcher.end(); } return certificates; }
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; } }
map(vertx.fileSystem()::readFileBlocking); tmp = Stream.concat(tmp, crlValues.stream()); CertificateFactory certificatefactory = CertificateFactory.getInstance("X.509"); ArrayList<CRL> crls = new ArrayList<>(); for (Buffer crlValue : tmp.collect(Collectors.toList())) { crls.addAll(certificatefactory.generateCRLs(new ByteArrayInputStream(crlValue.getBytes())));
@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); } }
/** * Load X509 from PEM file. */ private X509Certificate loadX509FromPEMFile(String filename) { try { return (X509Certificate) CertificateFactory.getInstance("X.509").generateCertificate(FileReader.openStreamToFileFromClassPathOrPath(filename)); } catch (Exception e) { throw new RuntimeException("Exception reading X509 from PEM file", e); } }