[java] HTTPS를 통한 HttpClient를 사용하여 모든 인증서 신뢰

기본적으로 httpclient를 사용하여 Android에서 “신뢰할 수 없음”예외를 해결하는 네 가지 가능한 솔루션이 있습니다.

1. 모든 인증서를 신뢰하십시오. 당신이하고있는 일을 정말로 알지 못한다면 이것을하지 마십시오.
2. 인증서 만 신뢰하는 사용자 정의 SSLSocketFactory를 작성하십시오. 연결하려는 서버를 정확히 알고있는 한 작동하지만 다른 SSL 인증서를 사용하여 새 서버에 연결해야하는 즉시 앱을 업데이트해야합니다.
3. Android의 “마스터 목록”인증서가 포함 된 키 저장소 파일을 작성한 후 직접 저장하십시오. 해당 인증서 중 어느 것이라도 만료되면 앱에서 업데이트해야합니다. 나는 이것을 할 이유를 생각할 수 없다.
4. 내장 인증서 KeyStore를 사용하는 사용자 정의 SSLSocketFactory를 작성하십시오. 그러나 기본값으로 확인하지 못하는 경우 대체 KeyStore로 대체됩니다.

이 답변은 솔루션 # 4를 사용합니다.

해결책은 여러 키 저장소를 승인 할 수있는 SSLSocketFactory를 사용하여 고유 한 인증서를 고유 한 키 저장소에 제공 할 수 있습니다. 이를 통해 일부 Android 기기에서 누락 될 수있는 Thawte와 같은 추가 최상위 인증서를로드 할 수 있습니다. 또한 자체 서명 된 인증서도로드 할 수 있습니다. 내장 된 기본 장치 인증서를 먼저 사용하고 필요한 경우에만 추가 인증서로 대체합니다.

먼저 KeyStore에서 누락 된 인증서를 확인해야합니다. 다음 명령을 실행하십시오.

openssl s_client -connect www.yourserver.com:443

그리고 당신은 다음과 같은 출력을 볼 수 있습니다 :

Certificate chain
 0 s:/O=www.yourserver.com/OU=Go to
   https://www.thawte.com/repository/index.html/OU=Thawte SSL123 
   certificate/OU=Domain Validated/CN=www.yourserver.com
   i:/C=US/O=Thawte, Inc./OU=Domain Validated SSL/CN=Thawte DV SSL CA
 1 s:/C=US/O=Thawte, Inc./OU=Domain Validated SSL/CN=Thawte DV SSL CA
   i:/C=US/O=thawte, Inc./OU=Certification Services Division/OU=(c)
   2006 thawte, Inc. - For authorized use only/CN=thawte Primary Root CA

보시다시피 루트 인증서는 Thawte의 것입니다. 공급자의 웹 사이트로 이동하여 해당 인증서를 찾으십시오. 우리에게는 여기 에 있으며, 필요한 것은 Copyright 2006이라는 것을 알 수 있습니다.

자체 서명 인증서를 사용하는 경우 서명 인증서가 이미 있으므로 이전 단계를 수행하지 않아도됩니다.

그런 다음 누락 된 서명 인증서가 포함 된 키 저장소 파일을 작성하십시오. Crazybob은 Android 에서이 작업을 수행하는 방법에 대한 세부 정보를 가지고 있지만 아이디어는 다음과 같습니다.

Bouncy Castle 제공자 라이브러리가없는 경우 http://www.bouncycastle.org/latest_releases.html 에서 다운로드 하십시오 . 이것은 아래 클래스 경로로 진행됩니다.

서버에서 인증서를 추출하고 pem 파일을 작성하는 명령을 실행하십시오. 이 경우 mycert.pem입니다.

echo | openssl s_client -connect ${MY_SERVER}:443 2>&1 | \
 sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > mycert.pem

그런 다음 다음 명령을 실행하여 키 저장소를 작성하십시오.

export CLASSPATH=/path/to/bouncycastle/bcprov-jdk15on-155.jar
CERTSTORE=res/raw/mystore.bks
if [ -a $CERTSTORE ]; then
    rm $CERTSTORE || exit 1
fi
keytool \
      -import \
      -v \
      -trustcacerts \
      -alias 0 \
      -file <(openssl x509 -in mycert.pem) \
      -keystore $CERTSTORE \
      -storetype BKS \
      -provider org.bouncycastle.jce.provider.BouncyCastleProvider \
      -providerpath /path/to/bouncycastle/bcprov-jdk15on-155.jar \
      -storepass some-password

위의 스크립트는 결과를에 배치한다는 것을 알 수 있습니다 res/raw/mystore.bks. 이제 누락 된 인증서를 제공하는 Android 앱에로드 할 파일이 있습니다.

이렇게하려면 SSL 구성표에 SSLSocketFactory를 등록하십시오.

final SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", createAdditionalCertsSSLSocketFactory(), 443));

// and then however you create your connection manager, I use ThreadSafeClientConnManager
final HttpParams params = new BasicHttpParams();
...
final ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params,schemeRegistry);

SSLSocketFactory를 작성하려면 다음을 수행하십시오.

protected org.apache.http.conn.ssl.SSLSocketFactory createAdditionalCertsSSLSocketFactory() {
    try {
        final KeyStore ks = KeyStore.getInstance("BKS");

        // the bks file we generated above
        final InputStream in = context.getResources().openRawResource( R.raw.mystore);
        try {
            // don't forget to put the password used above in strings.xml/mystore_password
            ks.load(in, context.getString( R.string.mystore_password ).toCharArray());
        } finally {
            in.close();
        }

        return new AdditionalKeyStoresSSLSocketFactory(ks);

    } catch( Exception e ) {
        throw new RuntimeException(e);
    }
}

마지막으로 AdditionalKeyStoresSSLSocketFactory 코드는 새 KeyStore를 승인하고 내장 KeyStore가 SSL 인증서의 유효성 검증에 실패하는지 확인합니다.

/**
 * Allows you to trust certificates from additional KeyStores in addition to
 * the default KeyStore
 */
public class AdditionalKeyStoresSSLSocketFactory extends SSLSocketFactory {
    protected SSLContext sslContext = SSLContext.getInstance("TLS");

    public AdditionalKeyStoresSSLSocketFactory(KeyStore keyStore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        super(null, null, null, null, null, null);
        sslContext.init(null, new TrustManager[]{new AdditionalKeyStoresTrustManager(keyStore)}, null);
    }

    @Override
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
        return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
    }

    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }



    /**
     * Based on http://download.oracle.com/javase/1.5.0/docs/guide/security/jsse/JSSERefGuide.html#X509TrustManager
     */
    public static class AdditionalKeyStoresTrustManager implements X509TrustManager {

        protected ArrayList<X509TrustManager> x509TrustManagers = new ArrayList<X509TrustManager>();


        protected AdditionalKeyStoresTrustManager(KeyStore... additionalkeyStores) {
            final ArrayList<TrustManagerFactory> factories = new ArrayList<TrustManagerFactory>();

            try {
                // The default Trustmanager with default keystore
                final TrustManagerFactory original = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                original.init((KeyStore) null);
                factories.add(original);

                for( KeyStore keyStore : additionalkeyStores ) {
                    final TrustManagerFactory additionalCerts = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                    additionalCerts.init(keyStore);
                    factories.add(additionalCerts);
                }

            } catch (Exception e) {
                throw new RuntimeException(e);
            }



            /*
             * Iterate over the returned trustmanagers, and hold on
             * to any that are X509TrustManagers
             */
            for (TrustManagerFactory tmf : factories)
                for( TrustManager tm : tmf.getTrustManagers() )
                    if (tm instanceof X509TrustManager)
                        x509TrustManagers.add( (X509TrustManager)tm );


            if( x509TrustManagers.size()==0 )
                throw new RuntimeException("Couldn't find any X509TrustManagers");

        }

        /*
         * Delegate to the default trust manager.
         */
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            final X509TrustManager defaultX509TrustManager = x509TrustManagers.get(0);
            defaultX509TrustManager.checkClientTrusted(chain, authType);
        }

        /*
         * Loop over the trustmanagers until we find one that accepts our server
         */
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            for( X509TrustManager tm : x509TrustManagers ) {
                try {
                    tm.checkServerTrusted(chain,authType);
                    return;
                } catch( CertificateException e ) {
                    // ignore
                }
            }
            throw new CertificateException();
        }

        public X509Certificate[] getAcceptedIssuers() {
            final ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
            for( X509TrustManager tm : x509TrustManagers )
                list.addAll(Arrays.asList(tm.getAcceptedIssuers()));
            return list.toArray(new X509Certificate[list.size()]);
        }
    }

}

답변

private void trustEveryone() {
    try {
            HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier(){
                    public boolean verify(String hostname, SSLSession session) {
                            return true;
                    }});
            SSLContext context = SSLContext.getInstance("TLS");
            context.init(null, new X509TrustManager[]{new X509TrustManager(){
                    public void checkClientTrusted(X509Certificate[] chain,
                                    String authType) throws CertificateException {}
                    public void checkServerTrusted(X509Certificate[] chain,
                                    String authType) throws CertificateException {}
                    public X509Certificate[] getAcceptedIssuers() {
                            return new X509Certificate[0];
                    }}}, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(
                            context.getSocketFactory());
    } catch (Exception e) { // should never happen 
            e.printStackTrace();
    }
} 

    KeyStore ks = KeyStore.getInstance("JKS");

    // get user password and file input stream
    char[] password = ("mykspassword")).toCharArray();
    ClassLoader cl = this.getClass().getClassLoader();
    InputStream stream = cl.getResourceAsStream("myjks.jks");
    ks.load(stream, password);
    stream.close();

    SSLContext sc = SSLContext.getInstance("TLS");
    KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
    TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");

    kmf.init(ks, password);
    tmf.init(ks);

    sc.init(kmf.getKeyManagers(), tmf.getTrustManagers(),null);

    return sc.getSocketFactory();

    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    if (conn instanceof HttpsURLConnection) {
        HttpsURLConnection httpsConn = (HttpsURLConnection) conn;
        httpsConn.setSSLSocketFactory(SSLCertificateSocketFactory.getInsecure(0, null));
        httpsConn.setHostnameVerifier(new AllowAllHostnameVerifier());
    }

public static HttpClient getTestHttpClient() {
    try {
        SSLSocketFactory sf = new SSLSocketFactory(new TrustStrategy(){
            @Override
            public boolean isTrusted(X509Certificate[] chain,
                    String authType) throws CertificateException {
                return true;
            }
        }, new AllowAllHostnameVerifier());

        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("https",8444, sf));
        ClientConnectionManager ccm = new ThreadSafeClientConnManager(registry);
        return new DefaultHttpClient(ccm);
    } catch (Exception e) {
        e.printStackTrace();
        return new DefaultHttpClient();
    }
}

    @Override
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
    SSLSocket sslSocket = (SSLSocket)sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
    getHostnameVerifier().verify(host, sslSocket);
    return sslSocket;
}