Configurare un Client Web Java per Richieste HTTPS

1. Introduzione

In questo breve tutorial, configureremo un WebClient Spring per richieste HTTPS.

Crittografare la comunicazione HTTP rende difficile per gli attaccanti manomettere i dati degli utenti. Al giorno d’oggi, è il default per la maggior parte delle applicazioni moderne che si integrano con altri servizi.

In questa guida, inizieremo con la verifica del certificato e del file della chiave, per poi passare alla configurazione di Spring WebClient.

2. Verifica dei file di certificato e chiave

Per prima cosa, verifichiamo che il nostro certificato e il file della chiave abbiano lo stesso MD5. In questo modo ci assicuriamo che il certificato e la chiave non siano stati modificati.

Possiamo usare openssl per visualizzare l’hash MD5:

openssl x509 -noout -modulus -in yourCertificate.crt | openssl md5

Allo stesso modo, possiamo fare lo stesso per il file chiave:

openssl rsa -noout -modulus -in yourPrivateKey.key | openssl md5

Gli output corrispondenti di entrambi i comandi confermano che il tuo certificato e la tua chiave sono allineati.

Possiamo testare il certificato e la chiave con un CURL:

curl -v --cert yourCertificate.crt --key yourPrivateKey.key https://yourEndpoint.com

Ora possiamo procedere a convertire il certificato e la chiave nel formato PKCS12.

3. Conversione del Certificato e della Chiave in Formato PKCS12

Per configurare Spring WebClient, dobbiamo convertire il certificato in formato PKCS12.

Ancora una volta, utilizziamo openssl per ottenere il file formato PKCS12:

openssl pkcs12 -export -in yourCertificate.crt -inkey yourPrivateKey.key -out certificate.p12

Eseguendo il comando sopra, ci verrà chiesto di creare una password. Inseriamo una a nostra scelta e salviamola da qualche parte, poiché la riutilizzeremo quando configureremo il SslContext per il WebClient.

Ora, abbiamo un file certificate.p12 che possiamo utilizzare per configurare la nostra applicazione.

4. Configurazione dell’SSLContext

Infine, possiamo creare un SslContext che legge il file che abbiamo creato in precedenza, insieme alla password che abbiamo impostato.

Utilizzeremo SslContextBuilder per creare SslContext:

SslContext sslContext = SslContextBuilder.forClient().keyManager(
    new FileInputStream("pathToP12CertificateFile"),
    "password".toCharArray()).build();

Ora, il sslContext può essere utilizzato per creare un bean WebClient in grado di effettuare chiamate HTTPS sicure:

@Bean
private WebClient getSecureWebClient() {
    HttpClient httpClient = HttpClient.create().secure(sslSpec -> sslSpec.sslContext(getSSLContext()));
    ClientHttpConnector clientHttpConnector = new ReactorClientHttpConnector(httpClient);
    return WebClient.builder()
            .clientConnector(clientHttpConnector)
            .build();
}

Utilizzare questo WebClient per effettuare richieste HTTPS sicure è semplice come iniettare il bean WebClient nel nostro servizio:

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

In effetti, non dobbiamo fare nulla di speciale nel nostro servizio per effettuare richieste HTTPS sicure. Il bean WebClient che abbiamo creato si occuperà di tutto per noi.

5. Conclusione

In questo tutorial, abbiamo convertito un certificato e un file di chiave nel formato PKCS12 e configurato un WebClient per effettuare richieste HTTPS sicure. Infine, abbiamo mostrato come possiamo utilizzare il WebClient per effettuare richieste HTTPS sicure nel nostro servizio.