Come correggere l'errore "java.security.cert.CertificateException: nessun nome alternativo del soggetto presente"?

Ho un client di servizi Web Java, che utilizza un servizio Web tramite HTTPS.

import javax.xml.ws.Service;

@WebServiceClient(name = "ISomeService", targetNamespace = "http://tempuri.org/", wsdlLocation = "...")
public class ISomeService
    extends Service
{

    public ISomeService() {
        super(__getWsdlLocation(), ISOMESERVICE_QNAME);
    }

Quando mi collego all'URL del servizio ( https://AAA.BBB.CCC.DDD:9443/ISomeService), ottengo l'eccezione java.security.cert.CertificateException: No subject alternative names present.

Per risolverlo, ho prima eseguito openssl s_client -showcerts -connect AAA.BBB.CCC.DDD:9443 > certs.txte ottenuto il seguente contenuto nel file certs.txt:

CONNECTED(00000003)
---
Certificate chain
 0 s:/CN=someSubdomain.someorganisation.com
   i:/CN=someSubdomain.someorganisation.com
-----BEGIN CERTIFICATE-----
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-----END CERTIFICATE-----
---
Server certificate
subject=/CN=someSubdomain.someorganisation.com
issuer=/CN=someSubdomain.someorganisation.com
---
No client certificate CA names sent
---
SSL handshake has read 489 bytes and written 236 bytes
---
New, TLSv1/SSLv3, Cipher is RC4-MD5
Server public key is 512 bit
Compression: NONE
Expansion: NONE
SSL-Session:
    Protocol  : TLSv1
    Cipher    : RC4-MD5            
    Session-ID: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    Session-ID-ctx:                 
    Master-Key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    Key-Arg   : None
    Start Time: 1382521838
    Timeout   : 300 (sec)
    Verify return code: 21 (unable to verify the first certificate)
---

AFAIK, ora ne ho bisogno

1. estrarre la parte di certs.txttra -----BEGIN CERTIFICATE-----e -----END CERTIFICATE-----,
2. modificarlo in modo che il nome del certificato sia uguale a AAA.BBB.CCC.DDDe
3. quindi importa il risultato usando keytool -importcert -file fileWithModifiedCertificate(dove fileWithModifiedCertificateè il risultato delle operazioni 1 e 2).

È corretto?

In tal caso, come posso far funzionare esattamente il certificato del passaggio 1 con adddress ( AAA.BBB.CCC.DDD) basato su IP ?

Aggiornamento 1 (23.10.2013 15:37 MSK): In una risposta a una domanda simile , ho letto quanto segue:

Se non hai il controllo di quel server, usa il suo nome host (a condizione che ci sia almeno un CN che corrisponde a quel nome host nel certificato esistente).

Cosa significa esattamente "uso"?

Ho risolto il problema disabilitando i controlli HTTPS utilizzando l'approccio presentato qui :

Ho inserito il seguente codice nella ISomeServiceclasse:

static {
    disableSslVerification();
}

private static void disableSslVerification() {
    try
    {
        // Create a trust manager that does not validate certificate chains
        TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager() {
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            public void checkClientTrusted(X509Certificate[] certs, String authType) {
            }
            public void checkServerTrusted(X509Certificate[] certs, String authType) {
            }
        }
        };

        // Install the all-trusting trust manager
        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

        // Create all-trusting host name verifier
        HostnameVerifier allHostsValid = new HostnameVerifier() {
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };

        // Install the all-trusting host verifier
        HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (KeyManagementException e) {
        e.printStackTrace();
    }
}

Poiché sto usando https://AAA.BBB.CCC.DDD:9443/ISomeServicesolo a scopo di test, è una soluzione abbastanza buona.

Ho lo stesso problema e risolto con questo codice. Ho inserito questo codice prima della prima chiamata ai miei servizi web.

javax.net.ssl.HttpsURLConnection.setDefaultHostnameVerifier(
new javax.net.ssl.HostnameVerifier(){

    public boolean verify(String hostname,
            javax.net.ssl.SSLSession sslSession) {
        return hostname.equals("localhost");
    }
});

È semplice e funziona bene.

Ecco la fonte originale.

Questa è una vecchia domanda, ma ho avuto lo stesso problema passando da JDK 1.8.0_144 a jdk 1.8.0_191

Abbiamo trovato un suggerimento nel changelog:

changelog

abbiamo aggiunto la seguente proprietà di sistema aggiuntiva, che ha aiutato nel nostro caso a risolvere questo problema:

-Dcom.sun.jndi.ldap.object.disableEndpointIdentification=true

La verifica dell'identità del certificato viene eseguita rispetto a quanto richiesto dal client.

Quando il tuo client utilizza https://xxx.xxx.xxx.xxx/something(dove xxx.xxx.xxx.xxxè un indirizzo IP), l'identità del certificato viene verificata rispetto a questo indirizzo IP (in teoria, utilizzando solo un'estensione IP SAN).

Se il tuo certificato non ha IP SAN, ma DNS SAN (o se non DNS SAN, un nome comune nel DN oggetto), puoi farlo funzionare facendo in modo che il tuo client utilizzi un URL con quel nome host invece (o un nome host per il quale il certificato sarebbe valido, se ci sono più valori possibili). Ad esempio, se cert ha un nome perwww.example.com , usa https://www.example.com/something.

Ovviamente, avrai bisogno di quel nome host per risolvere quell'indirizzo IP.

Inoltre, se sono presenti SAN DNS, il CN nel DN dell'oggetto verrà ignorato, quindi in questo caso utilizzare un nome che corrisponda a una delle SAN DNS.

Per importare il certificato:

1. Estrai il certificato dal server, ad es. openssl s_client -showcerts -connect AAA.BBB.CCC.DDD:9443 > certs.txtQuesto estrarrà i certificati in formato PEM.
2. Converti il ​​certificato in formato DER poiché questo è ciò che si aspetta keytool, ad es openssl x509 -in certs.txt -out certs.der -outform DER
3. Ora vuoi importare questo certificato nel file "cacert" predefinito del sistema. Individua il file "cacerts" predefinito del sistema per la tua installazione di Java. Dai un'occhiata a Come ottenere la posizione dei cacerts dell'installazione Java predefinita?
4. Importa i certificati in quel file cacerts: la sudo keytool -importcert -file certs.der -keystore <path-to-cacerts>password predefinita dei cacerts è "changeit".

Se il certificato viene emesso per un FQDN e stai tentando di connetterti tramite l'indirizzo IP nel codice Java, probabilmente questo dovrebbe essere corretto nel codice piuttosto che interferire con il certificato stesso. Cambia il tuo codice per connetterti tramite FQDN. Se FQDN non è risolvibile sulla tua macchina di sviluppo, aggiungilo semplicemente al tuo file hosts o configura la tua macchina con un server DNS in grado di risolvere questo FQDN.

Ho risolto questo problema in modo corretto aggiungendo i nomi alt del soggetto nel certificato piuttosto che apportare modifiche al codice o disabilitare SSL a differenza di quanto suggerito da altre risposte qui. Se vedi chiaramente l'eccezione dice "Mancano i nomi alt del soggetto", quindi il modo giusto dovrebbe essere quello di aggiungerli

Si prega di guardare questo collegamento per capire passo dopo passo .

L'errore sopra indica che nel tuo file JKS manca il dominio richiesto su cui stai tentando di accedere all'applicazione. Dovrai usare Open SSL e lo strumento chiave per aggiungere più domini

1. Copia openssl.cnf in una directory corrente
2. echo '[ subject_alt_name ]' >> openssl.cnf
3. echo 'subjectAltName = DNS:example.mydomain1.com, DNS:example.mydomain2.com, DNS:example.mydomain3.com, DNS: localhost'>> openssl.cnf
4. openssl req -x509 -nodes -newkey rsa:2048 -config openssl.cnf -extensions subject_alt_name -keyout private.key -out self-signed.pem -subj '/C=gb/ST=edinburgh/L=edinburgh/O=mygroup/OU=servicing/CN=www.example.com/emailAddress=postmaster@example.com' -days 365

5. Esporta il file della chiave pubblica (.pem) nel formato PKS12. Questo ti chiederà la password

   openssl pkcs12 -export -keypbe PBE-SHA1-3DES -certpbe PBE-SHA1-3DES -export -in
   self-signed.pem -inkey private.key -name myalias -out keystore.p12

6. Crea un JKS da PEM (Keystore) autofirmato

   keytool -importkeystore -destkeystore keystore.jks -deststoretype PKCS12 -srcstoretype PKCS12 -srckeystore keystore.p12

7. Genera un certificato dal file Keystore o JKS di cui sopra

   keytool -export -keystore keystore.jks -alias myalias -file selfsigned.crt

8. Poiché il certificato sopra è autofirmato e non è convalidato dalla CA, deve essere aggiunto in Truststore (file Cacerts nella posizione sottostante per MAC, per Windows, scopri dove è installato il tuo JDK.)

   sudo keytool -importcert -file selfsigned.crt -alias myalias -keystore /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts

Risposta originale pubblicata su questo link qui .

Potresti non voler disabilitare tutta la verifica ssl e quindi puoi semplicemente disabilitare la verifica del nome host tramite questo che è un po 'meno spaventoso dell'alternativa:

HttpsURLConnection.setDefaultHostnameVerifier(
    SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

[MODIFICARE]

Come accennato da conapart3 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIERè ora deprecato, quindi potrebbe essere rimosso in una versione successiva, quindi potresti essere costretto in futuro a lanciarne uno tuo, anche se direi comunque che mi allontanerei da qualsiasi soluzione in cui tutta la verifica è disattivata.

il mio problema con la ricezione di questo errore è stato risolto utilizzando l'URL completo "qatest.ourCompany.com/webService" anziché solo "qatest / webService". Il motivo era che il nostro certificato di sicurezza aveva un carattere jolly, ad esempio "* .ourCompany.com". Una volta inserito l'indirizzo completo, l'eccezione è scomparsa. Spero che questo ti aiuti.

Ho già risposto in https://stackoverflow.com/a/53491151/1909708 .

Ciò non riesce perché né il nome comune del certificato ( CNnella certificazione Subject) né alcuno dei nomi alternativi ( Subject Alternative Namenel certificato) corrispondono al nome host o all'indirizzo IP di destinazione.

Ad esempio, da una JVM, quando si tenta di connettersi a un indirizzo IP ( WW.XX.YY.ZZ) e non al nome DNS ( https://stackoverflow.com ), la connessione HTTPS fallirà perché il certificato memorizzato nel truststore javacacerts prevede un nome comune (o nome alternativo del certificato come stackexchange.com o * .stackoverflow.com ecc.) in modo che corrisponda all'indirizzo di destinazione.

Si prega di controllare: https://docs.oracle.com/javase/8/docs/technotes/guides/security/jsse/JSSERefGuide.html#HostnameVerifier

    HttpsURLConnection urlConnection = (HttpsURLConnection) new URL("https://WW.XX.YY.ZZ/api/verify").openConnection();
    urlConnection.setSSLSocketFactory(socketFactory());
    urlConnection.setDoOutput(true);
    urlConnection.setRequestMethod("GET");
    urlConnection.setUseCaches(false);
    urlConnection.setHostnameVerifier(new HostnameVerifier() {
        @Override
        public boolean verify(String hostname, SSLSession sslSession) {
            return true;
        }
    });
    urlConnection.getOutputStream();

Sopra, passato un HostnameVerifieroggetto implementato che restituisce sempre true:

new HostnameVerifier() {
        @Override
        public boolean verify(String hostname, SSLSession sslSession) {
            return true;
        }
    }

Per Spring Boot RestTemplate:

• aggiungi org.apache.httpcomponents.httpcoredipendenza

• utilizzare NoopHostnameVerifierper SSL factory:

  SSLContext sslContext = new SSLContextBuilder()
          .loadTrustMaterial(new URL("file:pathToServerKeyStore"), storePassword)
  //        .loadKeyMaterial(new URL("file:pathToClientKeyStore"), storePassword, storePassword)
          .build();
  SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
  CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(socketFactory).build();
  HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(client);
  RestTemplate restTemplate = new RestTemplate(factory);

Sono arrivato a questa domanda dopo se ho ricevuto lo stesso messaggio di errore. Tuttavia nel mio caso avevamo due URL con diversi sottodomini ( http://example1.xxx.com/someservice e http://example2.yyy.com/someservice ) che erano diretti allo stesso server. Questo server aveva un solo certificato jolly per il dominio * .xxx.com. Quando si utilizza il servizio tramite il secondo dominio, il certificato trovato (* .xxx.com) non corrisponde al dominio richiesto (* .yyy.com) e si verifica l'errore.

In questo caso non dovremmo provare a correggere un messaggio di errore di questo tipo abbassando la sicurezza SSL, ma dovremmo controllare il server ei certificati su di esso.

public class RESTfulClientSSL {

    static TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            // TODO Auto-generated method stub
        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            // TODO Auto-generated method stub
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            // TODO Auto-generated method stub
            return null;
        }
    }};

    public class NullHostNameVerifier implements HostnameVerifier {
        /*
         * (non-Javadoc)
         *
         * @see javax.net.ssl.HostnameVerifier#verify(java.lang.String,
         * javax.net.ssl.SSLSession)
         */
        @Override
        public boolean verify(String arg0, SSLSession arg1) {
            // TODO Auto-generated method stub
            return true;
        }
    }

    public static void main(String[] args) {

        HttpURLConnection connection = null;
        try {

            HttpsURLConnection.setDefaultHostnameVerifier(new RESTfulwalkthroughCer().new NullHostNameVerifier());
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());


            String uriString = "https://172.20.20.12:9443/rest/hr/exposed/service";
            URL url = new URL(uriString);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            //connection.setRequestMethod("POST");

            BASE64Encoder encoder = new BASE64Encoder();
            String username = "admin";
            String password = "admin";
            String encodedCredential = encoder.encode((username + ":" + password).getBytes());
            connection.setRequestProperty("Authorization", "Basic " + encodedCredential);

            connection.connect();
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                StringBuffer stringBuffer = new StringBuffer();
                String line = "";
                while ((line = reader.readLine()) != null) {
                    stringBuffer.append(line);
                }
                String content = stringBuffer.toString();
                System.out.println(content);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}

Stavo attraversando SSL a 2 vie in springboot. Ho effettuato tutto il servizio di configurazione corretto del server Tomcat e il chiamante del servizio RestTemplate. ma ho ricevuto un errore come "java.security.cert.CertificateException: nessun nome alternativo soggetto presente"

Dopo aver esaminato le soluzioni, ho trovato, JVM ha bisogno di questo certificato altrimenti dà un errore di handshaking.

Ora, come aggiungerlo a JVM.

vai al file jre / lib / security / cacerts. dobbiamo aggiungere il nostro file del certificato del server a questo file cacerts di jvm.

Comando per aggiungere il certificato del server al file cacerts tramite la riga di comando in Windows.

C: \ Programmi \ Java \ jdk1.8.0_191 \ jre \ lib \ security> keytool -import -noprompt -trustcacerts -alias sslserver -file E: \ spring_cloud_sachin \ ssl_keys \ sslserver.cer -keystore cacerts -storepass changeit

Verificare che il certificato del server sia installato o meno:

C: \ Programmi \ Java \ jdk1.8.0_191 \ jre \ lib \ security> keytool -list -keystore cacerts

puoi vedere l'elenco dei certificati installati:

per maggiori dettagli: https://sachin4java.blogspot.com/2019/08/javasecuritycertcertificateexception-no.html

aggiungere la voce host con l'ip corrispondente al CN nel certificato

CN = someSubdomain.someorganisation.com

ora aggiorna l'ip con il nome CN dove stai tentando di accedere all'url.

Ha funzionato per me.

Questo codice funzionerà come un fascino e utilizzerà l'oggetto restTemple per il resto del codice.

  RestTemplate restTemplate = new RestTemplate();   
  TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
            @Override
            public boolean isTrusted(java.security.cert.X509Certificate[] x509Certificates, String s) {
                return true;
            }

        };

        SSLContext sslContext = null;
        try {
            sslContext = org.apache.http.ssl.SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy)
                    .build();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        restTemplate.setRequestFactory(requestFactory);
}

Quando si dispone di un certificato sia con CN che con nomi alternativi soggetto (SAN), se si effettua la richiesta in base al contenuto CN, quel particolare contenuto deve essere presente anche sotto SAN, altrimenti fallirà con l'errore in questione.

Nel mio caso CN aveva qualcosa, SAN aveva qualcos'altro. Ho dovuto usare l'URL SAN e poi ha funzionato bene.

Aggiungi il tuo indirizzo IP nel file hosts, che si trova nella cartella C: \ Windows \ System32 \ drivers \ ecc. Aggiungere anche l'IP e il nome di dominio dell'indirizzo IP. esempio: aaa.bbb.ccc.ddd abc@def.com

Ho risolto il problema nel modo seguente.

1. Creazione di una classe. La classe ha alcune implementazioni vuote

class MyTrustManager implements X509TrustManager {
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    return null;
}

public void checkClientTrusted(X509Certificate[] certs, String authType) {
}

public void checkServerTrusted(X509Certificate[] certs, String authType) {
}

@Override
public void checkClientTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate, String paramString)
        throws CertificateException {
    // TODO Auto-generated method stub

}

@Override
public void checkServerTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate, String paramString)
        throws CertificateException {
    // TODO Auto-generated method stub

}

2. Creazione di un metodo

private static void disableSSL() {
    try {
        TrustManager[] trustAllCerts = new TrustManager[] { new MyTrustManager() };

        // Install the all-trusting trust manager
        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HostnameVerifier allHostsValid = new HostnameVerifier() {
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };
        HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

3. Chiama il metodo disableSSL () in cui viene generata l'eccezione. Ha funzionato bene.