Как я могу хэшировать пароль в Java?
Мне нужно хешировать пароли для хранения в базе данных. Как я могу сделать это на Java?
Я надеялся взять простой текстовый пароль, добавить случайную соль, затем сохранить соль и хешированный пароль в базе данных.
Затем, когда пользователь захотел войти в систему, я мог взять предоставленный им пароль, добавить случайную соль из данных своей учетной записи, хэшировать ее и посмотреть, соответствует ли она сохраненному хэш-паролю с информацией его учетной записи.
15 ответов
Вы можете фактически использовать средство, встроенное в среду выполнения 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://stackru.com/a/2861125/3474">Stackru</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% своего времени на вычисления хэшей.
Вы можете использовать Spring Security Crypto (имеет только 2 необязательные зависимости компиляции), который поддерживает шифрование паролей PBKDF2, BCrypt и SCrypt.
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);
Вы можете вычислить хэши, используя MessageDigest, но это неправильно с точки зрения безопасности. Хеши не должны использоваться для хранения паролей, так как они легко взламываются.
Вы должны использовать другой алгоритм, такой как bcrypt, PBKDF2 и scrypt, чтобы хранить ваши пароли. Смотрите здесь.
Вы можете использовать реализацию библиотеки Shiro (ранее JSecurity), описанную в OWASP.
Также похоже, что библиотека JASYPT имеет аналогичную утилиту.
В дополнение к bcrypt и PBKDF2, упомянутым в других ответах, я бы порекомендовал посмотреть на scrypt
MD5 и SHA-1 не рекомендуются, так как они относительно быстрые, поэтому при использовании распределенных вычислений "плата за час" (например, EC2) или современного высокопроизводительного графического процессора можно "взломать" пароли, используя атаки методом "грубой силы" / по словарю, при относительно низких затратах и разумных время.
Если вы должны их использовать, то, по крайней мере, повторите алгоритм заранее определенное значительное количество раз (1000+).
Смотрите здесь для получения дополнительной информации: https://security.stackexchange.com/questions/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
Несмотря на то, что рекомендация NIST PBKDF2 уже упоминалась, я хотел бы отметить, что с 2013 по 2015 год проводился открытый конкурс хэширования паролей. В конце концов, Argon2 был выбран в качестве рекомендуемой функции хэширования паролей.
Существует довольно хорошо принятая Java-привязка для исходной библиотеки (native C), которую вы можете использовать.
В среднем случае использования, я не думаю, что это имеет значение с точки зрения безопасности, если вы выбираете PBKDF2 вместо Argon2 или наоборот. Если у вас есть строгие требования к безопасности, я рекомендую рассмотреть Argon2 в вашей оценке.
Для получения дополнительной информации о безопасности функций хеширования паролей см. Security.se.
По состоянию на 2020 год самый надежный и гибкий алгоритм в использовании,
тот, который с наибольшей вероятностью оптимизирует свою мощность при любом оборудовании,
это Argon2id или Argon2i.
Он предоставляет необходимый инструмент калибровки для поиска оптимальных параметров прочности с учетом целевого времени хеширования и используемого оборудования.
- Argon2i специализируется на жадном хешировании памяти
- Argon2d специализируется на жадном хешировании процессора
- Argon2id использует оба метода.
Жадное хеширование памяти поможет предотвратить использование GPU для взлома.
Реализация Spring security/Bouncy Castle не оптимизирована и относительно неделя, учитывая, что может использовать злоумышленник. cf: Spring документация
Текущая реализация использует Bouncy Castle, который не использует параллелизм / оптимизацию, которую используют взломщики паролей, поэтому существует ненужная асимметрия между атакующим и защитником.
Наиболее надежной реализацией для java является реализация mkammerer,
jar-библиотека-оболочка официальной нативной реализации, написанной на Rust.
Он хорошо написан и прост в использовании.
Встроенная версия предоставляет собственные сборки для Linux, Windows и OSX.
В качестве примера, он используется JPMorganChase в тессера проекте безопасности, используемого для обеспечения кворума, его Эфириума реализации cryptocurency.
Вот пример кода из tessera.
Калибровку можно выполнить с помощью de.mkammerer.argon2.Argon2Helper#findIterations.
Алгоритмы SCRYPT и Pbkdf2 также можно откалибровать, написав простой тест, но текущие значения минимальных безопасных итераций потребуют более длительного времени хеширования.
Здесь у вас есть две ссылки для хеширования MD5 и других методов хеширования:
API Javadoc: http://java.sun.com/j2se/1.4.2/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 для хеширования.
Вы должны хранить соль в своей базе данных, как вы предложили.
import java.security.MessageDigest;
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Base64;
import java.util.Properties;
public class Main{
public static void main(String[]a]{
//enter code here
}
public static String hashPassword(String password) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-512");
byte[] hash = md.digest(password.getBytes());
return Base64.getEncoder().encodeToString(hash);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
hashPassword — это метод, который возвращает хэшированное значение, когда мы передаем строку в качестве параметра.MessageDigest — это класс, предоставляющий интерфейс для хеширования пароля.getInstance используется для получения экземпляра алгоритма хеширования, такого как MD-5, SHA 216, SHA-512 и т. д. Хешированный Sting имеет форму -byte [] В операторе return мы конвертируем байт, используя ToString.
Я взял это из видео на 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);
}
}
Вот мой простой
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Arrays;
public class PasswordHasher {
private static final String ALGO = "PBKDF2WithHmacSHA1";
private static final byte[] SALT = {
8, 8, 8, 8, 2,
8, 7, 7, 7, 2,
1, 1, 1, 1, 2,
11
};
private static final int ITERATION_COUNT = 1000;
private static final int KEY_LENGTH = 128;
private SecretKeyFactory mFactory;
byte[] hashPassword(String password) {
SecretKeyFactory factory = getFactory();
if (factory != null) {
try {
KeySpec spec = new PBEKeySpec(password.toCharArray(), SALT, ITERATION_COUNT, KEY_LENGTH);
return factory.generateSecret(spec).getEncoded();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
}
}
return null;
}
boolean verifyPassword(String password, byte[] expectedHashResult) {
byte[] hashedPassword = hashPassword(password);
if (hashedPassword == null) {
// Log fail result
return false;
}
return Arrays.equals(hashedPassword, expectedHashResult);
}
private SecretKeyFactory getFactory() {
if (mFactory == null) {
try {
mFactory = SecretKeyFactory.getInstance(ALGO);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
return mFactory;
}
}