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