1- Introduction
Dans ce tutoriel, nous allons apprendre à activer HTTPS dans Spring Boot. À cette fin, 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 nous 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é à l’échelle de l’industrie.
- JKS : Java KeyStore est similaire à PKCS12 ; c’est un format propriétaire et limité à l’environnement Java.
Nous pouvons utiliser les 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.
Pour notre démonstration, utilisons keytool.
2.1. Génération d’un magasin de clés
Nous allons maintenant créer un ensemble de clés cryptographiques et les stocker dans un magasin de clés.
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 -validité 3650
Nous pouvons stocker n’importe quel nombre de paires de clés dans le même magasin de clés, chacune étant identifiée 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 -validité 3650
Nous vous recommandons d’utiliser le format PKCS12, qui est un format standard de l’industrie. Ainsi, si nous avons 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 magasin de clés source et également définir un nouveau mot de passe du magasin de clés. L’alias et le mot de passe du magasin de clés seront nécessaires plus tard.
3. Activer 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 partirons d’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 copierons 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
Nous allons maintenant configurer les propriétés liées à SSL :
# Le format utilisé pour le magasin de clés. Il peut être défini sur JKS s’il s’agit d’un fichier JKS
serveur.ssl.key-store-type=PKCS12
# Le chemin vers le keystore contenant le certificat
server.ssl.key-store=classpath:keystore/baeldung.p12
# Le mot de passe utilisé pour générer le certificat
server.ssl.key-store-password=mot de passe
# L’alias mappé au certificat
server.ssl.key-alias=baeldung
Puisque nous utilisons une application compatible avec Spring Security, configurons-la pour n’accepter que les requêtes HTTPS :
serveur.ssl.enabled=true
4. Invoquer une URL HTTPS
Maintenant que nous avons activé HTTPS dans notre application, passons au client et explorons comment appeler 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 magasin de confiance. Définissons de nouvelles propriétés pour les détails du trust store :
#emplacement du magasin de confiance
trust.store=classpath:keystore/baeldung.p12
#mot de passe du magasin de confiance
trust.store.password=mot de passe
Ensuite, nous devons préparer un SSLContext avec le magasin de confiance et créer un RestTemplate personnalisé :
RestTemplate restTemplate() lance une exception {
SSLContext sslContext = nouveau SSLContextBuilder()
.loadTrustMaterial(trustStore.getURL(), trustStorePassword.toCharArray())
.construire();
SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext);
HttpClient httpClient = HttpClients.custom()
.setSSLSocketFactory(socketFactory)
.construire();
Usine HttpComponentsClientHttpRequestFactory =
nouveau HttpComponentsClientHttpRequestFactory(httpClient);
renvoie le nouveau RestTemplate (usine);
}
Pour les besoins de la démonstration, assurons-nous que Spring Security autorise toutes les requêtes entrantes :
protected void configure(HttpSecurity http) lance une exception {
http.authorizeRequests()
.antMatchers(« /** »)
.permitAll();
}
Enfin, nous pouvons faire un appel au point de terminaison HTTPS :
@Test
public void whenGETanHTTPSResource_thenCorrectResponse() lance une exception {
ResponseEntity<String> réponse =
restTemplate().getForEntity(WELCOME_URL, String.class, Collections.emptyMap());assertEquals(« <h1>Bienvenue sur le site sécurisé</h1> », response.getBody());
assertEquals(HttpStatus.OK, response.getStatusCode());
}
5. Conclusion
Dans cet article, nous avons d’abord appris à générer un certificat auto-signé pour activer HTTPS dans une application Spring Boot. Ensuite, nous avons expliqué comment appeler 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 décommenter la propriété start-class suivante dans le fichier pom.xml :
<start-class>com.baeldung.ssl.HttpsEnabledApplication</start-class>