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

So hashen Sie Passwörter sicher für die Speicherung

Das Speichern von Passwörtern im Klartext stellt ein erhebliches Sicherheitsrisiko dar. Um sensible Daten zu schützen, ist es wichtig, Passwörter vor dem Speichern zu hashen. Bei diesem Prozess werden Klartext-Passwörter in ein verschlüsseltes Format mit fester Größe konvertiert, das irreversibel und rechenintensiv zu knacken ist. Java bietet robuste Funktionen für das Passwort-Hashing und gewährleistet so die Sicherheit der Benutzeranmeldeinformationen.

Verwendung von PBKDF2 für sicheres Passwort-Hashing

Die SunJCE-Bibliothek in Java 6 führt PBKDF2 ein (Passwort- Basierend auf der Key Derivation Function 2), einem branchenüblichen Algorithmus für das Passwort-Hashing. Es wurde entwickelt, um Brute-Force-Angriffe und Rainbow-Table-Angriffe zu verhindern, indem ein zufälliges Salt und ein hoher Rechenaufwand integriert werden.

Implementierung von Passwort-Hashing mit PBKDF2

1. Salt erstellen: Generieren Sie ein zufälliges Salt, um die Verwendung eines vorberechneten Regenbogens zu verhindern Tabellen.
2. Hashen Sie das Passwort: Nutzen Sie den PBKDF2-Algorithmus, um einen Hash aus dem Passwort und dem Salt abzuleiten.
3. Speichern Sie das gehashte Passwort: Speichern Sie das Salt und das gehashte Passwort sicher in der Datenbank.

Passwörter während der Anmeldung überprüfen

Wenn ein Benutzer Meldet sich an:

1. Salt abrufen: Rufen Sie den Salt ab, der mit dem Konto des Benutzers verknüpft ist.
2. Hash des übermittelten Passworts: Berechnen Sie den Hash des übermittelten Passworts anhand des abgerufenen Salt.
3. Hashes vergleichen: Überprüfen Sie, ob der berechnete Hash mit dem gespeicherten Hash-Passwort übereinstimmt. Wenn sie übereinstimmen, ist das Passwort korrekt.

Beispielcode für Passwort-Hashing

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;

public class PasswordAuthentication {

  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);
    return ID + cost + '$' + enc.encodeToString(hash);
  }

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

Fazit

Das Hashing von Passwörtern mit PBKDF2 ist eine wesentliche Sicherheitsmaßnahme zum Schutz von Benutzerdaten. Durch die Implementierung eines robusten Passwort-Hashings können Entwickler die Sicherheit ihrer Anwendungen erheblich verbessern und das Risiko von Datenschutzverletzungen minimieren.

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