internal static byte[] GenerateSteamParentalHash(byte[] password, byte[] salt, byte hashLength, ESteamParentalAlgorithm steamParentalAlgorithm)
{
if ((password == null) || (salt == null) || (hashLength == 0) || !Enum.IsDefined(typeof(ESteamParentalAlgorithm), steamParentalAlgorithm))
{
ASF.ArchiLogger.LogNullError(nameof(password) + " || " + nameof(salt) + " || " + nameof(hashLength) + " || " + nameof(steamParentalAlgorithm));
return(null);
}
switch (steamParentalAlgorithm)
{
case ESteamParentalAlgorithm.Pbkdf2:
using (HMACSHA1 hmacAlgorithm = new HMACSHA1(password)) {
return(Pbkdf2.ComputeDerivedKey(hmacAlgorithm, salt, SteamParentalPbkdf2Iterations, hashLength));
}
case ESteamParentalAlgorithm.SCrypt:
return(SCrypt.ComputeDerivedKey(password, salt, SteamParentalSCryptIterations, SteamParentalSCryptBlocksCount, 1, null, hashLength));
default:
ASF.ArchiLogger.LogGenericError(string.Format(Strings.WarningUnknownValuePleaseReport, nameof(steamParentalAlgorithm), steamParentalAlgorithm));
return(null);
}
}
public byte[] DeriveSeed(string passphrase = null)
{
passphrase = passphrase ?? "";
byte[] salt = Concat(Encoding.UTF8.GetBytes("mnemonic"), Normalize(passphrase));
byte[] bytes = Normalize(this._Mnemonic);
var mac = new NBitcoin.BouncyCastle.Crypto.Macs.HMac(new NBitcoin.BouncyCastle.Crypto.Digests.Sha512Digest());
mac.Init(new KeyParameter(bytes));
return(Pbkdf2.ComputeDerivedKey(mac, salt, 2048, 64));
}
public static byte[] GetSeed(string words, string passphrase = "")
{
if (string.IsNullOrWhiteSpace(words))
{
throw new ArgumentNullException(nameof(words));
}
var pass = Utf8.Parse(words);
var salt = Utf8.Parse("mnemonic" + passphrase);
return(Pbkdf2.ComputeDerivedKey(new HMACSHA512(pass), salt, 2048, 64));
}
} // HashPassword
private HashedPassword Generate(string userName, string rawPassword, int?cycleCount, byte[] salt)
{
byte[] saltToUse = salt ?? GenerateSalt(userName);
int iterations = cycleCount ?? this.minCycleCount;
this.algo.Prepare(userName, rawPassword);
byte[] hashedPassword = Pbkdf2.ComputeDerivedKey(this.algo.Instance, saltToUse, iterations, this.algo.HashSize);
return(new HashedPassword(userName, iterations, hashedPassword, saltToUse));
} // Generate
public void Return_Correct_SHA1_Derived_Key_With_Length_16_And_4096_Iterations()
{
var expectedResult = "56FA6AA75548099DCC37D7F03425E0C3";
byte[] keyBytes = Encoding.ASCII.GetBytes("pass\0word");
byte[] saltBytes = Encoding.ASCII.GetBytes("sa\0lt");
byte[] derivedBytes = Pbkdf2.ComputeDerivedKey(hmacAlgorithm: new HMACSHA1(keyBytes),
salt: saltBytes, iterations: 4096, derivedKeyLength: 16);
var result = Base16Encoding.Hex.GetString(derivedBytes);
result.Should().Be(expectedResult);
}
public void Return_Correct_SHA1_Derived_Key_With_Length_25_And_4096_Iterations()
{
var expectedResult = "3D2EEC4FE41C849B80C8D83662C0E44A8B291A964CF2F07038";
byte[] keyBytes = Encoding.ASCII.GetBytes("passwordPASSWORDpassword");
byte[] saltBytes = Encoding.ASCII.GetBytes("saltSALTsaltSALTsaltSALTsaltSALTsalt");
byte[] derivedBytes = Pbkdf2.ComputeDerivedKey(hmacAlgorithm: new HMACSHA1(keyBytes),
salt: saltBytes, iterations: 4096, derivedKeyLength: 25);
var result = Base16Encoding.Hex.GetString(derivedBytes);
result.Should().Be(expectedResult);
}
public void Return_Correct_SHA1_Derived_Key_With_Length_20_And_4096_Iterations()
{
var expectedResult = "4B007901B765489ABEAD49D926F721D065A429C1";
byte[] keyBytes = Encoding.ASCII.GetBytes("password");
byte[] saltBytes = Encoding.ASCII.GetBytes("salt");
byte[] derivedBytes = Pbkdf2.ComputeDerivedKey(hmacAlgorithm: new HMACSHA1(keyBytes),
salt: saltBytes, iterations: 4096, derivedKeyLength: 20);
var result = Base16Encoding.Hex.GetString(derivedBytes);
result.Should().Be(expectedResult);
}
public void Return_Correct_SHA1_Derived_Key_With_Length_20_And_2_Iterations()
{
var expectedResult = "EA6C014DC72D6F8CCD1ED92ACE1D41F0D8DE8957";
byte[] keyBytes = Encoding.ASCII.GetBytes("password");
byte[] saltBytes = Encoding.ASCII.GetBytes("salt");
byte[] derivedBytes = Pbkdf2.ComputeDerivedKey(hmacAlgorithm: new HMACSHA1(keyBytes),
salt: saltBytes, iterations: 2, derivedKeyLength: 20);
var result = Base16Encoding.Hex.GetString(derivedBytes);
result.Should().Be(expectedResult);
}
public static byte[] HashWithPbkdf2 <T>(string password, byte[] saltBytes, int iterations) where T : KeyedHashAlgorithm, new()
{
var passwordBytes = Encoding.UTF8.GetBytes(password);
var algorithm = new T()
{
Key = passwordBytes
};
var hashSize = algorithm.HashSize / 8;
var hashedPassword = Pbkdf2.ComputeDerivedKey(algorithm, saltBytes, iterations, hashSize);
return(hashedPassword);
}
public void Return_Correct_SHA1_Derived_Key_With_Length_20_And_1_Iteration()
{
var expectedResult = "0C60C80F961F0E71F3A9B524AF6012062FE037A6";
byte[] keyBytes = Encoding.ASCII.GetBytes("password");
byte[] saltBytes = Encoding.ASCII.GetBytes("salt");
byte[] derivedBytes = Pbkdf2.ComputeDerivedKey(hmacAlgorithm: new HMACSHA1(keyBytes),
salt: saltBytes, iterations: 1, derivedKeyLength: 20);
var result = Base16Encoding.Hex.GetString(derivedBytes);
result.Should().Be(expectedResult);
}
public byte[] DeriveSeed(string passphrase = null)
{
passphrase = passphrase ?? "";
var salt = Concat(NoBOMUTF8.GetBytes("mnemonic"), Normalize(passphrase));
var bytes = Normalize(_Mnemonic);
#if USEBC || WINDOWS_UWP || NETSTANDARD1X
var mac = new NBitcoin.BouncyCastle.Crypto.Macs.HMac(new NBitcoin.BouncyCastle.Crypto.Digests.Sha512Digest());
mac.Init(new KeyParameter(bytes));
return(Pbkdf2.ComputeDerivedKey(mac, salt, 2048, 64));
#else
return(Pbkdf2.ComputeDerivedKey(new HMACSHA512(bytes), salt, 2048, 64));
#endif
}
public byte[] DeriveSeed(string passphrase = null)
{
passphrase = passphrase ?? "";
var salt = Concat(Encoding.UTF8.GetBytes("mnemonic"), Normalize(passphrase));
var bytes = Normalize(_Mnemonic);
#if USEBC || WINDOWS_UWP || NETCORE
var mac = new nStratis.BouncyCastle.crypto.macs.HMac(new nStratis.BouncyCastle.crypto.digests.Sha512Digest());
mac.Init(new nStratis.BouncyCastle.crypto.parameters.KeyParameter(bytes));
return(Pbkdf2.ComputeDerivedKey(mac, salt, 2048, 64));
#else
return(Pbkdf2.ComputeDerivedKey(new HMACSHA512(bytes), salt, 2048, 64));
#endif
}
public byte[] DeriveSeed(string passphrase = null)
{
passphrase = passphrase ?? "";
var salt = Concat(Encoding.UTF8.GetBytes("mnemonic"), Normalize(passphrase));
var bytes = Normalize(_Mnemonic);
#if !USEBC
return(Pbkdf2.ComputeDerivedKey(new HMACSHA512(bytes), salt, 2048, 64));
#else
var mac = MacUtilities.GetMac("HMAC-SHA_512");
mac.Init(new KeyParameter(bytes));
return(Pbkdf2.ComputeDerivedKey(mac, salt, 2048, 64));
#endif
}
public byte[] DeriveSeed(string passphrase = null)
{
passphrase = passphrase ?? "";
var salt = Concat(Encoding.UTF8.GetBytes("mnemonic"), Normalize(passphrase));
var bytes = Normalize(this._Mnemonic);
#if NETCORE
var mac = new HMac(new Sha512Digest());
mac.Init(new KeyParameter(bytes));
return(Pbkdf2.ComputeDerivedKey(mac, salt, 2048, 64));
#else
return(Pbkdf2.ComputeDerivedKey(new HMACSHA512(bytes), salt, 2048, 64));
#endif
}
private Key GetKeyFromPassword(string password)
{
var bytes = Encoding.UTF8.GetBytes(password);
#pragma warning disable CS0618 // Type or member is obsolete
#if USEBC || WINDOWS_UWP || NETSTANDARD1X
var mac = new NBitcoin.BouncyCastle.Crypto.Macs.HMac(new NBitcoin.BouncyCastle.Crypto.Digests.Sha512Digest());
mac.Init(new NBitcoin.BouncyCastle.Crypto.Parameters.KeyParameter(bytes));
var secret = Pbkdf2.ComputeDerivedKey(mac, new byte[0], 1024, 32);
#else
var secret = Pbkdf2.ComputeDerivedKey(new HMACSHA512(bytes), new byte[0], 1024, 32);
#endif
#pragma warning restore CS0618
return(new Key(secret));
}
public byte[] DeriveSeed(string passphrase = null)
{
passphrase = passphrase ?? "";
var salt = Concat(NoBOMUTF8.GetBytes("mnemonic"), Normalize(passphrase));
var bytes = Normalize(_Mnemonic);
#if NO_NATIVE_HMACSHA512
var mac = new NBitcoin.BouncyCastle.Crypto.Macs.HMac(new NBitcoin.BouncyCastle.Crypto.Digests.Sha512Digest());
mac.Init(new NBitcoin.BouncyCastle.Crypto.Parameters.KeyParameter(bytes));
return(Pbkdf2.ComputeDerivedKey(mac, salt, 2048, 64));
#elif NO_NATIVE_RFC2898_HMACSHA512
return(NBitcoin.Crypto.Pbkdf2.ComputeDerivedKey(new System.Security.Cryptography.HMACSHA512(bytes), salt, 2048, 64));
#else
using System.Security.Cryptography.Rfc2898DeriveBytes derive = new System.Security.Cryptography.Rfc2898DeriveBytes(bytes, salt, 2048, System.Security.Cryptography.HashAlgorithmName.SHA512);
return(derive.GetBytes(64));
#endif
}
static void TestFile(string filename)
{
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(filename))
{
using (StreamReader reader = new StreamReader(stream))
{
int startTime = Environment.TickCount;
string line; int count = 0;
while ((line = reader.ReadLine()) != null)
{
Console.Write(".");
string[] parts = line.Split(new[] { ',' }, 4);
if (parts.Length != 4)
{
continue;
}
byte[] key = Convert.FromBase64String(parts[0]);
byte[] salt = Convert.FromBase64String(parts[1]);
int iterations = int.Parse(parts[2]);
byte[] expectedKey = Convert.FromBase64String(parts[3]);
byte[] derivedKey = Pbkdf2.ComputeDerivedKey(new HMACSHA256(key), salt, iterations, 128);
for (int i = 0; i < expectedKey.Length; i++)
{
if (expectedKey[i] != derivedKey[i])
{
Console.WriteLine("PBKDF2 entry #{0} does not match.", count + 1);
break;
}
}
count++;
}
Console.Write("...({0} ms for {1} vectors)...", Environment.TickCount - startTime, count);
}
}
}
public void Return_Expected_Results_From_TestVectors_File()
{
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("CryptSharpStandard.SCryptSubset.UnitTests.TestVectors-PBKDF2.txt"))
{
using (StreamReader reader = new StreamReader(stream))
{
int startTime = Environment.TickCount;
string line; int count = 0;
while ((line = reader.ReadLine()) != null)
{
string[] parts = line.Split(new[] { ',' }, 4);
if (parts.Length != 4)
{
continue;
}
byte[] key = Convert.FromBase64String(parts[0]);
byte[] salt = Convert.FromBase64String(parts[1]);
int iterations = int.Parse(parts[2]);
byte[] expectedKey = Convert.FromBase64String(parts[3]);
byte[] derivedKey = Pbkdf2.ComputeDerivedKey(new HMACSHA256(key), salt, iterations, 128);
for (int i = 0; i < expectedKey.Length; i++)
{
if (expectedKey[i] != derivedKey[i])
{
derivedKey[i].Should().Be(expectedKey[i], "PBKDF2 entry #{0} does not match.", count + 1);
break;
}
}
count++;
}
}
}
}
public static byte[] DeriveKeyWithConfig(byte[] key, byte[] salt, int outputSize, Pbkdf2Configuration config)
{
var hmac = AuthenticatorFactory.CreateHmacPrimitive(config.FunctionName.ToEnum <HashFunction>(), key, null);
return(Pbkdf2.ComputeDerivedKey(hmac, salt, config.Iterations, outputSize));
}
private static byte[] DeriveKey(byte[] key, byte[] salt, int outputSize, int iterations)
{
var hmac = AuthenticatorFactory.CreateHmacPrimitive(DefaultFunction, key, null);
return(Pbkdf2.ComputeDerivedKey(hmac, salt, iterations, outputSize));
}
/// <summary>
/// Create Password Object from database
/// </summary>
/// <param name="passwordBytes"></param>
/// <param name="saltBytes"></param>
public Password(byte[] passwordBytes, byte[] saltBytes)
{
this.password = passwordBytes;
this.Salt = saltBytes;
this.DerivedKey = Pbkdf2.ComputeDerivedKey(new HMACSHA256(password), Salt, iterations, keyLength);
}