Comment corriger l'erreur «java.security.cert.CertificateException: aucun autre nom de sujet n'est présent»?

J'ai un client de service Web Java, qui consomme un service Web via 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);
    }

Lorsque je me connecte à l'URL du service ( https://AAA.BBB.CCC.DDD:9443/ISomeService), j'obtiens l'exceptionjava.security.cert.CertificateException: No subject alternative names present .

Pour le réparer, j'ai d'abord couru openssl s_client -showcerts -connect AAA.BBB.CCC.DDD:9443 > certs.txtet j'ai obtenu le contenu suivant dans le fichier 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, maintenant je dois

1. extraire la partie certs.txtentre -----BEGIN CERTIFICATE-----et-----END CERTIFICATE----- ,
2. modifiez-le pour que le nom du certificat soit égal à AAA.BBB.CCC.DDD et
3. puis importez le résultat en utilisant keytool -importcert -file fileWithModifiedCertificate(où fileWithModifiedCertificateest le résultat des opérations 1 et 2).

Est-ce correct?

Si tel est le cas, comment puis-je faire en sorte que le certificat de l'étape 1 fonctionne avec une adresse IP (AAA.BBB.CCC.DDD ) ?

Mise à jour 1 (23.10.2013 15:37 MSK): Dans une réponse à une question similaire , j'ai lu ce qui suit:

Si vous ne contrôlez pas ce serveur, utilisez son nom d'hôte (à condition qu'il y ait au moins un CN correspondant à ce nom d'hôte dans le certificat existant).

Que signifie exactement «utiliser»?

J'ai résolu le problème en désactivant les vérifications HTTPS en utilisant l'approche présentée ici :

J'ai mis le code suivant dans la 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();
    }
}

Puisque j'utilise le https://AAA.BBB.CCC.DDD:9443/ISomeServiceà des fins de test uniquement, c'est une solution assez bonne.

J'ai le même problème et résolu avec ce code. J'ai mis ce code avant le premier appel à mes webservices.

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

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

C'est simple et fonctionne bien.

Voici la source originale.

C'est une vieille question, mais j'ai eu le même problème lors du passage du JDK 1.8.0_144 au jdk 1.8.0_191

Nous avons trouvé un indice dans le changelog:

Changelog

nous avons ajouté la propriété système supplémentaire suivante, qui a aidé dans notre cas à résoudre ce problème:

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

La vérification de l'identité du certificat est effectuée par rapport à ce que le client demande.

Lorsque votre client utilise https://xxx.xxx.xxx.xxx/something(où xxx.xxx.xxx.xxxest une adresse IP), l'identité du certificat est vérifiée par rapport à cette adresse IP (en théorie, en utilisant uniquement une extension IP SAN).

Si votre certificat n'a pas de SAN IP, mais des SAN DNS (ou s'il n'y a pas de SAN DNS, un nom commun dans le DN du sujet), vous pouvez le faire fonctionner en faisant en sorte que votre client utilise à la place une URL avec ce nom d'hôte (ou un nom d'hôte pour lequel le certificat serait valide, s'il y a plusieurs valeurs possibles). Par exemple, si votre certificat a un nom pour www.example.com, utilisez https://www.example.com/something.

Bien sûr, vous aurez besoin de ce nom d'hôte pour résoudre cette adresse IP.

En outre, s'il existe des SAN DNS, le CN dans le DN du sujet sera ignoré, utilisez donc un nom qui correspond à l'un des SAN DNS dans ce cas.

Pour importer le certificat:

1. Extrayez le certificat du serveur, par exemple openssl s_client -showcerts -connect AAA.BBB.CCC.DDD:9443 > certs.txtCela extraira les certificats au format PEM.
2. Convertissez le certificat au format DER car c'est ce que keytool attend, par exemple openssl x509 -in certs.txt -out certs.der -outform DER
3. Vous voulez maintenant importer ce certificat dans le fichier système par défaut «cacert». Recherchez le fichier «cacerts» par défaut du système pour votre installation Java. Jetez un oeil à Comment obtenir l'emplacement des cacerts de l'installation java par défaut?
4. Importez les certificats dans ce fichier cacerts: le sudo keytool -importcert -file certs.der -keystore <path-to-cacerts>mot de passe par défaut de cacerts est «changeit».

Si le certificat est émis pour un FQDN et que vous essayez de vous connecter par adresse IP dans votre code Java, cela devrait probablement être corrigé dans votre code plutôt que de jouer avec le certificat lui-même. Modifiez votre code pour vous connecter par FQDN. Si le FQDN ne peut pas être résolu sur votre machine de développement, ajoutez-le simplement à votre fichier hosts ou configurez votre machine avec un serveur DNS capable de résoudre ce FQDN.

J'ai résolu ce problème de la bonne manière en ajoutant les noms alternatifs des sujets dans le certificat plutôt qu'en apportant des modifications au code ou en désactivant SSL contrairement à ce que d'autres réponses suggèrent ici. Si vous voyez clairement, l'exception indique que les "noms alternatifs des sujets manquent", la bonne façon devrait donc être de les ajouter

Veuillez regarder ce lien pour comprendre étape par étape .

L'erreur ci-dessus signifie que votre fichier JKS n'a pas le domaine requis sur lequel vous essayez d'accéder à l'application.Vous devrez utiliser Open SSL et l'outil clé pour ajouter plusieurs domaines

1. Copiez le fichier openssl.cnf dans un répertoire courant
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/[email protected]' -days 365

5. Exportez le fichier de clé publique (.pem) au format PKS12. Cela vous demandera le mot de passe

   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. Créer un.JKS à partir d'un PEM auto-signé (Keystore)

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

7. Générer un certificat à partir du Keystore ou du fichier JKS ci-dessus

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

8. Étant donné que le certificat ci-dessus est auto-signé et n'est pas validé par l'autorité de certification, il doit être ajouté dans Truststore (fichier Cacerts à l'emplacement ci-dessous pour MAC, pour Windows, découvrez où votre JDK est installé.)

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

Réponse originale publiée sur ce lien ici .

Vous ne voudrez peut-être pas désactiver toutes les vérifications ssl et vous pouvez donc simplement désactiver la vérification du nom d'hôte via ce qui est un peu moins effrayant que l'alternative:

HttpsURLConnection.setDefaultHostnameVerifier(
    SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

[ÉDITER]

Comme mentionné par conapart3 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIERest maintenant obsolète, il peut donc être supprimé dans une version ultérieure, vous pourriez donc être obligé à l'avenir de lancer le vôtre, même si je dirais toujours que je m'éloignerais de toute solution où toute vérification est désactivée.

mon problème avec cette erreur a été résolu en utilisant l'URL complète "qatest.ourCompany.com/webService" au lieu de simplement "qatest / webService". La raison était que notre certificat de sécurité avait un caractère générique, à savoir "* .ourCompany.com". Une fois que j'ai mis l'adresse complète, l'exception a disparu. J'espère que cela t'aides.

J'y ai déjà répondu dans https://stackoverflow.com/a/53491151/1909708 .

Cela échoue car ni le nom commun du certificat ( CNdans la certification Subject) ni aucun des autres noms ( Subject Alternative Namedans le certificat) ne correspondent au nom d'hôte ou à l'adresse IP cible.

Par exemple, à partir d'une JVM, lorsque vous essayez de vous connecter à une adresse IP ( WW.XX.YY.ZZ) et non au nom DNS ( https://stackoverflow.com ), la connexion HTTPS échouera car le certificat stocké dans le truststore javacacerts attend un nom commun (ou un autre nom du certificat comme stackexchange.com ou * .stackoverflow.com etc.) pour correspondre à l'adresse cible.

Veuillez vérifier: 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();

Ci-dessus, passé un HostnameVerifierobjet implémenté qui est toujours retourné true:

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

Pour Spring Boot RestTemplate:

• ajouter une org.apache.httpcomponents.httpcoredépendance

• utiliser NoopHostnameVerifierpour l'usine SSL:

  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);

Je suis arrivé à cette question après avoir reçu le même message d'erreur. Cependant, dans mon cas, nous avions deux URL avec des sous-domaines différents ( http://example1.xxx.com/someservice et http://example2.yyy.com/someservice ) qui étaient dirigés vers le même serveur. Ce serveur n'avait qu'un seul certificat générique pour le domaine * .xxx.com. Lors de l'utilisation du service via le deuxième domaine, le certificat trouvé (* .xxx.com) ne correspond pas au domaine demandé (* .yyy.com) et l'erreur se produit.

Dans ce cas, nous ne devrions pas essayer de corriger un tel message d'erreur en réduisant la sécurité SSL, mais nous devrions vérifier le serveur et les certificats qu'il contient.

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();
            }
        }
    }
}

Je passais par SSL 2 voies dans springboot. J'ai fait tout le serveur de tomcat de service de configuration correct et l'appelant de service RestTemplate. mais j'obtenais une erreur comme "java.security.cert.CertificateException: aucun autre nom de sujet présent"

Après avoir parcouru les solutions, j'ai trouvé que JVM a besoin de ce certificat, sinon cela donne une erreur de négociation.

Maintenant, comment ajouter ceci à JVM.

allez dans le fichier jre / lib / security / cacerts. nous devons ajouter notre fichier de certificat de serveur à ce fichier cacerts de jvm.

Commande pour ajouter un certificat de serveur au fichier cacerts via la ligne de commande dans Windows.

C: \ Program Files \ 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

Vérifiez que le certificat du serveur est installé ou non:

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

vous pouvez voir la liste des certificats installés:

pour plus de détails: https://sachin4java.blogspot.com/2019/08/javasecuritycertcertificateexception-no.html

ajoutez l'entrée d'hôte avec l'ip correspondant au CN dans le certificat

CN = someSubdomain.someorganisation.com

maintenant, mettez à jour l'adresse IP avec le nom CN où vous essayez d'accéder à l'url.

Cela a fonctionné pour moi.

Ce code fonctionnera comme du charme et utilisera l'objet restTemple pour le reste du code.

  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);
}

Lorsque vous avez un certificat avec à la fois CN et SAN (Subject Alternative Names), si vous faites votre demande en fonction du contenu CN, ce contenu particulier doit également être présent sous SAN, sinon il échouera avec l'erreur en question.

Dans mon cas, le CN avait quelque chose, le SAN avait autre chose. J'ai dû utiliser l'URL SAN, puis cela a très bien fonctionné.

Ajoutez votre adresse IP dans le fichier hosts qui se trouve dans le dossier C: \ Windows \ System32 \ drivers \ etc. Ajoutez également l'IP et le nom de domaine de l'adresse IP. exemple: aaa.bbb.ccc.ddd [email protected]

J'ai résolu le problème de la manière suivante.

1. Créer une classe. La classe a des implémentations vides

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. Créer une méthode

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. Appelez la méthode disableSSL () où l'exception est levée. Cela a bien fonctionné.