private X509Certificate unwrap() { X509Certificate wrapped = this.wrapped; if (wrapped == null) { try { wrapped = this.wrapped = (X509Certificate) SslContext.X509_CERT_FACTORY.generateCertificate( new ByteArrayInputStream(bytes)); } catch (CertificateException e) { throw new IllegalStateException(e); } } return wrapped; } }
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); } }
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);
protected static X509Certificate generateCertFromDER(byte[] certBytes) throws CertificateException { CertificateFactory factory = CertificateFactory.getInstance("X.509"); return (X509Certificate)factory.generateCertificate(new ByteArrayInputStream(certBytes)); } }
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();
/** * 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(); } }
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; }
private X509Certificate unwrap() { X509Certificate wrapped = this.wrapped; if (wrapped == null) { try { wrapped = this.wrapped = (X509Certificate) SslContext.X509_CERT_FACTORY.generateCertificate( new ByteArrayInputStream(bytes)); } catch (CertificateException e) { throw new IllegalStateException(e); } } return wrapped; } }
/** * 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); } }
public SingleCertTrustManager(InputStream in) throws IOException, GeneralSecurityException { KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType()); // Note: KeyStore requires it be loaded even if you don't load anything into it: ks.load(null); CertificateFactory cf = CertificateFactory.getInstance("X509"); cert = (X509Certificate) cf.generateCertificate(in); ks.setCertificateEntry(UUID.randomUUID().toString(), cert); TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init(ks); for (TrustManager tm : tmf.getTrustManagers()) { if (tm instanceof X509TrustManager) { trustManager = (X509TrustManager) tm; break; } } if (trustManager == null) { throw new GeneralSecurityException(GT.tr("No X509TrustManager found")); } }
public static PublicKey getPublicKeyByX509(String x509File) { if (x509File == null || x509File.length() == 0) { return ConfigTools.getPublicKey(null); } FileInputStream in = null; try { in = new FileInputStream(x509File); CertificateFactory factory = CertificateFactory .getInstance("X.509"); Certificate cer = factory.generateCertificate(in); return cer.getPublicKey(); } catch (Exception e) { throw new IllegalArgumentException("Failed to get public key", e); } finally { JdbcUtils.close(in); } }
private static X509Certificate formX509Certificate(byte[] encodedCertificate) throws CertificateException { try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); ByteArrayInputStream bais = new ByteArrayInputStream(encodedCertificate); return (X509Certificate) cf.generateCertificate(bais); } catch (CertificateException e) { logger.error("Error converting the certificate", e); throw e; } }
private static X509Certificate[] getCertificatesFromBuffers(ByteBuf[] certs) throws CertificateException { CertificateFactory cf = CertificateFactory.getInstance("X.509"); X509Certificate[] x509Certs = new X509Certificate[certs.length]; try { for (int i = 0; i < certs.length; i++) { InputStream is = new ByteBufInputStream(certs[i], false); try { x509Certs[i] = (X509Certificate) cf.generateCertificate(is); } finally { try { is.close(); } catch (IOException e) { // This is not expected to happen, but re-throw in case it does. throw new RuntimeException(e); } } } } finally { for (ByteBuf buf: certs) { buf.release(); } } return x509Certs; }
public SSLContext getCACertSSLContext() { try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); InputStream caInput = context.getAssets().open("cacert.pem"); Certificate ca = cf.generateCertificate(caInput); KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(null, null); ks.setCertificateEntry("ca", ca); TrustManagerFactory tmf = TrustManagerFactory.getInstance( TrustManagerFactory.getDefaultAlgorithm()); tmf.init(ks); SSLContext ctx = SSLContext.getInstance("TLS"); ctx.init(null, tmf.getTrustManagers(), null); return ctx; } catch (Exception e) { throw new RuntimeException(e); } } }
/** * 获取CA证书信息 * @param cafile CA证书文件 * @return Certificate * @throws CertificateException * @throws IOException */ public static Certificate getCertificate(File cafile) throws CertificateException, IOException { CertificateFactory cf = CertificateFactory.getInstance("X.509"); FileInputStream in = new FileInputStream(cafile); Certificate cert = cf.generateCertificate(in); in.close(); return cert; }
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; }
private List<Certificate> readCertificateList(BufferedSource source) throws IOException { int length = readInt(source); if (length == -1) return Collections.emptyList(); // OkHttp v1.2 used -1 to indicate null. try { CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509"); List<Certificate> result = new ArrayList<>(length); for (int i = 0; i < length; i++) { String line = source.readUtf8LineStrict(); Buffer bytes = new Buffer(); bytes.write(ByteString.decodeBase64(line)); result.add(certificateFactory.generateCertificate(bytes.inputStream())); } return result; } catch (CertificateException e) { throw new IOException(e.getMessage()); } }