Sécuriser les algorithmes de chiffrement symétrique en Java

Dans notre monde connecté, la protection des données numériques est devenue une priorité absolue. Les applications Java étant largement utilisées dans de nombreux secteurs, de la banque à la santé, il est essentiel de souligner l’importance du chiffrement. Le chiffrement consiste à convertir des données lisibles, ou texte en clair, en données illisibles, ou texte chiffré. Ainsi, même si les données chiffrées sont interceptées, elles restent inaccessibles aux personnes non autorisées.

En tant que développeur, vous devez d’abord déterminer si vous avez besoin du chiffrement. La question peut sembler étrange, mais le principe fondamental du chiffrement est que le texte chiffré peut être converti à nouveau en texte d’origine. Pour les mots de passe, par exemple, nous ne voulons pas utiliser le chiffrement, car nous ne voulons pas pouvoir « déchiffrer » le texte d’origine. Nous utilisons donc le hachage pour les mots de passe, et non le chiffrement. 

Le chiffrement en Java

Les applications Java traitent souvent des données sensibles, notamment des informations sur les clients, des données financières et des dossiers de transaction. En tant que développeur Java, vous devez utiliser des algorithmes de chiffrement robustes pour préserver l’intégrité et la confidentialité des données sensibles. Vous protégez ainsi vos utilisateurs et toutes les données essentielles présentes dans votre système.

Chiffrement symétrique et asymétrique

En règle générale, on distingue deux types de chiffrement : symétrique et asymétrique. Leur fonctionnement est fondamentalement différent, et chacun répond à des besoins spécifiques.

Le chiffrement symétrique utilise la même clé pour chiffrer et déchiffrer les données. Il est donc plus rapide, mais moins sûr lorsque la clé doit être partagée. Le chiffrement asymétrique, quant à lui, utilise une paire de clés (publique et privée). La clé publique sert au chiffrement, et la clé privée au déchiffrement. Le chiffrement symétrique convient aux situations où de grands volumes de données doivent être chiffrés, tandis que le chiffrement asymétrique est idéal pour partager des clés de manière sécurisée sur un réseau. Bien que nous distinguions deux types de chiffrement, cet article se concentrera uniquement sur le chiffrement symétrique dans les applications Java.

Lorsque vous utilisez le chiffrement symétrique, il est préférable de recourir à des services qui s’appuient sur des modules de sécurité matériels (HSM) pour gérer les clés, ainsi que sur le chiffrement par enveloppe. Ces solutions simplifient la gestion des clés, qui est l’aspect le plus complexe d’une solution de chiffrement. Si vous ne pouvez toutefois pas utiliser un service comme Amazon Key Management Service (KMS) et souhaitez tout de même procéder ainsi, les informations ci-dessous vous montreront comment le faire en toute sécurité. Dans la suite de cet article, nous verrons comment mettre en œuvre le chiffrement symétrique dans votre application Java à l’aide des packages javax.crypto.

Comprendre les algorithmes de chiffrement obsolètes et les risques associés

Malgré l’importance du chiffrement, les algorithmes ne se valent pas tous. Certains algorithmes anciens ou « obsolètes », comme DES (Data Encryption Standard) ou 3DES, présentent des vulnérabilités que des attaquants peuvent exploiter. Autrefois considérés comme sûrs, ces algorithmes ne le sont plus en raison des progrès de la puissance de calcul et des techniques de cryptanalyse.

L’utilisation d’algorithmes de chiffrement non sécurisés dans vos applications Java peut entraîner des risques. Un attaquant qui accède à vos données chiffrées peut être en mesure de les déchiffrer si l’algorithme utilisé est obsolète et présente des vulnérabilités connues. Cela pourrait entraîner une violation de données et avoir des conséquences potentiellement désastreuses pour vos utilisateurs et votre organisation.

Recommandations concernant les algorithmes et les modes de chiffrement

Pour les algorithmes de chiffrement symétrique, la fondation OWASP recommande actuellement AES (Advanced Encryption Standard), avec une clé d’au moins 128 bits, et de préférence de 256 bits. Vous devez également utiliser cet algorithme avec un mode sécurisé. Par ailleurs, les normes et recommandations cryptographiques du NIST approuvent le chiffrement AES comme méthode de chiffrement par blocs.

Un chiffrement comme AES peut utiliser plusieurs modes, qui présentent des caractéristiques différentes en matière de sécurité et de performances. Évitez le mode ECB (Electronic Codebook), qui ne garantit pas une confidentialité adéquate des messages. Préférez des modes comme CCM (Counter with CBC-MAC) ou GCM (Galois/Counter Mode). Ces deux modes sont des modes authentifiés qui garantissent l’intégrité, la confidentialité et l’authenticité des données.

Détecter les algorithmes de chiffrement faibles en Java

Il est relativement facile d’utiliser les API javax.crypto pour mettre en œuvre un petit service de chiffrement en Java. Voici un exemple de EncryptionService en Java basé sur l’algorithme DES obsolète et utilisant le mode ECB.

1public class EncryptionServiceDes {
2
3    private SecretKey secretKey;
4    private Cipher cipher;
5
6    public EncryptionServiceDes(String key) throws GeneralSecurityException {
7        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
8        DESKeySpec desKeySpec = new DESKeySpec(keyBytes);
9        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
10        secretKey = keyFactory.generateSecret(desKeySpec);
11        cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
12    }
13
14    public String encrypt(String original) throws GeneralSecurityException {
15        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
16        // Encrypt the original data
17        byte[] encryptedData = cipher.doFinal(original.getBytes(StandardCharsets.UTF_8));
18        // Encode the encrypted data in base64 for better handling
19        return Base64.getEncoder().encodeToString(encryptedData);
20    }
21    public String decrypt(String cypher) throws GeneralSecurityException{
22        cipher.init(Cipher.DECRYPT_MODE, secretKey);
23        // Decode the base64-encoded ciphertext
24        byte[] encryptedData = Base64.getDecoder().decode(cypher);
25        // Decrypt the data
26        byte[] decryptedData = cipher.doFinal(encryptedData);
27        return new String(decryptedData, StandardCharsets.UTF_8);
28    }
29}

Maintenant que nous avons intégré à un projet un algorithme de chiffrement notoirement non sécurisé, nous allons utiliser le service gratuit de Snyk pour détecter cette utilisation risquée et trouver une meilleure solution. 

Commencez par créer un compte Snyk gratuit. Vous pouvez facilement vous lancer avec votre compte GitHub, Bitbucket, Azure AD ou Docker.

J’ai ensuite connecté mon dépôt GitHub à Snyk. L’analyse statique de Snyk Code m’avertit immédiatement que mon application utilise un algorithme cryptographique défectueux ou risqué. L’alerte est tout à fait pertinente, car le service présenté ci-dessus fait plusieurs fois référence à DES. Le moteur Snyk Code me recommande également d’envisager AES, conformément aux conseils d’OWASP.

Même si j’utilise AES dans le court extrait ci-dessous, j’ai recours au mode CBC, qui n’est pas considéré comme sécurisé.

1…
2    public EncryptionServiceAES(String key) throws GeneralSecurityException {
3        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
4        secretKey = new SecretKeySpec(keyBytes, "AES");
5        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
6    }
7…

Snyk détecte également l’utilisation de modes non sécurisés, entre autres. La capture d’écran ci-dessous provient du plugin Snyk, qui analyse mon code dans IntelliJ IDEA et fournit des informations utiles, comme des exemples de correctifs externes.

Remplacer EncryptionService par une version qui utilise AES/GCM/NoPadding, comme ci-dessous, constitue une bien meilleure solution et respecte les recommandations actuelles d’OWASP.

1public class EncryptionServiceAESGCM {
2    private SecretKey secretKey;
3    private Cipher cipher;
4
5    public EncryptionServiceAESGCM(String key) throws GeneralSecurityException {
6        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
7        secretKey = new SecretKeySpec(keyBytes, "AES");
8        cipher = Cipher.getInstance("AES/GCM/NoPadding");
9    }
10
11    public String encrypt(String original) throws GeneralSecurityException{
12        byte[] iv = new byte[16]; // Initialization Vector
13        SecureRandom random = new SecureRandom();
14        random.nextBytes(iv); // Generate a random IV
15        cipher.init(Cipher.ENCRYPT_MODE, secretKey, new GCMParameterSpec(128, iv));
16        byte[] encryptedData = cipher.doFinal(original.getBytes());
17        var encoder = Base64.getEncoder();
18        var encrypt64 = encoder.encode(encryptedData);
19        var iv64 = encoder.encode(iv);
20        return new String(encrypt64) + "#" + new String(iv64);
21    }
22
23    public String decrypt(String cypher) throws GeneralSecurityException{
24        var split = cypher.split("#");
25        var decoder = Base64.getDecoder();
26        var cypherText = decoder.decode(split[0]);
27        var iv = decoder.decode(split[1]);
28        var paraSpec = new GCMParameterSpec(128, iv);
29        cipher.init(Cipher.DECRYPT_MODE, secretKey, paraSpec);
30        byte[] decryptedData = cipher.doFinal(cypherText);
31        return new String(decryptedData);
32    }
33}

Examiner en continu les algorithmes de chiffrement de vos applications Java

S’il est essentiel de mettre à jour les algorithmes de chiffrement obsolètes, il est tout aussi important de surveiller en permanence votre base de code afin de détecter les nouveaux problèmes de sécurité. Les algorithmes considérés comme sûrs au moment de la rédaction de cet article seront très certainement obsolètes dans quelques années. 

Il est donc essentiel d’analyser et de détecter ces problèmes de manière proactive et continue. Cela ne concerne pas uniquement les algorithmes de chiffrement, mais aussi, bien sûr, les autres problèmes présents dans le code que vous maintenez. En adoptant un outil de test de sécurité des applications statique (SAST) comme Snyk Code, vous pourrez facilement repérer, identifier et corriger ces problèmes avant qu’ils ne causent des dommages.

Snyk Code pour Java, gratuit pour vous

Snyk Code est un outil de test de sécurité des applications statique (SAST) de pointe qui détecte les vulnérabilités de sécurité dans votre base de code. Il prend en charge plusieurs langages de programmation, dont Java, en analysant le code et en fournissant des commentaires en temps réel aux développeurs. Vous pouvez intégrer Snyk Code à votre pipeline CI/CD pour analyser automatiquement votre code à chaque commit et ainsi détecter et corriger les problèmes de sécurité dès les premières étapes du cycle de développement. Vous pouvez également le connecter à votre dépôt Git, l’utiliser en ligne de commande avec notre CLI et l’intégrer à tous les IDE Java les plus populaires. 

Vous pouvez ainsi détecter rapidement et régulièrement les problèmes dans votre code, à chaque étape du cycle de développement. Plus important encore, vous pouvez l’utiliser gratuitement en vous inscrivant à Snyk ci-dessous.

Les exemples de code de cet article de blog sont publiés sur GitHub : vous pouvez les tester vous-même. Si vous recherchez d’autres ressources utiles sur la sécurité destinées aux développeurs Java, consultez :

• Utiliser JLink pour créer des images Docker plus légères pour votre application Java Spring Boot

• Prévenir les attaques XSS (Cross-Site Scripting) dans les applications Java avec Snyk Code

• Atténuer les vulnérabilités de traversée de chemin dans Java avec Snyk Code

• Comment utiliser les DTO Java pour renforcer la sécurité

• Bonnes pratiques pour gérer les dépendances Java

• 10 bonnes pratiques pour créer un conteneur Java avec Docker