Gérer facilement ses clés SSL avec Spring Boot 3.1

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

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

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.

@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

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.

@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

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

Se connecter à MongoDB en TLS

On applique encore une fois tout simplement le bundle

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.