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 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 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 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));
}
/// <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[] 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));
}
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>
/// 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));
}
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>
/// 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>
/// give password hash, using salt.
/// </summary>
/// <param name="password"></param>
/// <param name="salt"></param>
/// <returns></returns>
public static byte[] HashPassword(string password, byte[] salt)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = 8, // four cores
Iterations = 2,
MemorySize = 1024 * 64, // 64 MB
};
return(argon2.GetBytes(32));
}
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 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));
}
private byte[] HashPassword(string password, byte[] salt, int parallelism, int memorySize, int iterations)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password)) // Argon2 bruges til at hashe passwordet, ved metode kald kraves password og salt samt følgende argon2 specifikke parametre:
{ // Parallelism = Antal CPU tråde; MemorySize = RAM til hashing; Iterations = Antal gange hashprocessen køres igennem;
Salt = salt,
DegreeOfParallelism = parallelism,
Iterations = iterations,
MemorySize = memorySize
};
return(argon2.GetBytes(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));
}
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));
}
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));
}
public static byte[] GetStronglyHashedRecord(byte[] input, byte[] salt)
{
var argon2 = new Argon2id(input);
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8;
argon2.Iterations = 4;
argon2.MemorySize = 1024 * 1024;
byte[] hash = argon2.GetBytes(saltLength);
return(hash);
}
// First item is password hash, and second item is a salt
public static Tuple <byte[], byte[]> CreatePasswordHash(string password)
{
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
var salt = createSalt();
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8; // four cores
argon2.Iterations = 4;
argon2.MemorySize = 1024 * 1024; // 1 GB
return(new Tuple <byte[], byte[]>(argon2.GetBytes(32), salt));
}
private static byte[] HashPassword(string password, byte[] salt, int byteLength)
{
using var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8; // 8 = max CPU usage on CPU with 4 cores and hyper threading
argon2.MemorySize = 150_000; // kB
// This gives about 0.3 hashes per second on a Raspberry Pi 4 and about
// 4 hashes per second on a medium desktop CPU.
argon2.Iterations = 2;
return(argon2.GetBytes(byteLength));
}
public static byte[] CalculateArgon2Hash(string text, string salt)
{
var textBytes = Encoding.Unicode.GetBytes(text);
var saltBytes = Encoding.Unicode.GetBytes(salt);
var argon2 = new Argon2id(textBytes)
{
DegreeOfParallelism = 12,
MemorySize = 512,
Iterations = 20,
Salt = saltBytes
};
return(argon2.GetBytes(512));
}
private byte[] HashPassword(string password, byte[] salt)
{
//if password is empty, return error. wwq
Argon2id argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = 2,
Iterations = 6,
MemorySize = 128 * 128
};
argon2.Dispose();
return(argon2.GetBytes(16));
}
public string Argon2Impl(string password)
{
byte[] salt = new byte[16];
salt = Encoding.UTF8.GetBytes("fjH!wa+OAC#P*Avu");
var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password));
argon2.Salt = salt;
argon2.DegreeOfParallelism = 8;
argon2.Iterations = 4;
argon2.MemorySize = 1024;
string hash = Convert.ToBase64String(argon2.GetBytes(16));
// MessageBox.Show(hash);
return(hash);
}
private string GenerateArgon2idHash(string password, string salt)
{
var saltBytes = Encoding.UTF8.GetBytes(salt);
var passwordBytes = Encoding.UTF8.GetBytes(password);
var argon2id = new Argon2id(passwordBytes);
argon2id.DegreeOfParallelism = _degreeOfParallelism;
argon2id.Iterations = _iterations;
argon2id.MemorySize = _memorySize;
argon2id.Salt = saltBytes;
var hash = argon2id.GetBytes(_hashLength);
return(Convert.ToBase64String(hash));
}
public static byte[] HashPassword(string password, string username)
{
using (var argon2 = new Argon2id(
Encoding.Default.GetBytes(password))
{
DegreeOfParallelism = 1,
MemorySize = 1024 * 32,
Iterations = 1
})
{
argon2.Salt = Encoding.Default.GetBytes(username);
argon2.KnownSecret = Encoding.Default.GetBytes("Funat");
return(argon2.GetBytes(32));
}
}
/// <summary>Hashes a password using the Argon2 hashing scheme.</summary>
/// <param name="password">Plaintext password to be hashed</param>
/// <param name="salt">Salt to be added to the password</param>
/// <param name="saltLength">Number of bytes used for length of salt</param>
/// <param name="parallelism">Degree of parallelism (cores = value / 2)</param>
/// <param name="iterations">Number of iterations</param>
/// <param name="memorySize">Memory size in KB</param>
/// <returns>Hashed password</returns>
public static string HashPassword(string password, byte[] salt, int saltLength = 16, int parallelism = 8, int iterations = 4, int memorySize = 1024 * 1024)
{
Argon2id argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
DegreeOfParallelism = parallelism,
Iterations = iterations,
MemorySize = memorySize
};
byte[] hashed = argon2.GetBytes(16);
string saltString = Convert.ToBase64String(salt);
string hashedString = Convert.ToBase64String(hashed);
return($"$argon2$sl={saltLength}$p={parallelism}$i={iterations}$m={memorySize}${saltString}${hashedString}");
}
