Hash String über SHA-256 in Java

Indem ich mich hier und im Internet im Allgemeinen umgesehen habe , habe ich Bouncy Castle gefunden . Ich möchte Bouncy Castle (oder ein anderes frei verfügbares Dienstprogramm) verwenden, um einen SHA-256-Hash eines Strings in Java zu generieren. Wenn ich mir ihre Dokumentation ansehe, kann ich anscheinend keine guten Beispiele dafür finden, was ich tun möchte. Kann mir hier jemand helfen?

Verwenden Sie zum Hashing eines Strings die integrierte MessageDigest- Klasse:

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.nio.charset.StandardCharsets;
import java.math.BigInteger;

public class CryptoHash {
  public static void main(String[] args) throws NoSuchAlgorithmException {
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    String text = "Text to hash, cryptographically.";

    // Change this to UTF-16 if needed
    md.update(text.getBytes(StandardCharsets.UTF_8));
    byte[] digest = md.digest();

    String hex = String.format("%064x", new BigInteger(1, digest));
    System.out.println(hex);
  }
}

digestEnthält im obigen Snippet die Hash-Zeichenfolge und hexeine hexadezimale ASCII-Zeichenfolge mit Links-Null-Auffüllung.

Dies ist bereits in den Laufzeitbibliotheken implementiert.

public static String calc(InputStream is) {
    String output;
    int read;
    byte[] buffer = new byte[8192];

    try {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        while ((read = is.read(buffer)) > 0) {
            digest.update(buffer, 0, read);
        }
        byte[] hash = digest.digest();
        BigInteger bigInt = new BigInteger(1, hash);
        output = bigInt.toString(16);
        while ( output.length() < 32 ) {
            output = "0"+output;
        }
    } 
    catch (Exception e) {
        e.printStackTrace(System.err);
        return null;
    }

    return output;
}

In einer JEE6 + -Umgebung kann man auch JAXB DataTypeConverter verwenden :

import javax.xml.bind.DatatypeConverter;

String hash = DatatypeConverter.printHexBinary( 
           MessageDigest.getInstance("MD5").digest("SOMESTRING".getBytes("UTF-8")));

Sie benötigen nicht unbedingt die BouncyCastle-Bibliothek. Der folgende Code zeigt, wie dies mit der Funktion Integer.toHexString gemacht wird

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

Besonderer Dank geht an user1452273 aus diesem Beitrag: Wie wird ein String mit sha256 in Java gehasht ?

Mach weiter so !

Wenn Sie Hashcodes mit einem JCE-Anbieter verwenden, versuchen Sie zunächst, eine Instanz des Algorithmus abzurufen, aktualisieren ihn dann mit den Daten, die gehasht werden sollen, und rufen Sie Digest auf, um den Hash-Wert abzurufen.

MessageDigest sha = MessageDigest.getInstance("SHA-256");
sha.update(in.getBytes());
byte[] digest = sha.digest();

Sie können den Digest verwenden, um eine Base64- oder Hex-codierte Version entsprechend Ihren Anforderungen zu erhalten

Java 8: Base64 verfügbar:

    MessageDigest md = MessageDigest.getInstance( "SHA-512" );
    md.update( inbytes );
    byte[] aMessageDigest = md.digest();

    String outEncoded = Base64.getEncoder().encodeToString( aMessageDigest );
    return( outEncoded );

Ich nehme an, Sie verwenden eine relativ alte Java-Version ohne SHA-256. Daher müssen Sie den BouncyCastle-Anbieter zu den bereits bereitgestellten "Sicherheitsanbietern" in Ihrer Java-Version hinzufügen.

    // NEEDED if you are using a Java version without SHA-256    
    Security.addProvider(new BouncyCastleProvider());

    // then go as usual 
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    String text = "my string...";
    md.update(text.getBytes("UTF-8")); // or UTF-16 if needed
    byte[] digest = md.digest();

return new String(Hex.encode(digest));

Verwenden von Java 8

MessageDigest digest = null;
try {
    digest = MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
}
byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
String encoded = DatatypeConverter.printHexBinary(hash);        
System.out.println(encoded.toLowerCase());

Dies funktioniert mit dem folgenden Paket "org.bouncycastle.util.encoders.Hex"

return new String(Hex.encode(digest));

Es ist in Hüpfburg Glas.