Chaîne de hachage via SHA-256 en Java

En regardant ici et sur Internet en général, j'ai trouvé Bouncy Castle . Je souhaite utiliser Bouncy Castle (ou un autre utilitaire disponible gratuitement) pour générer un Hash SHA-256 d'une chaîne en Java. En regardant leur documentation, je n'arrive pas à trouver de bons exemples de ce que je veux faire. Quelqu'un ici peut-il m'aider?

Pour hacher une chaîne, utilisez la classe MessageDigest intégrée :

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.nio.charset.StandardCharsets;
import java.math.BigInteger;

public class CryptoHash {
  public static void main(String[] args) throws NoSuchAlgorithmException {
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    String text = "Text to hash, cryptographically.";

    // Change this to UTF-16 if needed
    md.update(text.getBytes(StandardCharsets.UTF_8));
    byte[] digest = md.digest();

    String hex = String.format("%064x", new BigInteger(1, digest));
    System.out.println(hex);
  }
}

Dans l'extrait de code ci-dessus, digestcontient la chaîne hachée et hexcontient une chaîne ASCII hexadécimale avec un remplissage de zéro à gauche.

Ceci est déjà implémenté dans les bibliothèques d'exécution.

public static String calc(InputStream is) {
    String output;
    int read;
    byte[] buffer = new byte[8192];

    try {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        while ((read = is.read(buffer)) > 0) {
            digest.update(buffer, 0, read);
        }
        byte[] hash = digest.digest();
        BigInteger bigInt = new BigInteger(1, hash);
        output = bigInt.toString(16);
        while ( output.length() < 32 ) {
            output = "0"+output;
        }
    } 
    catch (Exception e) {
        e.printStackTrace(System.err);
        return null;
    }

    return output;
}

Dans un environnement JEE6 +, on peut également utiliser JAXB DataTypeConverter :

import javax.xml.bind.DatatypeConverter;

String hash = DatatypeConverter.printHexBinary( 
           MessageDigest.getInstance("MD5").digest("SOMESTRING".getBytes("UTF-8")));

Vous n'avez pas nécessairement besoin de la bibliothèque BouncyCastle. Le code suivant montre comment procéder à l'aide de la fonction Integer.toHexString

public static String sha256(String base) {
    try{
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(base.getBytes("UTF-8"));
        StringBuffer hexString = new StringBuffer();

        for (int i = 0; i < hash.length; i++) {
            String hex = Integer.toHexString(0xff & hash[i]);
            if(hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }

        return hexString.toString();
    } catch(Exception ex){
       throw new RuntimeException(ex);
    }
}

Un merci spécial à user1452273 de ce post: Comment hacher une chaîne avec sha256 en Java?

Continuez votre bon travail!

Lorsque vous utilisez des hashcodes avec n'importe quel fournisseur jce, vous essayez d'abord d'obtenir une instance de l'algorithme, puis mettez-la à jour avec les données que vous souhaitez hacher et lorsque vous avez terminé, vous appelez digest pour obtenir la valeur de hachage.

MessageDigest sha = MessageDigest.getInstance("SHA-256");
sha.update(in.getBytes());
byte[] digest = sha.digest();

vous pouvez utiliser le condensé pour obtenir une version encodée en base64 ou hexadécimale selon vos besoins

Java 8: Base64 disponible:

    MessageDigest md = MessageDigest.getInstance( "SHA-512" );
    md.update( inbytes );
    byte[] aMessageDigest = md.digest();

    String outEncoded = Base64.getEncoder().encodeToString( aMessageDigest );
    return( outEncoded );

Je suppose que vous utilisez une version Java relativement ancienne sans SHA-256. Vous devez donc ajouter le fournisseur BouncyCastle aux «fournisseurs de sécurité» déjà fournis dans votre version java.

    // NEEDED if you are using a Java version without SHA-256    
    Security.addProvider(new BouncyCastleProvider());

    // then go as usual 
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    String text = "my string...";
    md.update(text.getBytes("UTF-8")); // or UTF-16 if needed
    byte[] digest = md.digest();

return new String(Hex.encode(digest));

Utilisation de Java 8

MessageDigest digest = null;
try {
    digest = MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
}
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
String encoded = DatatypeConverter.printHexBinary(hash);        
System.out.println(encoded.toLowerCase());

Cela fonctionnera avec le package suivant "org.bouncycastle.util.encoders.Hex"

return new String(Hex.encode(digest));

C'est dans un pot de château gonflable.