Configurer un client Web Java pour les requêtes HTTPS

1. Introduction

Dans ce tutoriel rapide, nous allons configurer un WebClient Spring pour les requêtes HTTPS.

Sécuriser la communication HTTP avec le chiffrement rend difficile pour les attaquants de manipuler les données des utilisateurs. De nos jours, c’est la norme pour la plupart des applications modernes qui s’intègrent à d’autres services.

Dans ce guide, nous commencerons par une vérification des fichiers de certificat et de clé, puis nous passerons à la configuration de Spring WebClient.

2. Vérification des fichiers de certificat et de clé

Tout d’abord, nous allons vérifier que notre certificat et notre fichier de clé ont le même MD5. Cela garantit que le certificat et la clé n’ont pas été modifiés.

Nous pouvons utiliser openssl pour afficher le hachage MD5 :

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

De la même manière, nous pouvons faire la même chose pour le fichier clé :

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

Les résultats correspondants des deux commandes confirment que votre certificat et votre clé sont alignés.

Nous pouvons tester le certificat et la clé avec un CURL :

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

Maintenant, nous pouvons passer à la conversion du certificat et de la clé au format PKCS12.

3. Conversion du certificat et de la clé au format PKCS12

Pour configurer Spring WebClient, nous devons convertir le certificat au format PKCS12.

Encore une fois, utilisons openssl pour obtenir le fichier au format PKCS12 :

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

Exécuter la commande ci-dessus nous demandera de créer un mot de passe. Insérons-en un de notre choix et gardons-le quelque part, car nous le réutiliserons lors de la configuration du SslContext pour le WebClient.

Maintenant, nous avons un fichier certificate.p12 que nous pouvons utiliser pour configurer notre application.

4. Configuration de l’SSLContext

Enfin, nous pouvons créer un SslContext qui lit le fichier que nous avons créé précédemment, ainsi que le mot de passe que nous avons défini.

Nous utiliserons le SslContextBuilder pour créer le SslContext :

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

Maintenant, le sslContext peut être utilisé pour créer un bean WebClient capable d’effectuer des appels HTTPS sécurisés :

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

Utiliser ce WebClient pour effectuer des requêtes HTTPS sécurisées est aussi simple que d’injecter le bean WebClient dans notre service :

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

En fait, nous n’avons rien de spécial à faire dans notre service pour effectuer des requêtes HTTPS sécurisées. Le bean WebClient que nous avons créé s’occupera de tout pour nous.

5. Conclusion

Dans ce tutoriel, nous avons converti un fichier de certificat et une clé au format PKCS12 et configuré un WebClient pour effectuer des requêtes HTTPS sécurisées. Enfin, nous avons montré comment nous pouvons utiliser le WebClient pour effectuer des requêtes HTTPS sécurisées dans notre service.