public static byte[] ToRawArgon2(byte[] data, byte[] salt, uint iterations, uint memorySizeKiB, uint parallelism, Argon2Variant variant = Argon2Variant.Argon2id, uint derivedKeyLength = Argon2DerivedKeyLength)
{
switch (variant)
{
case Argon2Variant.Argon2d:
Argon2d argon2d = new Argon2d(data);
argon2d.Salt = salt;
argon2d.Iterations = (int)iterations;
argon2d.MemorySize = (int)memorySizeKiB;
argon2d.DegreeOfParallelism = (int)parallelism;
return(argon2d.GetBytes((int)derivedKeyLength));
case Argon2Variant.Argon2i:
Argon2i argon2i = new Argon2i(data);
argon2i.Salt = salt;
argon2i.Iterations = (int)iterations;
argon2i.MemorySize = (int)memorySizeKiB;
argon2i.DegreeOfParallelism = (int)parallelism;
return(argon2i.GetBytes((int)derivedKeyLength));
case Argon2Variant.Argon2id:
Argon2id argon2id = new Argon2id(data);
argon2id.Salt = salt;
argon2id.Iterations = (int)iterations;
argon2id.MemorySize = (int)memorySizeKiB;
argon2id.DegreeOfParallelism = (int)parallelism;
return(argon2id.GetBytes((int)derivedKeyLength));
default:
throw new Exception("Invalid Argon2 variant");
}
}
public async Task <byte[]> DeriveHashAsync(byte[] value, byte[] salt, int byteCount)
{
// just to be safe
var k = new byte[value.Length];
value.AsSpan().CopyTo(k);
var s = salt != null
? new byte[salt.Length]
: null;
if (s != null)
{
salt.AsSpan().CopyTo(s);
}
var argon2 = new Argon2id(k)
{
DegreeOfParallelism = this.Parallelism ?? (Environment.ProcessorCount * 2),
MemorySize = this.MemorySize ?? 131072, /* 128 MiB */
Iterations = this.Iterations ?? ComputeIterations(Environment.ProcessorCount),
Salt = s
};
return(await argon2.GetBytesAsync(byteCount));
}
private void calculatePow_v3(byte[] hash_ceil)
{
// PoW = Argon2id( BlockChecksum + SolverAddress, Nonce)
byte[] nonce_bytes = randomNonce(64);
byte[] fullnonce = expandNonce(nonce_bytes, 234236);
byte[] hash = Argon2id.getHash(activeBlockChallenge, fullnonce, 2, 2048, 2);
if (hash.Length < 1)
{
Console.WriteLine("Stopping miner due to invalid hash.");
stop();
return;
}
hashesPerSecond++;
// We have a valid hash, update the corresponding block
if (Miner.validateHashInternal_v2(hash, hash_ceil) == true)
{
Console.WriteLine("SHARE FOUND FOR BLOCK {0}", currentBlockNum);
// Broadcast the nonce to the network
sendSolution(nonce_bytes);
hasBlock = false;
foundShares++;
}
}
/// <summary>
/// Sets the default variables for the given <see cref="Argon2id"/>
/// hasher instance.
/// </summary>
/// <param name="hasher"></param>
private void HydrateHasher(Argon2id hasher)
{
hasher.DegreeOfParallelism = Environment.ProcessorCount;
hasher.Iterations = 5;
hasher.MemorySize = 131_072; // 128MiB
hasher.Salt = CryptoRandom.GetBytes(32);
}
private static ExitCode RunArgon2idHashOptionsAndReturnExitCode(Argon2idHashOptions argon2idHashOptions)
{
var argon2idHashResult = new Argon2id().ComputeHash(System.Text.Encoding.UTF8.GetBytes(argon2idHashOptions.InputToComputeHash), argon2idHashOptions.Iterations,
argon2idHashOptions.MemorySize, argon2idHashOptions.DegreeOfParallelism, argon2idHashOptions.AmountBytesToReturn, System.Text.Encoding.UTF8.GetBytes(argon2idHashOptions.Salt),
System.Text.Encoding.UTF8.GetBytes(argon2idHashOptions.AssociatedData));
if (argon2idHashResult.Success && !string.IsNullOrWhiteSpace(argon2idHashOptions.CompareHash))
{
var hashesMatch = (argon2idHashResult.HashString.Equals(argon2idHashOptions.CompareHash, StringComparison.InvariantCultureIgnoreCase));
var outputMessage = (
hashesMatch
? $"Computed Argon2id hash MATCH with given hash: {argon2idHashResult.HashString}"
: $"Computed Argon2id hash DOES NOT MATCH with given hash.\nComputed hash: {argon2idHashResult.HashString}\nGiven hash: {argon2idHashOptions.CompareHash}"
);
Console.WriteLine(outputMessage);
return(hashesMatch ? ExitCode.Sucess : ExitCode.Error);
}
else if (argon2idHashResult.Success && string.IsNullOrWhiteSpace(argon2idHashOptions.CompareHash))
{
Console.WriteLine(argon2idHashResult.HashString);
return(ExitCode.Sucess);
}
else
{
Console.WriteLine(argon2idHashResult.Message);
return(ExitCode.Error);
}
}
public Argon2id MakeUnsaltedHasher(string password)
{
var argon2Id = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2Id.DegreeOfParallelism = DegreeOfParallelism;
argon2Id.MemorySize = MemorySize;
argon2Id.Iterations = Iterations;
return(argon2Id);
}
static byte[] GenerateArgon2idSensitive(string password, byte[] salt)
{
var argon2id = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2id.Salt = salt;
argon2id.DegreeOfParallelism = 1;
argon2id.Iterations = 4; // opsLimit
argon2id.MemorySize = 1048576; // memLimit
return(argon2id.GetBytes(32));
}
public void IterationSetup()
{
_argon = new Argon2id(Encoding.UTF8.GetBytes(_toHash))
{
DegreeOfParallelism = 4,
Iterations = Iterations,
MemorySize = RamKilobytes,
Salt = Guid.NewGuid().ToByteArray()
};
}
private byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 4; // / 2 = cantidad de núcleos (2 núcleos)
argon2.Iterations = 1; //Entre más alto más seguro
argon2.MemorySize = 700 * 700; // Ej: 1024 * 1024 = 1 GB
return(argon2.GetBytes(16));
}
private static byte[] _createPasswordHashWithCustomSalt(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8; // four cores
argon2.Iterations = 4;
argon2.MemorySize = 1024 * 1024; // 1 GB
return(argon2.GetBytes(32));
}
public byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8;
argon2.Iterations = 4;
argon2.MemorySize = 1024 * 1024;
return(argon2.GetBytes(16));
}
public static byte[] GenerateSaltedHash(byte[] plainText, byte[] salt)
{
Argon2id hash = new Argon2id(plainText);
hash.Salt = salt;
hash.DegreeOfParallelism = 1;
hash.Iterations = 2;
hash.MemorySize = 16000; // 1 GB
return(hash.GetBytes(32)); // 32 bytes == 256 bits ..
}
private static byte[] hashInternal(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 2;
argon2.Iterations = 4;
argon2.MemorySize = 1024;
return(argon2.GetBytes(16));
}
/// <summary>
/// Hash Password
/// </summary>
/// <param name="password"></param>
/// <param name="salt"></param>
/// <returns></returns>
private byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 1;
argon2.Iterations = 3;
argon2.MemorySize = 8192; // 8192kB
return(argon2.GetBytes(32));
}
public byte[] HashPassword(string password, byte[] salt, int memSize = 1024, int core = 8)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = core; // four cores
argon2.Iterations = 4;
argon2.MemorySize = memSize * memSize; // 1 GB
return(argon2.GetBytes(16));
}
private byte[] HashPassword(string password, byte[] salt)
{
using var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = 8, // four cores
Iterations = 4,
MemorySize = 100 * 100 // 1024
};
return(argon2.GetBytes(16));
}
private byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = DegreeOfParallelism;
argon2.Iterations = Iterations;
argon2.MemorySize = MemorySize;
return(argon2.GetBytes(16));
}
/// <summary>
/// Argon2 Password Hash
/// </summary>
/// <param name="password"></param>
/// <returns></returns>
public static byte[] Argon2HashPassword(string password)
{
s_argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = Encoding.UTF8.GetBytes(password.Substring(2, 10)),
DegreeOfParallelism = 2,
Iterations = 40,
MemorySize = 4096
};
return(s_argon2.GetBytes(32));
}
public byte[] EncryptWord(string word, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(word));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 1; // 1 Thread
argon2.Iterations = 4;
argon2.MemorySize = 1 * 1024; // 1 MB
return(argon2.GetBytes(16));
}
private byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8; // four cores
argon2.Iterations = 1;
argon2.MemorySize = 1024 * 1024; // 1 GB
return(argon2.GetBytes(16));
}
private static byte[] HashPasswordArgon2(string password, byte[] salt, int paralelismo, int interacoes, int tamanhoMemoria)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = paralelismo;
argon2.Iterations = interacoes;
argon2.MemorySize = tamanhoMemoria;
return(argon2.GetBytes(16));
}
public static byte[] HashPasswordArgon2(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 1; // four cores
argon2.Iterations = 2;
argon2.MemorySize = 512 * 512; // 1 GB
return(argon2.GetBytes(2));
}
/// <summary>
/// Creates a password hash based on the inputted string and salt.
/// </summary>
/// <param name="enteredPassword">Password string.</param>
/// <param name="salt">Salt represented as byte-array.</param>
/// <returns>Argon2 hash encoded in Base64.</returns>
static public string HashPassword(string enteredPassword, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(enteredPassword));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8; // four cores
argon2.Iterations = 4;
argon2.MemorySize = 1024; // 1 MB
return(Convert.ToBase64String(argon2.GetBytes(16)));
}
/// <summary>
/// Create a Hash byte array using Argon2id.
/// </summary>
/// <param name="passphrase"></param>
/// <param name="salt"></param>
/// <param name="size"></param>
public static async Task <byte[]> GetHashKeyAsync(byte[] passphrase, byte[] salt, int size)
{
using var argon2 = new Argon2id(passphrase)
{
DegreeOfParallelism = 4,
MemorySize = 2048,
Salt = salt,
Iterations = 12
};
return(await argon2.GetBytesAsync(size).ConfigureAwait(false));
}
public static byte[] Argon2(byte[] password, byte[] salt, int iterations, int memory, int outputLength)
{
var argon2 = new Argon2id(password)
{
DegreeOfParallelism = 1,
MemorySize = memory,
Iterations = iterations,
Salt = salt,
};
return(argon2.GetBytes(outputLength));
}
public byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
//DO NOT CHANGE THESE PARAMETERS. WILL MAKE ALL LOGIN INFORMATION OBSOLETE
argon2.Salt = salt;
argon2.DegreeOfParallelism = 2; // one core
argon2.Iterations = 4;
argon2.MemorySize = 128 * 128;
return(argon2.GetBytes(16));
}
public byte[] HashPassword(byte[] password, ref byte[] salt)
{
salt ??= CreateSalt();
using var argon2 = new Argon2id(password);
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8;
argon2.Iterations = 4;
argon2.MemorySize = 1024 * 128;
return(argon2.GetBytes(16));
}
public Task <byte[]> HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = 2,
Iterations = 2,
MemorySize = 1024
};
return(argon2.GetBytesAsync(16));
}
public static byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = 2, // cores
Iterations = 25,
MemorySize = 1024 * 12 // 12 MB
};
return(argon2.GetBytes(256));
}
private byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = 16,
MemorySize = 8192,
Iterations = 40
};
return(argon2.GetBytes(128));
}
