package me.jessyan.mvparms.demo.app.utils;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
public class SSLContextFactory {
public static class SSLParams
{
public SSLSocketFactorysSLSocketFactory;
public X509TrustManagertrustManager;
}
public static SSLParamsgetSslSocketFactory(InputStream[] certificates, InputStream bksFile, String password)
{
SSLParams sslParams =new SSLParams();
try
{
TrustManager[] trustManagers =prepareTrustManager(certificates);
KeyManager[] keyManagers =prepareKeyManager(bksFile, password);
SSLContext sslContext = SSLContext.getInstance("TLS");
X509TrustManager trustManager =null;
if (trustManagers !=null)
{
trustManager =new MyTrustManager(chooseTrustManager(trustManagers));
}else
{
trustManager =new UnSafeTrustManager();
}
sslContext.init(keyManagers, new TrustManager[]{trustManager},null);
sslParams.sSLSocketFactory = sslContext.getSocketFactory();
sslParams.trustManager = trustManager;
return sslParams;
}catch (NoSuchAlgorithmException e)
{
throw new AssertionError(e);
}catch (KeyManagementException e)
{
throw new AssertionError(e);
}catch (KeyStoreException e)
{
throw new AssertionError(e);
}
}
private class UnSafeHostnameVerifierimplements HostnameVerifier
{
@Override
public boolean verify(String hostname, SSLSession session)
{
return true;
}
}
private static class UnSafeTrustManagerimplements X509TrustManager
{
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType)
throws CertificateException
{
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType)
throws CertificateException
{
}
@Override
public X509Certificate[]getAcceptedIssuers()
{
return new java.security.cert.X509Certificate[]{};
}
}
private static TrustManager[]prepareTrustManager(InputStream... certificates)
{
if (certificates ==null || certificates.length <=0)return null;
try
{
CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(null);
int index =0;
for (InputStream certificate : certificates)
{
String certificateAlias = Integer.toString(index++);
keyStore.setCertificateEntry(certificateAlias, certificateFactory.generateCertificate(certificate));
try
{
if (certificate !=null)
certificate.close();
}catch (IOException e)
{
e.printStackTrace();
}
}
TrustManagerFactory trustManagerFactory =null;
trustManagerFactory = TrustManagerFactory.
getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keyStore);
TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
return trustManagers;
}catch (NoSuchAlgorithmException e)
{
e.printStackTrace();
}catch (CertificateException e)
{
e.printStackTrace();
}catch (KeyStoreException e)
{
e.printStackTrace();
}catch (Exception e)
{
e.printStackTrace();
}
return null;
}
private static KeyManager[]prepareKeyManager(InputStream bksFile, String password)
{
try
{
if (bksFile ==null || password ==null)return null;
KeyStore clientKeyStore = KeyStore.getInstance("BKS");
clientKeyStore.load(bksFile, password.toCharArray());
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyManagerFactory.init(clientKeyStore, password.toCharArray());
return keyManagerFactory.getKeyManagers();
}catch (KeyStoreException e)
{
e.printStackTrace();
}catch (NoSuchAlgorithmException e)
{
e.printStackTrace();
}catch (UnrecoverableKeyException e)
{
e.printStackTrace();
}catch (CertificateException e)
{
e.printStackTrace();
}catch (IOException e)
{
e.printStackTrace();
}catch (Exception e)
{
e.printStackTrace();
}
return null;
}
private static X509TrustManagerchooseTrustManager(TrustManager[] trustManagers)
{
for (TrustManager trustManager : trustManagers)
{
if (trustManagerinstanceof X509TrustManager)
{
return (X509TrustManager) trustManager;
}
}
return null;
}
private static class MyTrustManagerimplements X509TrustManager
{
private X509TrustManagerdefaultTrustManager;
private X509TrustManagerlocalTrustManager;
public MyTrustManager(X509TrustManager localTrustManager)throws NoSuchAlgorithmException, KeyStoreException
{
TrustManagerFactory var4 = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
var4.init((KeyStore)null);
defaultTrustManager =chooseTrustManager(var4.getTrustManagers());
this.localTrustManager = localTrustManager;
}
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType)throws CertificateException
{
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType)throws CertificateException
{
try
{
defaultTrustManager.checkServerTrusted(chain, authType);
}catch (CertificateException ce)
{
localTrustManager.checkServerTrusted(chain, authType);
}
}
@Override
public X509Certificate[]getAcceptedIssuers()
{
return new X509Certificate[0];
}
}
}
网友评论