Come posso eseguire l'hashing di una stringa con sha256
in Java? Qualcuno sa di qualche libreria gratuita per questo?
Come posso eseguire l'hashing di una stringa con sha256
in Java? Qualcuno sa di qualche libreria gratuita per questo?
Risposte:
SHA-256 non è una "codifica", è un hash unidirezionale.
Fondamentalmente convertiresti la stringa in byte (ad es. Usando text.getBytes(StandardCharsets.UTF_8)
) e poi hash i byte. Nota che il risultato dell'hash sarebbe anche dati binari arbitrari e se vuoi rappresentarlo in una stringa, dovresti usare base64 o hex ... non provare a usare il String(byte[], String)
costruttore.
per esempio
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
"UTF-8"
letterale in Java 7+: un'eccezione controllata in meno di cui preoccuparsi.
Penso che la soluzione più semplice sia usare Apache Common Codec :
String sha256hex = org.apache.commons.codec.digest.DigestUtils.sha256Hex(stringText);
Un'altra alternativa è Guava che ha una suite di utility Hashing di facile utilizzo . Ad esempio, per eseguire l'hashing di una stringa utilizzando SHA256 come stringa esadecimale, farebbe semplicemente:
final String hashed = Hashing.sha256()
.hashString("your input", StandardCharsets.UTF_8)
.toString();
Hash di esempio completo per stringa come un'altra stringa.
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);
}
}
Se stai usando Java 8 puoi codificarlo byte[]
facendo
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
? Non cede niente, vero?
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;
}
Ho rintracciato il codice Apache attraverso DigestUtils
e sha256
sembra tornare a default java.security.MessageDigest
per il calcolo. Apache non implementa una sha256
soluzione indipendente . Stavo cercando un'implementazione indipendente da confrontare con la java.security
biblioteca. FYI only.
Questo è stato il mio approccio con 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
non la password crittografata. Inoltre, sembra diverso ogni volta che viene chiamata questa funzione.
return hash.fold("", { str, it -> str + "%02x".format(it)})
quale restituisce la password crittografata e non l'oggetto stesso.
Ecco un modo leggermente più performante per trasformare il digest in una stringa esadecimale:
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);
}
Qualcuno sa di un modo più veloce in Java?
È possibile utilizzare MessageDigest nel modo seguente:
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();
}
In 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());
In Java, la classe MessageDigest viene utilizzata per calcolare il valore di hash crittografico. Questa classe fornisce la funzione hash crittografica ( MD5 , SHA-1 e SHA-256 ) per trovare il valore hash del testo.
Esempio di codice per l'utilizzo dell'algoritmo 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);
}
}
Questo è quello che sono stato usato per l'hash:
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);
Uscita: 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;
}
Puoi chiamare il metodo sopra con diversi algoritmi come di seguito.
getMessageDigest(message, "MD5");
getMessageDigest(message, "SHA-256");
getMessageDigest(message, "SHA-1");
È possibile fare riferimento a questo collegamento per l'applicazione completa.