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()] ); }
/** * 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); } } }
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 X509Certificate loadCertificateFromStream(InputStream in) throws Exception { if(in == null) { return null; } CertificateFactory fact = CertificateFactory.getInstance("X.509"); return (X509Certificate) fact.generateCertificate(in); }
private Collection<? extends CRL> getCRLs(InputStream crlStream) throws GeneralSecurityException { CertificateFactory cf = CertificateFactory.getInstance("X.509"); try { return cf.generateCRLs(crlStream); } finally { try { crlStream.close(); } catch (Exception ignore) {} } } }
/** * Get X509 Certificate * * @param certFilePath * @return Certificate */ public static Certificate getX509CertifaceteFromCrtFile(String certFilePath) { InputStream inStream = null; X509Certificate cert = null; try { inStream = new FileInputStream(certFilePath); CertificateFactory cf = CertificateFactory.getInstance("X.509"); cert = (X509Certificate) cf.generateCertificate(inStream); inStream.close(); } catch (Exception e) { e.printStackTrace(); Logs.e(e, ""); } finally { return cert; } }
InputStream in = new FileInputStream( file ); KeyStore ks = KeyStore.getInstance( KeyStore.getDefaultType() ); ks.load( in, passphrase ); in.close(); CertificateFactory cf = CertificateFactory.getInstance( "X.509" ); Certificate cert = cf.generateCertificate( getCertificateStream() );
public static KeyStore createTrustStore(InputStream pemInputStream, String trustStoreFile, char[] trustStorePassphrase) throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException { KeyStore trustStore = KeyStore.getInstance("JKS"); if (Utils.isNotNullOrEmpty(trustStoreFile)) { trustStore.load(new FileInputStream(trustStoreFile), trustStorePassphrase); } else { loadDefaultTrustStoreFile(trustStore, trustStorePassphrase); } while (pemInputStream.available() > 0) { CertificateFactory certFactory = CertificateFactory.getInstance("X509"); X509Certificate cert = (X509Certificate) certFactory.generateCertificate(pemInputStream); String alias = cert.getSubjectX500Principal().getName(); trustStore.setCertificateEntry(alias, cert); } return trustStore; }
/** * Load the collection of CRLs. */ protected Collection<? extends CRL> getCRLs(String crlf) throws IOException, CRLException, CertificateException { File crlFile = new File(crlf); if (!crlFile.isAbsolute()) { crlFile = new File(System.getProperty("catalina.base"), crlf); } Collection<? extends CRL> crls = null; InputStream is = null; try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); is = new FileInputStream(crlFile); crls = cf.generateCRLs(is); } finally { if (is != null) { try { is.close(); } catch (Exception ignored) { } } } return crls; }
FileInputStream is = new FileInputStream("yourKeyStore.keystore"); KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType()); keystore.load(is, "yourKeyStorePass".toCharArray()); CertificateFactory cf = CertificateFactory.getInstance("X.509"); InputStream certstream = fullStream (certfile); Certificate certs = cf.generateCertificate(certstream); FileInputStream in = new FileInputStream(keystoreFile); keystore.load(in, password); in.close(); byte[] bytes = new byte[dis.available()]; dis.readFully(bytes); ByteArrayInputStream bais = new ByteArrayInputStream(bytes); return bais;
protected static X509Certificate generateCertFromDER(byte[] certBytes) throws CertificateException { CertificateFactory factory = CertificateFactory.getInstance("X.509"); return (X509Certificate)factory.generateCertificate(new ByteArrayInputStream(certBytes)); } }
/** * 获取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; }
SSLContext ctx = SSLContext.getInstance("TLS"); // or "SSL" ? fis = new FileInputStream(sslrootcertfile); // NOSONAR } catch (FileNotFoundException ex) { throw new PSQLException( CertificateFactory cf = CertificateFactory.getInstance("X.509"); Object[] certs = cf.generateCertificates(fis).toArray(new Certificate[]{}); ks.load(null, null); for (int i = 0; i < certs.length; i++) { ks.setCertificateEntry("cert" + i, (Certificate) certs[i]); tmf.init(ks); } catch (IOException ioex) { throw new PSQLException( tm = tmf.getTrustManagers(); ctx.init(new KeyManager[]{km}, tm, null); } catch (KeyManagementException ex) { throw new PSQLException(GT.tr("Could not initialize SSL context."), _factory = ctx.getSocketFactory(); } catch (NoSuchAlgorithmException ex) { throw new PSQLException(GT.tr("Could not find a java cryptographic algorithm: {0}.",
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); } }
CertificateFactory cf = CertificateFactory.getInstance("X.509"); InputStream signatureIn = new ByteArrayInputStream(signature); DERObject obj = new ASN1InputStream(signatureIn).readObject(); ContentInfo contentInfo = ContentInfo.getInstance(obj); while (certificates.hasMoreElements()) { DERObject certObj = (DERObject) certificates.nextElement(); InputStream in = new ByteArrayInputStream(certObj.getDEREncoded()); certList.add(cf.generateCertificate(in)); CertPath certPath = cf.generateCertPath(certList); KeyStore keyStore = KeyStore.getInstance("JKS"); keyStore.load(new FileInputStream(keyStorePath), null);
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; } }
/** * 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(); } }
InputStream is = new FileInputStream(pServerCert); try { CertificateFactory certFactory = CertificateFactory.getInstance("X509"); X509Certificate cert = (X509Certificate) certFactory.generateCertificate(is); String alias = cert.getSubjectX500Principal().getName(); pKeyStore.setKeyEntry(alias, privateKey, pPassword, new Certificate[]{cert}); } finally { is.close();
/** * Verifies certs against public key of the local syncthing instance */ @Override public void checkServerTrusted(X509Certificate[] certs, String authType) throws CertificateException { InputStream is = null; try { is = new FileInputStream(mHttpsCertPath); CertificateFactory cf = CertificateFactory.getInstance("X.509"); X509Certificate ca = (X509Certificate) cf.generateCertificate(is); for (X509Certificate cert : certs) { cert.verify(ca.getPublicKey()); } } catch (FileNotFoundException | NoSuchAlgorithmException | InvalidKeyException | NoSuchProviderException | SignatureException e) { throw new CertificateException("Untrusted Certificate!", e); } finally { try { if (is != null) is.close(); } catch (IOException e) { Log.w(TAG, e); } } } public X509Certificate[] getAcceptedIssuers() {