Open source et architecture logicielle

Dans ce billet, vous trouverez une source simple et efficace pour chiffrer ou déchiffrer rapidement un texte avec l'algorithme AES.

Cette source utilise l'implémentation native de JCA (Java Cryptography Architecture) qu'offre Oracle en standard dans le JDKdepuis la version Java7. Donc pas besoin d'ajouter de .jar ni d'artefact MAVEN.
Néanmoins, l’utilisation de la classe Base64 contraint à utiliser le Java 8. Pour ceux qui veulent utiliser JDK 1.7, je pourrais fournir un code de contournement à la demande (en commentaires sur ce post)

On utilisera 3 objets pour exécuter les trois étapes majeures du processus :

• L'objet KeyGenerator pour la génération d'une clé aléatoire de 128 bits
• L'objet Base64 pour l'encodage d'une chaine de caractères (notre texte) dans un tableau d'octets et l'opération inverse associée en utilisant le codage Base64
• L'objet Cipher pour le chiffrement proprement dit du tableau d'octets (et respectivement le déchiffrement)

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
 
public class CodeDecodeAES 
{
	static Cipher cipher;
 
	public static void main(String[] args) throws Exception
	{
		// génération d'une clé AES de 128bits
		KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
		keyGenerator.init(128);
		SecretKey secretKey = keyGenerator.generateKey();
 
		// instanciation d'un objet chiffreur implémentant le chiffrement AES
		cipher = Cipher.getInstance("AES");
 
		// le clair
		String plainText = "AES Symmetric Encryption Decryption";
		System.out.println("Plain Text Before Encryption: " + plainText);
 
		// le chiffré
		String encryptedText = encrypt(plainText, secretKey);
		System.out.println("Encrypted Text After Encryption: " + encryptedText);
 
		// de nouveau le clair
		String decryptedText = decrypt(encryptedText, secretKey);
		System.out.println("Decrypted Text After Decryption: " + decryptedText);
	}
 
	private static String decrypt(String encryptedText, SecretKey secretKey) throws Exception
	{
		// chargement du chiffré dans un tableau d'octets
		Base64.Decoder decoder = Base64.getDecoder();
		byte[] encryptedTextByte = decoder.decode(encryptedText);
 
		// initialisation du chiffreur en mode déchiffrement avec clé secrete
		cipher.init(Cipher.DECRYPT_MODE, secretKey);
 
		// déchiffrement du tableau d'octets
		byte[] decryptedByte = cipher.doFinal(encryptedTextByte);
 
		// chaine de caractères représentant le clair
		String decryptedText = new String(decryptedByte);
		return decryptedText;
	}
 
	private static String encrypt(String plainText, SecretKey secretKey) throws Exception
	{
		// chargement du clair dans un tableau d'octets
		byte[] plainTextByte = plainText.getBytes();
 
		// initialisation du chiffreur en mode chiffrement avec clé secrete
		cipher.init(Cipher.ENCRYPT_MODE, secretKey);
 
		// chiffrement du tableau d'octets
		byte[] encryptedByte = cipher.doFinal(plainTextByte);
 
		// chaine de caractères représentant le chiffré 
		Base64.Encoder encoder = Base64.getEncoder();
		String encryptedText = encoder.encodeToString(encryptedByte);
		return encryptedText;
	}
}