Wie kann ich ein Passwort in Java hashen?

Ich muss Passwörter für die Speicherung in einer Datenbank hashen. Wie kann ich das in Java machen?

Ich hatte gehofft, das Klartext-Passwort zu nehmen, ein zufälliges Salt hinzuzufügen und dann das Salt und das Hash-Passwort in der Datenbank zu speichern.

Wenn sich ein Benutzer anmelden wollte, konnte ich sein übermitteltes Passwort verwenden, das zufällige Salz aus seinen Kontoinformationen hinzufügen, es hashen und prüfen, ob es dem gespeicherten Hash-Passwort mit seinen Kontoinformationen entspricht.

Sie können dazu tatsächlich eine in die Java-Laufzeit integrierte Funktion verwenden. Das SunJCE in Java 6 unterstützt PBKDF2, einen guten Algorithmus für das Passwort-Hashing.

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

Hier ist eine Dienstprogrammklasse, die Sie für die PBKDF2-Kennwortauthentifizierung verwenden können:

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

}

Hier ist eine vollständige Implementierung mit zwei Methoden, die genau das tun, was Sie wollen:

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

Der Punkt ist, dass die Passwörter auch dann sicher sind, wenn ein Angreifer Zugriff auf Ihre Datenbank und den Quellcode erhält.

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

Wir lagern 'salt$iterated_hash(password, salt)'. Das Salt besteht aus 32 zufälligen Bytes. Wenn zwei verschiedene Personen dasselbe Passwort wählen, sehen die gespeicherten Passwörter immer noch unterschiedlich aus.

Die iterated_hash, die im Grunde hash(hash(hash(... hash(password, salt) ...)))macht es sehr teuer für einen potentiellen Angreifer, der Zugriff auf die Datenbank zu erratende Kennwörter hat, Hash sie und schauen Hashes in der Datenbank. Sie müssen dies iterated_hashjedes Mal berechnen, wenn sich ein Benutzer anmeldet, aber es kostet Sie nicht so viel im Vergleich zu dem Angreifer, der fast 100% seiner Zeit damit verbringt, Hashes zu berechnen.

BCrypt ist eine sehr gute Bibliothek, und es gibt einen Java-Port davon.

Sie können Hashes mit berechnen MessageDigest, dies ist jedoch in Bezug auf die Sicherheit falsch. Hashes dürfen nicht zum Speichern von Passwörtern verwendet werden, da sie leicht zerbrechlich sind.

Sie sollten einen anderen Algorithmus wie bcrypt, PBKDF2 und scrypt verwenden, um Ihre Passwörter zu speichern. Siehe hier .

Sie können die Implementierung der von OWASP beschriebenen Shiro- Bibliothek (ehemals JSecurity ) verwenden .

Es sieht auch so aus, als hätte die JASYPT-Bibliothek ein ähnliches Dienstprogramm .

Zusätzlich zu bcrypt und PBKDF2, die in anderen Antworten erwähnt wurden, würde ich empfehlen, sich scrypt anzusehen

MD5 und SHA-1 werden nicht empfohlen, da sie relativ schnell sind. Wenn Sie also verteiltes Computing mit "Miete pro Stunde" (z. B. EC2) oder eine moderne High-End-GPU verwenden, können Sie Passwörter mithilfe von Brute-Force- / Wörterbuchangriffen zu relativ geringen Kosten und zu angemessenen Preisen "knacken" Zeit.

Wenn Sie sie verwenden müssen, wiederholen Sie den Algorithmus mindestens eine vordefinierte signifikante Anzahl von Malen (1000+).

• Weitere Informationen finden Sie hier: /security/211/how-to-securely-hash-passwords

• Und hier: http://codahale.com/how-to-safely-store-a-password/ (kritisiert SHA-Familie, MD5 usw. für Passwort-Hashing-Zwecke)

• Und hier: http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html (kritisiert bcrypt und empfiehlt scrypt und PBKDF2)

Stimmen Sie Erickson voll und ganz zu, dass PBKDF2 die Antwort ist.

Wenn Sie diese Option nicht haben oder nur einen Hash verwenden müssen, ist Apache Commons DigestUtils viel einfacher als der richtige JCE-Code: https://commons.apache.org/proper/commons-codec/apidocs/org/apache /commons/codec/digest/DigestUtils.html

Wenn Sie einen Hash verwenden, wählen Sie sha256 oder sha512. Diese Seite enthält gute Empfehlungen zur Behandlung und zum Hashing von Passwörtern (beachten Sie, dass für die Behandlung von Passwörtern kein Hashing empfohlen wird): http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html

Obwohl die NIST-Empfehlung PBKDF2 bereits erwähnt wurde, möchte ich darauf hinweisen, dass es von 2013 bis 2015 einen öffentlichen Passwort-Hashing-Wettbewerb gab . Am Ende wurde Argon2 als empfohlene Passwort-Hashing-Funktion ausgewählt.

Es gibt eine ziemlich gut angenommene Java-Bindung für die ursprüngliche (native C) Bibliothek, die Sie verwenden können.

Im durchschnittlichen Anwendungsfall denke ich, dass es aus Sicherheitsgründen keine Rolle spielt, wenn Sie PBKDF2 anstelle von Argon2 wählen oder umgekehrt. Wenn Sie hohe Sicherheitsanforderungen haben, empfehle ich, Argon2 in Ihrer Bewertung zu berücksichtigen.

Weitere Informationen zur Sicherheit von Passwort-Hashing-Funktionen finden Sie unter security.se .

Sie können Spring Security Crypto (hat nur 2 optionale Kompilierungsabhängigkeiten ) verwenden, das die Kennwortverschlüsselung von PBKDF2 , BCrypt , SCrypt und Argon2 unterstützt .

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

Hier haben Sie zwei Links für MD5-Hashing und andere Hash-Methoden:

Javadoc-API: http://java.sun.com/j2se/1.4.2/docs/api/java/security/MessageDigest.html

Tutorial: http://www.twmacinta.com/myjava/fast_md5.php

Unter allen Standard-Hash-Schemata ist LDAP ssha das sicherste.

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

Ich würde einfach den dort angegebenen Algorithmen folgen und MessageDigest verwenden, um den Hash auszuführen.

Sie müssen das Salz wie vorgeschlagen in Ihrer Datenbank speichern.

Ab 2020 ist der glaubwürdigste und flexibelste verwendete Algorithmus

derjenige, der seine Stärke bei jeder Hardware am wahrscheinlichsten optimiert,

ist Argon2id oder Argon2i .

Es bietet das erforderliche Kalibrierungswerkzeug, um optimierte Festigkeitsparameter unter Berücksichtigung einer Ziel-Hashing-Zeit und der verwendeten Hardware zu finden.

• Argon2i ist auf speichergieriges Hashing spezialisiert
• Argon2d ist auf CPU-gieriges Hashing spezialisiert
• Argon2id verwendet beide Methoden.

Speichergieriges Hashing würde gegen die Verwendung von GPUs zum Knacken helfen.

Die Implementierung von Spring Security / Bouncy Castle ist nicht optimiert und relativ wochenlang, wenn man bedenkt, was der Angreifer verwenden könnte. Vgl.: Federdokumentation

Die aktuelle Implementierung verwendet Bouncy Castle, das Parallelität / Optimierungen, die Passwort-Cracker bewirken, nicht ausnutzt, sodass eine unnötige Asymmetrie zwischen Angreifer und Verteidiger besteht.

Die glaubwürdigste Implementierung, die für Java verwendet wird, ist die von mkammerer .

ein Wrapper-Glas / eine Bibliothek der offiziellen nativen Implementierung, die in Rust geschrieben wurde.

Es ist gut geschrieben und einfach zu bedienen.

Die eingebettete Version bietet native Builds für Linux, Windows und OSX.

Als Beispiel wird es von jpmorganchase in seinem Tessera- Sicherheitsprojekt verwendet, das zur Sicherung von Quorum , seiner Cryptocurency-Implementierung von Ethereum, verwendet wird.

Hier ist der Beispielcode von tessera.

Die Kalibrierung kann mit de.mkammerer.argon2.Argon2Helper # findIterations durchgeführt werden

Der SCRYPT- und Pbkdf2-Algorithmus kann auch durch Schreiben eines einfachen Benchmarks kalibriert werden. Aktuelle minimale sichere Iterationswerte erfordern jedoch höhere Hashing-Zeiten.

Ich habe das aus einem Video auf udemy abgeleitet und bearbeitet, um ein stärkeres zufälliges Passwort zu erhalten

}

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






}