Comment puis-je hacher une chaîne avec sha256
en Java? Quelqu'un connaît-il une bibliothèque gratuite pour cela?
Comment puis-je hacher une chaîne avec sha256
en Java? Quelqu'un connaît-il une bibliothèque gratuite pour cela?
Réponses:
SHA-256 n'est pas un "encodage" - c'est un hachage unidirectionnel.
Vous convertiriez essentiellement la chaîne en octets (par exemple en utilisant text.getBytes(StandardCharsets.UTF_8)
), puis hacheriez les octets. Notez que le résultat du hachage serait également des données binaires arbitraires, et si vous voulez représenter cela dans une chaîne, vous devez utiliser base64 ou hex ... n'essayez pas d'utiliser le String(byte[], String)
constructeur.
par exemple
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
"UTF-8"
littéral dans Java 7+: une exception vérifiée de moins à se soucier.
Je pense que la solution la plus simple consiste à utiliser Apache Common Codec :
String sha256hex = org.apache.commons.codec.digest.DigestUtils.sha256Hex(stringText);
Une autre alternative est Guava qui a une suite d' utilitaires de hachage facile à utiliser . Par exemple, pour hacher une chaîne en utilisant SHA256 comme chaîne hexadécimale, vous feriez simplement:
final String hashed = Hashing.sha256()
.hashString("your input", StandardCharsets.UTF_8)
.toString();
Exemple complet de hachage à chaîne 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);
}
}
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);
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();
}
}
0xff
? Cela ne rapporte rien, n'est-ce pas?
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;
}
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.fold("", { str, it -> str + "%02x".format(it)})
}
[B@188363e
pas le mot de passe crypté. De plus, il semble différent chaque fois que cette fonction est appelée.
return hash.fold("", { str, it -> str + "%02x".format(it)})
qui renvoie le mot de passe crypté et non l'objet lui-même.
Voici une façon légèrement plus performante de transformer le résumé en une 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);
}
Quelqu'un connaît-il un moyen plus rapide en Java?
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();
}
Dans Java 8
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;
import javax.xml.bind.DatatypeConverter;
Scanner scanner = new Scanner(System.in);
String password = scanner.nextLine();
scanner.close();
MessageDigest digest = null;
try {
digest = MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
byte[] hash = digest.digest(password.getBytes(StandardCharsets.UTF_8));
String encoded = DatatypeConverter.printHexBinary(hash);
System.out.println(encoded.toLowerCase());
En Java, la classe MessageDigest est utilisée pour calculer la valeur de hachage cryptographique. Cette classe fournit une fonction de hachage cryptographique ( MD5 , SHA-1 et SHA-256 ) pour trouver la valeur de hachage du texte.
Exemple de code pour l'utilisation de l'algorithme SHA-256.
public void printHash(String str) throws NoSuchAlgorithmException {
MessageDigest md=MessageDigest.getInstance("SHA-256");
byte[] sha256=md.digest(str.getBytes(StandardCharsets.UTF_8));
for(byte b : sha256){
System.out.printf("%02x",b);
}
}
C'est ce que j'ai utilisé pour le hachage:
String pass = "password";
MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
byte hashBytes[] = messageDigest.digest(pass.getBytes(StandardCharsets.UTF_8));
BigInteger noHash = new BigInteger(1, hashBytes);
String hashStr = noHash.toString(16);
Sortie: 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8
private static String getMessageDigest(String message, String algorithm) {
MessageDigest digest;
try {
digest = MessageDigest.getInstance(algorithm);
byte data[] = digest.digest(message.getBytes("UTF-8"));
return convertByteArrayToHexString(data);
} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
Vous pouvez appeler la méthode ci-dessus avec différents algorithmes comme ci-dessous.
getMessageDigest(message, "MD5");
getMessageDigest(message, "SHA-256");
getMessageDigest(message, "SHA-1");
Vous pouvez renvoyer ce lien pour une demande complète.