Come posso eseguire l'hashing di una password in Java?

Ho bisogno di hash password per l'archiviazione in un database. Come posso farlo in Java?

Speravo di prendere la password in chiaro, aggiungere un salt casuale, quindi archiviare il salt e la password con hash nel database.

Quindi, quando un utente voleva accedere, potevo prendere la sua password inviata, aggiungere il salt casuale dalle informazioni del suo account, l'hash e vedere se corrisponde alla password hash memorizzata con le informazioni del suo account.

Per fare ciò, puoi effettivamente utilizzare una funzione integrata nel runtime Java. SunJCE in Java 6 supporta PBKDF2, che è un buon algoritmo da utilizzare per l'hash della password.

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

Ecco una classe di utilità che è possibile utilizzare per l'autenticazione della password 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);
  }

}

Ecco un'implementazione completa con due metodi che fanno esattamente quello che vuoi:

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

Il punto è che anche se un utente malintenzionato ha accesso sia al database che al codice sorgente, le password sono comunque sicure.

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

Stiamo memorizzando 'salt$iterated_hash(password, salt)'. Il sale è composto da 32 byte casuali e lo scopo è che se due persone diverse scelgono la stessa password, le password memorizzate appariranno comunque diverse.

Il iterated_hashche è fondamentalmente hash(hash(hash(... hash(password, salt) ...)))molto costoso per un potenziale attaccante che ha accesso al tuo database per indovinare le password, eseguirne l'hashing e cercare hash nel database. Devi calcolare questo iterated_hashogni volta che un utente accede, ma non ti costa molto rispetto all'attaccante che spende quasi il 100% del suo tempo nel calcolo degli hash.

BCrypt è un'ottima libreria e ne esiste una porta Java .

È possibile utilizzare l' implementazione della libreria Shiro (precedentemente JSecurity ) di ciò che è descritto da OWASP .

Sembra anche che la libreria JASYPT abbia un'utilità simile .

Puoi calcolare gli hash usando MessageDigest, ma questo è sbagliato in termini di sicurezza. Gli hash non devono essere utilizzati per archiviare le password, in quanto sono facilmente fragili.

Dovresti usare un altro algoritmo come bcrypt, PBKDF2 e scrypt per memorizzare le tue password. Vedi qui .

Oltre a bcrypt e PBKDF2 menzionati in altre risposte, consiglierei di guardare scrypt

MD5 e SHA-1 non sono raccomandati in quanto sono relativamente veloci, quindi utilizzando il calcolo distribuito "affitto all'ora" (ad es. EC2) o una moderna GPU di fascia alta si possono "crackare" le password usando attacchi di forza bruta / dizionario a costi relativamente bassi e ragionevoli tempo.

Se è necessario utilizzarli, almeno iterare l'algoritmo un numero di volte significativo predefinito (1000+).

• Vedi qui per maggiori informazioni: /security/211/how-to-securely-hash-passwords

• E qui: http://codahale.com/how-to-safely-store-a-password/ (critica la famiglia SHA, MD5 ecc. Per scopi di hashing della password)

• E qui: http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html (critica bcrypt e raccomanda scrypt e PBKDF2)

Concordo pienamente con Erickson che PBKDF2 è la risposta.

Se non hai questa opzione o hai solo bisogno di usare un hash, Apache Commons DigestUtils è molto più facile che ottenere il codice JCE giusto: https://commons.apache.org/proper/commons-codec/apidocs/org/apache /commons/codec/digest/DigestUtils.html

Se usi un hash, vai con sha256 o sha512. Questa pagina contiene buoni consigli sulla gestione delle password e sull'hash (si noti che non raccomanda l'hashing per la gestione delle password): http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html

È possibile utilizzare Spring Security Crypto (ha solo 2 dipendenze di compilazione opzionali ), che supporta la crittografia password PBKDF2 , BCrypt , SCrypt e 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);

Mentre la raccomandazione NIST PBKDF2 è già stata menzionata, vorrei sottolineare che c'era una competizione pubblica di hashing delle password che si è svolta dal 2013 al 2015. Alla fine, Argon2 è stato scelto come funzione di hashing della password consigliata.

Esiste un binding Java abbastanza ben adottato per la libreria originale (C nativa) che è possibile utilizzare.

Nel caso d'uso medio, non credo sia importante dal punto di vista della sicurezza se si sceglie PBKDF2 su Argon2 o viceversa. Se hai forti requisiti di sicurezza, ti consiglio di prendere in considerazione Argon2 nella tua valutazione.

Per ulteriori informazioni sulla sicurezza delle funzioni di hashing delle password, vedere security.se .

Qui hai due collegamenti per l'hash MD5 e altri metodi hash:

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

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

Tra tutti gli schemi hash standard, LDAP ssha è il più sicuro da usare,

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

Vorrei solo seguire gli algoritmi specificati lì e utilizzare MessageDigest per eseguire l'hash.

È necessario archiviare il sale nel database come suggerito.

A partire dal 2020, l'algoritmo più credibile e flessibile in uso,

quello che molto probabilmente ottimizzerà la sua forza dato qualsiasi hardware,

è Argon2id o Argon2i .

Fornisce lo strumento di calibrazione necessario per trovare parametri di resistenza ottimizzati dati un tempo di hashing target e l'hardware utilizzato.

• Argon2i è specializzato in hashing avidi di memoria
• Argon2d è specializzato nell'hashing avido di CPU
• Argon2id usa entrambi i metodi.

L'hashish di memoria avido aiuterebbe contro l'uso della GPU per cracking.

La sicurezza primaverile / L'implementazione di Bouncy Castle non è ottimizzata e relativamente settimana dato ciò che un utente malintenzionato potrebbe utilizzare. cf: documentazione di primavera

L'attuale implementazione utilizza Bouncy castle che non sfrutta il parallelismo / ottimizzazioni che i cracker di password faranno, quindi c'è un'asimmetria non necessaria tra attaccante e difensore.

L'implementazione più credibile in uso per java è quella di mkammerer ,

un vaso / libreria wrapper dell'implementazione nativa ufficiale scritta in Rust.

È ben scritto e semplice da usare.

La versione integrata fornisce build native per Linux, Windows e OSX.

Ad esempio, viene utilizzato da jpmorganchase nel suo progetto di sicurezza a tessera utilizzato per proteggere Quorum , l'implementazione della criptovaluta di Ethereum.

Ecco il codice di esempio da tessera.

La calibrazione può essere eseguita utilizzando de.mkammerer.argon2.Argon2Helper # findIterations

Gli algoritmi SCRYPT e Pbkdf2 potrebbero anche essere calibrati scrivendo alcuni semplici benchmark, ma gli attuali valori di iterazioni minime sicure richiederanno tempi di hashing più elevati.

lo ho appreso da un video su udemy e modificato per essere una password casuale più forte

}

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






}