Implémenter TLS en Java

TLS, ou sécurité de la couche transport, est un protocole utilisé dans le monde entier pour chiffrer et sécuriser les communications sur Internet.

Dans cet article, nous allons voir ce qu’est TLS, quels sont ses avantages et pourquoi vous en avez besoin. Nous verrons ensuite comment implémenter TLS en Java.

Qu’est-ce que TLS ?

TLS et son prédécesseur SSL (Secure Socket Layer) sont les protocoles cryptographiques les plus utilisés pour assurer le chiffrement, l’authenticité et l’intégrité, et ainsi garantir la sécurité de bout en bout des données échangées entre des applications sur Internet.

Les protocoles TLS et SSL se situent entre la couche application et la couche TCP/IP, où ils peuvent sécuriser les données des applications avant de les transmettre à la couche transport. De par leur position, TLS et SSL peuvent prendre en charge plusieurs protocoles de la couche application. Consultez cet article pour en savoir plus sur le modèle OSI.

Développé à l’origine par Netscape, SSL 1.0 comportait plusieurs failles de sécurité et n’a jamais été publié. SSL 2.0 a été introduit en 1995, puis SSL 3.0 en 1996. SSL a ensuite été renommé, et TLS 1.0 est sorti en 1999. La version actuelle, TLS 1.3, a été introduite en 2018. Pour vous protéger des vulnérabilités connues, il est toujours recommandé d’utiliser la dernière version de TLS. Vous pouvez en savoir plus sur TLS dans cet article.

L’importance de TLS

Historiquement, les communications sur Internet se faisaient en texte brut et avec peu de sécurité. Les données que vous envoyiez à un serveur étaient donc visibles sur le réseau et exposées aux attaques de l’homme du milieu : un acteur malveillant s’interpose dans l’échange entre un utilisateur et une application. Il peut alors consulter et modifier les données transmises, et ainsi exposer des informations personnelles, comme des mots de passe ou des coordonnées bancaires.

Pour résoudre ce type de problème, SSL et TLS ont été introduits. Ils offrent trois avantages principaux :

• Protection de l’intégrité : TLS protège les messages contre les modifications effectuées par un intercepteur actif sur le réseau.

• Authentification : Dans la plupart des modes, TLS authentifie les pairs à l’aide de certificats signés. Les serveurs sont généralement authentifiés, tandis que les clients peuvent l’être à la demande des serveurs. Cette authentification a lieu lors de la négociation TLS.

• Confidentialité : TLS chiffre les données échangées entre le client et le serveur, ce qui en protège la confidentialité et la vie privée. Les intercepteurs passifs ne peuvent ainsi pas voir les données sensibles échangées entre les machines.

Avec SSL ou TLS, les utilisateurs ont l’assurance que leurs données ne sont pas exposées et que celles qu’ils envoient ou reçoivent ne sont pas altérées. L’implémentation de TLS est donc indispensable pour les applications accessibles sur Internet, car elle vous permet de sécuriser les données de vos clients.

Concepts fondamentaux

Avant d’entrer dans le détail de l’implémentation de TLS en Java, passons en revue quelques concepts qui vous aideront à comprendre les aspects techniques de TLS.

Sockets

Un socket est l’une des extrémités d’une interface de communication bidirectionnelle entre des programmes en réseau. La couche transport sous-jacente (TCP ou UDP) identifie l’application de destination à laquelle les données seront transmises en associant un socket à un numéro de port.

Les classes Socket représentent la connexion entre les applications cliente et serveur. Le package java.net fournit deux classes — Socket et ServerSocket — qui implémentent respectivement le côté client et le côté serveur de la connexion.

Pour en savoir plus sur les sockets, consultez cet article.

Les communications TLS utilisent des sockets sécurisés : SSLSocket et SSLServerSocket. Ces classes étendent respectivement les classes Socket et ServerSocket.

Négociation TLS

Une négociation SSL ou TLS est une série d’actions menées par le client et le serveur pour s’authentifier mutuellement et établir les clés secrètes qu’ils utiliseront pour communiquer.

La négociation TLS est un sujet très vaste qui dépasse le cadre de cet article. Pour commencer à comprendre les négociations TLS, consultez cet article sur le déroulement d’une négociation TLS et cette présentation des négociations SSL ou TLS.

Versions LTS de Java

Les versions LTS (support à long terme) de Java bénéficient pendant une période prolongée de mises à jour trimestrielles de sécurité, de stabilité et de performances. Les versions standard (non-LTS) ne reçoivent des mises à jour et des correctifs que jusqu’à la sortie de la version suivante.

Java 7, 8, 11 et la version 17, récemment publiée, sont des versions LTS. En raison de leur période de support prolongée, il est recommandé d’utiliser exclusivement des versions LTS dans les environnements de production.

Comme pour tout logiciel, chaque version apporte de nouvelles fonctionnalités et améliorations. Vous trouverez ici les fonctionnalités de Java 11 et ici celles de Java 17. Les fonctionnalités variant d’une version de Java à l’autre, consultez la documentation de votre version si vous rencontrez des problèmes inattendus lors de l’implémentation de TLS.

Implémenter TLS en Java

Après toute cette théorie, passons enfin à la partie intéressante : l’implémentation. Dans les sections suivantes, vous découvrirez le framework JSSE et comment utiliser ses API pour implémenter TLS.

API JSSE

Java Secure Socket Extension, ou JSSE, est un framework qui abstrait l’implémentation sous-jacente de la sécurité de la couche transport (TLS). En masquant la complexité des protocoles sous-jacents, JSSE permet aux programmeurs d’implémenter facilement des communications chiffrées et sécurisées. JSSE utilise le protocole TLS pour sécuriser et chiffrer les communications entre vos clients et vos serveurs.

JSSE fournit quatre classes principales dans son implémentation standard :

• SSLSocketFactory : cette classe sert de fabrique pour créer des sockets sécurisés.

• SSLServerSocketFactory : cette classe est analogue à SSLSocketFactory, mais sert spécifiquement à créer des sockets serveur.

• SSLSocket : SSLSocket étend Socket en ajoutant une couche de protection au protocole de transport réseau sous-jacent, tel que TCP et UDP, et offre les avantages de SSL et TLS.

• SSLServerSocket : cette classe est similaire à SSLSocket. La principale différence est que SSLServerSocket sert à créer des sockets côté serveur, tandis que SSLSocket sert à en créer côté client.

Vous utiliserez ces classes pour implémenter TLS côté client et côté serveur.

Implémenter TLS côté client

Dans cette section, vous allez voir comment implémenter TLS côté client à l’aide de SSLSocketFactory et SSLSocket.

Créez un fichier texte nommé JavaTLSClientExample.class, puis copiez-collez le code suivant et enregistrez le fichier :

1package io.snyk.programming.tls;
2
3import javax.net.ssl.SSLSocket;
4import javax.net.ssl.SSLSocketFactory;
5import java.io.*;
6
7public class JavaTLSClientExample {
8
9    private static final String[] protocols = new String[]{"TLSv1.3"};
10    private static final String[] cipher_suites = new String[]{"TLS_AES_128_GCM_SHA256"};
11
12    public static void main(String[] args) throws Exception {
13
14        SSLSocket socket = null;
15        PrintWriter out = null;
16        BufferedReader in = null;
17
18        try {
19
20            // Step : 1
21            SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
22
23            // Step : 2
24            socket = (SSLSocket) factory.createSocket("google.com", 443);
25
26            // Step : 3
27            socket.setEnabledProtocols(protocols);
28            socket.setEnabledCipherSuites(cipher_suites); 
29
30            // Step : 4 {optional}
31            socket.startHandshake(); 
32
33            // Step : 5
34            out = new PrintWriter(
35                    new BufferedWriter(
36                            new OutputStreamWriter(
37                                    socket.getOutputStream())));
38
39            out.println("GET / HTTP/1.0");
40            out.println();
41            out.flush();
42
43            if (out.checkError()) {
44                System.out.println("SSLSocketClient:  java.io.PrintWriter error");
45            }
46
47            // Step : 6
48            in = new BufferedReader(
49                    new InputStreamReader(
50                            socket.getInputStream()));
51
52            String inputLine;
53            while ((inputLine = in.readLine()) != null) {
54                System.out.println(inputLine);
55            }
56
57        } catch (Exception e) {
58            e.printStackTrace();
59        } finally {
60            if (socket != null) {
61                socket.close();
62            }
63            if (out != null) {
64                out.close();
65            }
66            if (in != null) {
67                in.close();
68            }
69        }
70    }
71}

Pour exécuter le code, ouvrez votre terminal et utilisez la commande cd pour accéder au dossier où vous avez enregistré le fichier ci-dessus — cd <PathToFile>.

Compilez le fichier en exécutant javac JavaTLSClientExample.class, puis exécutez-le avec la commande java JavaTLSClientExample.class.

Voici le détail de ce qui se passe à chaque étape de l’exemple de code.

La première étape consiste à obtenir une instance de SSLSocketFactory, qui servira ensuite à créer le socket.

Il existe plusieurs façons d’obtenir une instance de SSLSocketFactory. Dans cet exemple, vous récupérez la fabrique par défaut en appelant la méthode statique SSLSocketFactory.getDefault().

La deuxième étape consiste à créer un socket SSL. Vous appelez la méthode createSocket et fournissez des informations telles que l’hôte distant et le port distant. Un socket est alors créé et connecté à l’hôte distant spécifié sur le port indiqué.

La troisième étape consiste à configurer les paramètres. Vous indiquez d’abord au socket la version de TLS à prendre en charge. Au moment de la rédaction de cet article, TLS v1.3 est la dernière version ; c’est donc celle qui est utilisée dans l’exemple ci-dessus. De plus, CipherSuite TLS_AES_128_GCM_SHA256 définit les différents paramètres à utiliser à chaque étape de la négociation TLS.

À la quatrième étape, vous lancez la négociation. C’est à ce moment que la négociation TLS est explicitement initiée.

Pendant la négociation, le socket utilise le protocole et le CipherSuite définis à l’étape précédente.

À la cinquième étape, la configuration est terminée et vous envoyez une véritable requête au serveur. Les informations textuelles sont alors transmises au flux de sortie du socket. OutputStreamWriter convertit le flux de caractères en flux d’octets. BufferedWriter évite les conversions répétées, et PrintWriter écrit la représentation formatée des objets dans le flux de sortie texte. Comme PrintWriter ne lève aucune exception, vous devez vérifier explicitement les erreurs à l’aide de la méthode checkError.

Enfin, à la sixième étape, vous lisez la réponse. Une fois la requête envoyée, la réponse est lue depuis le flux inputStream du socket, puis affichée.

Implémenter TLS côté serveur

Vous allez maintenant découvrir comment implémenter TLS côté serveur à l’aide de SSLServerSocketFactory et de SSLServerSocket.

Créez un fichier nommé JavaTLSServerExample.class, puis collez-y le code suivant :

1package io.snyk.programming.tls;
2
3import javax.net.ssl.SSLSocket;
4import javax.net.ssl.SSLServerSocket;
5import javax.net.ssl.SSLServerSocketFactory;
6import java.io.*;
7
8public class JavaTLSServerExample {
9
10    private static final String[] protocols = new String[]{"TLSv1.3"};
11    private static final String[] cipher_suites = new String[]{"TLS_AES_128_GCM_SHA256"};
12
13    public static void main(String[] args) throws Exception {
14
15        SSLServerSocket serverSocket = null;
16
17        try {
18
19            // Step : 1
20            SSLServerSocketFactory factory =
21                    (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
22
23            // Step : 2
24            serverSocket = (SSLServerSocket) factory.createServerSocket(8980);
25
26            // Step : 3
27            serverSocket.setEnabledProtocols(protocols);
28            serverSocket.setEnabledCipherSuites(cipher_suites);
29
30            // Step : 4
31            SSLSocket sslSocket = (SSLSocket) serverSocket.accept();
32
33            // Step : 5
34            InputStream inputStream = sslSocket.getInputStream();
35            InputStreamReader inputStreamReader = new
36                    InputStreamReader(inputStream);
37
38            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
39            String request = null;
40            while((request = bufferedReader.readLine()) != null) {
41                 System.out.println(request);
42                 System.out.flush();
43            }
44        } catch (Exception e) {
45            e.printStackTrace();
46        } finally {
47            if (serverSocket != null) {
48                serverSocket.close();
49            }
50        }
51    }
52}

Pour exécuter le code, ouvrez de nouveau un terminal dans le dossier où vous avez enregistré le fichier ci-dessus.

Compilez le fichier en exécutant javac JavaTLSServerExample.class.

Suivez ce guide pour configurer et ajouter un certificat d’AC à votre keystore.

Exécutez java -Djavax.net.ssl.keyStore=<KeystoreFilePath> -Djavax.net.ssl.keyStorePassword=<KeystorePassword> JavaTLSServerExample pour lancer le fichier. Djavax.net.ssl.keyStore et -Djavax.net.ssl.keyStorePassword sont nécessaires pour fournir au runtime Java le certificat SSL du serveur.

Reprenons une dernière fois les étapes du code. Les étapes 1 à 3 sont similaires à celles de l’exemple d’implémentation de TLS côté client.

À la première étape, vous obtenez une instance par défaut de SSLSocketFactory.

À la deuxième étape, vous créez un SSLServerSocket et le liez au port 8990.

À la troisième étape, vous définissez les protocoles et CipherSuites pris en charge par votre SSLServerSocket.

À la quatrième étape, vous acceptez la requête entrante. SSLServerSocket.accept() écoute les connexions à ce socket serveur, accepte la connexion et crée un nouveau socket. La méthode reste bloquée jusqu’à ce qu’une connexion soit établie.

À la cinquième étape, les données sont lues depuis le flux d’entrée du socket, puis affichées. InputStreamReader convertit le flux d’octets en flux de caractères, tandis que BufferedReader évite les conversions répétées.

Lien entre l’API JSSE et SSLSocketFactory

Comme indiqué précédemment, JSSE est un framework. Il fournit diverses classes et implémentations qui masquent la complexité de la sécurisation de la connexion entre le client et le serveur. JSSE propose également un ensemble de classes d’implémentation pouvant servir d’implémentations par défaut pour configurer des sockets sécurisés côté client et côté serveur.

Côté client, SSLSocketFactory permet d’obtenir une fabrique par défaut, qui sert ensuite à obtenir un SSLSocket côté client. Côté serveur, SSLServerSocketFactory sert à initialiser le SSLServerSocket.

Conclusion

Si vous avez créé une application Java qui communique sur Internet, il est nécessaire d’implémenter TLS côté client comme côté serveur. TLS garantit un transfert sécurisé des données grâce au chiffrement et à la protection de leur intégrité, et contribue également à authentifier les deux parties.

JSSE est un framework fourni par Java qui peut vous aider à implémenter TLS dans votre application. Vous pouvez utiliser ses classes, comme SSLSocket et SSLServerSocket, pour créer des sockets sécurisés.