Como posso hash uma senha em Java?

Preciso fazer hash de senhas para armazenamento em um banco de dados. Como posso fazer isso em Java?

Eu esperava pegar a senha de texto sem formatação, adicionar um sal aleatório e armazenar o sal e a senha com hash no banco de dados.

Então, quando um usuário queria fazer login, eu podia pegar a senha enviada, adicionar o sal aleatório das informações da conta, fazer hash e ver se isso equivale à senha hash armazenada com as informações da conta.

Você pode realmente usar um recurso incorporado ao tempo de execução Java para fazer isso. O SunJCE no Java 6 suporta PBKDF2, que é um bom algoritmo para usar no hash de senha.

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

Aqui está uma classe de utilitário que você pode usar para autenticação de senha 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);
  }

}

Aqui está uma implementação completa com dois métodos, fazendo exatamente o que você deseja:

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

O ponto é que, mesmo que um invasor obtenha acesso ao banco de dados e ao código-fonte, as senhas ainda estarão seguras.

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

Estamos armazenando 'salt$iterated_hash(password, salt)'. O salt tem 32 bytes aleatórios e seu objetivo é que, se duas pessoas diferentes escolherem a mesma senha, as senhas armazenadas ainda parecerão diferentes.

O iterated_hashbasicamente hash(hash(hash(... hash(password, salt) ...)))custa muito para um invasor em potencial que tenha acesso ao seu banco de dados adivinhar senhas, fazer hash e procurar hashes no banco de dados. Você precisa calcular isso iterated_hashtoda vez que um usuário faz login, mas não custa muito em comparação com o invasor que gasta quase 100% de seu tempo computando hashes.

O BCrypt é uma biblioteca muito boa e existe uma porta Java .

Você pode usar a implementação da biblioteca Shiro (anteriormente JSecurity ) do que é descrito pelo OWASP .

Também parece que a biblioteca JASYPT tem um utilitário semelhante .

Você pode calcular hashes usando MessageDigest, mas isso está errado em termos de segurança. Hashes não devem ser usados ​​para armazenar senhas, pois são facilmente quebráveis.

Você deve usar outro algoritmo como bcrypt, PBKDF2 e scrypt para armazenar suas senhas. Veja aqui .

Além de bcrypt e PBKDF2 mencionados em outras respostas, eu recomendaria examinar scrypt

MD5 e SHA-1 não são recomendados, pois são relativamente rápidos, portanto, usando a computação distribuída "aluguel por hora" (por exemplo, EC2) ou uma GPU de ponta moderna, pode-se "quebrar" senhas usando ataques de força bruta / dicionário a custos relativamente baixos e razoáveis Tempo.

Se você precisar usá-los, pelo menos itere o algoritmo uma quantidade significativa predefinida de vezes (mais de 1000).

• Veja aqui para mais informações: /security/211/how-to-security-hash-passwords

• E aqui: http://codahale.com/how-to-safely-store-a-password/ (critica a família SHA, MD5 etc. para fins de hash de senha)

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

Concordo plenamente com Erickson que PBKDF2 é a resposta.

Se você não tiver essa opção ou apenas precisar usar um hash, o Apache Commons DigestUtils é muito mais fácil do que acertar o código JCE: https://commons.apache.org/proper/commons-codec/apidocs/org/apache /commons/codec/digest/DigestUtils.html

Se você usar um hash, use sha256 ou sha512. Esta página tem boas recomendações sobre manipulação e hash de senhas (observe que não recomenda hash para manipulação de senhas): http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html

Você pode usar o Spring Security Crypto (possui apenas 2 dependências de compilação opcionais ), que suporta criptografia de senha 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);

Embora a recomendação NIST PBKDF2 já tenha sido mencionada, gostaria de salientar que houve uma competição de hash de senha pública que foi realizada de 2013 a 2015. No final, o Argon2 foi escolhido como a função de hash de senha recomendada.

Há uma ligação Java bastante bem adotada para a biblioteca original (C nativa) que você pode usar.

No caso de uso médio, acho que não importa da perspectiva de segurança se você escolher PBKDF2 em vez de Argônio2 ou vice-versa. Se você possui fortes requisitos de segurança, recomendo considerar o Argônio2 em sua avaliação.

Para obter mais informações sobre a segurança das funções de hash de senha, consulte security.se .

Aqui você tem dois links para o hash MD5 e outros métodos de 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

Entre todos os esquemas de hash padrão, o LDAP ssha é o mais seguro de usar,

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

Gostaria apenas de seguir os algoritmos especificados lá e usar o MessageDigest para fazer o hash.

Você precisa armazenar o sal no seu banco de dados, conforme sugerido.

A partir de 2020, o algoritmo mais confiável e flexível em uso,

o mais provável de otimizar sua força, considerando qualquer hardware,

é Argon2id ou Argon2i .

Ele fornece a ferramenta de calibração necessária para encontrar parâmetros de força otimizados, considerando um tempo de hash desejado e o hardware usado.

• Argon2i é especializado em hashing ganancioso de memória
• Argon2d é especializado em hashing ganancioso de CPU
• Argon2id usa os dois métodos.

O hashing ganancioso de memória ajudaria contra o uso da GPU para quebrar.

A segurança da primavera / a implementação do castelo insuflável não é otimizada e relativamente uma semana, considerando o que o invasor poderia usar. cf: documentação do Spring

A implementação atualmente usa o castelo Bouncy, que não explora paralelismo / otimizações que os crackers de senha, portanto, há uma assimetria desnecessária entre atacante e defensor.

A implementação mais credível em uso para java é a do mkammerer ,

uma jarra / biblioteca de wrapper da implementação nativa oficial escrita em Rust.

É bem escrito e simples de usar.

A versão incorporada fornece versões nativas para Linux, Windows e OSX.

Como exemplo, ele é usado pelo jpmorganchase em seu projeto de segurança de tessera usado para proteger o Quorum , sua implementação de criptomoeda Ethereum.

Aqui está o código de exemplo do tessera.

A calibração pode ser realizada usando de.mkammerer.argon2.Argon2Helper # findIterations

Os algoritmos SCRYPT e Pbkdf2 também podem ser calibrados, escrevendo alguns benchmarks simples, mas os valores mínimos atuais das iterações seguras exigirão tempos de hash mais altos.

Inclinei isso de um vídeo no udemy e editei para ser uma senha aleatória mais 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);
}






}