Aller au contenu

Connexions sécurisée (SSL et TSL) avec Java & SpringBoot

SSL (Secure Sockets Layer) et TLS (Transport Layer Security) sont des protocoles de sécurité qui permettent de chiffrer les communications sur Internet. Ils sont utilisés pour sécuriser les communications sensibles, telles que les transactions bancaires en ligne et les échanges de données confidentielles.

SSL et TLS fonctionnent en établissant une connexion sécurisée entre un client (par exemple, votre navigateur Web) et un serveur (par exemple, un site Web). Lorsque vous vous connectez à un site Web sécurisé via SSL ou TLS, votre navigateur Web et le serveur échangent des clés de chiffrement pour s’authentifier mutuellement. Une fois l’authentification terminée, toutes les données échangées entre votre navigateur et le serveur sont chiffrées et protégées contre la lecture ou l’interception par des tiers non autorisés.

SSL et TLS sont très largement utilisés sur Internet pour protéger les communications sensibles et garantir la confidentialité et l’intégrité des données. Ils sont également souvent utilisés pour vérifier l’identité des sites Web et des serveurs auxquels vous vous connectez, ce qui peut aider à prévenir les attaques de type “homme du milieu” et à protéger contre les sites Web frauduleux.

Voici un exemple simple de code Java qui montre comment établir une connexion sécurisée à un serveur en utilisant SSL ou TLS :

import java.io.*;
import java.net.*;
import javax.net.ssl.*;

public class SecureClient {
  public static void main(String[] args) {
    try {
      // Création d'une socket SSL
      SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
      SSLSocket socket = (SSLSocket) factory.createSocket("server.com", 8443);

      // Envoi d'une requête au serveur
      PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
      out.println("Hello from SSL client");
      out.flush();

      // Lecture de la réponse du serveur
      BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      String response = in.readLine();
      System.out.println("Received from server: " + response);

      // Fermeture de la connexion
      out.close();
      in.close();
      socket.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Dans cet exemple, nous utilisons la classe SSLSocketFactory pour créer une socket SSL et nous la connectons au serveur “server.com” sur le port 8443. Nous envoyons ensuite une requête au serveur et lisons sa réponse en utilisant les streams OutputStream et InputStream de la socket. Enfin, nous fermons la connexion en appelant les méthodes close des streams et de la socket.

Il s’agit là d’un exemple très simple de l’utilisation de SSL ou TLS en Java

Voici un exemple de code Java qui montre comment configurer une application Spring Boot pour utiliser SSL ou TLS :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.handler.TextWebSocketHandler;

@SpringBootApplication
@EnableWebSocket
public class SecureApplication implements WebSocketConfigurer {

  public static void main(String[] args) {
    SpringApplication.run(SecureApplication.class, args);
  }

  @Override
  public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    registry.addHandler(webSocketHandler(), "/ws").setAllowedOrigins("*").withSockJS();
  }

  @Bean
  public TextWebSocketHandler webSocketHandler() {
    return new SecureWebSocketHandler();
  }
}

class SecureWebSocketHandler extends TextWebSocketHandler {
  // Implementation de la gestion des WebSockets sécurisés...
}

Dans cet exemple, nous avons créé une application Spring Boot qui utilise WebSockets sécurisés en implémentant l’interface WebSocketConfigurer. Nous avons défini une classe SecureWebSocketHandler qui hérite de TextWebSocketHandler et qui gère les communications WebSocket sécurisées. Nous avons enfin enregistré notre gestionnaire de WebSockets sécurisés auprès de Spring Boot en appel

Pour continuer l’exemple précédent, voici comment configurer SSL ou TLS pour votre application Spring Boot :

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
    </dependency>
  1. Créez une classe de configuration qui étend AbstractHttpConfigurer et configure SSL ou TLS pour votre application
    import org.apache.catalina.Context;
    import org.apache.catalina.connector.Connector;
    import org.apache.tomcat.util.descriptor.web.SecurityCollection;
    import org.apache.tomcat.util.descriptor.web.SecurityConstraint;
    import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
    import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;

    @Configuration
    public class SecureConfiguration extends AbstractHttpConfigurer<SecureConfiguration, TomcatServletWebServerFactory> {
      @Bean
      public ServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory() {
          @Override
          protected void postProcessContext(Context context) {
            SecurityConstraint securityConstraint = new SecurityConstraint();
            securityConstraint.setUserConstraint("CONFIDENTIAL");
            SecurityCollection collection = new SecurityCollection();
            collection.addPattern("/*");
            securityConstraint.addCollection(collection);
            context.addConstraint(securityConstraint);
          }
        };
        tomcat.addAdditionalTomcatConnectors(redirectConnector());
        return tomcat;
      }

      private Connector redirectConnector() {
        Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
        connector.setScheme("http");
        connector.setPort(8080);
        connector.setSecure(false);
        connector.setRedirectPort(8443);
        return connector;
      }
    }

Dans cet exemple, nous avons configuré une contrainte de sécurité qui exige une connexion sécurisée (SSL ou TLS) pour toutes les requêtes envoyées à notre application. Nous avons également ajouté un Connector qui redirige toutes les requêtes HTTP vers HTTPS pour garantir que les utilisateurs ne peuvent pas accéder à notre application via une connexion non sécurisée.

Cette classe de configuration peut être ajoutée à votre application Spring Boot en la déclarant comme @Configuration et en la faisant étendre AbstractHttpConfigurer. Elle doit également définir une méthode @Bean qui retourne une instance de ServletWebServerFactory, telle que TomcatServletWebServerFactory, configurée pour utiliser SSL ou TLS. Vous pouvez également définir d’autres paramètres de configuration, comme le port d’écoute et le chemin vers le fichier de certificat, en utilisant les propriétés

  1. Ajoutez les propriétés suivantes à votre fichier application.properties pour configurer le serveur SSL ou TLS de votre application
    server.port: 8443
    server.ssl.key-store: classpath:keystore.p12
    server.ssl.key-store-password: password
    server.ssl.keyStoreType: PKCS12
    server.ssl.keyAlias: tomcat
  1. Démarrez votre application Spring Boot en utilisant la commande mvn spring-boot:run ou en exécutant la classe SecureApplication directement.

Votre application devrait maintenant être accessible via une connexion sécurisée SSL ou TLS.

Vous pouvez également utiliser d’autres méthodes pour configurer SSL ou TLS pour votre application Spring Boot, comme en utilisant un fichier de configuration externe ou en utilisant un conteneur de serveur externe comme Apache Tomcat. Consultez la documentation de Spring Boot pour obtenir plus d’informations sur les différentes options de configuration disponibles.

Voici quelques exemples de propriétés que vous pouvez utiliser pour configurer SSL ou TLS pour votre application Spring Boot :

server.port : définit le port d'écoute du serveur de votre application. Par exemple, server.port=8443 définit le port 8443 comme port d'écoute du serveur.

server.ssl.key-store : définit le chemin vers le fichier de certificat SSL ou TLS utilisé par votre application. Par exemple, server.ssl.key-store=classpath:keystore.p12 définit le fichier keystore.p12 situé dans le classpath de votre application comme fichier de certificat.

server.ssl.key-store-password : définit le mot de passe du fichier de certificat SSL ou TLS utilisé par votre application. Par exemple, server.ssl.key-store-password=password définit "password" comme mot de passe du fichier de certificat.

server.ssl.keyStoreType : définit le type de fichier de certificat SSL ou TLS utilisé par votre application. Par exemple, server.ssl.keyStoreType=PKCS12 définit le type de fichier de certificat comme PKCS12.

server.ssl.keyAlias : définit l'alias du certificat utilisé par votre application. Par exemple, server.ssl.keyAlias=tomcat définit l'alias du certificat comme "tomcat".

Ce ne sont là que quelques exemples de propriétés de configuration que vous pouvez utiliser pour configurer SSL ou TLS pour votre application Spring Boot. Consultez la documentation de Spring Boot pour obtenir une liste complète des propriétés de configuration disponibles et pour obtenir plus d’informations sur leur utilisation.