Làm cách nào để băm mật khẩu trong Java?

Tôi cần băm mật khẩu để lưu trữ trong cơ sở dữ liệu. Làm thế nào tôi có thể làm điều này trong Java?

Tôi đã hy vọng lấy mật khẩu văn bản đơn giản, thêm một muối ngẫu nhiên, sau đó lưu trữ muối và mật khẩu băm trong cơ sở dữ liệu.

Sau đó, khi người dùng muốn đăng nhập, tôi có thể lấy mật khẩu đã gửi của họ, thêm muối ngẫu nhiên từ thông tin tài khoản của họ, băm nó và xem liệu nó có tương đương với mật khẩu băm được lưu trữ với thông tin tài khoản của họ không.

Bạn thực sự có thể sử dụng một phương tiện được tích hợp sẵn trong thời gian chạy Java để làm điều này. SunJCE trong Java 6 hỗ trợ PBKDF2, đây là một thuật toán tốt để sử dụng để băm mật khẩu.

byte[] salt = new byte[16];
random.nextBytes(salt);
KeySpec spec = new PBEKeySpec("password".toCharArray(), salt, 65536, 128);
SecretKeyFactory f = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
byte[] hash = f.generateSecret(spec).getEncoded();
Base64.Encoder enc = Base64.getEncoder();
System.out.printf("salt: %s%n", enc.encodeToString(salt));
System.out.printf("hash: %s%n", enc.encodeToString(hash));

Đây là một lớp tiện ích mà bạn có thể sử dụng để xác thực mật khẩu PBKDF2:

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Arrays;
import java.util.Base64;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

/**
 * Hash passwords for storage, and test passwords against password tokens.
 * 
 * Instances of this class can be used concurrently by multiple threads.
 *  
 * @author erickson
 * @see <a href="http://stackoverflow.com/a/2861125/3474">StackOverflow</a>
 */
public final class PasswordAuthentication
{

  /**
   * Each token produced by this class uses this identifier as a prefix.
   */
  public static final String ID = "$31$";

  /**
   * The minimum recommended cost, used by default
   */
  public static final int DEFAULT_COST = 16;

  private static final String ALGORITHM = "PBKDF2WithHmacSHA1";

  private static final int SIZE = 128;

  private static final Pattern layout = Pattern.compile("\\$31\\$(\\d\\d?)\\$(.{43})");

  private final SecureRandom random;

  private final int cost;

  public PasswordAuthentication()
  {
    this(DEFAULT_COST);
  }

  /**
   * Create a password manager with a specified cost
   * 
   * @param cost the exponential computational cost of hashing a password, 0 to 30
   */
  public PasswordAuthentication(int cost)
  {
    iterations(cost); /* Validate cost */
    this.cost = cost;
    this.random = new SecureRandom();
  }

  private static int iterations(int cost)
  {
    if ((cost < 0) || (cost > 30))
      throw new IllegalArgumentException("cost: " + cost);
    return 1 << cost;
  }

  /**
   * Hash a password for storage.
   * 
   * @return a secure authentication token to be stored for later authentication 
   */
  public String hash(char[] password)
  {
    byte[] salt = new byte[SIZE / 8];
    random.nextBytes(salt);
    byte[] dk = pbkdf2(password, salt, 1 << cost);
    byte[] hash = new byte[salt.length + dk.length];
    System.arraycopy(salt, 0, hash, 0, salt.length);
    System.arraycopy(dk, 0, hash, salt.length, dk.length);
    Base64.Encoder enc = Base64.getUrlEncoder().withoutPadding();
    return ID + cost + '$' + enc.encodeToString(hash);
  }

  /**
   * Authenticate with a password and a stored password token.
   * 
   * @return true if the password and token match
   */
  public boolean authenticate(char[] password, String token)
  {
    Matcher m = layout.matcher(token);
    if (!m.matches())
      throw new IllegalArgumentException("Invalid token format");
    int iterations = iterations(Integer.parseInt(m.group(1)));
    byte[] hash = Base64.getUrlDecoder().decode(m.group(2));
    byte[] salt = Arrays.copyOfRange(hash, 0, SIZE / 8);
    byte[] check = pbkdf2(password, salt, iterations);
    int zero = 0;
    for (int idx = 0; idx < check.length; ++idx)
      zero |= hash[salt.length + idx] ^ check[idx];
    return zero == 0;
  }

  private static byte[] pbkdf2(char[] password, byte[] salt, int iterations)
  {
    KeySpec spec = new PBEKeySpec(password, salt, iterations, SIZE);
    try {
      SecretKeyFactory f = SecretKeyFactory.getInstance(ALGORITHM);
      return f.generateSecret(spec).getEncoded();
    }
    catch (NoSuchAlgorithmException ex) {
      throw new IllegalStateException("Missing algorithm: " + ALGORITHM, ex);
    }
    catch (InvalidKeySpecException ex) {
      throw new IllegalStateException("Invalid SecretKeyFactory", ex);
    }
  }

  /**
   * Hash a password in an immutable {@code String}. 
   * 
   * <p>Passwords should be stored in a {@code char[]} so that it can be filled 
   * with zeros after use instead of lingering on the heap and elsewhere.
   * 
   * @deprecated Use {@link #hash(char[])} instead
   */
  @Deprecated
  public String hash(String password)
  {
    return hash(password.toCharArray());
  }

  /**
   * Authenticate with a password in an immutable {@code String} and a stored 
   * password token. 
   * 
   * @deprecated Use {@link #authenticate(char[],String)} instead.
   * @see #hash(String)
   */
  @Deprecated
  public boolean authenticate(String password, String token)
  {
    return authenticate(password.toCharArray(), token);
  }

}

Đây là một triển khai hoàn chỉnh với hai phương thức thực hiện chính xác những gì bạn muốn:

String getSaltedHash(String password)
boolean checkPassword(String password, String stored)

Vấn đề là ngay cả khi kẻ tấn công có quyền truy cập vào cả cơ sở dữ liệu và mã nguồn của bạn, mật khẩu vẫn an toàn.

import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.SecureRandom;
import org.apache.commons.codec.binary.Base64;

public class Password {
    // The higher the number of iterations the more 
    // expensive computing the hash is for us and
    // also for an attacker.
    private static final int iterations = 20*1000;
    private static final int saltLen = 32;
    private static final int desiredKeyLen = 256;

    /** Computes a salted PBKDF2 hash of given plaintext password
        suitable for storing in a database. 
        Empty passwords are not supported. */
    public static String getSaltedHash(String password) throws Exception {
        byte[] salt = SecureRandom.getInstance("SHA1PRNG").generateSeed(saltLen);
        // store the salt with the password
        return Base64.encodeBase64String(salt) + "$" + hash(password, salt);
    }

    /** Checks whether given plaintext password corresponds 
        to a stored salted hash of the password. */
    public static boolean check(String password, String stored) throws Exception{
        String[] saltAndHash = stored.split("\\$");
        if (saltAndHash.length != 2) {
            throw new IllegalStateException(
                "The stored password must have the form 'salt$hash'");
        }
        String hashOfInput = hash(password, Base64.decodeBase64(saltAndHash[0]));
        return hashOfInput.equals(saltAndHash[1]);
    }

    // using PBKDF2 from Sun, an alternative is https://github.com/wg/scrypt
    // cf. http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html
    private static String hash(String password, byte[] salt) throws Exception {
        if (password == null || password.length() == 0)
            throw new IllegalArgumentException("Empty passwords are not supported.");
        SecretKeyFactory f = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
        SecretKey key = f.generateSecret(new PBEKeySpec(
            password.toCharArray(), salt, iterations, desiredKeyLen));
        return Base64.encodeBase64String(key.getEncoded());
    }
}

Chúng tôi đang lưu trữ 'salt$iterated_hash(password, salt)'. Muối là 32 byte ngẫu nhiên và mục đích của nó là nếu hai người khác nhau chọn cùng một mật khẩu, mật khẩu được lưu trữ sẽ vẫn trông khác nhau.

Điều này iterated_hash, về cơ bản hash(hash(hash(... hash(password, salt) ...)))làm cho nó rất tốn kém cho một kẻ tấn công tiềm năng có quyền truy cập vào cơ sở dữ liệu của bạn để đoán mật khẩu, băm chúng và tìm kiếm băm trong cơ sở dữ liệu. Bạn phải tính toán điều này iterated_hashmỗi khi người dùng đăng nhập, nhưng nó không tốn của bạn nhiều so với kẻ tấn công dành gần 100% thời gian băm máy tính của họ.

BCrypt là một thư viện rất tốt và có một cổng Java của nó.

Bạn có thể sử dụng triển khai của thư viện Shiro (trước đây là Bảo mật ) về những gì được mô tả bởi OWASP .

Dường như thư viện JASYPT có một tiện ích tương tự .

Bạn có thể tính toán băm bằng cách sử dụng MessageDigest, nhưng điều này là sai về mặt bảo mật. Băm không được sử dụng để lưu trữ mật khẩu, vì chúng rất dễ bị phá vỡ.

Bạn nên sử dụng một thuật toán khác như bcrypt, PBKDF2 và scrypt để lưu trữ mật khẩu của bạn. Xem ở đây .

Ngoài bcrypt và PBKDF2 được đề cập trong các câu trả lời khác, tôi khuyên bạn nên xem xét về tiền điện tử

MD5 và SHA-1 không được khuyến nghị vì chúng tương đối nhanh, do đó sử dụng máy tính phân tán "thuê mỗi giờ" (ví dụ EC2) hoặc GPU cao cấp hiện đại, người ta có thể "bẻ khóa" mật khẩu bằng cách sử dụng tấn công từ điển / mạnh mẽ với chi phí tương đối thấp và hợp lý thời gian.

Nếu bạn phải sử dụng chúng, thì ít nhất hãy lặp lại thuật toán một số lần đáng kể được xác định trước (1000+).

• Xem tại đây để biết thêm: /security/211/how-to-seciously-hash-passwords

• Và tại đây: http://codahale.com/how-to-safely-store-a-password/ (chỉ trích gia đình SHA, MD5, v.v ... vì mục đích băm mật khẩu)

• Và tại đây: http : //www.unlrictnov ERIC.com/2012/03/dont-use-bcrypt.html (chỉ trích bcrypt và đề xuất tiền điện tử và PBKDF2)

Hoàn toàn đồng ý với Erickson rằng PBKDF2 là câu trả lời.

Nếu bạn không có tùy chọn đó hoặc chỉ cần sử dụng hàm băm, Apache Commons DigestUtils dễ dàng hơn nhiều so với việc lấy mã JCE ngay: https://commons.apache.org/proper/commons-codec/apidocs/org/apache /commons/codec/digest/DigestUtils.html

Nếu bạn sử dụng hàm băm, hãy sử dụng sha256 hoặc sha512. Trang này có các đề xuất tốt về xử lý mật khẩu và băm (lưu ý không khuyến nghị băm để xử lý mật khẩu): http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html

Bạn có thể sử dụng Spring Security Crypto (chỉ có 2 phụ thuộc biên dịch tùy chọn ), hỗ trợ mã hóa mật khẩu PBKDF2 , BCrypt , SCrypt và Argon2 .

Argon2PasswordEncoder argon2PasswordEncoder = new Argon2PasswordEncoder();
String aCryptedPassword = argon2PasswordEncoder.encode("password");
boolean passwordIsValid = argon2PasswordEncoder.matches("password", aCryptedPassword);

SCryptPasswordEncoder sCryptPasswordEncoder = new SCryptPasswordEncoder();
String sCryptedPassword = sCryptPasswordEncoder.encode("password");
boolean passwordIsValid = sCryptPasswordEncoder.matches("password", sCryptedPassword);

BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
String bCryptedPassword = bCryptPasswordEncoder.encode("password");
boolean passwordIsValid = bCryptPasswordEncoder.matches("password", bCryptedPassword);

Pbkdf2PasswordEncoder pbkdf2PasswordEncoder = new Pbkdf2PasswordEncoder();
String pbkdf2CryptedPassword = pbkdf2PasswordEncoder.encode("password");
boolean passwordIsValid = pbkdf2PasswordEncoder.matches("password", pbkdf2CryptedPassword);

Mặc dù đề xuất PBKDF2 của NIST đã được đề cập, tôi muốn chỉ ra rằng có một cuộc thi băm mật khẩu công khai diễn ra từ năm 2013 đến 2015. Cuối cùng, Argon2 đã được chọn làm chức năng băm mật khẩu được đề xuất.

Có một ràng buộc Java được chấp nhận khá tốt cho thư viện gốc (C gốc) mà bạn có thể sử dụng.

Trong trường hợp sử dụng trung bình, tôi không nghĩ nó có vấn đề từ góc độ bảo mật nếu bạn chọn PBKDF2 thay vì Argon2 hoặc ngược lại. Nếu bạn có yêu cầu bảo mật mạnh mẽ, tôi khuyên bạn nên xem xét Argon2 trong đánh giá của mình.

Để biết thêm thông tin về bảo mật của các chức năng băm mật khẩu, xem security.se .

Ở đây bạn có hai liên kết để băm MD5 và các phương thức băm khác:

API Javadoc: https://docs.oracle.com/javase/1.5.0/docs/api/java/security/MessageDigest.html

Hướng dẫn: http://www.twmacinta.com/myjava/fast_md5.php

Trong số tất cả các lược đồ băm tiêu chuẩn, LDAP ssha là phương thức an toàn nhất để sử dụng,

http://www.openldap.org/faq/data/cache/347.html

Tôi sẽ chỉ làm theo các thuật toán được chỉ định ở đó và sử dụng MessageDigest để thực hiện băm.

Bạn cần lưu trữ muối trong cơ sở dữ liệu của bạn như bạn đề xuất.

Tính đến năm 2020, thuật toán đáng tin cậy và linh hoạt nhất được sử dụng,

một trong những khả năng tối ưu hóa sức mạnh của nó với bất kỳ phần cứng nào,

là Argon2id hoặc Argon2i .

Nó cung cấp công cụ hiệu chuẩn cần thiết để tìm các tham số cường độ được tối ưu hóa theo thời gian băm mục tiêu và phần cứng được sử dụng.

• Argon2i chuyên băm tham lam
• Argon2d chuyên băm CPU
• Argon2id sử dụng cả hai phương pháp.

Băm tham lam bộ nhớ sẽ giúp chống lại việc sử dụng GPU để bẻ khóa.

Bảo mật mùa xuân / Bouncy Castle không được tối ưu hóa và tương đối tuần cho những gì kẻ tấn công có thể sử dụng. cf: Tài liệu mùa xuân

Việc triển khai hiện tại sử dụng lâu đài Bouncy không khai thác song song / tối ưu hóa mà những kẻ bẻ khóa mật khẩu sẽ có, do đó có sự bất cân xứng không cần thiết giữa kẻ tấn công và kẻ phòng thủ.

Việc triển khai đáng tin cậy nhất được sử dụng cho java là của mkammerer ,

một thư viện / thư viện của bản triển khai chính thức được viết bằng Rust.

Nó được viết tốt và đơn giản để sử dụng.

Phiên bản nhúng cung cấp các bản dựng gốc cho Linux, windows và OSX.

Ví dụ, nó được jpmorganchase sử dụng trong dự án bảo mật tessera của nó được sử dụng để bảo mật Quorum , triển khai tiền điện tử Ethereum của nó.

Đây là mã ví dụ từ tessera.

Hiệu chuẩn có thể được thực hiện bằng de.mkammerer.argon2.Argon2Helper # findIterations

Thuật toán SCRYPT và Pbkdf2 cũng có thể được hiệu chỉnh bằng cách viết một số điểm chuẩn đơn giản, nhưng các giá trị lặp an toàn tối thiểu hiện tại, sẽ yêu cầu thời gian băm cao hơn.

tôi đã dựa vào video từ udemy và chỉnh sửa thành mật khẩu ngẫu nhiên mạnh hơn

}

private String pass() {
        String passswet="1234567890zxcvbbnmasdfghjklop[iuytrtewq@#$%^&*" ;

        char icon1;
        char[] t=new char[20];

         int rand1=(int)(Math.random()*6)+38;//to make a random within the range of special characters

            icon1=passswet.charAt(rand1);//will produce char with a special character

        int i=0;
        while( i <11) {

             int rand=(int)(Math.random()*passswet.length());
             //notice (int) as the original value of Math>random() is double

             t[i] =passswet.charAt(rand);

             i++;
                t[10]=icon1;
//to replace the specified item with icon1
         }
        return new String(t);
}






}