How can I hash some string with sha256 in Java?
16 Answers
SHA-256 isn't an "encoding" - it's a one-way hash.
You'd basically convert the string into bytes (e.g. using text.getBytes(StandardCharsets.UTF_8)) and then hash the bytes. Note that the result of the hash would also be arbitrary binary data, and if you want to represent that in a string, you should use base64 or hex... don't try to use the String(byte[], String) constructor.
e.g.
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));I think that the easiest solution is to use Apache Common Codec:
String sha256hex = org.apache.commons.codec.digest.DigestUtils.sha256Hex(stringText); Another alternative is Guava which has an easy-to-use suite of Hashing utilities. For example, to hash a string using SHA256 as a hex-string you would simply do:
final String hashed = Hashing.sha256() .hashString("your input", StandardCharsets.UTF_8) .toString();Full example hash to string as another string.
public static String sha256(final String base) { try{ final MessageDigest digest = MessageDigest.getInstance("SHA-256"); final byte[] hash = digest.digest(base.getBytes("UTF-8")); final StringBuilder hexString = new StringBuilder(); for (int i = 0; i < hash.length; i++) { final 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); }
}If you are using Java 8 you can encode the byte[] by doing
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(); }
}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;
}I traced the Apache code through DigestUtils and sha256 seems to default back to java.security.MessageDigest for calculation. Apache does not implement an independent sha256 solution. I was looking for an independent implementation to compare against the java.security library. FYI only.
This was my approach using 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)})
}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());Here is a slightly more performant way to turn the digest into a hex string:
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);
}Does anyone know of a faster way in Java?
You can use MessageDigest in the following way:
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();
}This is what i have been used for hashing:
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);Output: 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8
In Java, MessageDigest class is used to calculate cryptographic hashing value. This class provides cryptographic hash function ( MD5, SHA-1 and SHA-256) to find hash value of text.
Code example for using SHA-256 algorithm.
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); }
}Here's a method which returns a String:
public static String sha256(final String data) { try { final byte[] hash = MessageDigest.getInstance("SHA-256").digest(data.getBytes(StandardCharsets.UTF_8)); final StringBuilder hashStr = new StringBuilder(hash.length); for (byte hashByte : hash) hashStr.append(Integer.toHexString(255 & hashByte)); return hashStr.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return null; }
}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;
}You can call above method with different algorithms like below.
getMessageDigest(message, "MD5");
getMessageDigest(message, "SHA-256");
getMessageDigest(message, "SHA-1");You can refer this link for complete application.
