Problem z SSL z Androidem

Question

Mam bardzo specyficzny problem z SSL na moim Androidzie. Jeśli staram się odwiedzić daną stronę internetową za pomocą kodu, pojawia się następujący błąd:

SSL handshake failure: Failure in SSL library, usually a protocol error 
error:140773F2:SSL routines:SSL23_GET_SERVER_HELLO: sslv3 alert unexpected message (external/openssl/ssl/s23_cInt.c:500 0xaf076228:0x00000000) 

uzyskać to niezależnie od budowy ... Próbowałem go na poziomie API 1,5, 1,6, 2,2, i 4,0 i za każdym razem otrzymali ten sam wynik.

Po pewnym rozwiązywania problemów Próbowałem znaleźć na stronie internetowej za pośrednictwem przeglądarki i mam następujący błąd:

Data connectivity problem 
A secure connection could not be established. 

Oto rzeczy, choć ... strona otwiera się dobrze w przeglądarkach systemu Windows (testowane na Firefox , IE i Chrome). Otwiera się również dobrze na urządzeniach z iOS, które używają tego samego zestawu webowego, co Android, co jest dziwne. Strona działa również bezproblemowo w przeglądarce Opera Mini.

Here's the website.

Próbowałam obejść przez dodanie certyfikatu klienta do magazynu kluczy i ignorowanie nieprawidłowych certyfikatów klienta, bez żadnych rezultatów. Jednak wydaje się, że sam certyfikat nie jest problemem.

Jestem w impasie. Czy ktokolwiek może udzielić wskazówek, jak mogę to osiągnąć?

Answer 1

W jaki sposób uzyskujesz dostęp do tej witryny? Przez przeglądarkę Android? WebView? Czy HttpClient/HTTPSURLConnection? Wygląda na to, że odpowiada tylko na SSL3, musisz zmusić swojego klienta, aby z niego korzystał.

Answer 2

Znalazłem rozwiązanie (dziękuję Nikolay za skierowanie mnie we właściwym kierunku).

Problem był dwojaki ... Jeden, zwrócił certyfikat witryny, który nie podobał się Androidowi, a po drugie, miał włączony tylko SSLv3 (a nie TLS).

Oto moje rozwiązanie. Najpierw miałem utworzyć klasy fabrycznej gniazdo niestandardowe:

public class MySSLSocketFactory extends SSLSocketFactory { 
SSLContext sslContext = SSLContext.getInstance("SSLv3"); 

public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException { 
    super(truststore); 

    TrustManager tm = new X509TrustManager() { 
     public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {} 
     public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {} 
     public X509Certificate[] getAcceptedIssuers() { 
      return null; 
     } 
    }; 

    sslContext.init(null, new TrustManager[] { tm }, null); 
} 

@Override 
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException { 
    SSLSocket S = (SSLSocket) sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); 
    S.setEnabledProtocols(new String[] {"SSLv3"}); 
    return S; 
} 

@Override 
public Socket createSocket() throws IOException { 
    SSLSocket S = (SSLSocket) sslContext.getSocketFactory().createSocket(); 
    S.setEnabledProtocols(new String[] {"SSLv3"}); 
    return S; 
} 

}

II, miałem ten zwyczaj httpclient zdefiniowany w moim kodu:

public HttpClient getNewHttpClient() { 
    try { 
     KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 
     trustStore.load(null, null); 

     MySSLSocketFactory sf = new MySSLSocketFactory(trustStore); 
     sf.setHostnameVerifier(MySSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); 

     HttpParams params = new BasicHttpParams(); 
     HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); 
     HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); 

     SchemeRegistry registry = new SchemeRegistry(); 
     registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); 
     registry.register(new Scheme("https", sf, 443)); 

     ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry); 

     return new DefaultHttpClient(ccm, params); 
    } catch (Exception e) { 
     return new DefaultHttpClient(); 
    } 
} 

trzecie, zadzwoniłem zwyczaj HttpClient i przeanalizował wyniki:

public String test(String URIString) { 
    HttpClient httpClient = getNewHttpClient(); 
    String result = ""; 
    URI uri; 
    try { 
     uri = new URI(URIString); 
    } catch (URISyntaxException e1) { 
     return "ERROR"; 
    } 
    HttpHost host = new HttpHost(uri.getHost(), 443, uri.getScheme()); 
    HttpPost httppost = new HttpPost(uri.getPath()); 
    try { 
     HttpResponse response = httpClient.execute(host, httppost); 
     BufferedReader reader = new BufferedReader(
       new InputStreamReader(
        response.getEntity().getContent() 
       ) 
      ); 
      String line = null; 
      while ((line = reader.readLine()) != null){ 
       result += line + "\n"; 
      } 

      return result; 
    } catch (ClientProtocolException e) { 
     return "ERROR"; 
    } catch (IOException e) { 
     return "ERROR"; 
    } 
} 

Answer 3

Użyj tej i wywołaj tę metodę HttpsTrustManager.allowAllSSL()

Rozwiązuje to problem i działa dobrze dla mnie.

public class HttpsTrustManager realizuje X509TrustManager {

private static TrustManager[] trustManagers; 
private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[]{}; 

@Override 
public void checkClientTrusted( 
     java.security.cert.X509Certificate[] x509Certificates, String s) 
     throws java.security.cert.CertificateException { 

} 

@Override 
public void checkServerTrusted( 
     java.security.cert.X509Certificate[] x509Certificates, String s) 
     throws java.security.cert.CertificateException { 

} 

public boolean isClientTrusted(X509Certificate[] chain) { 
    return true; 
} 

public boolean isServerTrusted(X509Certificate[] chain) { 
    return true; 
} 

@Override 
public X509Certificate[] getAcceptedIssuers() { 
    return _AcceptedIssuers; 
} 

public static void allowAllSSL() { 
    HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() { 

     @Override 
     public boolean verify(String arg0, SSLSession arg1) { 
      return true; 
     } 

    }); 

    SSLContext context = null; 
    if (trustManagers == null) { 
     trustManagers = new TrustManager[]{new HttpsTrustManager()}; 
    } 

    try { 
     context = SSLContext.getInstance("TLS"); 
     context.init(null, trustManagers, new SecureRandom()); 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } catch (KeyManagementException e) { 
     e.printStackTrace(); 
    } 

    HttpsURLConnection.setDefaultSSLSocketFactory(context 
      .getSocketFactory()); 
} 

}