データベースに保存するためにパスワードをハッシュする必要があります。Javaでこれを行うにはどうすればよいですか?
私はプレーンテキストのパスワードを取り、ランダムなソルトを追加し、ソルトとハッシュされたパスワードをデータベースに保存したいと思っていました。
次に、ユーザーがログインするときに、送信したパスワードを取得し、ランダムなソルトをアカウント情報から追加し、ハッシュして、保存されているハッシュパスワードとアカウント情報が等しいかどうかを確認します。
データベースに保存するためにパスワードをハッシュする必要があります。Javaでこれを行うにはどうすればよいですか?
私はプレーンテキストのパスワードを取り、ランダムなソルトを追加し、ソルトとハッシュされたパスワードをデータベースに保存したいと思っていました。
次に、ユーザーがログインするときに、送信したパスワードを取得し、ランダムなソルトをアカウント情報から追加し、ハッシュして、保存されているハッシュパスワードとアカウント情報が等しいかどうかを確認します。
回答:
これを行うには、Javaランタイムに組み込まれた機能を実際に使用できます。Java 6のSunJCEは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);
}
}
BigInteger
。先行ゼロは削除されます。これはクイックデバッグには問題ありませんが、その影響による製品コードにバグが見られます。
以下は、2つのメソッドを使用して完全に実装し、必要なことを正確に実行します。
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バイトであり、その目的は、2人の異なるユーザーが同じパスワードを選択した場合でも、保存されているパスワードの外観が異なることです。
iterated_hash
基本的にある、hash(hash(hash(... hash(password, salt) ...)))
ハッシュそれらを、パスワードを推測するために、データベースへのアクセス権を持っている潜在的な攻撃者のために、それは非常に高価になり、データベースにハッシュを見上げます。iterated_hash
ユーザーがログインするたびにこれを計算する必要がありますが、ハッシュの計算に時間のほぼ100%を費やす攻撃者と比べてそれほどコストはかかりません。
char[] password
ではなくに変更する必要がありString password
ます。
BCryptは非常に優れたライブラリであり、Javaの移植版があります。
を使用してハッシュを計算できますMessageDigest
が、これはセキュリティの点で間違っています。ハッシュは簡単に解読できるため、パスワードの保存には使用しないでください。
パスワードを保存するには、bcrypt、PBKDF2、scryptなどの別のアルゴリズムを使用する必要があります。こちらをご覧ください。
他の回答で言及されているbcryptとPBKDF2に加えて、scryptを確認することをお勧めします
MD5とSHA-1は比較的高速であり、したがって「時間あたりの賃料」の分散コンピューティング(EC2など)または最新のハイエンドGPUを使用しているため、お勧めできません。時間。
それらを使用する必要がある場合は、少なくともアルゴリズムを事前定義された有意な回数(1000回以上)繰り返します。
詳しくはこちらをご覧ください:https : //security.stackexchange.com/questions/211/how-to-securely-hash-passwords
そしてここ:http : //codahale.com/how-to-safely-store-a-password/(パスワードハッシュの目的でSHAファミリ、MD5などを批判します)
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
あなたは使用することができます春のセキュリティ 暗号(唯一持っている2オプションのコンパイル依存関係をサポートしています)、PBKDF2、bcryptの、SCryptと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);
一方でNISTの勧告PBKDF2は、公開があったことを既に述べた、私が指摘したいのですが、パスワードのハッシュ化競争が最後に2013年から2015年に実行されたことを、Argon2を推奨パスワードハッシュ関数として選ばれました。
使用できる元の(ネイティブC)ライブラリには、かなりよく採用されているJavaバインディングがあります。
平均的なユースケースでは、Argon2よりもPBKDF2を選択した場合、またはその逆を選択した場合、セキュリティの観点からは問題ないと思います。強力なセキュリティ要件がある場合は、評価でArgon2を検討することをお勧めします。
パスワードのハッシュ関数のセキュリティの詳細について参照security.seを。
ここには、MD5ハッシュと他のハッシュ方式の2つのリンクがあります。
Javadoc API: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。
目標のハッシュ時間と使用するハードウェアを考慮して、最適化された強度パラメーターを見つけるために必要なキャリブレーションツールを提供します。
メモリの貪欲なハッシュは、GPUがクラッキングに使用されないようにするのに役立ちます。
Springのセキュリティ/ Bouncy Castleの実装は最適化されておらず、攻撃者が何を使用できるかを考えると、比較的数週間かかります。cf:Springドキュメント
現在の実装では、パスワードクラッカーが行う並列処理/最適化を利用しないBouncy Castleを使用しているため、攻撃者と防御者の間に不必要な非対称性があります。
Javaで使用されている最も信頼できる実装はmkammererのものです。
Rustで書かれた公式のネイティブ実装のラッパーjar /ライブラリ。
よく書かれていて、使い方は簡単です。
組み込みバージョンは、Linux、Windows、OSXのネイティブビルドを提供します。
例として、イーサリアムの暗号化実装であるQuorumを保護するために使用されるテッセラセキュリティプロジェクトでjpmorganchaseによって使用されています。
ここでテセラからのコード例です。
キャリブレーションは、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);
}
}