HTTPS con certificado autofirmado en Spring Boot

Programación

1. Información general

En este tutorial, mostraremos cómo habilitar HTTPS en Spring Boot. Para ello, también generaremos un certificado autofirmado y configuraremos una aplicación sencilla.

Para obtener más detalles sobre los proyectos de Spring Boot, podemos consultar varios recursos aquí.

2. Generación de un certificado autofirmado

Antes de comenzar, crearemos un certificado autofirmado. Usaremos cualquiera de los siguientes formatos de certificado:

  • PKCS12: Estándares criptográficos de clave pública es un formato protegido por contraseña que puede contener varios certificados y claves; es un formato utilizado en toda la industria
  • JKS: Java KeyStore es similar a PKCS12; es un formato propietario y está limitado al entorno Java.

Podemos utilizar las herramientas keytool o OpenSSL para generar los certificados desde la línea de comandos. Keytool se envía con Java Runtime Environment y OpenSSL se puede descargar desde aquí.

Usemos keytool para nuestra demostración.

2.1. Generando un almacén de claves

Ahora crearemos un conjunto de claves criptográficas y lo almacenaremos en un almacén de claves.

Podemos usar el siguiente comando para generar nuestro formato de almacén de claves PKCS12:

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

Podemos almacenar tantos números de pares de claves en el mismo almacén de claves, cada uno identificado por un alias único.

Para generar nuestro almacén de claves en formato JKS, podemos usar el siguiente comando:

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

Se recomienda utilizar el formato PKCS12, que es un formato estándar de la industria. Entonces, en caso de que ya tengamos un almacén de claves JKS, podemos convertirlo al formato PKCS12 usando el siguiente comando:

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

Tendremos que proporcionar la contraseña del almacén de claves de origen y también establecer una nueva contraseña del almacén de claves. El alias y la contraseña del almacén de claves se necesitarán más adelante.

3. Habilitación de HTTPS en Spring Boot

Spring Boot proporciona un conjunto de propiedades declarativas server.ssl. *. Usaremos esas propiedades en nuestra aplicación de muestra para configurar HTTPS.

Comenzaremos con una aplicación Spring Boot simple con Spring Security que contiene una página de bienvenida manejada por el punto final " / welcome ".

Luego, copiaremos el archivo llamado " baeldung.p12" generado en el paso anterior en el directorio " src / main / resources / keystore ".

3.1. Configuración de propiedades SSL

Ahora, configuraremos las propiedades relacionadas con 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/baeldung.p12 # The password used to generate the certificate server.ssl.key-store-password=password # The alias mapped to the certificate server.ssl.key-alias=baeldung

Dado que estamos usando la aplicación habilitada para Spring Security, configurémosla para aceptar solo solicitudes HTTPS:

server.ssl.enabled=true

4. Invocar una URL HTTPS

Ahora que hemos habilitado HTTPS en nuestra aplicación, pasemos al cliente y exploremos cómo invocar un punto final HTTPS con el certificado autofirmado.

Primero, necesitamos crear una tienda de confianza. Como hemos generado un archivo PKCS12, podemos usar el mismo que el almacén de confianza. Definamos nuevas propiedades para los detalles de la tienda de confianza:

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

Ahora necesitamos preparar un SSLContext con el almacén de confianza y crear una RestTemplate personalizada :

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 el bien de la demostración, asegurémonos de que Spring Security permita cualquier solicitud entrante:

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

Finalmente, podemos hacer una llamada al punto final HTTPS:

@Test public void whenGETanHTTPSResource_thenCorrectResponse() throws Exception { ResponseEntity response = restTemplate().getForEntity(WELCOME_URL, String.class, Collections.emptyMap()); assertEquals("", response.getBody()); assertEquals(HttpStatus.OK, response.getStatusCode()); }

5. Conclusión

En el tutorial, primero aprendimos cómo generar un certificado autofirmado para habilitar HTTPS en una aplicación Spring Boot. Además, mostramos cómo invocar un punto final habilitado para HTTPS.

Como siempre, podemos encontrar el código fuente completo en el repositorio de GitHub.

Finalmente, para ejecutar la muestra de código, necesitamos quitar los comentarios de la siguiente propiedad de clase de inicio en el pom.xml :

com.baeldung.ssl.HttpsEnabledApplication