Hachage SHA-256 et SHA3-256 en Java

Aperçu

Le SHA (Secure Hash Algorithm) est l’une des fonctions de hachage cryptographique populaires. Un hachage cryptographique peut être utilisé pour faire une signature pour un texte ou un fichier de données. Dans ce tutoriel, voyons comment nous pouvons effectuer des opérations de hachage SHA-256 et SHA3-256 à l’aide de diverses bibliothèques Java.

L’algorithme SHA-256 génère un hachage presque unique et de taille fixe de 256 bits (32 octets). Il s’agit d’une fonction à sens unique, le résultat ne peut donc pas être décrypté pour retrouver la valeur d’origine.

À l’heure actuelle, le hachage SHA-2 est largement utilisé car il est considéré comme l’algorithme de hachage le plus sûr dans l’arène cryptographique.

SHA-3 est la dernière norme de hachage sécurisée après SHA-2. Par rapport à SHA-2, SHA-3 fournit une approche différente pour générer un hachage unidirectionnel unique, et il peut être beaucoup plus rapide sur certaines implémentations matérielles. Semblable à SHA-256, SHA3-256 est l’algorithme à longueur fixe de 256 bits dans SHA-3.

Le NIST a publié SHA-3 en 2015, il n’y a donc pas tout à fait autant de bibliothèques SHA-3 que SHA-2 pour le moment. Il faut attendre le JDK 9 pour que les algorithmes SHA-3 soient disponibles dans les fournisseurs intégrés par défaut.

Maintenant, commençons par SHA-256.

La classe MessageDigest en Java

Java fournit une classe MessageDigest intégrée pour le hachage SHA-256 :

MessageDigest digest = MessageDigest.getInstance("SHA-256");byte encodedhash = digest.digest( originalString.getBytes(StandardCharsets.UTF_8));

Mais ici, nous devons utiliser un convertisseur personnalisé octet vers hexadécimal pour obtenir la valeur hachée en hexadécimal:

private static String bytesToHex(byte hash) { StringBuilder hexString = new StringBuilder(2 * hash.length); for (int i = 0; i < hash.length; i++) { String hex = Integer.toHexString(0xff & hash); if(hex.length() == 1) { hexString.append('0'); } hexString.append(hex); } return hexString.toString();}

Nous devons être conscients, que le MessageDigest n’est pas thread-safe. Par conséquent, nous devons utiliser une nouvelle instance pour chaque thread.

La bibliothèque Guava

La bibliothèque Guava de Google fournit également une classe utilitaire pour le hachage.

D’abord, définissons la dépendance:

<dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>20.0</version></dependency>

Maintenant, voici comment nous pouvons utiliser Guava pour hacher une Chaîne :

String sha256hex = Hashing.sha256() .hashString(originalString, StandardCharsets.UTF_8) .toString();

Apache Commons Codecs

De même, nous pouvons également utiliser Apache Commons Codecs :

<dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</artifactId> <version>1.11</version></dependency>

Voici la classe utilitaire – appelée DigestUtils – qui prend en charge le hachage SHA-256:

String sha256hex = DigestUtils.sha256Hex(originalString);

Bouncy Castle Library

5.1. Dépendance Maven

<dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.60</version></dependency>

5.2. Hachage à l’aide de la bibliothèque Bouncy Castle

L’API Bouncy Castle fournit une classe utilitaire pour convertir des données hexadécimales en octets et inversement.

Cependant, il est nécessaire de peupler un condensé en utilisant d’abord l’API Java intégrée :

MessageDigest digest = MessageDigest.getInstance("SHA-256");byte hash = digest.digest( originalString.getBytes(StandardCharsets.UTF_8));String sha256hex = new String(Hex.encode(hash));

SHA3-256

Poursuivons maintenant avec SHA3-256. Le hachage SHA3-256 en Java n’a rien de bien différent de SHA-256.

6.1. Classe MessageDigest en Java

À partir du JDK 9, nous pouvons simplement utiliser l’algorithme SHA3-256 intégré:

final MessageDigest digest = MessageDigest.getInstance("SHA3-256");final byte hashbytes = digest.digest( originalString.getBytes(StandardCharsets.UTF_8));String sha3Hex = bytesToHex(hashbytes);

6.2. Apache Commons Codecs

Apache Commons Codecs fournit un wrapper DigestUtils pratique pour la classe MessageDigest. Cette bibliothèque a commencé à supporter SHA3-256 depuis la version 1.11, et elle nécessite également le JDK 9+ :

String sha3Hex = new DigestUtils("SHA3-256").digestAsHex(originalString);

6.3. Keccak-256

Keccak-256 est un autre algorithme de hachage SHA3-256 populaire. Actuellement, il sert d’alternative à la norme SHA3-256. Keccak-256 offre le même niveau de sécurité que le SHA3-256 standard, et il ne diffère du SHA3-256 que sur la règle de remplissage. Il a été utilisé dans plusieurs projets de blockchain, tels que Monero.

Encore, nous devons importer la bibliothèque Bouncy Castle pour utiliser le hachage Keccak-256 :

Security.addProvider(new BouncyCastleProvider());final MessageDigest digest = MessageDigest.getInstance("Keccak-256");final byte encodedhash = digest.digest( originalString.getBytes(StandardCharsets.UTF_8));String sha3Hex = bytesToHex(encodedhash);

Nous pouvons également faire appel à l’API Bouncy Castle pour effectuer le hachage :

Keccak.Digest256 digest256 = new Keccak.Digest256();byte hashbytes = digest256.digest( originalString.getBytes(StandardCharsets.UTF_8));String sha3Hex = new String(Hex.encode(hashbytes));

Conclusion

Dans ce rapide article, nous avons eu un aperçu de quelques façons de mettre en œuvre le hachage SHA-256 et SHA3-256 en Java, en utilisant des bibliothèques intégrées et tierces.