/// <summary>MAC値を検証</summary>
/// <param name="msg">メッセージ（文字列）</param>
/// <param name="ekha">MACアルゴリズム列挙型</param>
/// <param name="key">キー（文字列）</param>
/// <param name="mac">MAC値（base64文字列）</param>
/// <returns>検証結果( true:検証成功, false:検証失敗 )</returns>
public static bool VerifyMAC(string msg, EnumKeyedHashAlgorithm ekha, string key, string mac)
{
return(MsgAuthCode.VerifyMAC(
CustomEncode.StringToByte(msg, CustomEncode.UTF_8),
ekha, CustomEncode.StringToByte(key, CustomEncode.UTF_8),
CustomEncode.FromBase64String(mac)));
}
/// <summary>
/// Password entered by the userをDB保存する際、
/// Salted and hashed passwordとして保存する必要がある。
/// </summary>
/// <param name="rawPassword">Password entered by the user.</param>
/// <param name="ekha">ハッシュ・アルゴリズム列挙型</param>
/// <param name="key">キー</param>
/// <param name="saltLength">ソルトの文字列長</param>
/// <param name="stretchCount">ストレッチ回数</param>
/// <returns>Salted and hashed password.</returns>
public static string GetSaltedPassword(string rawPassword,
EnumKeyedHashAlgorithm ekha, string key, int saltLength, int stretchCount)
{
// ランダム・ソルト文字列を生成（区切り記号は含まなくても良い）
string salt = GetPassword.Generate(saltLength, 0); //Membership.GeneratePassword(saltLength, 0);
byte[] saltByte = CustomEncode.StringToByte(salt, CustomEncode.UTF_8);
// KeyedHashのキーを生成する。
Rfc2898DeriveBytes passwordKey = new Rfc2898DeriveBytes(key, saltByte, stretchCount);
// Salted and hashed password（文字列）を生成して返す。
return
// key
(CustomEncode.ToBase64String(CustomEncode.StringToByte(key, CustomEncode.UTF_8))
// saltByte
+ "." + CustomEncode.ToBase64String(saltByte)
// stretchCount
+ "." + CustomEncode.ToBase64String(CustomEncode.StringToByte(stretchCount.ToString(), CustomEncode.UTF_8))
// Salted and hashed password
+ "." + CustomEncode.ToBase64String(
GetPasswordHashV2.GetKeyedHashBytes(
CustomEncode.StringToByte(salt + rawPassword, CustomEncode.UTF_8),
ekha, passwordKey.GetBytes(24))));
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="asb">バイト配列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <param name="stretchCount">ストレッチ回数</param>
/// <returns>ハッシュ値（バイト配列）</returns>
public static byte[] GetKeyedHashBytes(byte[] asb, EnumKeyedHashAlgorithm ekha, string password, byte[] salt, int stretchCount)
{
// キーを生成する。
Rfc2898DeriveBytes passwordKey = new Rfc2898DeriveBytes(password, salt, stretchCount);
// HMACMD5 ：どのサイズのキーでも受け入れる ◯
// HMACRIPEMD160：どのサイズのキーでも受け入れる ◯
// HMACSHA1 ：どのサイズのキーでも受け入れる ◯
// HMACSHA256 ：どのサイズのキーでも受け入れる ◯
// HMACSHA384 ：どのサイズのキーでも受け入れる ◯
// HMACSHA512 ：どのサイズのキーでも受け入れる ◯
// MACTripleDES ：長さが 16 または 24 バイトのキーを受け入れる
// ハッシュ（キー付き）サービスプロバイダを生成
KeyedHashAlgorithm kha = GetKeyedHash.CreateKeyedHashAlgorithmServiceProvider(
ekha,
passwordKey.GetBytes(24) // 上記より、24 決め打ちとする。
);
// ハッシュ（キー付き）を生成して返す。
byte[] temp = kha.ComputeHash(asb);
kha.Clear(); // devps(1725)
return(temp);
}
/// <summary>MAC値を検証</summary>
/// <param name="msg">メッセージ（バイト配列）</param>
/// <param name="ekha">MACアルゴリズム列挙型</param>
/// <param name="key">キー（バイト配列）</param>
/// <param name="mac">MAC値（バイト配列）</param>
/// <returns>検証結果( true:検証成功, false:検証失敗 )</returns>
public static bool VerifyMAC(byte[] msg, EnumKeyedHashAlgorithm ekha, byte[] key, byte[] mac)
{
// 文字列にしてから計算
string paramMac = CustomEncode.ToBase64String(mac);
string calcMac = CustomEncode.ToBase64String(MsgAuthCode.GetMAC(msg, ekha, key));
return(paramMac == calcMac);
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="ss">文字列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <param name="stretching">ストレッチング</param>
/// <returns>ハッシュ値（文字列）</returns>
public static string GetKeyedHashString(string ss, EnumKeyedHashAlgorithm ekha, string password, byte[] salt, int stretching)
{
// ハッシュ（Base64）
return(CustomEncode.ToBase64String(
GetKeyedHashBytes(
CustomEncode.StringToByte(ss, CustomEncode.UTF_8),
ekha, password, salt, stretching)));
}
/// <summary>ハッシュ（キー付き）サービスプロバイダの生成</summary>
/// <param name="ekha">ハッシュ（キー付き）サービスプロバイダの列挙型</param>
/// <param name="key">キー</param>
/// <returns>ハッシュ（キー付き）サービスプロバイダ</returns>
private static KeyedHashAlgorithm CreateKeyedHashAlgorithmServiceProvider(EnumKeyedHashAlgorithm ekha, byte[] key)
{
// ハッシュ（キー付き）サービスプロバイダ
KeyedHashAlgorithm kha = null;
// HMACSHA1.Create(); だと、全部、HMACSHA1になってしまう現象があったので、
// 全部、= new HMACSHA1(key); のスタイルに変更した。
if (ekha == EnumKeyedHashAlgorithm.Default)
{
// 既定の暗号化サービスプロバイダ
kha = new HMACSHA1(key); // devps(1703)
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA1)
{
// HMACSHA1サービスプロバイダ
kha = new HMACSHA1(key); // devps(1703)
}
// -- ▼追加▼ --
else if (ekha == EnumKeyedHashAlgorithm.HMACMD5)
{
// HMACMD5サービスプロバイダ
kha = new HMACMD5(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACRIPEMD160)
{
// HMACRIPEMD160サービスプロバイダ
kha = new HMACRIPEMD160(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA256)
{
// HMACSHA256サービスプロバイダ
kha = new HMACSHA256(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA384)
{
// HMACSHA384サービスプロバイダ
kha = new HMACSHA384(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA512)
{
// HMACSHA512サービスプロバイダ
kha = new HMACSHA512(key);
}
// -- ▲追加▲ --
else if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
// MACTripleDESサービスプロバイダ
kha = new MACTripleDES(key); // devps(1703)
}
return(kha);
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="data">データ（バイト配列）</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="key">キー（バイト配列）</param>
/// <returns>ハッシュ値（バイト配列）</returns>
public static byte[] GetKeyedHashBytes(byte[] data, EnumKeyedHashAlgorithm ekha, byte[] key)
{
// HMACMD5 ：どのサイズのキーでも受け入れる ◯
// HMACRIPEMD160：どのサイズのキーでも受け入れる ◯
// HMACSHA1 ：どのサイズのキーでも受け入れる ◯
// HMACSHA256 ：どのサイズのキーでも受け入れる ◯
// HMACSHA384 ：どのサイズのキーでも受け入れる ◯
// HMACSHA512 ：どのサイズのキーでも受け入れる ◯
// MACTripleDES ：長さが 16 または 24 バイトのキーを受け入れる
if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
if (24 <= key.Length)
{
key = ArrayOperator.ShortenByteArray(key, 24);
}
else if (16 <= key.Length)
{
key = ArrayOperator.ShortenByteArray(key, 16);
}
else
{
throw new ArgumentException(
PublicExceptionMessage.ARGUMENT_INCORRECT, "byte[] key");
}
}
#if NETSTD
// NETSTDの場合の実装
if (ekha == EnumKeyedHashAlgorithm.HMACRIPEMD160)
{
return(GetKeyedHash.GetMacBytesByBC(
data, key, new HMac(new RipeMD160Digest())));
}
else if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
return(GetKeyedHash.GetMacBytesByBC(
data, key, new CbcBlockCipherMac(new DesEdeEngine(), 64)));
}
#endif
// ハッシュ（キー付き）サービスプロバイダを生成
KeyedHashAlgorithm kha = HashAlgorithmCmnFunc.
CreateKeyedHashAlgorithmSP(ekha, key);
// ハッシュ（キー付き）を生成して返す。
byte[] temp = kha.ComputeHash(data);
kha.Clear(); // devps(1725)
return(temp);
}
/// <summary>
/// Password entered by the userをDB保存する際、
/// Salted and hashed passwordとして保存する必要がある。
/// </summary>
/// <param name="rawPassword">Password entered by the user.</param>
/// <param name="ekha">ハッシュ・アルゴリズム列挙型</param>
/// <param name="key">キー</param>
/// <param name="saltLength">ソルトの文字列長</param>
/// <param name="stretchCount">ストレッチ回数</param>
/// <returns>Salted and hashed password.</returns>
public static string GetSaltedPassword(string rawPassword, EnumKeyedHashAlgorithm ekha, string key, int saltLength, int stretchCount)
{
// ランダム・ソルト文字列を生成（区切り記号は含まなくても良い）
string salt = GetPassword.Generate(saltLength, 0); //Membership.GeneratePassword(saltLength, 0);
byte[] saltByte = CustomEncode.StringToByte(salt, CustomEncode.UTF_8);
// Salted and hashed password（文字列）を生成して返す。
return
(CustomEncode.ToBase64String(CustomEncode.StringToByte(key, CustomEncode.UTF_8))
+ "." + CustomEncode.ToBase64String(saltByte)
+ "." + CustomEncode.ToBase64String(CustomEncode.StringToByte(stretchCount.ToString(), CustomEncode.UTF_8))
+ "." + CustomEncode.ToBase64String(CustomEncode.StringToByte(
GetKeyedHash.GetKeyedHashString(salt + rawPassword, ekha, key, saltByte, stretchCount), CustomEncode.UTF_8)));
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="asb">バイト配列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <param name="stretchCount">ストレッチ回数</param>
/// <returns>ハッシュ値（バイト配列）</returns>
private static byte[] GetKeyedHashBytes(byte[] asb, EnumKeyedHashAlgorithm ekha, string password, byte[] salt, int stretchCount)
{
// キーを生成する。
Rfc2898DeriveBytes passwordKey = new Rfc2898DeriveBytes(password, salt, stretchCount);
// HMACMD5 ：どのサイズのキーでも受け入れる ◯
// HMACRIPEMD160：どのサイズのキーでも受け入れる ◯
// HMACSHA1 ：どのサイズのキーでも受け入れる ◯
// HMACSHA256 ：どのサイズのキーでも受け入れる ◯
// HMACSHA384 ：どのサイズのキーでも受け入れる ◯
// HMACSHA512 ：どのサイズのキーでも受け入れる ◯
// MACTripleDES ：長さが 16 または 24 バイトのキーを受け入れる
// ハッシュ（キー付き）サービスプロバイダを生成
#if NETSTD
// NETSTDの場合の実装
if (ekha == EnumKeyedHashAlgorithm.HMACRIPEMD160)
{
return(GetKeyedHash.GetMacBytesByBC(
asb, passwordKey.GetBytes(24), new HMac(new RipeMD160Digest())));
}
else if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
return(GetKeyedHash.GetMacBytesByBC(
asb, passwordKey.GetBytes(24), new CbcBlockCipherMac(new DesEdeEngine(), 64)));
}
#endif
KeyedHashAlgorithm kha = HashAlgorithmCmnFunc.CreateKeyedHashAlgorithmSP(
ekha,
passwordKey.GetBytes(24) // 上記より、24 決め打ちとする。
);
// ハッシュ（キー付き）を生成して返す。
byte[] temp = kha.ComputeHash(asb);
kha.Clear(); // devps(1725)
return(temp);
}
[TestCase(null, 999, "test@123", ExpectedException = typeof(ArgumentNullException), TestName = "TestID-018A")] // The encryption method that is not defined
public void GetKeyedHashStringTest(string sourceString, EnumKeyedHashAlgorithm eha, string password)
{
try
{
// Get the hash value using the components of touryo.
string hashString = GetKeyedHash.GetKeyedHashString(sourceString, eha, password);
// Using the components of touryo, and get the hash value again.
string hashString2 = GetKeyedHash.GetKeyedHashString(sourceString, eha, password);
// Check the hash value.
Assert.AreNotEqual(sourceString, hashString);
Assert.AreNotEqual(sourceString, hashString2);
Assert.AreEqual(hashString, hashString2);
}
catch (Exception ex)
{
// Print a stack trace when an exception occurs.
Console.WriteLine(":" + ex.StackTrace);
throw;
}
}
public void GetKeyedHashBytesTest(byte[] asb, EnumKeyedHashAlgorithm eha, string password)
{
try
{
// anyWarp 棟梁の部品を使用してハッシュ値を取得
byte[] hashBytes = GetKeyedHash.GetKeyedHashBytes(asb, eha, password);
// anyWarp 棟梁の部品を使用して、もう一度ハッシュ値を取得
byte[] hashBytes2 = GetKeyedHash.GetKeyedHashBytes(asb, eha, password);
// ハッシュ値が同じかどうかをチェック
Assert.AreNotEqual(asb, hashBytes);
Assert.AreNotEqual(asb, hashBytes2);
Assert.AreEqual(hashBytes, hashBytes2);
}
catch (Exception ex)
{
// Print a stack trace when an exception occurs.
Console.WriteLine(ex.StackTrace);
throw;
}
}
/// <summary>ハッシュ（キー付き）サービスプロバイダの生成</summary>
/// <param name="ekha">ハッシュ（キー付き）サービスプロバイダの列挙型</param>
/// <returns>ハッシュ（キー付き）サービスプロバイダ</returns>
private static KeyedHashAlgorithm CreateKeyedHashAlgorithmServiceProvider(EnumKeyedHashAlgorithm ekha)
{
// ハッシュ（キー付き）サービスプロバイダ
KeyedHashAlgorithm kha = null;
if (ekha == EnumKeyedHashAlgorithm.Default)
{
// 既定の暗号化サービスプロバイダ
kha = KeyedHashAlgorithm.Create(); // devps(1703)
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA1)
{
// HMACSHA1サービスプロバイダ
kha = HMACSHA1.Create(); // devps(1703)
}
else if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
// MACTripleDESサービスプロバイダ
kha = MACTripleDES.Create(); // devps(1703)
}
return(kha);
}
/// <summary>パスワードを比較して認証する。</summary>
/// <param name="rawPassword">Password entered by the user.</param>
/// <param name="saltedPassword">Salted and hashed password.</param>
/// <param name="ekha">ハッシュ・アルゴリズム列挙型</param>
/// <returns>
/// true：パスワードは一致した。
/// false：パスワードは一致しない。
/// </returns>
public static bool EqualSaltedPassword(string rawPassword, string saltedPassword, EnumKeyedHashAlgorithm ekha)
{
// ソルト部分を取得
string[] temp = saltedPassword.Split('.');
string key = CustomEncode.ByteToString(CustomEncode.FromBase64String(temp[0]), CustomEncode.UTF_8);
byte[] saltByte = CustomEncode.FromBase64String(temp[1]);
string salt = CustomEncode.ByteToString(saltByte, CustomEncode.UTF_8);
int stretchCount = int.Parse(CustomEncode.ByteToString(CustomEncode.FromBase64String(temp[2]), CustomEncode.UTF_8));
string hashedPassword = CustomEncode.ByteToString(CustomEncode.FromBase64String(temp[3]), CustomEncode.UTF_8);
// 引数のsaltedPasswordと、rawPasswordから自作したsaltedPasswordを比較
if (hashedPassword == GetKeyedHash.GetKeyedHashString(salt + rawPassword, ekha, key, saltByte, stretchCount))
{
// 一致した。
return(true);
}
else
{
// 一致しなかった。
return(false);
}
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="data">データ（文字列）</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="key">キー（文字列）</param>
/// <returns>ハッシュ値（base64文字列）</returns>
public static string GetKeyedHashString(string data, EnumKeyedHashAlgorithm ekha, string key)
{
return(CustomEncode.ToBase64String(GetKeyedHashBytes(
CustomEncode.StringToByte(data, CustomEncode.UTF_8),
ekha, CustomEncode.StringToByte(key, CustomEncode.UTF_8))));
}
/// <summary>
/// Password entered by the userをDB保存する際、
/// Salted and hashed passwordとして保存する必要がある。
/// </summary>
/// <param name="rawPassword">Password entered by the user.</param>
/// <param name="ekha">ハッシュ・アルゴリズム列挙型</param>
/// <param name="key">キー（システム共通）</param>
/// <param name="saltLength">ソルトの文字列長</param>
/// <returns>Salted and hashed password.</returns>
/// <see ref="http://www.atmarkit.co.jp/ait/articles/1110/06/news154_2.html"/>
public static string GetSaltedPassword(string rawPassword, EnumKeyedHashAlgorithm ekha, string key, int saltLength)
{
// overloadへ
return(GetKeyedHash.GetSaltedPassword(rawPassword, ekha, key, saltLength, 1));
}
/// <summary>パスワードを比較して認証する。</summary>
/// <param name="rawPassword">Password entered by the user.</param>
/// <param name="saltedPassword">Salted and hashed password.</param>
/// <param name="ekha">ハッシュ・アルゴリズム列挙型</param>
/// <returns>
/// true：パスワードは一致した。
/// false：パスワードは一致しない。
/// </returns>
public static bool EqualSaltedPassword(string rawPassword, string saltedPassword, EnumKeyedHashAlgorithm ekha)
{
// ソルト部分を取得
string[] temp = saltedPassword.Split('.');
// key
string key = CustomEncode.ByteToString(CustomEncode.FromBase64String(temp[0]), CustomEncode.UTF_8);
// saltByte
byte[] saltByte = CustomEncode.FromBase64String(temp[1]);
// salt
string salt = CustomEncode.ByteToString(saltByte, CustomEncode.UTF_8);
// stretchCount
int stretchCount = int.Parse(CustomEncode.ByteToString(CustomEncode.FromBase64String(temp[2]), CustomEncode.UTF_8));
// Salted and hashed password
string hashedPassword = temp[3];
// KeyedHashのキーを生成する。
Rfc2898DeriveBytes passwordKey = new Rfc2898DeriveBytes(key, saltByte, stretchCount);
// 引数のsaltedPasswordと、rawPasswordから自作したsaltedPasswordを比較
string compare = CustomEncode.ToBase64String(
GetPasswordHashV2.GetKeyedHashBytes(
CustomEncode.StringToByte(salt + rawPassword, CustomEncode.UTF_8),
ekha, passwordKey.GetBytes(24)));
if (hashedPassword == compare)
{
// 一致した。
return(true);
}
else
{
// 一致しなかった。
return(false);
}
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="ss">文字列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <returns>ハッシュ値（文字列）</returns>
public static string GetKeyedHashString(string ss, EnumKeyedHashAlgorithm ekha, string password, byte[] salt)
{
return GetKeyedHash.GetKeyedHashString(
ss, ekha, password, salt, GetKeyedHash.Stretching);
}
/// <summary>MAC値を返す。</summary>
/// <param name="msg">メッセージ（バイト配列）</param>
/// <param name="ekha">MACアルゴリズム列挙型</param>
/// <param name="key">キー（バイト配列）</param>
/// <returns>MAC値（バイト配列）</returns>
public static byte[] GetMAC(byte[] msg, EnumKeyedHashAlgorithm ekha, byte[] key)
{
return(MsgAuthCode.GetKeyedHashBytes(msg, ekha, key));
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="asb">バイト配列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <returns>ハッシュ値（バイト配列）</returns>
public static byte[] GetKeyedHashBytes(byte[] asb, EnumKeyedHashAlgorithm ekha, string password)
{
return(GetKeyedHash.GetKeyedHashBytes(
asb, ekha, password, CustomEncode.StringToByte(GetKeyedHash._salt, CustomEncode.UTF_8), GetKeyedHash.StretchCount));
}
public void GetKeyedHashBytesTest2(byte[] asb, EnumKeyedHashAlgorithm eha, string password, byte[] salt)
{
try
{
// anyWarp 棟梁の部品を使用してハッシュ値を取得
byte[] hashBytes = GetKeyedHash.GetKeyedHashBytes(asb, eha, password, salt);
// anyWarp 棟梁の部品を使用して、もう一度ハッシュ値を取得
byte[] hashBytes2 = GetKeyedHash.GetKeyedHashBytes(asb, eha, password, salt);
// ハッシュ値が同じかどうかをチェック
Assert.AreNotEqual(asb, hashBytes);
Assert.AreNotEqual(asb, hashBytes2);
Assert.AreEqual(hashBytes, hashBytes2);
}
catch (Exception ex)
{
// Print a stack trace when an exception occurs.
Console.WriteLine(ex.StackTrace);
throw;
}
}
/// <summary>MAC値を返す。</summary>
/// <param name="msg">メッセージ（文字列）</param>
/// <param name="ekha">MACアルゴリズム列挙型</param>
/// <param name="key">キー（文字列）</param>
/// <returns>MAC値（base64文字列）</returns>
public static string GetMAC(string msg, EnumKeyedHashAlgorithm ekha, string key)
{
return(CustomEncode.ToBase64String(MsgAuthCode.GetMAC(
CustomEncode.StringToByte(msg, CustomEncode.UTF_8),
ekha, CustomEncode.StringToByte(key, CustomEncode.UTF_8))));
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="asb">バイト配列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <returns>ハッシュ値（バイト配列）</returns>
public static byte[] GetKeyedHashBytes(byte[] asb, EnumKeyedHashAlgorithm ekha, string password)
{
return GetKeyedHash.GetKeyedHashBytes(
asb, ekha, password, GetKeyedHash.Salt, GetKeyedHash.Stretching);
}
/// <summary>ハッシュ（キー付き）サービスプロバイダの生成</summary>
/// <param name="ekha">ハッシュ（キー付き）サービスプロバイダの列挙型</param>
/// <returns>ハッシュ（キー付き）サービスプロバイダ</returns>
private static KeyedHashAlgorithm CreateKeyedHashAlgorithmServiceProvider(EnumKeyedHashAlgorithm ekha)
{
// ハッシュ（キー付き）サービスプロバイダ
KeyedHashAlgorithm kha = null;
if (ekha == EnumKeyedHashAlgorithm.Default)
{
// 既定の暗号化サービスプロバイダ
kha = KeyedHashAlgorithm.Create(); // devps(1703)
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA1)
{
// HMACSHA1サービスプロバイダ
kha = HMACSHA1.Create(); // devps(1703)
}
else if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
// MACTripleDESサービスプロバイダ
kha = MACTripleDES.Create(); // devps(1703)
}
return kha;
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="ss">文字列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <param name="stretching">ストレッチング</param>
/// <returns>ハッシュ値（文字列）</returns>
public static string GetKeyedHashString(string ss, EnumKeyedHashAlgorithm ekha, string password, byte[] salt, int stretching)
{
// ハッシュ（Base64）
return CustomEncode.ToBase64String(
GetKeyedHashBytes(
CustomEncode.StringToByte(ss, CustomEncode.UTF_8),
ekha, password, salt, stretching));
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="ss">文字列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <returns>ハッシュ値（文字列）</returns>
public static string GetKeyedHashString(string ss, EnumKeyedHashAlgorithm ekha, string password)
{
return(GetKeyedHash.GetKeyedHashString(
ss, ekha, password, CustomEncode.StringToByte(GetKeyedHash._salt, CustomEncode.UTF_8), GetKeyedHash.StretchCount));
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="ss">文字列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <returns>ハッシュ値（文字列）</returns>
public static string GetKeyedHashString(string ss, EnumKeyedHashAlgorithm ekha, string password, byte[] salt)
{
return(GetKeyedHash.GetKeyedHashString(
ss, ekha, password, salt, GetKeyedHash.StretchCount));
}
/// <summary>文字列のハッシュ値を計算して返す。</summary>
/// <param name="ss">文字列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <returns>ハッシュ値（文字列）</returns>
public static string GetKeyedHashString(string ss, EnumKeyedHashAlgorithm ekha, string password)
{
return(GetKeyedHash.GetKeyedHashString(
ss, ekha, password, GetKeyedHash.Salt, GetKeyedHash.Stretching));
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="asb">バイト配列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <returns>ハッシュ値（バイト配列）</returns>
public static byte[] GetKeyedHashBytes(byte[] asb, EnumKeyedHashAlgorithm ekha, string password, byte[] salt)
{
return(GetKeyedHash.GetKeyedHashBytes(
asb, ekha, password, salt, GetKeyedHash.StretchCount));
}
public void GetKeyedHashStringTest2(string sourceString, EnumKeyedHashAlgorithm eha, string password, byte[] salt)
{
try
{
// Get the Salt password using the components of touryo.
string hashString = GetKeyedHash.GetKeyedHashString(sourceString, eha, password, salt);
// Using the components of touryo, and get the hash value again.
string hashString2 = GetKeyedHash.GetKeyedHashString(sourceString, eha, password, salt);
// Check the hash value.
Assert.AreNotEqual(sourceString, hashString);
Assert.AreNotEqual(sourceString, hashString2);
Assert.AreEqual(hashString, hashString2);
}
catch (Exception ex)
{
// Print a stack trace when an exception occurs.
Console.WriteLine(ex.StackTrace);
throw;
}
}
/// <summary>ハッシュ（キー付き）サービスプロバイダの生成</summary>
/// <param name="ekha">ハッシュ（キー付き）サービスプロバイダの列挙型</param>
/// <param name="key">キー</param>
/// <returns>ハッシュ（キー付き）サービスプロバイダ</returns>
public static KeyedHashAlgorithm CreateKeyedHashAlgorithmSP(EnumKeyedHashAlgorithm ekha, byte[] key)
{
// ハッシュ（キー付き）サービスプロバイダ
KeyedHashAlgorithm kha = null;
// HMACSHA1.Create(); だと、全部、HMACSHA1になってしまう現象があったので、
// 全部、= new HMACSHA1(key); のスタイルに変更した。
if (ekha == EnumKeyedHashAlgorithm.Default)
{
// 既定の暗号化サービスプロバイダ
kha = new HMACSHA1(key); // devps(1703)
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA1)
{
// HMACSHA1サービスプロバイダ
kha = new HMACSHA1(key); // devps(1703)
}
// -- ▼追加▼ --
else if (ekha == EnumKeyedHashAlgorithm.HMACMD5)
{
// HMACMD5サービスプロバイダ
kha = new HMACMD5(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACRIPEMD160)
{
#if NETSTD
kha = null; // BouncyCastleを使用する。
#else
// HMACRIPEMD160サービスプロバイダ
kha = new HMACRIPEMD160(key);
#endif
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA256)
{
// HMACSHA256サービスプロバイダ
kha = new HMACSHA256(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA384)
{
// HMACSHA384サービスプロバイダ
kha = new HMACSHA384(key);
}
else if (ekha == EnumKeyedHashAlgorithm.HMACSHA512)
{
// HMACSHA512サービスプロバイダ
kha = new HMACSHA512(key);
}
// -- ▲追加▲ --
else if (ekha == EnumKeyedHashAlgorithm.MACTripleDES)
{
#if NETSTD
kha = null; // BouncyCastleを使用する。
#else
// MACTripleDESサービスプロバイダ
kha = new MACTripleDES(key); // devps(1703)
#endif
}
else
{
throw new ArgumentException(
PublicExceptionMessage.ARGUMENT_INCORRECT, "EnumKeyedHashAlgorithm ekha");
}
return(kha);
}
/// <summary>バイト配列のハッシュ値を計算して返す。</summary>
/// <param name="asb">バイト配列</param>
/// <param name="ekha">ハッシュ（キー付き）アルゴリズム列挙型</param>
/// <param name="password">使用するパスワード</param>
/// <param name="salt">ソルト</param>
/// <param name="stretching">ストレッチング</param>
/// <returns>ハッシュ値（バイト配列）</returns>
public static byte[] GetKeyedHashBytes(byte[] asb, EnumKeyedHashAlgorithm ekha, string password, byte[] salt, int stretching)
{
// ハッシュ（キー付き）サービスプロバイダを生成
KeyedHashAlgorithm kha = GetKeyedHash.CreateKeyedHashAlgorithmServiceProvider(ekha);
// キーを生成する。
Rfc2898DeriveBytes passwordKey = new Rfc2898DeriveBytes(password, salt, stretching);
// HMACSHA1 ：どのサイズのキーでも受け入れる
// MACTripleDES ：長さが 16 または 24 バイトのキーを受け入れる
kha.Key = passwordKey.GetBytes(24); // 上記より、24 決め打ちとする。
// ハッシュ（キー付き）を生成して返す。
byte[] temp = kha.ComputeHash(asb);
kha.Clear(); // devps(1725)
return temp;
}