HTTPS utilisant un certificat auto-signé dans Spring Boot

1. Vue d'ensemble

Dans ce tutoriel, nous allons montrer comment activer HTTPS dans Spring Boot. Pour cela, nous allons également générer un certificat auto-signé et configurer une application simple.

Pour plus de détails sur les projets Spring Boot, nous pouvons vous référer à un tas de ressources ici.

2. Génération d'un certificat auto-signé

Avant de commencer, nous allons créer un certificat auto-signé. Nous utiliserons l'un des formats de certificat suivants:

  • PKCS12: Public Key Cryptographic Standards est un format protégé par mot de passe qui peut contenir plusieurs certificats et clés; c'est un format utilisé dans toute l'industrie
  • JKS: Java KeyStore est similaire à PKCS12; c'est un format propriétaire et est limité à l'environnement Java.

Nous pouvons utiliser l'un des outils keytool ou OpenSSL pour générer les certificats à partir de la ligne de commande. Keytool est livré avec Java Runtime Environment et OpenSSL peut être téléchargé à partir d'ici.

Utilisons keytool pour notre démonstration.

2.1. Générer un keystore

Nous allons maintenant créer un ensemble de clés cryptographiques et le stocker dans un keystore.

Nous pouvons utiliser la commande suivante pour générer notre format de keystore PKCS12:

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

Nous pouvons stocker autant de numéros de paires de clés dans le même keystore, chacun identifié par un alias unique.

Pour générer notre keystore au format JKS, nous pouvons utiliser la commande suivante:

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

Il est recommandé d'utiliser le format PKCS12 qui est un format standard de l'industrie. Donc, au cas où nous aurions déjà un keystore JKS, nous pouvons le convertir au format PKCS12 à l'aide de la commande suivante:

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

Nous devrons fournir le mot de passe du keystore source et également définir un nouveau mot de passe du keystore. L'alias et le mot de passe du fichier de clés seront nécessaires ultérieurement.

3. Activation de HTTPS dans Spring Boot

Spring Boot fournit un ensemble de propriétés déclaratives server.ssl. *. Nous utiliserons ces propriétés dans notre exemple d'application pour configurer HTTPS.

Nous commencerons par une simple application Spring Boot avec Spring Security qui contient une page d'accueil gérée par le point de terminaison « / welcome ».

Ensuite, nous allons copier le fichier nommé « baeldung.p12» généré à l'étape précédente dans le répertoire « src / main / resources / keystore ».

3.1. Configuration des propriétés SSL

Maintenant, nous allons configurer les propriétés liées au 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

Puisque nous utilisons l'application activée Spring Security, configurons-la pour n'accepter que les requêtes HTTPS:

server.ssl.enabled=true

4. Appel d'une URL HTTPS

Maintenant que nous avons activé HTTPS dans notre application, passons au client et explorons comment invoquer un point de terminaison HTTPS avec le certificat auto-signé.

Tout d'abord, nous devons créer un magasin de confiance. Comme nous avons généré un fichier PKCS12, nous pouvons utiliser le même que le trust store. Définissons de nouvelles propriétés pour les détails du magasin de confiance:

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

Nous devons maintenant préparer un SSLContext avec le magasin de confiance et créer un RestTemplate personnalisé :

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

Pour les besoins de la démo, assurons-nous que Spring Security autorise toutes les demandes entrantes:

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

Enfin, nous pouvons faire un appel au point de terminaison 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. Conclusion

Dans le didacticiel, nous avons d'abord appris à générer un certificat auto-signé pour activer HTTPS dans une application Spring Boot. De plus, nous avons montré comment invoquer un point de terminaison compatible HTTPS.

Comme toujours, nous pouvons trouver le code source complet sur le référentiel GitHub.

Enfin, pour exécuter l'exemple de code, nous devons annuler le commentaire de la propriété de classe de démarrage suivante dans le pom.xml :

com.baeldung.ssl.HttpsEnabledApplication