Як я можу хеш-пароль на Java?

Мені потрібно хеш-паролі для зберігання в базі даних. Як я можу це зробити на Java?

Я сподівався взяти звичайний текстовий пароль, додати випадкову сіль, а потім зберегти сіль і хешированний пароль у базі даних.

Тоді, коли користувач захотів увійти, я міг взяти поданий пароль, додати випадкову сіль із інформації свого облікового запису, хеш і перевірити, чи прирівнюється він до збереженого пароля хешу з інформацією про його рахунок.

Ви можете реально використовувати засоби, вбудовані в час виконання Java для цього. SunJCE в Java 6 підтримує PBKDF2, що є хорошим алгоритмом для використання для хешування паролів.

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

Ось клас утиліти, який можна використовувати для автентифікації пароля 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);
  }

}

Ось повна реалізація з двома методами, які роблять саме те, що ви хочете:

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

Справа в тому, що навіть якщо зловмисник отримує доступ як до вашої бази даних, так і до вихідного коду, паролі залишаються в безпеці.

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

Ми зберігаємо 'salt$iterated_hash(password, salt)' . Сіль - 32 випадкові байти, і її мета полягає в тому, що якщо двоє різних людей виберуть один і той же пароль, збережені паролі все одно будуть виглядати по-різному.

Це iterated_hash, в основному, hash(hash(hash(... hash(password, salt) ...)))робить дуже дорогим для потенційного зловмисника, який має доступ до вашої бази даних, відгадувати паролі, хешувати їх та шукати хеші в базі даних. Ви повинні обчислити це iterated_hashкожен раз, коли користувач входить, але це не коштує вам стільки в порівнянні з зловмисником, який витрачає майже 100% часу на обчислення хешей.

BCrypt - дуже хороша бібліотека, і в ній є порт Java .

Ви можете використовувати Shiro бібліотека (раніше JSecurity ) здійснення того , що описується OWASP .

Також схоже, що бібліотека JASYPT має подібну корисну програму .

Ви можете скласти хеші, використовуючи MessageDigest , але це неправильно з точки зору безпеки. Хеші не слід використовувати для зберігання паролів, оскільки вони легко зламані.

Ви повинні використовувати інший алгоритм, такий як bcrypt, PBKDF2 та scrypt, щоб зберігати ваші паролі. Дивіться тут .

Окрім bcrypt та PBKDF2, згаданих в інших відповідях, я б рекомендував переглянути scrypt

MD5 і SHA-1 не рекомендуються, оскільки вони відносно швидкі, тому використовуючи розподілені обчислення "оренду за годину" (наприклад, EC2) або сучасний GPU високого класу, можна "зламати" паролі, використовуючи атаки грубої сили / словника при порівняно низьких витратах і розумних час.

Якщо ви повинні їх використовувати, то принаймні повторіть алгоритм заздалегідь задану значну кількість разів (1000+).

• Дивіться тут докладніше: /security/211/how-to-securely-hash-passwords

• А тут: http://codahale.com/how-to-safely-store-a-password/ (критикує сім'ю SHA, MD5 тощо для цілей пароля)

• І ось: http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html (критикує bcrypt та рекомендує scrypt та PBKDF2)

Повністю згоден з Еріксоном, що PBKDF2 - це відповідь.

Якщо у вас немає цього варіанту або потрібно використовувати хеш, Apache Commons DigestUtils набагато простіше, ніж отримати код JCE правильно: https://commons.apache.org/proper/commons-codec/apidocs/org/apache /commons/codec/digest/DigestUtils.html

Якщо ви використовуєте хеш, перейдіть з sha256 або sha512. На цій сторінці є хороші рекомендації щодо керування паролем та хешування (врахуйте, що не рекомендується хешування для обробки паролів): http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html

Ви можете використовувати Spring Security Crypto (має тільки 2 додаткових залежностей компіляції ), який підтримує PBKDF2 , BCrypt , Scrypt і Argon 2 шифрування паролів.

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

Незважаючи на те, що рекомендація NIST PBKDF2 вже згадувалася, я хотів би зазначити, що існувала публічна конкуренція за тестування паролів, яка проходила з 2013 по 2015 рік. Зрештою, Argon2 був обраний як рекомендована функція переміщення паролів.

Існує досить добре прийнята Java-прив’язка для оригінальної (рідної C) бібліотеки, яку ви можете використовувати.

У середньому випадку використання, я не думаю, що це має значення з точки зору безпеки, якщо ви вибираєте PBKDF2 над Argon2 або навпаки. Якщо у вас є чіткі вимоги до безпеки, рекомендую врахувати Argon2 у вашій оцінці.

Детальну інформацію про безпеку функцій хешування паролів див. У безпеці .

Тут ви маєте два посилання на хешування MD5 та інші хеш-методи:

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

Підручник: http://www.twmacinta.com/myjava/fast_md5.php

Серед усіх стандартних хеш-схем LDAP ssha є найбільш безпечною для використання,

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

Я просто слідкую за алгоритмами, вказаними там, і використовую MessageDigest, щоб зробити хеш.

Потрібно зберігати сіль у вашій базі даних, як ви запропонували.

Станом на 2020 рік, найбільш надійний і гнучкий алгоритм у використанні,

той, який найімовірніше оптимізує свою міцність, враховуючи будь-яке обладнання,

є Argon2id або Argon2i .

Він надає необхідний інструмент калібрування для пошуку оптимізованих параметрів міцності з урахуванням заданого часу хешування та використовуваного обладнання.

• Argon2i спеціалізується на жадібному хешуванні пам'яті
• Argon2d спеціалізується на жадібному хешуванні процесора
• Argon2id використовують обидва методи.

Жадібне хешування пам'яті допоможе проти використання GPU для розтріскування.

Весняна безпека / Реалізація замкового підстрибу не оптимізована та відносно тиждень враховує те, що може використати нападник. cf: Весняна документація

В даний час реалізація використовує замок Bouncy, який не використовує паралелізм / оптимізацію, яку будуть мати взломники паролів, тому між нападником та захисником існує непотрібна асиметрія.

Найбільш надійна реалізація, яка використовується для Java, - це mkammerer 's,

баночка / бібліотека офіційної натурної реалізації, написана в Rust.

Він добре написаний і простий у використанні.

Вбудована версія забезпечує вбудовані версії для Linux, Windows та OSX.

В якості прикладу, він використовується JPMorganChase в тессера проект безпеки , що використовується для забезпечення кворуму , його Ефіріума реалізації cryptocurency.

Ось приклад коду від tessera.

Калібрування може проводитися за допомогою de.mkammerer.argon2.Argon2Helper # findIterations

Алгоритм SCRYPT та Pbkdf2 також може бути відкалібрований, записавши простий орієнтир, але поточні мінімальні безпечні значення ітерацій вимагатимуть більшого часу хешування.

Я нахилився, що з відео на udemy і відредагований, щоб бути сильнішим випадковим паролем

}

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






}