> ## Content Index
> Fetch the complete content index at: https://www.sfeir.dev/llms.txt
> Use this file to discover other available public pages before exploring further.

# Gérer facilement ses clés SSL avec Spring Boot 3.1
- URL: https://www.sfeir.dev/back/gerer-facilement-ses-cles-ssl-avec-spring-boot-3-1/
- Published: 2023-06-05T18:03:00.000Z
- Updated: 2023-06-07T11:37:09.000Z
- Description: Spring Boot 3.1 introduit des bundles SSL pour gérer facilement les clés SSL entre les composants. Les bundles permettent notamment de configurer un serveur en HTTPS ou d'utiliser RestTemplate avec TLS ou mTLS.
- Author: Yves Dautremay
- Tags: Back, Java, Spring Boot, SSL

Spring Boot 3.1 a apporté quelques nouveautés intéressantes. Parmi elles, une gestion des clés SSL cohérente entre les différents composants.

## SSL Bundle

La notion de SSL bundle permet de configurer des éléments SSL et de pouvoir ensuite les appliquer à d'autres composants devant communiquer à travers une connexion sécurisée.

Configurer un bundle SSL est très simple et se fait dans le fichier *application.yml*. Deux cas de figure sont supportés

### Avec un Keystore

Si les clés SSL sont déjà dans un keystore

```yaml
spring:
  ssl:
    bundle:
      jks:
        mybundle:
          key:
            alias: "application"
          keystore:
            location: "classpath:application.p12"
            password: "secret"
            type: "PKCS12"
          truststore:
            location: "classpath:server.p12"
            password: "secret"            

```

On configure ici un bundle JKS (Java KeyStore) qu'on appelle mybundle. C'est par ce nom qu'on le référencera plus tard. On retrouve aussi les propriétés standards du keystore. On peut aussi configurer un trustore si on veut faire du TLS.

### Avec une paire de clés SSL

Si l'on possède directement une paire de clés publique/privée au format PEM

```yaml
spring:
  ssl:
    bundle:
      pem:
        mybundle:
          keystore:
            certificate: "classpath:application.crt"
            private-key: "classpath:application.key"
          truststore:
            certificate: "classpath:server.crt"            

```

On configure ici un bundle PEM appelé mybundle. On référence directement les fichiers de clé.

## Utilisation des bundles

Spring boot configure automatiquement un bean SslBundles qui va nous permettre de travailler avec nos bundles, et notamment récupérer le SslContext.

```java
@Component
public class MyComponent {

    public MyComponent(SslBundles sslBundles) {
        SslBundle sslBundle = sslBundles.getBundle("mybundle");
        SSLContext sslContext = sslBundle.createSslContext();
        // do something with the created sslContext
    }

}

```

## Intégration avec des composants standards

Une fois un bundle configuré, il devient très facile de l'appliquer sur des technologies prises en charge par Spring boot.

### Configurer le serveur en HTTPS

Une seule ligne de configuration permet de passer son serveur en HTTPS

```yaml
server:
  port: 8443
  ssl:
    bundle: "mybundle"

```

### Utiliser RestTemplate en TLS (ou mTLS)

Il suffit d'appliquer le bundle SSL lors de la création du RestTemplate. Si le bundle contient un truststore avec le certificat du serveur on pourra faire du TLS. S'il contient un keystore dont le certificat est connu du serveur, on pourra faire du mTLS.

```java
@Service
public class MyService {

    private final RestTemplate restTemplate;

    public MyService(RestTemplateBuilder restTemplateBuilder, SslBundles sslBundles) {
        this.restTemplate = restTemplateBuilder.setSslBundle(sslBundles.getBundle("mybundle")).build();
    }
}

```

### Se connecter à Redis en TLS

De la même manière, si on a un bundle avec un truststore, une simple configuration permet de se connecter à Redis en TLS

```yaml
spring:
  data:
    redis:
      ssl:
        enabled: true
        bundle: "mybundle"

```

### Se connecter à MongoDB en TLS

On applique encore une fois tout simplement le bundle

```yaml
spring:
  data:
    mongodb:
      uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
      ssl:
        enabled: true
        bundle: "mybundle"

```

## Conclusion

Les bundles SSL permettent d'intégrer facilement les problématiques de connexion sécurisées avec les composants Spring Boot existants, ainsi que pour des utilisations custom.

### sources

Documentation Spring Boot  
[https://docs.spring.io/spring-boot/docs/3.1.0/reference/html/features.html#features.ssl](https://docs.spring.io/spring-boot/docs/3.1.0/reference/html/features.html?ref=sfeir.dev#features.ssl)