HTTPS utilisant un certificat auto-signé dans un démarrage initial

HTTPS utilisant un certificat auto-signé dans un démarrage printanier

1. Vue d'ensemble

Dans ce didacticiel, nous allons illustrer étape par étape un exemple d'activation de HTTPS dans une application Spring Boot.

Nous allons générer un certificat auto-signé et le configurer dans un exemple d'application. Pour plus de détails sur les projets Spring Boot, nous pouvons nous référer à un tas de ressourceshere.

Lectures complémentaires:

Configuration automatique de la sécurité de démarrage du printemps

Un guide rapide et pratique de la configuration Spring Security par défaut de Spring Boot.

Introduction à Java Config pour Spring Security

Guide rapide et pratique de Java Config pour Spring Security

2. Générer 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 tout le secteur
JKS:Java KeyStore est similaire à PKCS12; c'est un format propriétaire 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é depuishere.

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 magasin de clés.

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

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

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

Pour générer notre magasin de clés au format JKS, nous pouvons utiliser la commande suivante:

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

Il est recommandé d'utiliser le format PKCS12, qui est un format standard. Donc, si nous avons déjà un magasin de clés JKS, nous pouvons le convertir au format PKCS12 à l'aide de la commande suivante:

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

Nous devrons fournir le mot de passe du fichier de clés source et également définir un nouveau mot de passe pour le fichier de clés. Le mot de passe alias et keystore sera nécessaire ultérieurement.

3. Activation de HTTPS dans Spring Boot

Spring Boot fournit un ensemble deserver.ssl.* properties. déclaratifs. Nous allons configurer ces propriétés dans notre exemple d'application pour configurer HTTPS.

Nous allons commencer à partir d'une simple application Spring Bootwith Spring Security contenant une page d'accueil gérée par le point de terminaison «/welcome».

Nous copierons le fichier nommé "example.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/example.p12
# The password used to generate the certificate
server.ssl.key-store-password=password
# The alias mapped to the certificate
server.ssl.key-alias=example

Étant donné que nous utilisons l'application compatible Spring Security, configurons-la pour n'accepter que les requêtes HTTPS:

security.require-ssl=true

4. Appel d'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é.

Premièrement, 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 Trust Store:

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

Nous devons maintenant préparer unSSLContext avec le magasin de confiance et créer unRestTemplate: 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émonstration, assurons-nous queSpring Security accepte toutes les demandes entrantes:

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

Enfin, nous pouvons appeler le noeud final HTTPS:

@Test
public void whenGETanHTTPSResource_thenCorrectResponse() throws Exception {
    ResponseEntity response =
      restTemplate().getForEntity(WELCOME_URL, String.class, Collections.emptyMap());

    assertEquals("Welcome to Secured Site", response.getBody());
    assertEquals(HttpStatus.OK, response.getStatusCode());
}

5. Conclusion

Dans le didacticiel, nous avons appris à générer un certificat auto-signé pour activer HTTPS dans une application Spring Boot. Nous avons également appris à appeler un point de terminaison HTTPS.

Comme toujours, nous pouvons trouver le code source complet surGitHub repository.

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

org.example.ssl.HttpsEnabledApplication

TOC