web-dev-qa-db-fra.com

Comment hacher une chaîne avec sha256 en Java?

Comment hacher une chaîne avec sha256 dans Java? Est-ce que quelqu'un connaît une bibliothèque gratuite pour cela?

javacryptographysha256cryptographic-hash-function
179
Ivana

SHA-256 n'est pas un "encodage" - c'est un hachage à sens unique.

En gros, vous convertissez la chaîne en octets (par exemple, en utilisant text.getBytes(StandardCharsets.UTF_8)), puis vous hachez les octets. Notez que le résultat du hachage aussi sera des données binaires arbitraires, et si vous voulez représenter cela dans une chaîne, vous devez utiliser base64 ou hex ... ne pas = essayez d'utiliser le constructeur String(byte[], String).

par exemple.

MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
271
Jon Skeet

Je pense que la solution la plus simple est d’utiliser Apache Common Codec :

String sha256hex = org.Apache.commons.codec.digest.DigestUtils.sha256Hex(stringText);
149
seba

Une autre alternative est Guava qui propose une suite d’utilitaires hachage facile à utiliser. Par exemple, pour hacher une chaîne en utilisant SHA256 comme chaîne hexagonale, vous feriez simplement:

final String hashed = Hashing.sha256()
        .hashString("your input", StandardCharsets.UTF_8)
        .toString();
93
Jonathan

Exemple complet hash to string comme une autre chaîne.

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);
    }
}
77
user1452273

Si vous utilisez Java 8, vous pouvez encoder le byte[] en faisant

MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
String encoded = Base64.getEncoder().encodeToString(hash);
36
Eduardo Dennis
String hashWith256(String textToHash) {
    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    byte[] byteOfTextToHash = textToHash.getBytes(StandardCharsets.UTF_8);
    byte[] hashedByetArray = digest.digest(byteOfTextToHash);
    String encoded = Base64.getEncoder().encodeToString(hashedByetArray);
    return encoded;
}
8
Ezd

Convertir Java Chaîne en Hash Sha-256

import Java.security.MessageDigest;

public class CodeSnippets {

 public static String getSha256(String value) {
    try{
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(value.getBytes());
        return bytesToHex(md.digest());
    } catch(Exception ex){
        throw new RuntimeException(ex);
    }
 }
 private static String bytesToHex(byte[] bytes) {
    StringBuffer result = new StringBuffer();
    for (byte b : bytes) result.append(Integer.toString((b & 0xff) + 0x100, 16).substring(1));
    return result.toString();
 }
}
7
Chathura Wijesinghe

J'ai tracé le code Apache via DigestUtils et sha256 semble revenir par défaut à Java.security.MessageDigest pour le calcul. Apache n'implémente pas de solution sha256 indépendante. Je recherchais une implémentation indépendante à comparer avec la bibliothèque Java.security. FYI seulement.

5
garyn

Voici un moyen légèrement plus performant de transformer le résumé en chaîne hexadécimale:

private static final char[] hexArray = "0123456789abcdef".toCharArray();

public static String getSHA256(String data) {
    StringBuilder sb = new StringBuilder();
    try {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(data.getBytes());
        byte[] byteData = md.digest();
        sb.append(bytesToHex(byteData);
    } catch(Exception e) {
        e.printStackTrace();
    }
    return sb.toString();
}

private static String bytesToHex(byte[] bytes) {
    char[] hexChars = new char[bytes.length * 2];
    for ( int j = 0; j < bytes.length; j++ ) {
        int v = bytes[j] & 0xFF;
        hexChars[j * 2] = hexArray[v >>> 4];
        hexChars[j * 2 + 1] = hexArray[v & 0x0F];
    }
    return String.valueOf(hexChars);
}

Est-ce que quelqu'un connaît un moyen plus rapide en Java?

2
andi

Vous pouvez utiliser MessageDigest de la manière suivante:

public static String getSHA256(String data){
    StringBuffer sb = new StringBuffer();
    try{
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(data.getBytes());
        byte byteData[] = md.digest();

        for (int i = 0; i < byteData.length; i++) {
         sb.append(Integer.toString((byteData[i] & 0xff) + 0x100, 16).substring(1));
        }
    } catch(Exception e){
        e.printStackTrace();
    }
    return sb.toString();
}
1
thatman

C'était mon approche en utilisant Kotlin:

private fun getHashFromEmailString(email : String) : String{
    val charset = Charsets.UTF_8
    val byteArray = email.toByteArray(charset)
    val digest = MessageDigest.getInstance("SHA-256")
    val hash = digest.digest(byteArray)

    return hash.toString()
}
0
Samuel Luís