Ricevuto avviso irreversibile: handshake_failure tramite SSLHandshakeException


134

Ho un problema con la connessione SSL autorizzata. Ho creato Struts Action che si collega al server esterno con il certificato SSL autorizzato dal client. Nella mia azione sto provando a inviare alcuni dati al server della banca ma senza fortuna, perché ho come risultato dal server il seguente errore:

error: javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure

Il mio metodo dalla mia classe Action che invia dati al server

//Getting external IP from host
    URL whatismyip = new URL("http://automation.whatismyip.com/n09230945.asp");
    BufferedReader inIP = new BufferedReader(new InputStreamReader(whatismyip.openStream()));

    String IPStr = inIP.readLine(); //IP as a String

    Merchant merchant;

    System.out.println("amount: " + amount + ", currency: " + currency + ", clientIp: " + IPStr + ", description: " + description);

    try {

        merchant = new Merchant(context.getRealPath("/") + "merchant.properties");

    } catch (ConfigurationException e) {

        Logger.getLogger(HomeAction.class.getName()).log(Level.INFO, "message", e);
        System.err.println("error: " + e.getMessage());
        return ERROR;
    }

    String result = merchant.sendTransData(amount, currency, IPStr, description);

    System.out.println("result: " + result);

    return SUCCESS;

Il mio file merchant.properties:

bank.server.url=https://-servernameandport-/
https.cipher=-cipher-

keystore.file=-key-.jks
keystore.type=JKS
keystore.password=-password-
ecomm.server.version=2.0

encoding.source=UTF-8
encoding.native=UTF-8

Per la prima volta ho pensato che si trattasse di un problema con il certificato, l'ho convertito da .pfx a .jks, ma ho lo stesso errore, senza modifiche.


hai aggiunto il certificato SSL del server al tuo truststore?
Happymeal,

scusa, non capisco cosa significhi, sono nuovo su SSL
Denees,

suppongo che la tua app stia utilizzando il truststore predefinito java. Il truststore predefinito è <java-home> / lib / security / cacerts. apri l'URL del server con il tuo browser e scarica tutti i certificati SSL; comprese eventuali catene / certificati intermedi. quindi aggiungi tutti questi certificati al truststore.
Happymeal,

Non riesco ad aprire l'URL nel browser, a causa del certificato di autenticazione client, posso inviare a questo link solo parametri specifici che ottengo dai client.
Denees,

basta aprire l'URL. ignora tutti gli errori che vedi sul tuo browser. quando accedi all'URL, dovresti vedere l'icona di un lucchetto sulla barra degli indirizzi del tuo browser. cliccaci sopra e scarica il certificato SSL del server.
Happymeal,

Risposte:


251

Il fallimento della stretta di mano potrebbe essersi verificato per vari motivi:

  • Suite di cifratura incompatibili utilizzate dal client e dal server. Ciò richiederebbe al client di utilizzare (o abilitare) una suite di crittografia supportata dal server.
  • Versioni incompatibili di SSL in uso (il server potrebbe accettare solo TLS v1, mentre il client è in grado di utilizzare solo SSL v3). Ancora una volta, il client potrebbe dover assicurarsi di utilizzare una versione compatibile del protocollo SSL / TLS.
  • Percorso di trust incompleto per il certificato del server; il certificato del server probabilmente non è considerato attendibile dal client. Ciò comporterebbe generalmente un errore più dettagliato, ma è del tutto possibile. Di solito la correzione consiste nell'importare il certificato CA del server nel truststore del client.
  • Il certificato viene rilasciato per un dominio diverso. Ancora una volta, ciò avrebbe comportato un messaggio più dettagliato, ma indicherò la correzione qui nel caso in cui questa sia la causa. La risoluzione in questo caso sarebbe ottenere il server (non sembra essere tuo) per utilizzare il certificato corretto.

Poiché l'errore sottostante non può essere individuato, è meglio attivare il -Djavax.net.debug=allflag per abilitare il debug della connessione SSL stabilita. Con il debug attivato, è possibile individuare quale attività nell'handshake non è riuscita.

Aggiornare

Sulla base dei dettagli ora disponibili, sembra che il problema sia dovuto a un percorso di affidabilità del certificato incompleto tra il certificato emesso sul server e una CA principale. Nella maggior parte dei casi, ciò è dovuto al fatto che il certificato della CA principale è assente nel truststore, portando alla situazione in cui non può esistere un percorso sicuro del certificato; il certificato non è sostanzialmente attendibile dal client. I browser possono presentare un avviso in modo che gli utenti possano ignorarlo, ma lo stesso non è il caso dei client SSL (come la classe HttpsURLConnection o qualsiasi libreria client HTTP come Apache HttpComponents Client ).

La maggior parte di queste classi / librerie client farebbe affidamento sull'archivio di fiducia utilizzato da JVM per la convalida del certificato. Nella maggior parte dei casi, questo sarà il cacertsfile nella directory JRE_HOME / lib / security. Se il percorso del truststore è stato specificato utilizzando la proprietà di sistema JVM javax.net.ssl.trustStore, l'archivio in quel percorso è in genere quello utilizzato dalla libreria client. In caso di dubbi, dai un'occhiata alla tua Merchantclasse e scopri la classe / libreria che sta utilizzando per stabilire la connessione.

L'aggiunta del certificato del server che emette CA a questo truststore dovrebbe risolvere il problema. È possibile fare riferimento alla mia risposta su una domanda correlata su come ottenere strumenti per questo scopo, ma l' utilità keytool Java è sufficiente per questo scopo.

Avviso : l'archivio sicuro è essenzialmente l'elenco di tutte le autorità di certificazione di cui ti fidi. Se si inserisce un certificato che non appartiene a una CA di cui non ci si fida, le connessioni SSL / TLS a siti con certificati emessi da tale entità possono essere decodificate se la chiave privata è disponibile.

Aggiornamento n. 2: comprensione dell'output della traccia JSSE

Il keystore e i truststor usati dalla JVM sono di solito elencati all'inizio, un po 'come i seguenti:

keyStore is : 
keyStore type is : jks
keyStore provider is : 
init keystore
init keymanager of type SunX509
trustStore is: C:\Java\jdk1.6.0_21\jre\lib\security\cacerts
trustStore type is : jks
trustStore provider is : 

Se viene utilizzato il truststore errato, sarà necessario reimportare il certificato del server in quello corretto o riconfigurare il server per utilizzare quello elencato (non consigliato se si dispone di più JVM e tutti vengono utilizzati per diversi esigenze).

Se si desidera verificare se l'elenco di certificati attendibili contiene i certificati richiesti, esiste una sezione per lo stesso, che inizia come:

adding as trusted cert:
  Subject: CN=blah, O=blah, C=blah
  Issuer:  CN=biggerblah, O=biggerblah, C=biggerblah
  Algorithm: RSA; Serial number: yadda
  Valid from SomeDate until SomeDate

Dovrai cercare se la CA del server è un argomento.

Il processo di handshake avrà alcune voci salienti (sarà necessario conoscere SSL per capirle in dettaglio, ma ai fini del debug del problema corrente, sarà sufficiente sapere che un server handshake_failure è generalmente riportato in ServerHello.

1. ClientHello

Una serie di voci verrà segnalata durante l'inizializzazione della connessione. Il primo messaggio inviato dal client in una configurazione di connessione SSL / TLS è il messaggio ClientHello, generalmente riportato nei registri come:

*** ClientHello, TLSv1
RandomCookie:  GMT: 1291302508 bytes = { some byte array }
Session ID:  {}
Cipher Suites: [SSL_RSA_WITH_RC4_128_MD5, SSL_RSA_WITH_RC4_128_SHA, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_DHE_RSA_WITH_AES_128_CBC_SHA, TLS_DHE_DSS_WITH_AES_128_CBC_SHA, SSL_RSA_WITH_3DES_EDE_CBC_SHA, SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA, SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA, SSL_RSA_WITH_DES_CBC_SHA, SSL_DHE_RSA_WITH_DES_CBC_SHA, SSL_DHE_DSS_WITH_DES_CBC_SHA, SSL_RSA_EXPORT_WITH_RC4_40_MD5, SSL_RSA_EXPORT_WITH_DES40_CBC_SHA, SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA, SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA]
Compression Methods:  { 0 }
***

Nota le suite di crittografia utilizzate. Ciò potrebbe dover concordare con la voce nel file merchant.properties, poiché la stessa convenzione potrebbe essere utilizzata dalla biblioteca della banca. Se la convenzione utilizzata è diversa, non c'è motivo di preoccuparsi, poiché ServerHello lo dichiarerà, se la suite di crittografia è incompatibile.

2. ServerHello

Il server risponde con un ServerHello, che indicherà se la configurazione della connessione può procedere. Le voci nei registri sono in genere del seguente tipo:

*** ServerHello, TLSv1
RandomCookie:  GMT: 1291302499 bytes = { some byte array}
Cipher Suite: SSL_RSA_WITH_RC4_128_SHA
Compression Method: 0
***

Nota la suite di crittografia che ha scelto; questa è la migliore suite disponibile sia per il server che per il client. Di solito la suite di crittografia non viene specificata in caso di errore. Il certificato del server (e facoltativamente l'intera catena) viene inviato dal server e verrà trovato nelle voci come:

*** Certificate chain
chain [0] = [
[
  Version: V3
  Subject: CN=server, O=server's org, L=server's location, ST =Server's state, C=Server's country
  Signature Algorithm: SHA1withRSA, OID = some identifer

.... the rest of the certificate
***

Se la verifica del certificato ha avuto esito positivo, troverai una voce simile a:

Found trusted certificate:
[
[
  Version: V1
  Subject: OU=Server's CA, O="Server's CA's company name", C=CA's country
  Signature Algorithm: SHA1withRSA, OID = some identifier

Uno dei passaggi precedenti non avrebbe avuto esito positivo, risultante in handshake_failure, poiché l'handshake è in genere completa in questa fase (non proprio, ma le fasi successive dell'handshake in genere non causano un fallimento della stretta di mano). Dovrai capire quale passaggio ha avuto esito negativo e pubblicare il messaggio appropriato come aggiornamento alla domanda (a meno che tu non abbia già compreso il messaggio e tu sappia cosa fare per risolverlo).


Per favore pubblica tutto quello che hai, se puoi, in modo che io possa aggiornare la risposta con una più specifica.
Vineet Reynolds,

1
Ok Vineet, non riesco a capire come affrontarlo, sono già sfinito. Ho trovato un modo per controllare l'URL del server con openssl "openssl s_client -connect servername: 4402" e guarda cosa ho ottenuto: img225.imageshack.us/img225/8999/screenshoturr.png
Denees

@hoss, sembra che il certificato del server sia stato emesso da un'entità che non è presente nel truststore usato da OpenSSL e che forse non è presente nel truststore utilizzato dal tuo server (il client), quando si connette a il server. In tal caso, dovrai importare il certificato della CA che ha emesso il certificato ( e non il server ) nel truststore del tuo client (OpenSSL / tuo server).
Vineet Reynolds,

1
Bene, può darsi che si stia basando su dolci. Ma puoi determinarlo solo se hai compreso l'output del debug di rete. Se vuoi verificarlo, dovrai usare il keytool -list -v -keystore $JAVA_HOME/jre/lib/security/cacertscomando per stampare il contenuto. Quindi verificare se i certificati nei certificati corrispondono alla CA del certificato della banca.
Vineet Reynolds,

5
L'impostazione predefinita è di solito changeit. A meno che non sia stato modificato.
Vineet Reynolds,

20

L'installazione di Java Cryptography Extension (JCE) Unlimited Strength ( per JDK7 | per JDK8 ) potrebbe correggere questo errore. Decomprimi il file e segui il readme per installarlo.


16

L'errore della stretta di mano potrebbe essere un'implementazione del protocollo TLSv1 errata.

Nel nostro caso questo ha aiutato con Java 7:

java -Dhttps.protocols=TLSv1.2,TLSv1.1,TLSv1 

Il jvm negozierà in questo ordine. I server con l'ultimo aggiornamento faranno 1.2, quelli con errori passeranno alla v1 e funzionerà con la v1 simile in java 7.


1
Questo mi ha aiutato. C'era il mio ClientHello, ma nessun server, la fine è stata piuttosto improvvisa. Questo mi ha risolto per me su Java 7. Grazie mille.
virgo47

15

Questo può accadere anche quando il cliente deve presentare un certificato. Dopo che il server ha elencato la catena di certificati, può accadere quanto segue:

3. Richiesta certificato Il server emetterà una richiesta di certificato dal client. La richiesta elencherà tutti i certificati accettati dal server.

*** CertificateRequest
Cert Types: RSA
Cert Authorities:
<CN=blah, OU=blah, O=blah, L=blah, ST=blah, C=blah>
<CN=yadda, DC=yadda, DC=yadda>
<CN=moreblah, OU=moreblah, O=moreblah, C=moreblah>
<CN=moreyada, OU=moreyada, O=moreyada, C=moreyada>
... the rest of the request
*** ServerHelloDone

4. Catena di certificati client Questo è il certificato che il client sta inviando al server.

*** Certificate chain
chain [0] = [
[
  Version: V3
  Subject: EMAILADDRESS=client's email, CN=client, OU=client's ou, O=client's Org, L=client's location, ST=client's state, C=client's Country
  Signature Algorithm: SHA1withRSA, OID = 1.2.840.113549.1.1.5
  ... the rest of the certificate
*** ClientKeyExchange, RSA PreMasterSecret, TLSv1    
... key exchange info 

Se non esiste un certificato nella catena e il server ne richiede uno, qui verrà visualizzato l'errore di handshake. Una causa probabile è che il percorso del certificato non è stato trovato.

5. Verifica certificato Il client chiede al server di verificare il certificato

*** CertificateVerify
... payload of verify check

Questo passaggio si verificherà solo se si sta inviando un certificato.

6. Terminato Il server risponderà con una risposta di verifica

*** Finished
verify_data:  { 345, ... }

nel mio caso sembra che tutti i passaggi siano corretti ma ottenga comunque l'errore di stretta di mano.
Tibi,

risposta molto bella ... ma tutti questi sono ok nel mio fallimento della stretta di mano ma ho ancora l'errore. potresti dare un'occhiata alla mia domanda simile?
Tibi,

La mancata presentazione di un certificato client non costituisce alcun tipo di errore in TLS. Se il server richiede un certificato client e uno non viene presentato, chiuderà la connessione.
Marchese di Lorne,

@EJP è vero, non è un errore in TLS, tuttavia la connessione non riuscita viene visualizzata come errore nel codice Java.
Brig

1
@Brig Ma non come un avviso, che è ciò che dice questa risposta e di cosa tratta la domanda.
Marchese di Lorne,

15

Non penso che questo risolva il problema con il primo interrogante, ma per i googler che vengono qui per le risposte:


All'aggiornamento 51, java 1.8 proibiva [1] le cifre RC4 per impostazione predefinita, come possiamo vedere nella pagina delle Note di rilascio:

Correzione bug: proibire le suite di crittografia RC4

RC4 è ora considerato un codice compromesso.

Le suite di crittografia RC4 sono state rimosse dall'elenco delle suite di crittografia abilitate per impostazione predefinita sia client che server nell'implementazione Oracle JSSE. Queste suite di cifratura possono ancora essere abilitate con SSLEngine.setEnabledCipherSuites()e SSLSocket.setEnabledCipherSuites()metodi. Vedi JDK-8077109 (non pubblico).

Se il tuo server ha una forte preferenza per questo codice (o usa solo questo codice), questo può innescare un handshake_failureon java.

Puoi testare la connessione al server abilitando le cifre RC4 (prima prova senza enabledargomenti per vedere se innesca a handshake_failure, quindi imposta enabled:

import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import java.io.*;

import java.util.Arrays;

/** Establish a SSL connection to a host and port, writes a byte and
 * prints the response. See
 * http://confluence.atlassian.com/display/JIRA/Connecting+to+SSL+services
 */
public class SSLRC4Poke {
    public static void main(String[] args) {
        String[] cyphers;
        if (args.length < 2) {
            System.out.println("Usage: "+SSLRC4Poke.class.getName()+" <host> <port> enable");
            System.exit(1);
        }
        try {
            SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
            SSLSocket sslsocket = (SSLSocket) sslsocketfactory.createSocket(args[0], Integer.parseInt(args[1]));
        
            cyphers = sslsocketfactory.getSupportedCipherSuites();
            if (args.length ==3){
                sslsocket.setEnabledCipherSuites(new String[]{
                    "SSL_DH_anon_EXPORT_WITH_RC4_40_MD5",
                    "SSL_DH_anon_WITH_RC4_128_MD5",
                    "SSL_RSA_EXPORT_WITH_RC4_40_MD5",
                    "SSL_RSA_WITH_RC4_128_MD5",
                    "SSL_RSA_WITH_RC4_128_SHA",
                    "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
                    "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
                    "TLS_ECDH_ECDSA_WITH_RC4_128_SHA",
                    "TLS_ECDH_RSA_WITH_RC4_128_SHA",
                    "TLS_ECDH_anon_WITH_RC4_128_SHA",
                    "TLS_KRB5_EXPORT_WITH_RC4_40_MD5",
                    "TLS_KRB5_EXPORT_WITH_RC4_40_SHA",
                    "TLS_KRB5_WITH_RC4_128_MD5",
                    "TLS_KRB5_WITH_RC4_128_SHA"
                });     
            }

            InputStream in = sslsocket.getInputStream();
            OutputStream out = sslsocket.getOutputStream();

            // Write a test byte to get a reaction :)
            out.write(1);

            while (in.available() > 0) {
                System.out.print(in.read());
            }
            System.out.println("Successfully connected");

        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }
}

1 - https://www.java.com/en/download/faq/release_changes.xml


10

Ho questo errore durante il tentativo di utilizzare JDK 1.7. Quando ho aggiornato il mio JDK a jdk1.8.0_66 tutto ha iniziato a funzionare bene.

Quindi la soluzione più semplice per questo problema potrebbe essere: aggiorna il tuo JDK e potrebbe iniziare a funzionare bene.


4
Bello. La soluzione più semplice è aggiornare JDK? : D Sai quanto può essere complicato a seconda dell'ambiente in cui viene fatto? Supponiamo che Amazon abbia eseguito JDK 7 e ora dovrebbe passare a JDK 8 all'improvviso ... Bello!
Arturas M

1
Un semplice aggiornamento di versione minore ha risolto questo problema per me .. da JDK 11.0.1 a 11.0.6
Clint

4

Nel mio caso, il cert viene importato, l'errore rimane, risolto aggiungendolo System.setProperty("https.protocols", "TLSv1.2,TLSv1.1,SSLv3");prima di connettersi


Ha funzionato per me in Java 1.8. Grazie :)
Supun Amarasinghe

3

Supponendo che tu stia utilizzando i protocolli SSL / TLS corretti, configurato correttamente il tuo keyStoree trustStore, e confermato che non esistono problemi con i certificati stessi, potresti dover rafforzare i tuoi algoritmi di sicurezza .

Come indicato nella risposta di Vineet , un possibile motivo per cui si riceve questo errore è dovuto all'uso di suite di crittografia incompatibili. Aggiornando my local_policye US_export_policyjars nella securitycartella del mio JDK con quelli forniti in Java Cryptography Extension (JCE) , sono riuscito a completare l'handshake con successo.


2

Oggi incontro lo stesso problema con il client OkHttp per ottenere un URL basato su https. È stato causato dalla versione del protocollo Https e dalla mancata corrispondenza del metodo Cipher tra lato server e lato client .

1) controlla la versione del protocollo https del tuo sito web e il metodo Cipher.

openssl>s_client -connect your_website.com:443 -showcerts

Riceverai molte informazioni dettagliate, le informazioni chiave sono elencate come segue:

SSL-Session:
    Protocol  : TLSv1
    Cipher    : RC4-SHA
2) configura il tuo client http, ad esempio, nel caso del client OkHttp :
@Test()
public void testHttpsByOkHttp() {
    ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
            .tlsVersions(TlsVersion.TLS_1_0) //protocol version
            .cipherSuites(
                    CipherSuite.TLS_RSA_WITH_RC4_128_SHA, //cipher method
                    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)
            .build();

    OkHttpClient client = new OkHttpClient();
    client.setConnectionSpecs(Collections.singletonList(spec));
    Request request = new Request.Builder().url("https://your_website.com/").build();
    try {
        Response response = client.newCall(request).execute();
        if(response.isSuccessful()){
            logger.debug("result= {}", response.body().string());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Questo otterrà ciò che vogliamo.


2

Ho trovato un server HTTPS che non è riuscito in questo modo se il mio processo client Java è stato configurato

-Djsse.enableSNIExtension=false

La connessione non è riuscita handshake_failuredopo il ServerHellocompletamento con esito positivo ma prima dell'avvio del flusso di dati.

Non c'era un chiaro messaggio di errore che identificasse il problema, l'errore sembrava proprio

main, READ: TLSv1.2 Alert, length = 2
main, RECV TLSv1.2 ALERT:  fatal, handshake_failure
%% Invalidated:  [Session-3, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384]
main, called closeSocket()
main, handling exception: javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure

Ho isolato il problema provando con e senza l' -Djsse.enableSNIExtension=falseopzione " "


Ricevo lo stesso errore durante la connessione alla sandbox GDAX, qualche soluzione per questo?
Nitin Vavdiya,

1

Il mio era un TLSerrore incompatibile con la versione.

In precedenza era stato TLSv1modificato TLSV1.2questo risolto il mio problema.


1

Sto utilizzando il client http com.google.api. Quando comunico con un sito aziendale interno, ho riscontrato questo problema quando ho utilizzato erroneamente https, anziché http.

main, READ: TLSv1.2 Alert, length = 2
main, RECV TLSv1.2 ALERT:  fatal, handshake_failure
main, called closeSocket()
main, handling exception: javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure
main, IOException in getSession():  javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure
main, called close()
main, called closeInternal(true)
262 [main] DEBUG org.apache.http.impl.conn.DefaultClientConnection  - Connection shut down
main, called close()
main, called closeInternal(true)
263 [main] DEBUG org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager  - Released connection is not reusable.
263 [main] DEBUG org.apache.http.impl.conn.tsccm.ConnPoolByRoute  - Releasing connection [HttpRoute[{s}->https://<I-replaced>]][null]
263 [main] DEBUG org.apache.http.impl.conn.tsccm.ConnPoolByRoute  - Notifying no-one, there are no waiting threads
Exception in thread "main" javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated
    at sun.security.ssl.SSLSessionImpl.getPeerCertificates(SSLSessionImpl.java:431)
    at org.apache.http.conn.ssl.AbstractVerifier.verify(AbstractVerifier.java:128)
    at org.apache.http.conn.ssl.SSLSocketFactory.connectSocket(SSLSocketFactory.java:339)
    at org.apache.http.impl.conn.DefaultClientConnectionOperator.openConnection(DefaultClientConnectionOperator.java:123)
    at org.apache.http.impl.conn.AbstractPoolEntry.open(AbstractPoolEntry.java:147)
    at org.apache.http.impl.conn.AbstractPooledConnAdapter.open(AbstractPooledConnAdapter.java:108)
    at org.apache.http.impl.client.DefaultRequestDirector.execute(DefaultRequestDirector.java:415)
    at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:641)
    at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:576)
    at org.apache.http.impl.client.AbstractHttpClient.execute(AbstractHttpClient.java:554)
    at com.google.api.client.http.apache.ApacheHttpRequest.execute(ApacheHttpRequest.java:67)
    at com.google.api.client.http.HttpRequest.execute(HttpRequest.java:960)

No non puoi. Il server non può inviare un avviso TLS se non parla TLS.
Marchese di Lorne,

Ho aggiornato il mio commento per mostrare l'output del mio programma. Questo è vero. Lo apprezzerei se togliessi il voto negativo.
thebiggestlebowski il

È reale, ma non è causato dal parlare TLS con un server in chiaro. Un server in chiaro non sta parlando di TLS, per definizione, e quindi non è possibile ricevere un avviso TLS da esso, per definizione. Non hai alcuna informazione su chi abbia votato in negativo la tua risposta.
Marchese di Lorne,

Ho ipotizzato che tu abbia votato in negativo - le mie scuse se non è così. Il mio messaggio di errore corrisponde esattamente al titolo di questa domanda. È un valido percorso / test per ottenere questo messaggio di errore e ho una soluzione che potrebbe aiutare gli altri. Rispettosamente, non penso che importi se è causato da una risposta di errore del server TLS o meno. Qualcuno arriverà qui da Google e la mia risposta potrebbe essere d'aiuto se commettessero lo stesso errore.
thebiggestlebowski il

Non ho detto nulla sul tuo messaggio di errore. Sto commentando la tua affermazione errata che è dovuta a "utilizzare erroneamente HTTPS anziché HTTP". Non è, e non può essere, per ragioni che ho affermato e che non hai affrontato in alcun modo. L'uso dell'HTTP lo farà sicuramente andare via, ovviamente, poiché non ci sono avvisi TLS in testo normale, ma non risolve il problema sottostante.
Marchese di Lorne,

1

Ho avuto un problema simile; l'aggiornamento a Apache HTTPClient 4.5.3 risolto.


1

Ugg! Questo si è rivelato essere semplicemente un problema di versione Java per me. Ho riscontrato l'errore di stretta di mano con JRE 1.6 e tutto ha funzionato perfettamente con JRE 1.8.0_144.


0

Dichiarazione di non responsabilità: non sono consapevole se la risposta sarà utile per molte persone, condividendola solo perché potrebbe.

Stavo ottenendo questo errore durante l'utilizzo di Parasoft SOATest per inviare richieste XML (SOAP).

Il problema era che avevo selezionato l'alias sbagliato dall'elenco a discesa dopo aver aggiunto il certificato e averlo autenticato.


0

Nel mio caso, il sito Web può semplicemente utilizzare TLSv1.2. e utilizzo apache httpclient 4.5.6, utilizzo questo codice e installo jce per risolverlo (JDK1.7):

JCE

jdk7 http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html

jdk 8 http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html

codice:

SSLContext sslContext = SSLContext.getDefault();

  SSLConnectionSocketFactory sslConnectionFactory = new SSLConnectionSocketFactory(
      sslContext,
      new String[]{"TLSv1.2"}, // important
      null,
      NoopHostnameVerifier.INSTANCE);

  Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
      .register("https", sslConnectionFactory)
      .register("http", PlainConnectionSocketFactory.INSTANCE)
      .build();

  HttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(registry);
  httpclient = HttpClientBuilder.create().
      .setSSLSocketFactory(sslConnectionFactory)
      .setConnectionManager(ccm)
      .build();

0

Per risolvere i problemi dal punto di vista dello sviluppatore (elemento 1) e dell'amministratore di sistema (elemento 2 e 3):

  1. Abilitare il debug dell'handshake SSL su Java tramite -Djavax.net.debug=ssl:handshake:verbose.
  2. Installa ssldump sul server tramite sudo apt install ssldumpo compila dal sorgente seguendo questo link se osservi Unknown valuein codice quando esegui il passaggio seguente.
  3. Al server, sudo ssldump -k <your-private-key> -i <your-network-interface>
  4. Controlla il registro sulla vera ragione dell'errore.

Esempio di stretta di mano non funzionante del registro ssldump:

New TCP connection #1: 10.1.68.86(45308) <-> 10.1.68.83(5671)
1 1  0.0111 (0.0111)  C>S  Handshake
      ClientHello
        Version 3.3
        cipher suites
        TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
        TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
        TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        TLS_RSA_WITH_AES_256_GCM_SHA384
        TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384
        TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384
        TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
        TLS_DHE_DSS_WITH_AES_256_GCM_SHA384
        TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
        TLS_RSA_WITH_AES_128_GCM_SHA256
        TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256
        TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256
        TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
        TLS_DHE_DSS_WITH_AES_128_GCM_SHA256
        TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
        TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
        TLS_RSA_WITH_AES_256_CBC_SHA256
        TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384
        TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384
        TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
        TLS_DHE_DSS_WITH_AES_256_CBC_SHA256
        TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
        TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
        TLS_RSA_WITH_AES_256_CBC_SHA
        TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA
        TLS_ECDH_RSA_WITH_AES_256_CBC_SHA
        TLS_DHE_RSA_WITH_AES_256_CBC_SHA
        TLS_DHE_DSS_WITH_AES_256_CBC_SHA
        TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
        TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
        TLS_RSA_WITH_AES_128_CBC_SHA256
        TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256
        TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256
        TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
        TLS_DHE_DSS_WITH_AES_128_CBC_SHA256
        TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
        TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
        TLS_RSA_WITH_AES_128_CBC_SHA
        TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA
        TLS_ECDH_RSA_WITH_AES_128_CBC_SHA
        TLS_DHE_RSA_WITH_AES_128_CBC_SHA
        TLS_DHE_DSS_WITH_AES_128_CBC_SHA
        TLS_EMPTY_RENEGOTIATION_INFO_SCSV
        compression methods
                  NULL
1 2  0.0122 (0.0011)  S>C  Alert
    level           fatal
    value           insufficient_security
1    0.0126 (0.0004)  S>C  TCP RST

Esempio di stretta di mano riuscita del registro ssldump

New TCP connection #1: 10.1.68.86(56558) <-> 10.1.68.83(8443)
1 1  0.0009 (0.0009)  C>S  Handshake
      ClientHello
        Version 3.3
        cipher suites
        TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
        TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
        Unknown value 0xcca9
        Unknown value 0xcca8
        Unknown value 0xccaa
        TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
        TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
        TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
        TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
        TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
        TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
        TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
        TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
        TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
        TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
        TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
        TLS_DHE_RSA_WITH_AES_256_CBC_SHA
        TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
        TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
        TLS_DHE_RSA_WITH_AES_128_CBC_SHA
        TLS_RSA_WITH_AES_256_GCM_SHA384
        TLS_RSA_WITH_AES_128_GCM_SHA256
        TLS_RSA_WITH_AES_256_CBC_SHA256
        TLS_RSA_WITH_AES_128_CBC_SHA256
        TLS_RSA_WITH_AES_256_CBC_SHA
        TLS_RSA_WITH_AES_128_CBC_SHA
        TLS_EMPTY_RENEGOTIATION_INFO_SCSV
        compression methods
                  NULL
1 2  0.0115 (0.0106)  S>C  Handshake
      ServerHello
        Version 3.3
        session_id[0]=

        cipherSuite         TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        compressionMethod                   NULL
1 3  0.0115 (0.0000)  S>C  Handshake
      Certificate
1 4  0.0115 (0.0000)  S>C  Handshake
      ServerKeyExchange
Not enough data. Found 294 bytes (expecting 32767)
1 5    0.0115   (0.0000)    S>C    Handshake
        ServerHelloDone
1 6    0.0141   (0.0025)    C>S    Handshake
        ClientKeyExchange
Not enough data. Found 31 bytes (expecting 16384)
1 7    0.0141   (0.0000)    C>S    ChangeCipherSpec
1 8    0.0141   (0.0000)    C>S      Handshake
1 9    0.0149   (0.0008)    S>C    Handshake
1 10   0.0149   (0.0000)    S>C    ChangeCipherSpec
1 11   0.0149   (0.0000)    S>C      Handshake

Esempio di log Java non funzionante

javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.778 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.779 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.779 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.780 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_RSA_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.780 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.780 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.781 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.781 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.781 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.782 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_RSA_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.782 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.782 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.782 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.783 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.783 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.783 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.783 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_RSA_WITH_AES_256_CBC_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.783 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: T LS_DHE_RSA_WITH_AES_256_CBC_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 for TLS11
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.784 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_RSA_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_RSA_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.785 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_RSA_WITH_AES_256_CBC_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 for TLS10 javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.786 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 for TLS10
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.787 MYT|HandshakeContext.java:294|Ignore unsupported cipher suite: TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 for TLS10
javax.net.ssl|WARNING|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.818 MYT|SignatureScheme.java:282|Signature algorithm, ed25519, is not supported by the underlying providers
javax.net.ssl|WARNING|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.818 MYT|SignatureScheme.java:282|Signature algorithm, ed448, is not supported by the underlying providers
javax.net.ssl|ALL|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.822 MYT|SignatureScheme.java:358|Ignore disabled signature sheme: rsa_md5
javax.net.ssl|INFO|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.822 MYT|AlpnExtension.java:161|No available application protocols
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.823 MYT|SSLExtensions.java:256|Ignore, context unavailable extension: application_layer_protocol_negotiation
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.823 MYT|SSLExtensions.java:256|Ignore, context unavailable extension: renegotiation_info
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.825 MYT|ClientHello.java:651|Produced ClientHello handshake message (
"ClientHello": {
  "client version"      : "TLSv1.2",
  "random"              : "FB BC CD 7C 17 65 86 49 3E 1C 15 37 24 94 7D E7 60 44 1B B8 F4 18 21 D0 E1 B1 31 0D E1 80 D6 A7",
  "session id"          : "",
  "cipher suites"       : "[TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384(0xC02C), TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256(0xC02B), TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384(0xC030), TLS_RSA_WITH_AES_256_GCM_SHA384(0x009D), TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384(0xC02E), TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384(0xC032), TLS_DHE_RSA_WITH_AES_256_GCM_SHA384(0x009F), TLS_DHE_DSS_WITH_AES_256_GCM_SHA384(0x00A3), TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256(0xC02F), TLS_RSA_WITH_AES_128_GCM_SHA256(0x009C), TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256(0xC02D), TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256(0xC031), TLS_DHE_RSA_WITH_AES_128_GCM_SHA256(0x009E), TLS_DHE_DSS_WITH_AES_128_GCM_SHA256(0x00A2), TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384(0xC024), TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384(0xC028), TLS_RSA_WITH_AES_256_CBC_SHA256(0x003D), TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384(0xC026), TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384(0xC02A), TLS_DHE_RSA_WITH_AES_256_CBC_SHA256(0x006B), TLS_DHE_DSS_WITH_AES_256_CBC_SHA256(0x006A), TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA(0xC00A), TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA(0xC014), TLS_RSA_WITH_AES_256_CBC_SHA(0x0035), TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA(0xC005), TLS_ECDH_RSA_WITH_AES_256_CBC_SHA(0xC00F), TLS_DHE_RSA_WITH_AES_256_CBC_SHA(0x0039), TLS_DHE_DSS_WITH_AES_256_CBC_SHA(0x0038), TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256(0xC023), TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256(0xC027), TLS_RSA_WITH_AES_128_CBC_SHA256(0x003C), TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256(0xC025), TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256(0xC029), TLS_DHE_RSA_WITH_AES_128_CBC_SHA256(0x0067), TLS_DHE_DSS_WITH_AES_128_CBC_SHA256(0x0040), TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA(0xC009), TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA(0xC013), TLS_RSA_WITH_AES_128_CBC_SHA(0x002F), TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA(0xC004), TLS_ECDH_RSA_WITH_AES_128_CBC_SHA(0xC00E), TLS_DHE_RSA_WITH_AES_128_CBC_SHA(0x0033), TLS_DHE_DSS_WITH_AES_128_CBC_SHA(0x0032), TLS_EMPTY_RENEGOTIATION_INFO_SCSV(0x00FF)]",
  "compression methods" : "00",  "extensions"          : [
    "server_name (0)": {
      type=host_name (0), value=mq.tpc-ohcis.moh.gov.my
    },
    "status_request (5)": {
      "certificate status type": ocsp
      "OCSP status request": {
        "responder_id": <empty>
        "request extensions": {
          <empty>
        }
      }
    },
    "supported_groups (10)": {
      "versions": [secp256r1, secp384r1, secp521r1, sect283k1, sect283r1, sect409k1, sect409r1, sect571k1, sect571r1, secp256k1, ffdhe2048, ffdhe3072, ffdhe4096, ffdhe6144, ffdhe8192]
    },
    "ec_point_formats (11)": {
      "formats": [uncompressed]
    },
    "signature_algorithms (13)": {
      "signature schemes": [ecdsa_secp256r1_sha256, ecdsa_secp384r1_sha384, ecdsa_secp512r1_sha512, rsa_pss_rsae_sha256, rsa_pss_rsae_sha384, rsa_pss_rsae_sha512, rsa_pss_pss_sha256, rsa_pss_pss_sha384, rsa_pss_pss_sha512, rsa_pkcs1_sha256, rsa_pkcs1_sha384, rsa_pkcs1_sha512, dsa_sha256, ecdsa_sha224, rsa_sha224, dsa_sha224, ecdsa_sha1, rsa_pkcs1_sha1, dsa_sha1]
    },
    "signature_algorithms_cert (50)": {
      "signature schemes": [ecdsa_secp256r1_sha256, ecdsa_secp384r1_sha384, ecdsa_secp512r1_sha512, rsa_pss_rsae_sha256, rsa_pss_rsae_sha384, rsa_pss_rsae_sha512, rsa_pss_pss_sha256, rsa_pss_pss_sha384, rsa_pss_pss_sha512, rsa_pkcs1_sha256, rsa_pkcs1_sha384, rsa_pkcs1_sha512, dsa_sha256, ecdsa_sha224, rsa_sha224, dsa_sha224, ecdsa_sha1, rsa_pkcs1_sha1, dsa_sha1]
    },
    "status_request_v2 (17)": {
      "cert status request": {
        "certificate status type": ocsp_multi
        "OCSP status request": {
          "responder_id": <empty>
          "request extensions": {
            <empty>
          }
        }      }
    },
    "extended_master_secret (23)": {
      <empty>
    },
    "supported_versions (43)": {
      "versions": [TLSv1.2, TLSv1.1, TLSv1]
    }
  ]
}
)
javax.net.ssl|DEBUG|43|SimpleAsyncTaskExecutor-1|2019-07-03 17:35:01.829 MYT|Alert.java:238|Received alert message (
"Alert": {
  "level"      : "fatal",
  "description": "insufficient_security"
}
)

0

Nel mio caso ho avuto un problema con la versione 1.1. Stavo riproducendo facilmente il problema con il ricciolo. Il server non supportava versioni precedenti rispetto a TLS1.2.

Questo ha ricevuto il problema della stretta di mano:

curl --insecure --tlsv1.1 -i https://youhost --noproxy "*"

Con la versione 1.2 funzionava bene:

curl --insecure --tlsv1.2 -i https://youhost --noproxy "*"

Il server stava eseguendo un Weblogic e aggiungendo questo argomento in setEnvDomain.sh ha funzionato con TLSv1.1:

-Dweblogic.security.SSL.minimumProtocolVersion=TLSv1.1

0

Questo problema si verifica a causa della versione java. Stavo usando 1.8.0.231 JDK e ottenevo questo errore. Ho degradato la mia versione java da 1.8.0.231 a 1.8.0.171, ora funziona bene.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.