¿Cómo puedo codificar una contraseña en Java?

Si hallas algún fallo en tu código o trabajo, recuerda probar siempre en un entorno de testing antes aplicar el código al trabajo final.

Solución:

De hecho, puede utilizar una función integrada en el tiempo de ejecución de Java para hacer esto. SunJCE en Java 6 es compatible con PBKDF2, que es un buen algoritmo para usar para el hash de contraseñas.

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

Aquí hay una clase de utilidad que puede usar para la autenticación de contraseña 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 StackOverflow
 */
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)
   (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)
  = 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. 
   * 
   * 
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);
  

BCrypt es una biblioteca muy buena, y tiene una versión Java.

Puedes comput hashes usando MessageDigest, pero esto es incorrecto en términos de seguridad. Los hash no se deben utilizar para almacenar contraseñas, ya que se pueden romper fácilmente.

Debe utilizar otro algoritmo como bcrypt, PBKDF2 y scrypt para almacenar sus contraseñas. Mira aquí.

Aquí tienes las reseñas y puntuaciones

Si eres capaz, tienes la habilidad dejar un enunciado acerca de qué le añadirías a este escrito.

---

---

Utiliza Nuestro Buscador