Wie kann ich Passwörter in Java mit PBKDF2 sicher hashen?

So hashen Sie Passwörter sicher in Java

Das Sichern von Passwörtern ist in jeder Anwendung, die vertrauliche Benutzerinformationen verarbeitet, von entscheidender Bedeutung. Das Hashing von Passwörtern bietet eine Einweg-Verschlüsselungsmethode, die verhindert, dass Passwörter entschlüsselt und im Klartext gespeichert werden.

Szenario:

Sie möchten Passwörter für die Speicherung in einem hashen Datenbank, Hinzufügen eines zufälligen Salzes für zusätzliche Sicherheit.

Lösung:

Die Java Runtime Environment (JRE) enthält eine integrierte Funktion für Passwort-Hashing mit PBKDF2 (Password-Based Key Derivation Function 2). Diese Methode bietet einen robusten Passwortschutz. So implementieren Sie ihn:

SecureRandom random = new SecureRandom();
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));

PBKDF2 benötigt ein Passwort, einen zufälligen Salt und einen Kostenparameter, um den Hash zu berechnen. Der Kostenparameter steuert die Rechenintensität des Hashings, wobei höhere Kosten zu einem langsameren Hashing, aber höherer Sicherheit führen.

Um die Sicherheit weiter zu erhöhen, sollten Sie die Verwendung einer Dienstprogrammklasse wie dieser in Betracht ziehen:

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;

/**
 * Utility class for PBKDF2 password authentication
 */
public final class PasswordAuthentication {

  // Constants
  public static final String ID = "$";
  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("\\$(\d\d?)\$(.{43})");

  // Instance variables
  private final SecureRandom random;
  private final int cost;

  /**
   * Constructor with default cost
   */
  public PasswordAuthentication() {
    this(DEFAULT_COST);
  }

  /**
   * Constructor with 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);
    }
  }
}

Diese Dienstprogrammklasse stellt Methoden zum Hashing von Passwörtern (Hash) und zur Authentifizierung von Benutzern (Authenticate) bereit. Es verwendet einen anpassbaren Rechenkostenparameter und integriert einen zufälligen Salt für zusätzlichen Schutz. Mit diesem Dienstprogramm können Sie Passwörter in Ihrer Java-Anwendung sicher speichern und überprüfen.

Das obige ist der detaillierte Inhalt vonWie kann ich Passwörter in Java mit PBKDF2 sicher hashen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!