Conexão SSL em aplicações JAVA

O uso de SSL para criptografar a comunicação entre o cliente e as aplicações é muito comum, principalmente em webservices. Em JAVA, isso acaba causando problemas que, apesar de serem simples de solucionar, são pouco documentados ou a documentação é de difícil acesso. Por isso, resolvi escrever este post para ajudar na solução desses problemas.

Na comunicação via SSL, ao enviar a primeira requisição o cliente recebe o certificado do servidor, que contem uma chave pública. O cliente então utiliza essa chave pública para criptografar os dados antes de cada requisição para o servidor, que por sua vez utiliza a sua chave privada para decriptografar os dados antes de processá-lo.

Em Java, existe o conceito de certificados confiáveis, que são aqueles armazenados em um repositório de chaves, chamado keystore. Ao tentar estabelecer a requisição, a JVM utiliza o gerenciador de certificados para aceitar ou não a conexão. Caso o certificado não esteja importado ou o keystore não esteja presente a conexão será rejeitada.

Para resolver esse problema pode-se usar duas abordagens. A primeira é importar manualmente o certificado e informar a JVM qual keystore utilizar. Para importar o certificado, é necessário primeiro fazer o download (.cer), o que pode ser feito pelo browser, e então utilizar o utilitário keytool para importá-lo.

keytool -importcert -alias certificado_do_servidor -keystore arquivo_keystore -file arquivo.cer

O keytool solicitará a senha do keystore para armazenar o certificado.

Feito isso, agora falta informar a JVM sobre o keystore que deve ser utilizado. Isso é feito por meio de variáveis de ambiente que podem ser passadas para a JVM pela linha de comando, utilizando a notação -Dnome=valor, ou dentro do seu código, utilizando o método System.setProperty. As variáveis que devem ser definidas são:

javax.net.ssl.trustStore=/caminho/arquivo_keystore
javax.net.ssl.trustStorePassword=senha_keystore

O problema dessa solução é que você precisa primeiro importar o certificado manualmente antes de distribuir sua aplicação e, no caso de uma mudança do certificado, sua aplicação pode parar de funcionar, apresentando o erro SSLHandshakeException, e aí você precisaria importar o novo certificado. A segunda abordagem é um pouco mais complicada, mas evita que a aplicação quebre quando houver mudanças de certificados.

Ao estabelecer uma conexão SSL a JVM utilizará um contexto SSL. O que faremos é criar um novo contexto SSL, substituindo o gerenciador de certificados por uma implementação customizada, que  importará os novos certificados automaticamente.

A seguir, está a classe customizada para gerenciamento dos certificados.

/**
 * Classe responsável pelo gerenciamento dos certificados
 */
public class CustomTrustManager implements X509TrustManager {

 // Nome da variável de ambiente que contem a senha 
 // do arquivo de keystore
 private static final String SENHA_KEYSTORE_VAR = 
    "javax.net.ssl.trustStorePassword";
 // Nome da variável de ambiente que contem o caminho 
 // para o arquivo de keystore
 private static final String TRUST_STORE_VAR = 
    "javax.net.ssl.trustStore";


 // O caminho para o arquivo de keystore
 private String keyStorePath;

 // A senha do arquivo de keystore
 private String senhaKeystore;

 // O objeto keystore que será carregado do arquivo
 private KeyStore keyStore;

 // O gerenciador padrão, que será utilizado pela nossa classe
 // evitando que precisemos reimplementar toda a 
 // lógica de gerenciamento
 private X509TrustManager trustManager;

 public CustomTrustManager() throws Exception {
  super();
  
  // Carrega os certificados armazenados
  setKeyStorePath();
  
  // Inicia o gerenciador padrão
  getTrustManager();
 }

 // Método obrigatório para implementar a interface do gerenciador
 public void checkClientTrusted(X509Certificate[] chain, 
   String authType) throws CertificateException {

  // Utiliza o gerenciador padrão para executar a verificação
  trustManager.checkClientTrusted(chain, authType);
 }

 // Método obrigatório para implementar a interface do gerenciador
 public void checkServerTrusted(X509Certificate[] chain, 
   String authType) throws CertificateException {

  try {
   // Utiliza o gerenciador padrão para executar a verificação
   trustManager.checkClientTrusted(chain, authType);
  } catch (CertificateException e) {
   // No caso de erro, o certificado é importado e 
   // a verificação é refeita
   adicionarCertificado(chain);
   trustManager.checkClientTrusted(chain, authType);
  }
 }

 // Método obrigatório para implementar a interface do gerenciador
 public X509Certificate[] getAcceptedIssuers() {
  // Utiliza o gerenciador padrão recuperar os certificados
  return trustManager.getAcceptedIssuers();
 }

 // Método responsável por importar o certificado
 private void adicionarCertificado(X509Certificate[] chain) 
  throws CertificateException {
 
  // É comum que o certificado contenha toda a rede de certificação.
  // Nesse caso, toda ela será carregada
  for (X509Certificate cert : chain) {
   try {
    // Armazena o certificado com o alias Certificado_X_Y, 
    // onde X é o serial e Y é o Current Time Millis.
    // Isso evita a duplicidade de alias.
    keyStore.setCertificateEntry("Certificado_" 
      + cert.getSerialNumber() + "_"
      + System.currentTimeMillis(), cert);
   } catch (KeyStoreException e) {
   throw new CertificateException("Erro ao aceitar o certificado.", e);
   }
  }

  try {
   // Armazena os certificados no arquivo informado pela
   // variável de ambiente com a senha específica
   OutputStream streamKeyStore = new FileOutputStream(
      new File(keyStorePath));
   keyStore.store(streamKeyStore, senhaKeystore.toCharArray());
   getTrustManager();
  } catch (Exception e) {
  throw new CertificateException("Erro ao aceitar o certificado.", e);
  }
 }

 // Método responsável por iniciar o gerenciador de certificados
 protected void getTrustManager() throws Exception {
  // Recupera o algoritmo default de certificados
  String algoritmo = TrustManagerFactory.getDefaultAlgorithm();
  // Recupera a fabrica de gerenciadores para o algoritmo padrão
  TrustManagerFactory fabricaTM = 
      TrustManagerFactory.getInstance(algoritmo);

  // Inicia a fábrica com o keystore
  fabricaTM.init(this.keyStore);

  // Recupera todos os gerenciadores do sistema para encontrar o 
  // responsável pelos certificados
  TrustManager tms[] = fabricaTM.getTrustManagers();
  for (TrustManager tm : tms) {
   if (tm instanceof X509TrustManager) {
    this.trustManager = (X509TrustManager) tm;
    return;
   }
  }

  // Caso não seja encontrado um gerenciador para os certificados, 
  // lança a exceção
  throw new NoSuchAlgorithmException("TrustManager não encontrado!");
 }

 // Método responsável por carregar o keystore do arquivo especificado
 protected void setKeyStorePath() throws Exception {
  // Recupera o caminho do arquivo e a senha do keystore
  this.keyStorePath = System.getProperty(TRUST_STORE_VAR);
  this.senhaKeystore = System.getProperty(SENHA_KEYSTORE_VAR);

  if (this.keyStorePath == null) {
   throw new KeyStoreException("O caminho do keystore não pode " +
     " ser null. Informe em " + TRUST_STORE_VAR);
  }

  // Obtem o keystore para o tipo padrão do sistema
  this.keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
  
  // Inicia o stream para leitura dos certificados já importados
  InputStream streamKeyStore = 
      new FileInputStream(new File(keyStorePath));

  try {
   // Carrega os certificados já importados utilizando 
   // a senha informada
   this.keyStore.load(streamKeyStore, senhaKeystore.toCharArray());
  } finally {
   if (streamKeyStore != null) {
    streamKeyStore.close();
   }
  }
 }
}

Perceba que os métodos obrigatórios da interface são implementados por delegação para um gerenciador que foi obtido do sistema. Dessa forma evitamos a implementação de toda a lógica de um gerenciador padrão e somente fazemos o tratamento necessário no momento de carregar os certificados que ainda não foram importados. Note também que é obrigatório que já exista um arquivo de keystore.

Vejamos agora como utilizar o nosso gerenciador para realizar a conexão com um servidor https do qual não possuímos o certificado.

public class TesteHttpsURLConnection {

  public static void main(String[] args) throws Exception {
  
  // Define a variável de ambiente com o caminho do keystore
  System.setProperty("javax.net.ssl.trustStore", "/tmp/keystore");
  // Define a variável de ambiente com a senha do keystore
  System.setProperty("javax.net.ssl.trustStorePassword", "changeit");

  // Recupera o contexto SSL
  SSLContext context = SSLContext.getInstance("SSL");
  // Define o nosso gerenciador como o gerenciador default do contexto
  context.init(null, 
     new TrustManager[] { new CustomTrustManager() }, null);

  // Cria a conexão com o endereço https
  URL httpsURL = new URL("https://internetbanking.caixa.gov.br/");
  HttpsURLConnection connection = 
     (HttpsURLConnection) httpsURL.openConnection();
  // Define a fábrica de sockets do nosso contexto
  connection.setSSLSocketFactory(context.getSocketFactory());

  // Realiza a conexão
  connection.connect();
  
  // Exibe as chaves dos certificados do servidor
  Certificate[] certs = connection.getServerCertificates();
  for (Certificate cert: certs) {
   System.out.println(cert.getPublicKey());
  }
 }
}

Como demonstração, você pode executar o main sem a linha que define o socket factory para ver que será lançada a exceção SSLHandshakeException.

Se você utilizar o utilitário keytool para verificar os certificados no arquivo de keystore, verá que todos os certificados do servidor foram armazenados lá. Evitando que seja necessário importá-los novamente.