HTTPS usando certificado autoassinado na inicialização do Spring

1. Visão geral

Neste tutorial, vamos ilustrar passo a passo um exemplo de ativação de HTTPS em um aplicativo Spring Boot.

Vamos gerar um certificado autoassinado e configurá-lo em um aplicativo de amostra. Para obter mais detalhes sobre projetos Spring Boot, podemos nos referir a vários recursoshere.

Leitura adicional:

Configuração Automática de Segurança de Inicialização Spring

Um guia rápido e prático para a configuração padrão do Spring Security do Spring Boot.

Introdução ao Java Config para Spring Security

Um guia rápido e prático para o Java Config for Spring Security

2. Gerando um certificado autoassinado

Antes de começar, criaremos um certificado autoassinado. Usaremos um dos seguintes formatos de certificado:

PKCS12:Public Key Cryptographic Standards é um formato protegido por senha que pode conter vários certificados e chaves; é um formato usado em todo o setor
JKS:Java KeyStore é semelhante a PKCS12; é um formato proprietário e é limitado ao ambiente Java.

Podemos usar as ferramentas keytool ou OpenSSL para gerar os certificados a partir da linha de comando. Keytool é fornecido com o Java Runtime Environment e o OpenSSL pode ser baixado dehere.

Vamos usar o keytool para nossa demonstração.

2.1. Gerando um Keystore

Agora vamos criar um conjunto de chaves criptográficas e armazená-lo em um armazenamento de chaves.

Podemos usar o seguinte comando para gerar nosso formato de keystore PKCS12:

keytool -genkeypair -alias example -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore example.p12 -validity 3650

Podemos armazenar o maior número de pares de chaves no mesmo keystore, cada um identificado por um alias exclusivo.

Para gerar nosso keystore em um formato JKS, podemos usar o seguinte comando:

keytool -genkeypair -alias example -keyalg RSA -keysize 2048 -keystore example.jks -validity 3650

É recomendável usar o formato PKCS12, que é um formato padrão do setor. Portanto, caso já tenhamos um keystore JKS, podemos convertê-lo para o formato PKCS12 usando o seguinte comando:

keytool -importkeystore -srckeystore example.jks -destkeystore example.p12 -deststoretype pkcs12

Teremos que fornecer a senha do keystore de origem e também definir uma nova senha do keystore. O alias e a senha do keystore serão necessários posteriormente.

3. Habilitando HTTPS no Spring Boot

Spring Boot fornece um conjunto deserver.ssl.* properties. declarativo. Vamos configurar essas propriedades em nosso aplicativo de amostra para configurar HTTPS.

Começaremos com um simples aplicativo Spring Bootwith Spring Security contendo uma página de boas-vindas tratada pelo endpoint “/welcome”.

Vamos copiar o arquivo chamado “example.p12″ gerado na etapa anterior para o diretório“src/main/resources/keystore ”.

3.1. Configurando Propriedades SSL

Agora, vamos configurar as propriedades relacionadas ao SSL:

# The format used for the keystore. It could be set to JKS in case it is a JKS file
server.ssl.key-store-type=PKCS12
# The path to the keystore containing the certificate
server.ssl.key-store=classpath:keystore/example.p12
# The password used to generate the certificate
server.ssl.key-store-password=password
# The alias mapped to the certificate
server.ssl.key-alias=example

Como estamos usando o aplicativo habilitado para Spring Security, vamos configurá-lo para aceitar apenas solicitações HTTPS:

security.require-ssl=true

4. Invocar um URL HTTPS

Agora que habilitamos o HTTPS em nosso aplicativo, vamos prosseguir para o cliente e explorar como invocar um endpoint HTTPS com o certificado autoassinado.

Primeiro, precisamos criar um armazenamento confiável. Como geramos um arquivo PKCS12, podemos usar o mesmo que o armazenamento confiável. Vamos definir novas propriedades para os detalhes do armazenamento confiável:

#trust store location
trust.store=classpath:keystore/example.p12
#trust store password
trust.store.password=password

Agora precisamos preparar umSSLContext com o armazenamento confiável e criar umRestTemplate: personalizado

RestTemplate restTemplate() throws Exception {
    SSLContext sslContext = new SSLContextBuilder()
      .loadTrustMaterial(trustStore.getURL(), trustStorePassword.toCharArray())
      .build();
    SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext);
    HttpClient httpClient = HttpClients.custom()
      .setSSLSocketFactory(socketFactory)
      .build();
    HttpComponentsClientHttpRequestFactory factory =
      new HttpComponentsClientHttpRequestFactory(httpClient);
    return new RestTemplate(factory);
}

Por causa da demonstração, vamos ter certeza de queSpring Security permite todas as solicitações recebidas:

protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
      .antMatchers("/**")
      .permitAll();
}

Por fim, podemos fazer uma chamada para o terminal HTTPS:

@Test
public void whenGETanHTTPSResource_thenCorrectResponse() throws Exception {
    ResponseEntity response =
      restTemplate().getForEntity(WELCOME_URL, String.class, Collections.emptyMap());

    assertEquals("Welcome to Secured Site", response.getBody());
    assertEquals(HttpStatus.OK, response.getStatusCode());
}

5. Conclusão

No tutorial, aprendemos sobre como gerar um certificado autoassinado para ativar o HTTPS em um aplicativo Spring Boot. Também aprendemos como chamar um terminal habilitado para HTTPS.

Como sempre, podemos encontrar o código-fonte completo emGitHub repository.

Finalmente, para executar o exemplo de código, precisamos descomentar a seguinte propriedade start-class empom.xml:

org.example.ssl.HttpsEnabledApplication

TOC

HTTPS usando certificado autoassinado na inicialização do Spring