Como corrigir o erro “java.security.cert.CertificateException: Nenhum nome alternativo de assunto presente”?

Eu tenho um cliente de serviço web Java, que consome um serviço 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);
    }

Quando me conecto ao URL do serviço ( https://AAA.BBB.CCC.DDD:9443/ISomeService), recebo a exceção java.security.cert.CertificateException: No subject alternative names present.

Para corrigi-lo, primeiro executei openssl s_client -showcerts -connect AAA.BBB.CCC.DDD:9443 > certs.txte obtive o seguinte conteúdo no arquivo 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, agora eu preciso

1. extraia a parte certs.txtentre -----BEGIN CERTIFICATE-----e -----END CERTIFICATE-----,
2. modifique-o para que o nome do certificado seja igual a AAA.BBB.CCC.DDDe
3. em seguida, importe o resultado usando keytool -importcert -file fileWithModifiedCertificate(onde fileWithModifiedCertificateé o resultado das operações 1 e 2).

Isso está correto?

Em caso afirmativo, como exatamente posso fazer o certificado da etapa 1 funcionar com endereço baseado em IP ( AAA.BBB.CCC.DDD)?

Atualização 1 (23/10/2013 15:37 MSK): Em uma resposta a uma pergunta semelhante , li o seguinte:

Se você não estiver no controle desse servidor, use seu nome de host (desde que haja pelo menos um CN correspondente a esse nome de host no certificado existente).

O que exatamente significa "usar"?

Corrigi o problema desabilitando as verificações de HTTPS usando a abordagem apresentada aqui :

Eu coloquei o seguinte código na 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();
    }
}

Como estou usando https://AAA.BBB.CCC.DDD:9443/ISomeServiceapenas para fins de teste, é uma solução boa o suficiente.

Estou com o mesmo problema e resolvi com este código. Eu coloquei esse código antes da primeira chamada para meus serviços da 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");
    }
});

É simples e funciona bem.

Aqui está a fonte original.

Esta é uma pergunta antiga, mas eu tive o mesmo problema ao mudar de JDK 1.8.0_144 para jdk 1.8.0_191

Encontramos uma dica no changelog:

Changelog

adicionamos a seguinte propriedade de sistema adicional, que ajudou em nosso caso a resolver esse problema:

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

A verificação da identidade do certificado é realizada em relação ao que o cliente solicita.

Quando o seu cliente usa https://xxx.xxx.xxx.xxx/something(onde xxx.xxx.xxx.xxxé um endereço IP), a identidade do certificado é verificada em relação a este endereço IP (em teoria, usando apenas uma extensão IP SAN).

Se o seu certificado não tem SAN IP, mas SANs DNS (ou se não SANs DNS, um nome comum no DN do assunto), você pode fazer isso funcionar fazendo seu cliente usar um URL com esse nome de host (ou um nome de host para o qual o cert seria válido, se houver vários valores possíveis). Por exemplo, se você cert tem um nome parawww.example.com , use https://www.example.com/something.

Claro, você precisará desse nome de host para resolver esse endereço IP.

Além disso, se houver SANs DNS, o CN no DN do assunto será ignorado, portanto, use um nome que corresponda a um dos SANs DNS neste caso.

Para importar o certificado:

1. Extraia o certificado do servidor, por exemplo openssl s_client -showcerts -connect AAA.BBB.CCC.DDD:9443 > certs.txt isso irá extrair certificados no formato PEM.
2. Converta o certificado no formato DER, pois é isso que o keytool espera, por exemplo openssl x509 -in certs.txt -out certs.der -outform DER
3. Agora você deseja importar este certificado para o arquivo 'cacert' padrão do sistema. Localize o arquivo 'cacerts' padrão do sistema para a instalação do Java. Dê uma olhada em Como obter a localização dos cacerts da instalação padrão do java?
4. Importe os certs para esse arquivo cacerts: sudo keytool -importcert -file certs.der -keystore <path-to-cacerts>A senha cacerts padrão é 'changeit'.

Se o certificado for emitido para um FQDN e você estiver tentando se conectar por endereço IP em seu código Java, isso provavelmente deve ser corrigido em seu código, em vez de mexer com o próprio certificado. Altere seu código para se conectar por FQDN. Se o FQDN não puder ser resolvido em sua máquina de desenvolvimento, basta adicioná-lo ao arquivo hosts ou configurar sua máquina com um servidor DNS que possa resolver esse FQDN.

Corrigi esse problema de maneira correta adicionando os nomes alternativos do assunto no certificado, em vez de fazer qualquer alteração no código ou desabilitar o SSL, ao contrário do que outras respostas sugerem aqui. Se você vir claramente, a exceção diz "Faltam nomes alternativos de assunto", portanto, a maneira certa deve ser adicioná-los

Por favor, olhe este link para entender passo a passo .

O erro acima significa que seu arquivo JKS não tem o domínio necessário no qual você está tentando acessar o aplicativo. Você precisará usar Open SSL e a ferramenta-chave para adicionar vários domínios

1. Copie o openssl.cnf para um diretório atual
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. Exporte o arquivo de chave pública (.pem) para o formato PKS12. Isso irá solicitar a senha

   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. Crie um.JKS a partir de PEM autoassinado (Keystore)

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

7. Gerar um certificado do Keystore ou arquivo JKS acima

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

8. Como o certificado acima é autoassinado e não é validado pela CA, ele precisa ser adicionado ao Truststore (arquivo Cacerts no local abaixo para MAC, para Windows, descubra onde seu JDK está instalado).

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

Resposta original postada neste link aqui .

Você pode não querer desabilitar toda a verificação SSL e, portanto, pode simplesmente desabilitar a verificação hostName por meio disso, o que é um pouco menos assustador do que a alternativa:

HttpsURLConnection.setDefaultHostnameVerifier(
    SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

[EDITAR]

Conforme mencionado por conapart3, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIERagora está obsoleto, por isso pode ser removido em uma versão posterior, então você pode ser forçado no futuro a lançar o seu próprio, embora eu ainda diria que evitaria qualquer solução em que toda a verificação fosse desligada.

meu problema em obter esse erro foi resolvido usando o URL completo "qatest.ourCompany.com/webService" em vez de apenas "qatest / webService". O motivo era que nosso certificado de segurança tinha um caractere curinga, ou seja, "* .nossa empresa.com". Assim que coloquei o endereço completo, a exceção foi embora. Espero que isto ajude.

Já respondi em https://stackoverflow.com/a/53491151/1909708 .

Isso falha porque nem o nome comum do certificado ( CNna certificação Subject) nem qualquer um dos nomes alternativos ( Subject Alternative Nameno certificado) correspondem ao nome do host de destino ou ao endereço IP.

Por exemplo, a partir de uma JVM, ao tentar se conectar a um endereço IP ( WW.XX.YY.ZZ) e não ao nome DNS ( https://stackoverflow.com ), a conexão HTTPS falhará porque o certificado armazenado no armazenamento confiável javacacerts espera um nome comum (ou nome alternativo do certificado, como stackexchange.com ou * .stackoverflow.com etc.) para corresponder ao endereço de destino.

Verifique: 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();

Acima, passou um HostnameVerifierobjeto implementado que sempre retorna true:

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

Para Spring Boot RestTemplate:

• adicionar org.apache.httpcomponents.httpcoredependência

• usar NoopHostnameVerifierpara fábrica 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);

Eu cheguei a essa pergunta depois se recebi essa mesma mensagem de erro. No entanto, no meu caso, tínhamos dois URLs com subdomínios diferentes ( http://example1.xxx.com/someservice e http://example2.yyy.com/someservice ) que foram direcionados para o mesmo servidor. Este servidor tinha apenas um certificado curinga para o domínio * .xxx.com. Ao usar o serviço por meio do segundo domínio, o certificado encontrado (* .xxx.com) não corresponde ao domínio solicitado (* .yyy.com) e o erro ocorre.

Nesse caso, não devemos tentar consertar tal mensagem de erro diminuindo a segurança SSL, mas devemos verificar o servidor e os certificados nele.

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

Eu estava passando por SSL de 2 vias no springboot. Eu fiz toda a configuração correta do servidor tomcat do serviço e do chamador do serviço RestTemplate. mas eu estava recebendo um erro como "java.security.cert.CertificateException: Nenhum nome alternativo de assunto presente"

Depois de passar pelas soluções, descobri, a JVM precisa desse certificado, caso contrário, dá erro de handshaking.

Agora, como adicionar isso ao JVM.

vá para o arquivo jre / lib / security / cacerts. precisamos adicionar nosso arquivo de certificado do servidor a este arquivo cacerts de jvm.

Comando para adicionar certificado de servidor ao arquivo cacerts via linha de comando no Windows.

C: \ Arquivos de programas \ 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

Verifique se o certificado do servidor está instalado ou não:

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

você pode ver a lista de certificados instalados:

para mais detalhes: https://sachin4java.blogspot.com/2019/08/javasecuritycertcertificateexception-no.html

adicione a entrada do host com o ip correspondente ao CN no certificado

CN = someSubdomain.someorganisation.com

agora atualize o ip com o nome CN onde você está tentando acessar a url.

Funcionou para mim

Este código funcionará perfeitamente e usará o objeto restTemple para o resto do código.

  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 você tem um certificado com CN e nomes alternativos de assunto (SAN), se você fizer sua solicitação com base no conteúdo CN, esse conteúdo específico também deverá estar presente no SAN, caso contrário, falhará com o erro em questão.

No meu caso, CN tinha algo, SAN tinha algo mais. Tive que usar o URL da SAN e funcionou perfeitamente.

Adicione seu endereço IP no arquivo hosts.que está na pasta C: \ Windows \ System32 \ drivers \ etc. Adicione também o IP e o nome de domínio do endereço IP. exemplo: aaa.bbb.ccc.ddd abc@def.com

Resolvi o problema da seguinte maneira.

1. Criação de uma classe. A classe tem algumas implementações vazias

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. Criação de um método

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. Chame o método disableSSL () onde a exceção é lançada. Funcionou bem.