Làm thế nào để băm một số chuỗi với sha256 trong Java?

Làm thế nào tôi có thể băm một số chuỗi với sha256trong Java? Có ai biết bất kỳ thư viện miễn phí cho điều này?

SHA-256 không phải là "mã hóa" - đó là hàm băm một chiều.

Về cơ bản, bạn sẽ chuyển đổi chuỗi thành byte (ví dụ: sử dụng text.getBytes(StandardCharsets.UTF_8)) và sau đó băm các byte. Lưu ý rằng kết quả của hàm băm cũng sẽ là dữ liệu nhị phân tùy ý và nếu bạn muốn biểu diễn chuỗi đó trong chuỗi, bạn nên sử dụng base64 hoặc hex ... đừng cố sử dụng hàm String(byte[], String)tạo.

ví dụ

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

Tôi nghĩ rằng giải pháp đơn giản nhất là sử dụng Apache Common Codec :

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

Một lựa chọn khác là Guava có bộ tiện ích Hashing dễ sử dụng . Ví dụ: để băm một chuỗi bằng SHA256 dưới dạng chuỗi hex bạn chỉ cần làm:

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

Ví dụ đầy đủ băm để chuỗi như một chuỗi khác.

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

Nếu bạn đang sử dụng Java 8, bạn có thể mã hóa byte[]bằng cách thực hiện

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

Tôi đã lần theo mã Apache DigestUtilsvà sha256dường như mặc định quay lại để java.security.MessageDigesttính toán. Apache không thực hiện một sha256giải pháp độc lập . Tôi đang tìm kiếm một triển khai độc lập để so sánh với java.securitythư viện. Chỉ có FYI.

Đây là cách tiếp cận của tôi bằng cách sử dụng 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)})
}

Đây là một cách hiệu quả hơn một chút để biến digest thành chuỗi hex:

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

Có ai biết một cách nhanh hơn trong Java?

Bạn có thể sử dụng MessageDigest theo cách sau:

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

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

Trong Java, lớp MessageDigest được sử dụng để tính giá trị băm mật mã. Lớp này cung cấp hàm băm mật mã ( MD5 , SHA-1 và SHA-256 ) để tìm giá trị băm của văn bản.

Ví dụ mã để sử dụng thuật toán 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);

  }
}

Đây là những gì tôi đã được sử dụng để băm:

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

Đầu ra: 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;
}

Bạn có thể gọi phương thức trên với các thuật toán khác nhau như dưới đây.

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

Bạn có thể tham khảo liên kết này cho ứng dụng hoàn chỉnh.