Javax.net.ssl.SSLHandshakeException: javax.net.ssl.SSLProtocolException: négociation SSL interrompue: échec de la bibliothèque SSL, généralement une erreur de protocole

Question

J'essaie d'exécuter le code suivant sous Android

URLConnection l_connection = null; // Create connection uzip=new UnZipData(mContext); l_url = new URL(serverurl); if ("https".equals(l_url.getProtocol())) { System.out.println("<<<<<<<<<<<<< Before TLS >>>>>>>>>>>>"); sslcontext = SSLContext.getInstance("TLS"); System.out.println("<<<<<<<<<<<<< After TLS >>>>>>>>>>>>"); sslcontext.init(null, new TrustManager[] { new CustomTrustManager()}, new Java.security.SecureRandom()); HttpsURLConnection .setDefaultHostnameVerifier(new CustomHostnameVerifier()); HttpsURLConnection.setDefaultSSLSocketFactory(sslcontext .getSocketFactory()); l_connection = (HttpsURLConnection) l_url.openConnection(); ((HttpsURLConnection) l_connection).setRequestMethod("POST"); } else { l_connection = (HttpURLConnection) l_url.openConnection(); ((HttpURLConnection) l_connection).setRequestMethod("POST"); } /*System.setProperty("http.agent", "Android_Phone");*/ l_connection.setConnectTimeout(10000); l_connection.setRequestProperty("Content-Language", "en-US"); l_connection.setUseCaches(false); l_connection.setDoInput(true); l_connection.setDoOutput(true); System.out.println("<<<<<<<<<<<<< Before Connection >>>>>>>>>>>>"); l_connection.connect();

Sur l_connection.connect(), il donne cette exception SSLhandshakeException. Parfois cela fonctionne, mais la plupart du temps cela donne une exception. Cela ne se produit que sur l'émulateur Android 4.0. Je l'ai testé sur Android 4.4 et 5.0, cela fonctionne bien. Quelle pourrait en être la cause? S'il vous plaît aider

TRACE DE LA PILE

 04-28 15:51:13.143: W/System.err(2915): javax.net.ssl.SSLHandshakeException: javax.net.ssl.SSLProtocolException: SSL handshake aborted: ssl=0x870c918: Failure in SSL library, usually a protocol error 04-28 15:51:13.143: W/System.err(2915): error:14077410:SSL routines:SSL23_GET_SERVER_HELLO:sslv3 alert handshake failure (external/openssl/ssl/s23_clnt.c:658 0xb7c393a1:0x00000000) 04-28 15:51:13.143: W/System.err(2915): at org.Apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl.startHandshake(OpenSSLSocketImpl.Java:460) 04-28 15:51:13.143: W/System.err(2915): at org.Apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl.startHandshake(OpenSSLSocketImpl.Java:257) 04-28 15:51:13.143: W/System.err(2915): at libcore.net.http.HttpConnection.setupSecureSocket(HttpConnection.Java:210) 04-28 15:51:13.143: W/System.err(2915): at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.makeSslConnection(HttpsURLConnectionImpl.Java:477) 04-28 15:51:13.153: W/System.err(2915): at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.connect(HttpsURLConnectionImpl.Java:441) 04-28 15:51:13.153: W/System.err(2915): at libcore.net.http.HttpEngine.sendSocketRequest(HttpEngine.Java:282) 04-28 15:51:13.153: W/System.err(2915): at libcore.net.http.HttpEngine.sendRequest(HttpEngine.Java:232) 04-28 15:51:13.153: W/System.err(2915): at libcore.net.http.HttpURLConnectionImpl.connect(HttpURLConnectionImpl.Java:80) 04-28 15:51:13.153: W/System.err(2915): at libcore.net.http.HttpsURLConnectionImpl.connect(HttpsURLConnectionImpl.Java:164) 04-28 15:51:13.153: W/System.err(2915): at com.ofss.fcdb.mobile.Android.rms.helpers.NetworkConnector.getConnection(NetworkConnector.Java:170) 04-28 15:51:13.153: W/System.err(2915): at com.ofss.fcdb.mobile.Android.rms.util.InitiateRMS$2.run(InitiateRMS.Java:221) 04-28 15:51:13.153: W/System.err(2915): at Java.lang.Thread.run(Thread.Java:856) 04-28 15:51:13.153: W/System.err(2915): Caused by: javax.net.ssl.SSLProtocolException: SSL handshake aborted: ssl=0x870c918: Failure in SSL library, usually a protocol error 04-28 15:51:13.153: W/System.err(2915): error:14077410:SSL routines:SSL23_GET_SERVER_HELLO:sslv3 alert handshake failure (external/openssl/ssl/s23_clnt.c:658 0xb7c393a1:0x00000000) 04-28 15:51:13.153: W/System.err(2915): at org.Apache.harmony.xnet.provider.jsse.NativeCrypto.SSL_do_handshake(Native Method) 04-28 15:51:13.153: W/System.err(2915): at org.Apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl.startHandshake(OpenSSLSocketImpl.Java:410) 04-28 15:51:13.153: W/System.err(2915): ... 11 more 04-28 16:42:44.139: W/ResourceType(3140): No package identifier when getting value for resource number 0x00000000

Bhavit S. Sengar · Accepted Answer

J'ai trouvé la solution en analysant les paquets de données à l'aide de Wireshark. Ce que j’ai trouvé, c’est que lorsqu’il établissait une connexion sécurisée, Android retombait sur SSLv3 de TLSv1. Il s’agit d’un bogue dans les versions Android <4.4, et il peut être résolu en supprimant le protocole SSLv3 de la liste des protocoles activés. J'ai créé une classe socketFactory personnalisée appelée NoSSLv3SocketFactory.Java. Utilisez ceci pour créer une socketfactory.

/*Copyright 2015 Bhavit Singh Sengar Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.You may obtain a copy of the License at http://www.Apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.*/ import Java.io.IOException; import Java.io.InputStream; import Java.io.OutputStream; import Java.net.InetAddress; import Java.net.Socket; import Java.net.SocketAddress; import Java.net.SocketException; import Java.nio.channels.SocketChannel; import Java.util.ArrayList; import Java.util.Arrays; import Java.util.List; import javax.net.ssl.HandshakeCompletedListener; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLSession; import javax.net.ssl.SSLSocket; import javax.net.ssl.SSLSocketFactory; public class NoSSLv3SocketFactory extends SSLSocketFactory{ private final SSLSocketFactory delegate; public NoSSLv3SocketFactory() { this.delegate = HttpsURLConnection.getDefaultSSLSocketFactory(); } public NoSSLv3SocketFactory(SSLSocketFactory delegate) { this.delegate = delegate; } @Override public String[] getDefaultCipherSuites() { return delegate.getDefaultCipherSuites(); } @Override public String[] getSupportedCipherSuites() { return delegate.getSupportedCipherSuites(); } private Socket makeSocketSafe(Socket socket) { if (socket instanceof SSLSocket) { socket = new NoSSLv3SSLSocket((SSLSocket) socket); } return socket; } @Override public Socket createSocket(Socket s, String Host, int port, boolean autoClose) throws IOException { return makeSocketSafe(delegate.createSocket(s, Host, port, autoClose)); } @Override public Socket createSocket(String Host, int port) throws IOException { return makeSocketSafe(delegate.createSocket(Host, port)); } @Override public Socket createSocket(String Host, int port, InetAddress localHost, int localPort) throws IOException { return makeSocketSafe(delegate.createSocket(Host, port, localHost, localPort)); } @Override public Socket createSocket(InetAddress Host, int port) throws IOException { return makeSocketSafe(delegate.createSocket(Host, port)); } @Override public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException { return makeSocketSafe(delegate.createSocket(address, port, localAddress, localPort)); } private class NoSSLv3SSLSocket extends DelegateSSLSocket { private NoSSLv3SSLSocket(SSLSocket delegate) { super(delegate); } @Override public void setEnabledProtocols(String[] protocols) { if (protocols != null && protocols.length == 1 && "SSLv3".equals(protocols[0])) { List<String> enabledProtocols = new ArrayList<String>(Arrays.asList(delegate.getEnabledProtocols())); if (enabledProtocols.size() > 1) { enabledProtocols.remove("SSLv3"); System.out.println("Removed SSLv3 from enabled protocols"); } else { System.out.println("SSL stuck with protocol available for " + String.valueOf(enabledProtocols)); } protocols = enabledProtocols.toArray(new String[enabledProtocols.size()]); } super.setEnabledProtocols(protocols); } } public class DelegateSSLSocket extends SSLSocket { protected final SSLSocket delegate; DelegateSSLSocket(SSLSocket delegate) { this.delegate = delegate; } @Override public String[] getSupportedCipherSuites() { return delegate.getSupportedCipherSuites(); } @Override public String[] getEnabledCipherSuites() { return delegate.getEnabledCipherSuites(); } @Override public void setEnabledCipherSuites(String[] suites) { delegate.setEnabledCipherSuites(suites); } @Override public String[] getSupportedProtocols() { return delegate.getSupportedProtocols(); } @Override public String[] getEnabledProtocols() { return delegate.getEnabledProtocols(); } @Override public void setEnabledProtocols(String[] protocols) { delegate.setEnabledProtocols(protocols); } @Override public SSLSession getSession() { return delegate.getSession(); } @Override public void addHandshakeCompletedListener(HandshakeCompletedListener listener) { delegate.addHandshakeCompletedListener(listener); } @Override public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) { delegate.removeHandshakeCompletedListener(listener); } @Override public void startHandshake() throws IOException { delegate.startHandshake(); } @Override public void setUseClientMode(boolean mode) { delegate.setUseClientMode(mode); } @Override public boolean getUseClientMode() { return delegate.getUseClientMode(); } @Override public void setNeedClientAuth(boolean need) { delegate.setNeedClientAuth(need); } @Override public void setWantClientAuth(boolean want) { delegate.setWantClientAuth(want); } @Override public boolean getNeedClientAuth() { return delegate.getNeedClientAuth(); } @Override public boolean getWantClientAuth() { return delegate.getWantClientAuth(); } @Override public void setEnableSessionCreation(boolean flag) { delegate.setEnableSessionCreation(flag); } @Override public boolean getEnableSessionCreation() { return delegate.getEnableSessionCreation(); } @Override public void bind(SocketAddress localAddr) throws IOException { delegate.bind(localAddr); } @Override public synchronized void close() throws IOException { delegate.close(); } @Override public void connect(SocketAddress remoteAddr) throws IOException { delegate.connect(remoteAddr); } @Override public void connect(SocketAddress remoteAddr, int timeout) throws IOException { delegate.connect(remoteAddr, timeout); } @Override public SocketChannel getChannel() { return delegate.getChannel(); } @Override public InetAddress getInetAddress() { return delegate.getInetAddress(); } @Override public InputStream getInputStream() throws IOException { return delegate.getInputStream(); } @Override public boolean getKeepAlive() throws SocketException { return delegate.getKeepAlive(); } @Override public InetAddress getLocalAddress() { return delegate.getLocalAddress(); } @Override public int getLocalPort() { return delegate.getLocalPort(); } @Override public SocketAddress getLocalSocketAddress() { return delegate.getLocalSocketAddress(); } @Override public boolean getOOBInline() throws SocketException { return delegate.getOOBInline(); } @Override public OutputStream getOutputStream() throws IOException { return delegate.getOutputStream(); } @Override public int getPort() { return delegate.getPort(); } @Override public synchronized int getReceiveBufferSize() throws SocketException { return delegate.getReceiveBufferSize(); } @Override public SocketAddress getRemoteSocketAddress() { return delegate.getRemoteSocketAddress(); } @Override public boolean getReuseAddress() throws SocketException { return delegate.getReuseAddress(); } @Override public synchronized int getSendBufferSize() throws SocketException { return delegate.getSendBufferSize(); } @Override public int getSoLinger() throws SocketException { return delegate.getSoLinger(); } @Override public synchronized int getSoTimeout() throws SocketException { return delegate.getSoTimeout(); } @Override public boolean getTcpNoDelay() throws SocketException { return delegate.getTcpNoDelay(); } @Override public int getTrafficClass() throws SocketException { return delegate.getTrafficClass(); } @Override public boolean isBound() { return delegate.isBound(); } @Override public boolean isClosed() { return delegate.isClosed(); } @Override public boolean isConnected() { return delegate.isConnected(); } @Override public boolean isInputShutdown() { return delegate.isInputShutdown(); } @Override public boolean isOutputShutdown() { return delegate.isOutputShutdown(); } @Override public void sendUrgentData(int value) throws IOException { delegate.sendUrgentData(value); } @Override public void setKeepAlive(boolean keepAlive) throws SocketException { delegate.setKeepAlive(keepAlive); } @Override public void setOOBInline(boolean oobinline) throws SocketException { delegate.setOOBInline(oobinline); } @Override public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { delegate.setPerformancePreferences(connectionTime, latency, bandwidth); } @Override public synchronized void setReceiveBufferSize(int size) throws SocketException { delegate.setReceiveBufferSize(size); } @Override public void setReuseAddress(boolean reuse) throws SocketException { delegate.setReuseAddress(reuse); } @Override public synchronized void setSendBufferSize(int size) throws SocketException { delegate.setSendBufferSize(size); } @Override public void setSoLinger(boolean on, int timeout) throws SocketException { delegate.setSoLinger(on, timeout); } @Override public synchronized void setSoTimeout(int timeout) throws SocketException { delegate.setSoTimeout(timeout); } @Override public void setTcpNoDelay(boolean on) throws SocketException { delegate.setTcpNoDelay(on); } @Override public void setTrafficClass(int value) throws SocketException { delegate.setTrafficClass(value); } @Override public void shutdownInput() throws IOException { delegate.shutdownInput(); } @Override public void shutdownOutput() throws IOException { delegate.shutdownOutput(); } @Override public String toString() { return delegate.toString(); } @Override public boolean equals(Object o) { return delegate.equals(o); } } }

Utilisez cette classe comme ceci lors de la connexion:

SSLContext sslcontext = SSLContext.getInstance("TLSv1"); sslcontext.init(null, null, null); SSLSocketFactory NoSSLv3Factory = new NoSSLv3SocketFactory(sslcontext.getSocketFactory()); HttpsURLConnection.setDefaultSSLSocketFactory(NoSSLv3Factory); l_connection = (HttpsURLConnection) l_url.openConnection(); l_connection.connect();

METTRE À JOUR :

Maintenant, la solution correcte serait d'installer un fournisseur de sécurité plus récent en utilisant Services Google Play :

 ProviderInstaller.installIfNeeded(getApplicationContext());

Cela donne effectivement à votre application un accès à une version plus récente d'OpenSSL et du fournisseur de sécurité Java, qui inclut la prise en charge de TLSv1.2 dans SSLEngine. Une fois le nouveau fournisseur installé, vous pouvez créer un SSLEngine qui prend en charge SSLv3, TLSv1, TLSv1.1 et TLSv1.2 de la manière habituelle:

 SSLContext sslContext = SSLContext.getInstance("TLSv1.2"); sslContext.init(null, null, null); SSLEngine engine = sslContext.createSSLEngine();

Ou vous pouvez restreindre les protocoles activés à l'aide de engine.setEnabledProtocols.

N'oubliez pas d'ajouter la dépendance suivante ( dernière version trouvée ici ):

compile 'com.google.Android.gms:play-services-auth:11.8.0'

Pour plus d'informations, consultez ce link .

Maurice Gavin · Answer

Scénario

Je recevais des exceptions SSLHandshake sur des appareils exécutant des versions d'Android antérieures à Android 5.0. Dans mon cas d'utilisation, je souhaitais également créer un TrustManager pour faire confiance à mon certificat client.

J'ai mis en œuvre NoSSLv3SocketFactory et NoSSLv3Factory pour supprimer SSLv3 de la liste des protocoles pris en charge par mon client, mais aucune de ces solutions ne pouvait fonctionner.

Certaines choses que j'ai apprises:

Sur les appareils antérieurs à Android 5.0, les protocoles TLSv1.1 et TLSv1.2 ne sont pas activés par défaut.
Le protocole SSLv3 n'est pas désactivé par défaut sur les périphériques antérieurs à Android 5.0.
SSLv3 n'est pas un protocole sécurisé et il est donc souhaitable de le supprimer de la liste des protocoles pris en charge par notre client avant qu'une connexion ne soit établie.

Ce qui a fonctionné pour moi

Autoriser la sécurité Provider d'Android à se mettre à jour au démarrage de votre application.

Le fournisseur par défaut avant la version 5.0+ ne désactive pas SSLv3. Si vous avez accès aux services Google Play, il est relativement simple de corriger le fournisseur de sécurité d'Android à partir de votre application.

private void updateAndroidSecurityProvider(Activity callingActivity) { try { ProviderInstaller.installIfNeeded(this); } catch (GooglePlayServicesRepairableException e) { // Thrown when Google Play Services is not installed, up-to-date, or enabled // Show dialog to allow users to install, update, or otherwise enable Google Play services. GooglePlayServicesUtil.getErrorDialog(e.getConnectionStatusCode(), callingActivity, 0); } catch (GooglePlayServicesNotAvailableException e) { Log.e("SecurityException", "Google Play Services not available."); } }

Si vous créez maintenant votre OkHttpClient ou votre HttpURLConnection, TLSv1.1 et TLSv1.2 doivent être disponibles en tant que protocoles et SSLv3 doit être supprimé. Si le client/la connexion (ou plus précisément SSLContext) a été initialisé avant d'appeler ProviderInstaller.installIfNeeded(...), il devra être recréé.

N'oubliez pas d'ajouter la dépendance suivante ( dernière version trouvée ici ):

compile 'com.google.Android.gms:play-services-auth:16.0.1'

Sources:

De côté

Je n'avais pas besoin de définir explicitement les algorithmes de chiffrement que mon client devait utiliser, mais j'ai trouvé un message SO recommandant ceux considérés comme les plus sécurisés au moment de la rédaction: Quelles suites de chiffrement activer pour SSL Socket?

Mayur Gangurde · Answer

Vous devez également savoir que vous pouvez forcer TLS v1.2 pour les périphériques Android 4.0 qui ne l’ont pas activé par défaut:

Cela devrait être dans la première ligne de votre application:

try { ProviderInstaller.installIfNeeded(getApplicationContext()); SSLContext sslContext; sslContext = SSLContext.getInstance("TLSv1.2"); sslContext.init(null, null, null); sslContext.createSSLEngine(); } catch (GooglePlayServicesRepairableException | GooglePlayServicesNotAvailableException | NoSuchAlgorithmException | KeyManagementException e) { e.printStackTrace(); }

Fragment · Answer

Auparavant, j'avais également résolu ce problème avec l'implémentation personnalisée SSLFactory, mais selon OkHttp docs la solution est beaucoup plus simple.

Ma solution finale avec les chiffrements TLS nécessaires pour les périphériques 4.2+ ressemble à ceci:

public UsersApi provideUsersApi() { private ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.COMPATIBLE_TLS) .supportsTlsExtensions(true) .tlsVersions(TlsVersion.TLS_1_2, TlsVersion.TLS_1_1, TlsVersion.TLS_1_0) .cipherSuites( CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, CipherSuite.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, CipherSuite.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, CipherSuite.TLS_ECDHE_RSA_WITH_RC4_128_SHA, CipherSuite.TLS_DHE_RSA_WITH_AES_128_CBC_SHA, CipherSuite.TLS_DHE_DSS_WITH_AES_128_CBC_SHA, CipherSuite.TLS_DHE_RSA_WITH_AES_256_CBC_SHA) .build(); OkHttpClient client = new OkHttpClient.Builder() .connectionSpecs(Collections.singletonList(spec)) .build(); return new Retrofit.Builder() .baseUrl(USERS_URL) .addConverterFactory(GsonConverterFactory.create()) .client(client) .build() .create(UsersApi.class); }

Notez que cet ensemble de protocoles pris en charge dépend de la configuration de votre serveur.

littlenoname · Answer

Cela a résolu le problème pour moi:

La documentation Android pour SSLSocket indique que TLS 1.1 et TLS 1.2 sont pris en charge par l'API de démarrage Android de niveau 16+ (Android 4.1, Jelly bean). Mais il est désactivé par défaut, mais à compter du niveau 20 (API Android 4.4 pour Watch, KitKat Watch et Android 5.0 pour téléphone, Lollipop), ils sont activés. Mais il est très difficile de trouver de la documentation sur la façon de l'activer pour les téléphones fonctionnant sous 4.1 par exemple . Pour activer TLS 1.1 et 1.2, vous devez créer un SSLSocketFactory personnalisé qui envoie par proxy tous les appels à une implémentation SSLSocketFactory par défaut. En plus de cela, nous devons remplacer toutes les méthodes createSocket et callsetEnabledProtocols sur le SSLSocket retourné pour activer TLS 1.1 et TLS 1.2. Pour un exemple d'implémentation, suivez le lien ci-dessous.

Android 4.1. active tls1.1 et tls 1.2

yifan · Answer

Il était reproductible uniquement lorsque j'utilise le proxy sur genymotion (<4.4).

Vérifiez vos paramètres de proxy dans Paramètres-> Sans fil et réseaux-> WiFi -> (Appuyez longuement sur WiredSSID) -> Modifier le réseau

Sélectionnez Afficher les options avancées: Définissez les paramètres du proxy sur NONE.

Wowo Ot · Answer

Ma réponse est proche des réponses ci-dessus, mais vous devez écrire la classe exactement sans rien changer.

public class TLSSocketFactory extends SSLSocketFactory { private SSLSocketFactory delegate; public TLSSocketFactory() throws KeyManagementException, NoSuchAlgorithmException { SSLContext context = SSLContext.getInstance("TLS"); context.init(null, null, null); delegate = context.getSocketFactory(); } @Override public String[] getDefaultCipherSuites() { return delegate.getDefaultCipherSuites(); } @Override public String[] getSupportedCipherSuites() { return delegate.getSupportedCipherSuites(); } @Override public Socket createSocket() throws IOException { return enableTLSOnSocket(delegate.createSocket()); } @Override public Socket createSocket(Socket s, String Host, int port, boolean autoClose) throws IOException { return enableTLSOnSocket(delegate.createSocket(s, Host, port, autoClose)); } @Override public Socket createSocket(String Host, int port) throws IOException, UnknownHostException { return enableTLSOnSocket(delegate.createSocket(Host, port)); } @Override public Socket createSocket(String Host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException { return enableTLSOnSocket(delegate.createSocket(Host, port, localHost, localPort)); } @Override public Socket createSocket(InetAddress Host, int port) throws IOException { return enableTLSOnSocket(delegate.createSocket(Host, port)); } @Override public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException { return enableTLSOnSocket(delegate.createSocket(address, port, localAddress, localPort)); } private Socket enableTLSOnSocket(Socket socket) { if(socket != null && (socket instanceof SSLSocket)) { ((SSLSocket)socket).setEnabledProtocols(new String[] {"TLSv1.1", "TLSv1.2"}); } return socket; }

}

et de l'utiliser avec HttpsURLConnection

HttpsURLConnection conn = (HttpsURLConnection) url.openConnection(); int sdk = Android.os.Build.VERSION.SDK_INT; if (sdk < Build.VERSION_CODES.Lollipop) { if (url.toString().startsWith("https")) { try { TLSSocketFactory sc = new TLSSocketFactory(); conn.setSSLSocketFactory(sc); } catch (Exception e) { String sss = e.toString(); } } }

Girish Patel · Answer

J'ai résolu le problème par ceci: NoSSLv3SocketFactory.Java

import Java.io.IOException; import Java.io.InputStream; import Java.io.OutputStream; import Java.net.InetAddress; import Java.net.Socket; import Java.net.SocketAddress; import Java.net.SocketException; import Java.nio.channels.SocketChannel; import Java.util.ArrayList; import Java.util.Arrays; import Java.util.List; import javax.net.ssl.HandshakeCompletedListener; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLSession; import javax.net.ssl.SSLSocket; import javax.net.ssl.SSLSocketFactory; public class NoSSLv3SocketFactory extends SSLSocketFactory { private final SSLSocketFactory delegate; public NoSSLv3SocketFactory() { this.delegate = HttpsURLConnection.getDefaultSSLSocketFactory(); } public NoSSLv3SocketFactory(SSLSocketFactory delegate) { this.delegate = delegate; } @Override public String[] getDefaultCipherSuites() { return delegate.getDefaultCipherSuites(); } @Override public String[] getSupportedCipherSuites() { return delegate.getSupportedCipherSuites(); } private Socket makeSocketSafe(Socket socket) { if (socket instanceof SSLSocket) { socket = new NoSSLv3SSLSocket((SSLSocket) socket); } return socket; } @Override public Socket createSocket(Socket s, String Host, int port, boolean autoClose) throws IOException { return makeSocketSafe(delegate.createSocket(s, Host, port, autoClose)); } @Override public Socket createSocket(String Host, int port) throws IOException { return makeSocketSafe(delegate.createSocket(Host, port)); } @Override public Socket createSocket(String Host, int port, InetAddress localHost, int localPort) throws IOException { return makeSocketSafe(delegate.createSocket(Host, port, localHost, localPort)); } @Override public Socket createSocket(InetAddress Host, int port) throws IOException { return makeSocketSafe(delegate.createSocket(Host, port)); } @Override public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException { return makeSocketSafe(delegate.createSocket(address, port, localAddress, localPort)); } private class NoSSLv3SSLSocket extends DelegateSSLSocket { private NoSSLv3SSLSocket(SSLSocket delegate) { super(delegate); } @Override public void setEnabledProtocols(String[] protocols) { if (protocols != null && protocols.length == 1 && "SSLv3".equals(protocols[0])) { List<String> enabledProtocols = new ArrayList<String>( Arrays.asList(delegate.getEnabledProtocols())); if (enabledProtocols.size() > 1) { enabledProtocols.remove("SSLv3"); System.out.println("Removed SSLv3 from enabled protocols"); } else { System.out.println("SSL stuck with protocol available for " + String.valueOf(enabledProtocols)); } protocols = enabledProtocols .toArray(new String[enabledProtocols.size()]); } // super.setEnabledProtocols(protocols); super.setEnabledProtocols(new String[]{"TLSv1.2"}); } } public class DelegateSSLSocket extends SSLSocket { protected final SSLSocket delegate; DelegateSSLSocket(SSLSocket delegate) { this.delegate = delegate; } @Override public String[] getSupportedCipherSuites() { return delegate.getSupportedCipherSuites(); } @Override public String[] getEnabledCipherSuites() { return delegate.getEnabledCipherSuites(); } @Override public void setEnabledCipherSuites(String[] suites) { delegate.setEnabledCipherSuites(suites); } @Override public String[] getSupportedProtocols() { return delegate.getSupportedProtocols(); } @Override public String[] getEnabledProtocols() { return delegate.getEnabledProtocols(); } @Override public void setEnabledProtocols(String[] protocols) { delegate.setEnabledProtocols(protocols); } @Override public SSLSession getSession() { return delegate.getSession(); } @Override public void addHandshakeCompletedListener( HandshakeCompletedListener listener) { delegate.addHandshakeCompletedListener(listener); } @Override public void removeHandshakeCompletedListener( HandshakeCompletedListener listener) { delegate.removeHandshakeCompletedListener(listener); } @Override public void startHandshake() throws IOException { delegate.startHandshake(); } @Override public void setUseClientMode(boolean mode) { delegate.setUseClientMode(mode); } @Override public boolean getUseClientMode() { return delegate.getUseClientMode(); } @Override public void setNeedClientAuth(boolean need) { delegate.setNeedClientAuth(need); } @Override public void setWantClientAuth(boolean want) { delegate.setWantClientAuth(want); } @Override public boolean getNeedClientAuth() { return delegate.getNeedClientAuth(); } @Override public boolean getWantClientAuth() { return delegate.getWantClientAuth(); } @Override public void setEnableSessionCreation(boolean flag) { delegate.setEnableSessionCreation(flag); } @Override public boolean getEnableSessionCreation() { return delegate.getEnableSessionCreation(); } @Override public void bind(SocketAddress localAddr) throws IOException { delegate.bind(localAddr); } @Override public synchronized void close() throws IOException { delegate.close(); } @Override public void connect(SocketAddress remoteAddr) throws IOException { delegate.connect(remoteAddr); } @Override public void connect(SocketAddress remoteAddr, int timeout) throws IOException { delegate.connect(remoteAddr, timeout); } @Override public SocketChannel getChannel() { return delegate.getChannel(); } @Override public InetAddress getInetAddress() { return delegate.getInetAddress(); } @Override public InputStream getInputStream() throws IOException { return delegate.getInputStream(); } @Override public boolean getKeepAlive() throws SocketException { return delegate.getKeepAlive(); } @Override public InetAddress getLocalAddress() { return delegate.getLocalAddress(); } @Override public int getLocalPort() { return delegate.getLocalPort(); } @Override public SocketAddress getLocalSocketAddress() { return delegate.getLocalSocketAddress(); } @Override public boolean getOOBInline() throws SocketException { return delegate.getOOBInline(); } @Override public OutputStream getOutputStream() throws IOException { return delegate.getOutputStream(); } @Override public int getPort() { return delegate.getPort(); } @Override public synchronized int getReceiveBufferSize() throws SocketException { return delegate.getReceiveBufferSize(); } @Override public SocketAddress getRemoteSocketAddress() { return delegate.getRemoteSocketAddress(); } @Override public boolean getReuseAddress() throws SocketException { return delegate.getReuseAddress(); } @Override public synchronized int getSendBufferSize() throws SocketException { return delegate.getSendBufferSize(); } @Override public int getSoLinger() throws SocketException { return delegate.getSoLinger(); } @Override public synchronized int getSoTimeout() throws SocketException { return delegate.getSoTimeout(); } @Override public boolean getTcpNoDelay() throws SocketException { return delegate.getTcpNoDelay(); } @Override public int getTrafficClass() throws SocketException { return delegate.getTrafficClass(); } @Override public boolean isBound() { return delegate.isBound(); } @Override public boolean isClosed() { return delegate.isClosed(); } @Override public boolean isConnected() { return delegate.isConnected(); } @Override public boolean isInputShutdown() { return delegate.isInputShutdown(); } @Override public boolean isOutputShutdown() { return delegate.isOutputShutdown(); } @Override public void sendUrgentData(int value) throws IOException { delegate.sendUrgentData(value); } @Override public void setKeepAlive(boolean keepAlive) throws SocketException { delegate.setKeepAlive(keepAlive); } @Override public void setOOBInline(boolean oobinline) throws SocketException { delegate.setOOBInline(oobinline); } @Override public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { delegate.setPerformancePreferences(connectionTime, latency, bandwidth); } @Override public synchronized void setReceiveBufferSize(int size) throws SocketException { delegate.setReceiveBufferSize(size); } @Override public void setReuseAddress(boolean reuse) throws SocketException { delegate.setReuseAddress(reuse); } @Override public synchronized void setSendBufferSize(int size) throws SocketException { delegate.setSendBufferSize(size); } @Override public void setSoLinger(boolean on, int timeout) throws SocketException { delegate.setSoLinger(on, timeout); } @Override public synchronized void setSoTimeout(int timeout) throws SocketException { delegate.setSoTimeout(timeout); } @Override public void setTcpNoDelay(boolean on) throws SocketException { delegate.setTcpNoDelay(on); } @Override public void setTrafficClass(int value) throws SocketException { delegate.setTrafficClass(value); } @Override public void shutdownInput() throws IOException { delegate.shutdownInput(); } @Override public void shutdownOutput() throws IOException { delegate.shutdownOutput(); } @Override public String toString() { return delegate.toString(); } @Override public boolean equals(Object o) { return delegate.equals(o); } } }

Classe principale:

URL url = new URL("https://www.example.com/test.png"); URLConnection l_connection = null; SSLContext sslcontext = SSLContext.getInstance("TLSv1.2"); sslcontext.init(null, null, null); SSLSocketFactory NoSSLv3Factory = new NoSSLv3SocketFactory(sslcontext.getSocketFactory());

Gumby The Green · Answer

Lorsque j'ai eu cette erreur, c'est parce que les protocoles (versions TLS) et/ou les suites de chiffrement pris en charge par le serveur n'étaient pas activés sur le périphérique (et même éventuellement pas par celui-ci). Pour l'API 16-19, TLSv1.1 et TLSv1.2 sont pris en charge mais ne sont pas activés par défaut. Une fois que je les ai activées pour ces versions, le problème persiste car ces versions ne prennent en charge aucun des chiffrements sur notre instance AWS CloudFront.

Comme il n’est pas possible d’ajouter des chiffrements à Android, nous avons dû passer de TLSv1.2_2018 à TLSv1.1_2016 (qui ne prend toujours pas en charge TLSv1.2; il n’en a pas besoin) les versions antérieures d'Android, dont deux sont toujours considérées comme solides.

À ce stade, l'erreur a disparu et les appels ont été acheminés (avec TLSv1.2) car il existait au moins un protocole et au moins un chiffre partagé par le périphérique et le serveur.

Reportez-vous à les tableaux de cette page pour voir quels protocoles et quels chiffrements sont supportés et activés sur quelles versions d’Android.

Maintenant, Android essayait-il vraiment d’utiliser SSLv3 comme l’impliquait la partie "Échec de la négociation de l’alerte sslv3" du message d’erreur? J'en doute; Je soupçonne que ceci est une vieille toile d'araignée dans la bibliothèque SSL qui n'a pas été nettoyée mais je ne peux pas le dire avec certitude.

Afin d’activer TLSv1.2 (et TLSv1.1), j’ai pu utiliser une variable SSLSocketFactory beaucoup plus simple que celles vues ailleurs (comme NoSSLv3SocketFactory). Il s'assure simplement que les protocoles activés incluent tous les protocoles pris en charge et que les chiffrements activés incluent tous les chiffrements pris en charge (ce dernier n'était pas nécessaire pour moi, mais pourrait l'être pour d'autres) - voir configure() en bas. Si vous préférez activer uniquement les derniers protocoles, vous pouvez remplacer socket.supportedProtocols par quelque chose comme arrayOf("TLSv1.1", "TLSv1.2") (de même pour les chiffrements):

class TLSSocketFactory : SSLSocketFactory() { private val socketFactory: SSLSocketFactory init { val sslContext = SSLContext.getInstance("TLS") sslContext.init(null, null, null) socketFactory = sslContext.socketFactory } override fun getDefaultCipherSuites(): Array<String> { return socketFactory.defaultCipherSuites } override fun getSupportedCipherSuites(): Array<String> { return socketFactory.supportedCipherSuites } override fun createSocket(s: Socket, Host: String, port: Int, autoClose: Boolean): Socket { return configure(socketFactory.createSocket(s, Host, port, autoClose) as SSLSocket) } override fun createSocket(Host: String, port: Int): Socket { return configure(socketFactory.createSocket(Host, port) as SSLSocket) } override fun createSocket(Host: InetAddress, port: Int): Socket { return configure(socketFactory.createSocket(Host, port) as SSLSocket) } override fun createSocket(Host: String, port: Int, localHost: InetAddress, localPort: Int): Socket { return configure(socketFactory.createSocket(Host, port, localHost, localPort) as SSLSocket) } override fun createSocket(address: InetAddress, port: Int, localAddress: InetAddress, localPort: Int): Socket { return configure(socketFactory.createSocket(address, port, localAddress, localPort) as SSLSocket) } private fun configure(socket: SSLSocket): SSLSocket { socket.enabledProtocols = socket.supportedProtocols socket.enabledCipherSuites = socket.supportedCipherSuites return socket } }

X.Professor · Answer

J'ai aussi ce problème de rapport d'erreur. Mon code est ci-dessous.

public static void getShop() throws Exception { new Thread(new Runnable() { @Override public void run() { try { OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("https://10.0.2.2:8010/getShopInfo/aaa") .build(); Response response = client.newCall(request).execute(); Log.d("response", response.body().string()); } catch (Exception e) { e.printStackTrace(); } } }).start(); }

J'ai mon Springboot comme serveur principal et j'utilise Android OKHttp pour obtenir des informations. L'erreur critique que j'ai commise est d'utiliser un .url ( "https : //10.0.2.2: 8010/getShopInfo/aaa") dans le code d'Android. Mais la mon backend n'est pas autorisé demande https. Après avoir utilisé .url (" http : //10.0.2.2: 8010/getShopInfo/aaa") , mon code s’est bien passé. Donc, je veux dire que mon erreur n’est pas la version de l’émulateur, c’est le protocole de requête. Je rencontre un autre problème après avoir fait ce que j'ai dit, mais c'est un autre problème et j'attache la méthode de résolution du nouveau problème.
Bonne chance! GUY!