web-dev-qa-db-ja.com

Javaでパスワードをハッシュするにはどうすればよいですか？

データベースに保存するためにパスワードをハッシュする必要があります。 Javaでこれを行うにはどうすればよいですか？

プレーンテキストのパスワードを取得し、ランダムなソルトを追加し、ソルトとハッシュされたパスワードをデータベースに保存することを望んでいました。

次に、ユーザーがログインするときに、送信されたパスワードを取得し、アカウント情報からランダムなソルトを追加してハッシュし、保存されたハッシュパスワードとアカウント情報が一致するかどうかを確認できます。

javapasswordscryptographic-hash-function
163
Chris Dutrow

これを行うには、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);
  }

}
143
erickson

これが完全な実装で、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)'を保存しています。 saltは32のランダムバイトであり、その目的は、2人の異なるユーザーが同じパスワードを選択した場合でも、保存されたパスワードが異なるように見えることです。

基本的にhash(hash(hash(... hash(password, salt) ...)))であるiterated_hashは、データベースにアクセスできる潜在的な攻撃者にとって、パスワードを推測し、ハッシュし、データベース内のハッシュを検索するのに非常にコストがかかります。ユーザーがログインするたびにこのiterated_hashを計算する必要がありますが、ハッシュの計算にほぼ100％を費やしている攻撃者と比較すると、それほどコストはかかりません。

90
Martin Konicek

BCryptは非常に優れたライブラリであり、 Javaポート があります。

27
Michael Borgwardt

MessageDigest を使用してハッシュを計算できますが、これはセキュリティの観点から間違っています。ハッシュは簡単に解読できるため、パスワードの保存には使用しないでください。

パスワードを保存するには、bcrypt、PBKDF2、scryptなどの別のアルゴリズムを使用する必要があります。 こちらを参照 。

8
Bozho

Shiro ライブラリの（以前の JSecurity ） 実装OWASP で記述されているものを使用できます。

また、JASYPTライブラリには 類似のユーティリティ があるように見えます。

6
laz

他の回答で言及されているbcryptとPBKDF2に加えて、 scrypt を参照することをお勧めします

MD5およびSHA-1は比較的高速であるためお勧めできません。したがって、「1時間あたりのレンタル」分散コンピューティング（EC2など）または最新のハイエンドGPUを使用し、比較的低コストで合理的なブルートフォース/辞書攻撃を使用してパスワードを「クラック」できます時間。

それらを使用する必要がある場合は、少なくともアルゴリズムを事前定義されたかなりの回数（1000回以上）繰り返します。

6
Eran Medan

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

6
David Carboni

NISTの推奨PBKDF2 は既に言及されていますが、2013年から2015年にかけて公開された パスワードハッシュコンテスト があったことを指摘したいと思います。 Argon2が推奨パスワードハッシュ関数として選択されました。

使用できる元の（ネイティブC）ライブラリには、かなりよく採用されている Javaバインディング があります。

平均的なユースケースでは、Argon2ではなくPBKDF2を選択した場合、またはその逆を選択した場合、セキュリティの観点からは重要ではないと思います。強力なセキュリティ要件がある場合は、評価でArgon2を検討することをお勧めします。

パスワードハッシュ関数のセキュリティの詳細については、 security.se を参照してください。

4
Qw3ry

ここには、MD5ハッシュと他のハッシュメソッドの2つのリンクがあります。

Javadoc API： http://Java.Sun.com/j2se/1.4.2/docs/api/Java/security/MessageDigest.html

チュートリアル： http://www.twmacinta.com/myjava/fast_md5.php

2
Simon

Spring SecurityCrypto （has only 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);
1
BuZZ-dEE

すべての標準ハッシュスキームの中で、LDAP sshaは最も安全なものであり、

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

そこで指定されたアルゴリズムに従い、MessageDigestを使用してハッシュを実行します。

提案したように、データベースに塩を保存する必要があります。

1
ZZ Coder