Wie kann man einen String mit sha256 in Java hashen?

Wie kann ich einen String sha256in Java hashen? Kennt jemand eine kostenlose Bibliothek dafür?

SHA-256 ist keine "Codierung" - es ist ein Einweg-Hash.

Sie würden den String grundsätzlich in Bytes konvertieren (z. B. using text.getBytes(StandardCharsets.UTF_8)) und dann die Bytes hashen. Beachten Sie, dass das Ergebnis des Hashs auch beliebige Binärdaten sind. Wenn Sie dies in einer Zeichenfolge darstellen möchten, sollten Sie base64 oder hex verwenden. Versuchen Sie nicht , den String(byte[], String)Konstruktor zu verwenden.

z.B

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

Ich denke, dass die einfachste Lösung die Verwendung von Apache Common Codec ist :

String sha256hex = org.apache.commons.codec.digest.DigestUtils.sha256Hex(stringText);   

Eine weitere Alternative ist Guava mit einer benutzerfreundlichen Suite von Hashing- Dienstprogrammen. Um beispielsweise einen String mit SHA256 als Hex-String zu hashen, gehen Sie einfach wie folgt vor:

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

Vollständiges Beispiel für einen Hash als weiteren String.

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

Wenn Sie Java 8 verwenden, können Sie das byte[]durch Codieren codieren

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;
}

Ich habe den Apache-Code durchverfolgt DigestUtilsund sha256scheint java.security.MessageDigestfür die Berechnung standardmäßig auf zurück zu gehen . Apache implementiert keine unabhängige sha256Lösung. Ich suchte nach einer unabhängigen Implementierung, um sie mit der java.securityBibliothek zu vergleichen . Nur zu Ihrer Information.

Dies war mein Ansatz mit 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)})
}

Hier ist eine etwas performantere Möglichkeit, den Digest in eine Hex-Zeichenfolge umzuwandeln:

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

Kennt jemand einen schnelleren Weg in Java?

Sie können MessageDigest folgendermaßen verwenden:

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 wird die MessageDigest- Klasse verwendet, um den kryptografischen Hashing-Wert zu berechnen. Diese Klasse bietet eine kryptografische Hash-Funktion ( MD5 , SHA-1 und SHA-256 ), um den Hash-Wert von Text zu ermitteln.

Codebeispiel für die Verwendung des SHA-256-Algorithmus.

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);

  }
}

Dies ist, was ich für das Hashing verwendet wurde:

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);

Ausgabe: 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;
}

Sie können die obige Methode mit verschiedenen Algorithmen wie unten aufrufen.

getMessageDigest(message, "MD5");
getMessageDigest(message, "SHA-256");
getMessageDigest(message, "SHA-1");

Sie können diesen Link für die vollständige Anwendung verweisen .