1. Introducción
En este breve tutorial, configuraremos un WebClient de Spring para solicitudes HTTPS.
Asegurar la comunicación HTTP con cifrado dificulta que los atacantes manipulen los datos de los usuarios. Hoy en día, es la configuración predeterminada para la mayoría de las aplicaciones modernas que se integran con otros servicios.
En esta guía, comenzaremos con la verificación de un archivo de certificado y clave, y luego pasaremos a configurar Spring WebClient.
2. Verificando Archivos de Certificado y Clave
Primero, verificaremos que nuestro certificado y archivo de clave tengan el mismo MD5. Hacer esto asegura que el certificado y la clave no han sido modificados.
Podemos usar openssl para mostrar el hash MD5:
openssl x509 -noout -modulus -in yourCertificate.crt | openssl md5
De manera similar, podemos hacer lo mismo para el archivo clave:
openssl rsa -noout -modulus -in yourPrivateKey.key | openssl md5
Las salidas coincidentes de ambos comandos confirman que su certificado y clave están alineados.
Podemos probar el certificado y la clave con un CURL:
curl -v --cert yourCertificate.crt --key yourPrivateKey.key https://yourEndpoint.com
Ahora, podemos pasar a convertir el certificado y la clave al formato PKCS12.
3. Convertir el Certificado y la Clave al Formato PKCS12
Para configurar Spring WebClient, necesitamos convertir el certificado al formato PKCS12.
Nuevamente, utilicemos openssl para obtener el archivo en formato PKCS12:
openssl pkcs12 -export -in yourCertificate.crt -inkey yourPrivateKey.key -out certificate.p12
Ejecutar el comando anterior nos pedirá que creemos una contraseña. Introduzcamos una de nuestra elección y guardémosla en un lugar seguro, ya que la reutilizaremos al configurar el SslContext para el WebClient.
Ahora, tenemos un archivo certificate.p12 que podemos utilizar para configurar nuestra aplicación.
4. Configurando el SSLContext
Finalmente, podemos crear un SslContext que lea el archivo que creamos anteriormente, junto con la contraseña que establecimos.
Usaremos el SslContextBuilder para crear el SslContext:
SslContext sslContext = SslContextBuilder.forClient().keyManager(
new FileInputStream("pathToP12CertificateFile"),
"password".toCharArray()).build();
Ahora, el sslContext se puede utilizar para crear un bean de WebClient que puede realizar llamadas seguras HTTPS:
@Bean
private WebClient getSecureWebClient() {
HttpClient httpClient = HttpClient.create().secure(sslSpec -> sslSpec.sslContext(getSSLContext()));
ClientHttpConnector clientHttpConnector = new ReactorClientHttpConnector(httpClient);
return WebClient.builder()
.clientConnector(clientHttpConnector)
.build();
}
Usar este WebClient para realizar solicitudes HTTPS seguras es tan simple como inyectar el bean WebClient en nuestro servicio:
@Service
public class MyService {
private final WebClient webClient;
public MyService(WebClient webClient) {
this.webClient = webClient;
}
public Mono<String> getSecureData() {
return webClient.get()
.uri("https://yourEndpoint.com")
.retrieve()
.bodyToMono(String.class);
}
}
De hecho, no necesitamos hacer nada especial en nuestro servicio para realizar solicitudes HTTPS seguras. El bean WebClient que creamos se encargará de todo por nosotros.
5. Conclusión
En este tutorial, convertimos un archivo de certificado y clave al formato PKCS12 y configuramos un WebClient para realizar solicitudes HTTPS seguras. Finalmente, mostramos cómo podemos usar el WebClient para hacer solicitudes HTTPS seguras en nuestro servicio.