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


176

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

私はプレーンテキストのパスワードを取り、ランダムなソルトを追加し、ソルトとハッシュされたパスワードをデータベースに保存したいと思っていました。

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


11
@YGLこれは実際には最近の再結合ではなく、GPU攻撃は非常に安価であるため、SHAファミリは実際にはソルトを使用しても(速すぎる)パスワードハッシュの非常に悪い選択です。bcrypt、scrypt、またはPBKDF2を使用
Eran Medan

11
なぜこの質問は閉じられたのですか?これは実際のエンジニアリング問題に対する質問であり、答えは非常に貴重です。OPはライブラリを求めているのではなく、エンジニアリングの問題を解決する方法を求めています。
stackoverflowuser2010

12
すごい。この質問には52の賛成票があり、誰かが「オフトピック」としてそれを閉じることにしました。
stackoverflowuser2010 2015

1
ええ、私は以前にこのクロージングの問題についてメタに投稿しましたが、かなりひどく打たれました。
Chris Dutrow、2015

8
この質問は再開する必要があります。記述されている問題(パスワード認証)を解決するためのプログラムを、短いコードソリューションでどのように作成するかという問題です。トリガーワード「library」が表示されても、質問を再帰的に閉じることは正当化されません。彼は図書館の推薦を求めているのではなく、パスワードをハッシュする方法を求めています。編集:そこに、それを修正しました。
エリクソン2015

回答:


157

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

}

11
バイトから16進数への変換に少し注意したい場合がありますBigInteger。先行ゼロは削除されます。これはクイックデバッグには問題ありませんが、その影響による製品コードにバグが見られます。
Thomas Pornin、

24
@ thomas-porninのハイライトは、ほとんど存在するコードブロックではなく、ライブラリが必要な理由を強調しいます。受け入れられた答えがそのような重要なトピックに関する質問に答えないことを怖い。
Nilzor 2013

9
Java 8以降のアルゴリズムPBKDF2WithHmacSHA512を使用します。これは少し強力です。
iwan.z 2014年

1
それ以降のバージョンでは、既存のalgは削除されないことに注意してください:java_4:PBEWithMD5AndDES、DESede、DES java_5 / 6/7:PBKDF2WithHmacSHA1、PBE(Java 5のみ)、PBEWithSHA1AndRC2_40、PBEWithSHA1And、PBEWithMD5AndHAHES128HESSMACSHA128ESPHAESES_ES_HES_MACSHA128SES_ESP_ESP_ESP_ESP_ESH_SHAES_ES_SHAES_ES_ES_SHAES_ES_ES_SHAS_ES_SHAES_ES_ES_ESP_SHAES_S_SES 、PBEWithHmacSHA1AndAES_128、RC4_128、PBKDF2WithHmacSHA224、PBEWithHmacSHA256AndAES_256、RC2_128、PBEWithHmacSHA224AndAES_256、PBEWithHmacSHA384AndAES_256、PBEWithHmacSHA512AndAES_256、PBKDF2WithHmacSHA512、PBEWithHmacSHA256AndAES_128、PBKDF2WithHmacSHA384、PBEWithHmacSHA1AndAES_256
iwan.z

4
@TheTostersはい、不正なパスワードの実行時間は長くなります。より具体的には、間違ったパスワードは正しいパスワードと同じ時間を要します。この場合、このような脆弱性を利用する実用的な方法は考えられませんが、タイミング攻撃を防ぎます。しかし、手抜きはしません。私がそれを見ることができないからといって、より邪悪な心が見えないという意味ではありません。
エリクソン2016年

97

以下は、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%を費やす攻撃者と比べてそれほどコストはかかりません。


14
申し訳ありませんが、なぜこれを既存のライブラリよりも選択する必要があるのですか?図書館は徹底的にレビューされる可能性が高いでしょう。14の賛成票のすべてが問題についてコードを分析したとは思えません。
Joachim Sauer、

2
@JoachimSauerこれは基本的にライブラリ(javax.crypto)を使用しているだけですが、正しい-空のパスワードはサポートされていません。明示的にするために例外を追加しました。ありがとう!
Martin Konicek、2013年

3
メソッドのシグネチャをchar[] passwordではなくに変更する必要がありString passwordます。
アッシリアス2013年

2
参照は全会一致の同意を得ていないようですが。これも参照してください:security.stackexchange.com/a/20369/12614
assylias

3
文字列の.equals()がショートしないことを確認しますか(つまり、等しくない2バイトが見つかったときにループを停止します)?その場合、タイミング攻撃がパスワードハッシュに関する情報を漏洩するリスクがあります。
bobpoekert


7

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

JASYPTライブラリにも同様のユーティリティがあるようです


それは実際に私が使っていたものです。しかし、Shiroを使用しないことにしたため、その1つのパッケージだけにShiroライブラリ全体を含める必要があることの非効率性が懸念されました。
Chris Dutrow、2010年

パスワードハッシュユーティリティだけで構成されたライブラリについては知りません。依存関係が懸念される場合は、自分でロールするほうがよいでしょう。エリクソンの答えは私にはかなりよさそうです。または、安全な方法でSHAを使用する場合は、参照したOWASPリンクからコードをコピーします。
laz

7

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

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


3
データベースにソルトを保存せずに、ログイン時にパスワードをどのようにハッシュしますか?
ZZ Coder

9
ユーザー名をソルトとして使用することは致命的な欠陥ではありませんが、暗号化RNGからソルトを使用することほど良くはありません。そして、ソルトをデータベースに保存することは全く問題ありません。塩は秘密ではありません。
エリクソン

1
ユーザー名と電子メールもデータベースに保存されませんか?
Chris Dutrow、2010年

@ZZ Coder、@ erickson正解、それはすべてのパスワードに対して1つのソルトであると何とか想定していたため、簡単に計算可能なレインボーテーブルが作成されます。
Bozho

13
ユーザー名(または電子メールなどの他のID)をソルトとして使用する場合の問題の1つは、ユーザーが新しいパスワードを設定しないとIDを変更できないことです。
Lawrence Dol、

6

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

MD5とSHA-1は比較的高速であり、したがって「時間あたりの賃料」の分散コンピューティング(EC2など)または最新のハイエンドGPUを使用しているため、お勧めできません。時間。

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


6

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


数が多いからといって、SHA512がSHA256(この目的のために)よりも優れていないことは注目に値します。
Azsgy

5

あなたは使用することができます春のセキュリティ 暗号(唯一持っている2オプションのコンパイル依存関係をサポートしています)、PBKDF2bcryptのSCryptArgon2パスワードの暗号化を。

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

4

一方でNISTの勧告PBKDF2は、公開があったことを既に述べた、私が指摘したいのですが、パスワードのハッシュ化競争が最後に2013年から2015年に実行されたことを、Argon2を推奨パスワードハッシュ関数として選ばれました。

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

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

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


@zaphより客観的になるように回答を編集しました。NISTの推奨が常に最良の選択であるとは限らないことに注意してください(例については、こちらを参照してください)。もちろん、これは、他のどこかで推奨されているものにも当てはまります。したがって、私はこの答えがこの質問に価値を提供すると思います。
Qw3ry 2017

2

ここには、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


3
パスワードハッシュの場合は、遅いほど良いことを覚えておいてください。「キー強化」手法として、ハッシュ関数の数千回の反復を使用する必要があります。また、塩は必須です。
エリクソン2010年

バイトの長さが同じであるため、品質ハッシュアルゴリズムの複数の反復が1つの反復とほぼ同じセキュリティを生成するという印象を受けましたか?
Chris Dutrow、2010年

@erickson攻撃者を明示的にスローダウンすることをお勧めします。
デーモン

6
キーの強化について:事前計算されたハッシュを使用不可にするためにソルトが存在します。しかし、攻撃者は事前計算する必要はありません。攻撃者は、正しい文字列が見つかるまで、文字列とソルトを「オンザフライ」でハッシュできます。しかし、もしあなたがあなたのハッシュのために何千回も繰り返すなら、彼らは同じことをしなければならないでしょう。頻繁に発生することはないので、サーバーは1万回の反復による大きな影響は受けません。攻撃者は1万倍の計算能力を必要とします。
zockman、

2
@Simon今日のMD5は、GPUブルートフォース/ディクショナリ攻撃を使用して数秒で解読される可能性があるため、パスワードハッシュには役に立たないと見なされています。ここを参照してください:codahale.com/how-to-safely-store-a-password
Eran Medan

1

すべての標準ハッシュスキームの中で、LDAP sshaは最も安全に使用できます。

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

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

あなたが提案したようにあなたはあなたのデータベースにソルトを保存する必要があります。


1
SSHAはハッシュ関数を反復しないため、速すぎます。これにより、攻撃者はより迅速にパスワードを試すことができます。Bcrypt、PBBKDF1、およびPBKDF2などのより優れたアルゴリズムは、「キー強化」技術を使用して、攻撃者が8文字のパスワードスペースでさえもブルートフォースになる前にパスワードが期限切れになるまでの速度を落とします。
エリクソン2010年

これらすべてのメカニズムの問題は、クライアントサポートを受けられないことです。ハッシュされたパスワードの問題は、別のアルゴリズムでハッシュされたパスワードをサポートできないことです。sshaでは、少なくともすべてのLDAPクライアントがそれをサポートしています。
ZZ Coder、

「最も安全」ではなく、「完全に互換性がある」だけです。bcrypt / scryptは、リソースを集中的に使用する方法です。
eckes

1

2020年現在、最も信頼性が高く、柔軟なアルゴリズムが使用されています。

ハードウェアを考慮してその強度を最適化する可能性が最も高いもの、

あるArgon2idまたはArgon2i

目標のハッシュ時間と使用するハードウェアを考慮して、最適化された強度パラメーターを見つけるために必要なキャリブレーションツールを提供します。

  • Argon2iはメモリ貪欲ハッシュに特化しています
  • Argon2dはCPU貪欲ハッシュに特化しています
  • Argon2idは両方の方法を使用します。

メモリの貪欲なハッシュは、GPUがクラッキングに使用されないようにするのに役立ちます。

Springのセキュリティ/ Bouncy Castleの実装は最適化されておらず、攻撃者が何を使用できるかを考えると、比較的数週間かかります。cf:Springドキュメント

現在の実装では、パスワードクラッカーが行う並列処理/最適化を利用しないBouncy Castleを使用しているため、攻撃者と防御者の間に不必要な非対称性があります。

Javaで使用されている最も信頼できる実装はmkammererのものです。

Rustで書かれた公式のネイティブ実装のラッパーjar /ライブラリ。

よく書かれていて、使い方は簡単です。

組み込みバージョンは、Linux、Windows、OSXのネイティブビルドを提供します。

例として、イーサリアムの暗号化実装であるQuorumを保護するために使用されるテッセラセキュリティプロジェクトでjpmorganchaseによって使用されています。

ここでテセラからのコード例です。

キャリブレーションは、de.mkammerer.argon2.Argon2Helper#findIterationsを使用して実行できます

SCRYPTおよびPbkdf2アルゴリズムも、いくつかの単純なベンチマークを作成することで調整できますが、現在の最小限の安全な反復値では、より長いハッシュ時間が必要になります。


0

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






}

私は修正の余地がありますが、ハッシュするときに乱数を使うべきではないと思います。これは、ハッシュ関数が確定的であるためです。つまり、文字列を複数回ハッシュすると、常にその文字列に対して同じハッシュ値が返されます。
ダルディ
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.