private static byte[] MFcrypt(byte[] P, byte[] S,
int cost, int blockSize, int parallel, int?maxThreads)
{
int MFLen = blockSize * 128;
if (maxThreads == null)
{
maxThreads = int.MaxValue;
}
if (cost <= 0 || (cost & (cost - 1)) != 0)
{
throw new ArgumentOutOfRangeException("cost", "Cost must be a positive power of 2.");
}
Helper.CheckRange("blockSize", blockSize, 1, int.MaxValue / 32);
Helper.CheckRange("parallel", parallel, 1, int.MaxValue / MFLen);
Helper.CheckRange("maxThreads", (int)maxThreads, 1, int.MaxValue);
byte[] B = new byte[parallel * MFLen];
Pbkdf2.ComputeKey(P, S, 1, HmacCallback, HLen, B);
uint[] B0 = new uint[B.Length / 4];
for (int i = 0; i < B0.Length; i++)
{
B0[i] = Helper.BytesToUInt32LE(B, i * 4);
} // code is easier with uint[]
ThreadSMixCalls(B0, MFLen, cost, blockSize, parallel, (int)maxThreads);
for (int i = 0; i < B0.Length; i++)
{
Helper.UInt32ToBytesLE(B0[i], B, i * 4);
}
Clear(B0);
return(B);
}
static byte[] MFcrypt(byte[] P, byte[] S,
int cost, int blockSize, int parallel, int?maxThreads)
{
int MFLen = blockSize * 128;
if (maxThreads == null)
{
maxThreads = int.MaxValue;
}
if (!BitMath.IsPositivePowerOf2(cost))
{
throw Exceptions.ArgumentOutOfRange("cost", "Cost must be a positive power of 2.");
}
Check.Range("blockSize", blockSize, 1, int.MaxValue / 128);
Check.Range("parallel", parallel, 1, int.MaxValue / MFLen);
Check.Range("maxThreads", (int)maxThreads, 1, int.MaxValue);
byte[] B = Pbkdf2.ComputeDerivedKey(new HMACSHA256(P), S, 1, parallel * MFLen);
uint[] B0 = new uint[B.Length / 4];
for (int i = 0; i < B0.Length; i++)
{
B0[i] = BitPacking.UInt32FromLEBytes(B, i * 4);
} // code is easier with uint[]
ThreadSMixCalls(B0, MFLen, cost, blockSize, parallel, (int)maxThreads);
for (int i = 0; i < B0.Length; i++)
{
BitPacking.LEBytesFromUInt32(B0[i], B, i * 4);
}
Security.Clear(B0);
return(B);
}
public static void ComputeKey(byte[] key, byte[] salt,
int cost, int blockSize, int parallel, int?maxThreads, byte[] output)
{
using (Pbkdf2 kdf = GetStream(key, salt, cost, blockSize, parallel, maxThreads))
{
kdf.Read(output);
}
}
/// <summary>
/// Creates a derived key stream from which a derived key can be read.
/// </summary>
/// <param name="key">The key to derive from.</param>
/// <param name="salt">
/// The salt.
/// A unique salt means a unique scrypt stream, even if the original key is identical.
/// </param>
/// <param name="cost">
/// The cost parameter, typically a fairly large number such as 262144.
/// Memory usage and CPU time scale approximately linearly with this parameter.
/// </param>
/// <param name="blockSize">
/// The mixing block size, typically 8.
/// Memory usage and CPU time scale approximately linearly with this parameter.
/// </param>
/// <param name="parallel">
/// The level of parallelism, typically 1.
/// CPU time scales approximately linearly with this parameter.
/// </param>
/// <param name="maxThreads">
/// The maximum number of threads to spawn to derive the key.
/// This is limited by the <paramref name="parallel"/> value.
/// <c>null</c> will use as many threads as possible.
/// </param>
/// <returns>The derived key stream.</returns>
public static Pbkdf2 GetStream(byte[] key, byte[] salt,
int cost, int blockSize, int parallel, int?maxThreads)
{
byte[] B = GetEffectivePbkdf2Salt(key, salt, cost, blockSize, parallel, maxThreads);
Pbkdf2 kdf = new Pbkdf2(new HMACSHA256(key), B, 1);
Security.Clear(B); return(kdf);
}
public static Pbkdf2 GetStream(byte[] key, byte[] salt,
int cost, int blockSize, int parallel, int?maxThreads)
{
byte[] B = GetEffectivePbkdf2Salt(key, salt, cost, blockSize, parallel, maxThreads);
Pbkdf2 kdf = new Pbkdf2(key, B, 1, _hmacCallback, hLen);
Clear(B); return(kdf);
}
public static void ComputeKey(byte[] key, byte[] salt, int iterations,
ComputeHmacCallback computeHmacCallback, int hmacLength, byte[] output)
{
using (Pbkdf2 kdf = new Pbkdf2(key, salt, iterations, computeHmacCallback, hmacLength))
{
kdf.Read(output);
}
}
/// <summary>
/// Computes a derived key.
/// </summary>
/// <param name="hmacAlgorithm">
/// The HMAC algorithm to use, for example <see cref="HMACSHA256"/>.
/// Make sure to set <see cref="KeyedHashAlgorithm.Key"/>.
/// </param>
/// <param name="salt">
/// The salt.
/// A unique salt means a unique derived key, even if the original key is identical.
/// </param>
/// <param name="iterations">The number of iterations to apply.</param>
/// <param name="derivedKeyLength">The desired length of the derived key.</param>
/// <returns>The derived key.</returns>
public static byte[] ComputeDerivedKey(KeyedHashAlgorithm hmacAlgorithm, byte[] salt, int iterations,
int derivedKeyLength)
{
Check.Range("derivedKeyLength", derivedKeyLength, 0, int.MaxValue);
using (Pbkdf2 kdf = new Pbkdf2(hmacAlgorithm, salt, iterations))
{
return(kdf.Read(derivedKeyLength));
}
}
/// <summary>
/// Computes a derived key.
/// </summary>
/// <param name="key">The key to derive from.</param>
/// <param name="salt">
/// The salt.
/// A unique salt means a unique SCrypt stream, even if the original key is identical.
/// </param>
/// <param name="cost">
/// The cost parameter, typically a fairly large number such as 262144.
/// Memory usage and CPU time scale approximately linearly with this parameter.
/// </param>
/// <param name="blockSize">
/// The mixing block size, typically 8.
/// Memory usage and CPU time scale approximately linearly with this parameter.
/// </param>
/// <param name="parallel">
/// The level of parallelism, typically 1.
/// CPU time scales approximately linearly with this parameter.
/// </param>
/// <param name="maxThreads">
/// The maximum number of threads to spawn to derive the key.
/// This is limited by the <paramref name="parallel"/> value.
/// <c>null</c> will use as many threads as possible.
/// </param>
/// <param name="derivedKeyLength">The desired length of the derived key.</param>
/// <returns>The derived key.</returns>
public static byte[] ComputeDerivedKey(byte[] key, byte[] salt,
int cost, int blockSize, int parallel, int?maxThreads,
int derivedKeyLength)
{
Check.Range("derivedKeyLength", derivedKeyLength, 0, int.MaxValue);
using (Pbkdf2 kdf = GetStream(key, salt, cost, blockSize, parallel, maxThreads))
{
return(kdf.Read(derivedKeyLength));
}
}
