private static string ComputeHash(HashProvider hashAlgorithm, string plainText, byte[] salt)
{
// Convert plain text into a byte array
byte[] data = Encoding.UTF8.GetBytes(plainText);
int dataLength = data.Length;
// Random salt
int saltLength = salt.Length;
// Append the salt to the end of the plainText
byte[] dataSalt = new byte[dataLength + saltLength];
// Copy both the data and salt into the new array
Array.Copy(data, dataSalt, dataLength);
Array.Copy(salt, 0, dataSalt, dataLength, saltLength);
// Compute hash value of our plain text with appended salt.
byte[] encrypt = GetHashProvider(hashAlgorithm).ComputeHash(dataSalt);
int encryptLength = encrypt.Length;
// Append the salt to the end of the encrypt
byte[] encryptSalt = new byte[encryptLength + saltLength];
Array.Copy(encrypt, encryptSalt, encryptLength);
Array.Copy(salt, 0, encryptSalt, encryptLength, saltLength);
return Convert.ToBase64String(encryptSalt);
}
private static HashAlgorithm GetHashProvider(HashProvider hashAlgorithm)
{
HashAlgorithm hash;
switch (hashAlgorithm)
{
case HashProvider.SHA1:
hash = new SHA1Managed();
break;
case HashProvider.SHA256:
hash = new SHA256Managed();
break;
case HashProvider.SHA384:
hash = new SHA384Managed();
break;
case HashProvider.SHA512:
hash = new SHA512Managed();
break;
case HashProvider.MD5:
default:
hash = new MD5CryptoServiceProvider();
break;
}
return hash;
}
/// <summary>
/// Creates a SaltedHasher, configuring it to use the specified hashing provider, salt position and salt length, and password generator
/// </summary>
/// <param name="provider">Hash algorithm to use by default</param>
/// <param name="saltLength">Length for the salt</param>
/// <param name="saltPosition">Position for the salt</param>
/// <param name="passwordGenerator">Password generator for generating the salts</param>
SaltedHasher(HashProvider provider, int saltLength, SaltPosition saltPosition, PasswordGenerator passwordGenerator)
{
Provider = provider;
SaltPosition = saltPosition;
SaltLength = saltLength;
PasswordGenerator = passwordGenerator;
}
static UsersConfiguration()
{
var appSettings = ConfigurationManager.AppSettings;
UserLockoutEnabledByDefault = ToBool(appSettings["UserLockoutEnabledByDefault"], true);
DefaultAccountLockoutTimeSpan = ToInt(appSettings["DefaultAccountLockoutTimeSpan"], 5);
MaxFailedAccessAttemptsBeforeLockout = ToInt(appSettings["MaxFailedAccessAttemptsBeforeLockout"], 5);
SaltSize = ToInt(appSettings["SaltSize"], 12);
HashProvider = ToHashProvider(appSettings["HashProvider"]);
}
public static HashAlgorithm GetInstance(HashProvider algorithm)
{
switch (algorithm)
{
case HashProvider.SHA1:
return new SHA1CryptoServiceProvider();
case HashProvider.MD5:
return new MD5CryptoServiceProvider();
case HashProvider.HMACSHA1:
return new HMACSHA1();
case HashProvider.HMACMD5:
return new HMACMD5();
default:
return null;
}
}
/// <summary>
/// Generate random hash value to store against password
/// </summary>
/// <param name="password">String to encrypt</param>
/// <param name="salt">Random string to salt computed hash, automatically generated if empty</param>
/// <param name="provider">Hash algorithm to use for computing hash value</param>
/// <returns>Hash value for the password with the addition of salt 'MD5$Salt$Hash'</returns>
public static string GenerateHash(string password, string salt = null, HashProvider provider = HashProvider.MD5)
{
Guard.CheckNullOrTrimEmpty(password, "Password cannot be empty");
salt = salt ?? GenerateSalt();
var bytes = Encoding.Unicode.GetBytes(salt + password);
try
{
var hash = hashProviders[provider].ComputeHash(bytes);
return provider + "$" + salt + "$" + hash.ToHexString();
}
catch (KeyNotFoundException ex)
{
throw new NotSupportedException(string.Format("Hash Provider '{0}' is not supported", provider), ex);
}
}
public static bool CompareStringToHash(HashProvider hashAlgorithm, string plainText, string encrypt, int saltSize = 0)
{
byte[] encryptBuffer = Convert.FromBase64String(encrypt);
int encryptLength = encryptBuffer.Length;
// Pluck the salt size off of the end of the hash.
if (saltSize < 0)
{
saltSize = 0;
}
byte[] saltBuffer = new byte[saltSize];
Array.Copy(encryptBuffer, encryptLength - saltSize, saltBuffer, 0, saltSize);
string hash = ComputeHash(hashAlgorithm, plainText, saltBuffer);
return string.Equals(encrypt, hash);
}
/// <summary>
/// Initialize a new instance of the class <see cref="Hash"/>.
/// </summary>
/// <param name="provider">Provider</param>
public Hash(HashProvider provider)
: this()
{
switch (provider)
{
case HashProvider.MD5:
_algorithm = new MD5CryptoServiceProvider();
break;
case HashProvider.SHA1:
_algorithm = new SHA1Managed();
break;
case HashProvider.SHA256:
_algorithm = new SHA256Managed();
break;
case HashProvider.SHA384:
_algorithm = new SHA384Managed();
break;
case HashProvider.SHA512:
_algorithm = new SHA512Managed();
break;
}
}
/// <summary>
/// Creates and returns the HashAlgorithm object for the specified provider
/// </summary>
/// <param name="provider">The desired hash algorithm provider</param>
/// <returns>The required hashing object</returns>
public static HashAlgorithm GetHashAlgorithm(HashProvider provider)
{
switch( provider )
{
case HashProvider.MD5:
return System.Security.Cryptography.MD5.Create();
case HashProvider.SHA1:
return SHA1.Create();
case HashProvider.SHA256:
return SHA256.Create();
case HashProvider.SHA384:
return SHA384.Create();
case HashProvider.SHA512:
return SHA512.Create();
}
throw new ArgumentException("Unsupported HashProvider: {0}! ".FormatCurrentCulture(provider) +
"If you add a new algorithm to the HashProvider, make sure you add it to the " +
"switch statement in the Hasher.GetHashAlgorithm method!", "provider");
}
public SqlPasswordHasher(int saltLength, HashProvider hashProvider)
{
_saltLength = saltLength;
_hashProvider = hashProvider;
}
internal async Task <bool> Register()
{
bool isNew = false;
if (string.IsNullOrEmpty(FirstName))
{
_errorMessage = "Please enter a Name";
return(false);
}
else if (string.IsNullOrEmpty(Surname))
{
_errorMessage = "Please enter a Surname";
return(false);
}
else if (string.IsNullOrEmpty(EmailAddress))
{
_errorMessage = "Please enter a Email";
return(false);
}
else if (string.IsNullOrEmpty(Password))
{
_errorMessage = "Please enter a Password";
return(false);
}
else if (Password != ConfirmPassword)
{
_errorMessage = "The password and Confirm Password must match";
return(false);
}
var user = _context.Users.FirstOrDefault(x => ((x.EmailAddress == EmailAddress && x.EmailAddress != null)));
if (user == null)
{
user = new User();
isNew = true;
user.UserID = Guid.NewGuid();
user.IsSuspended = false;
user.LoginTries = 0;
user.CreatedUserID = user.UserID;
user.CreatedDateTime = DateTime.UtcNow;
user.IsRemoved = false;
user.Password = HashProvider.ComputeHash(Password, HashProvider.HashAlgorithmList.SHA256, _securityOptions.PasswordSalt);
}
else
{
_errorMessage = "The user email address already exists. Find the existing user first and edit their details";
return(false);
}
user.DisplayName = DisplayName;
user.EmailAddress = EmailAddress;
user.IsSuspended = false;
user.LoginTries = 0;
user.EditUserID = user.UserID;
user.EditDateTime = DateTime.UtcNow;
user.FirstName = FirstName;
user.Surname = Surname;
user.Timezone = _context.SystemConfiguration.First(x => x.EventCode == PublicEnums.SystemConfigurationList.KEY_DEFAULT_TIME_ZONE.ToString()).ConfigValue;
if (isNew)
{
_context.Add(user);
//Add default student user role
LinkUserRole link = new LinkUserRole();
link.LinkUserRoleID = Guid.NewGuid();
link.UserID = user.UserID;
link.UserRoleID = _context.UserRoles.First(x => x.EventCode == PublicEnums.UserRoleList.ROLE_USER).UserRoleID;
link.CreatedUserID = user.UserID;
link.EditUserID = user.UserID;
_context.Add(link);
}
else
{
_context.Update(user);
}
await _context.SaveChangesAsync();
return(true);
}
/// <summary>
/// Creates a SaltedHasher, configuring it to use the specified hashing provider and using a default prefixed salt of 8 characters
/// </summary>
/// <param name="provider">Hash algorithm to use by default</param>
public SaltedHasher(HashProvider provider)
: this(provider, DefaultSaltLength, SaltPosition.Prefix, new PasswordGenerator())
{
}
public HashProvider BuildHashProvider(string value)
{
var bytes = value.GetBytes();
return(HashProvider.New(bytes));
}
public static Oid GetOID(this HashProvider ForProvider)
{
return(Oid.FromFriendlyName(ForProvider.ToString(), OidGroup.HashAlgorithm));
}
private Data DoHash(HashProvider p)
{
using (var h = new Hash(p))
{
return h.Calculate(new Data(_targetString));
}
}
/// <summary>
/// Loads the certificate using a SecureString for decryption
/// This function is only needed when the certificate is encrypted with a password.
/// </summary>
public void LoadCertificate(SecureString EncryptionPassword, HashProvider Provider)
{
this.EncryptionPassword = EncryptionPassword;
this.Provider = Provider;
LoadCertificate(Provider);
}
public void HashProvider_ReturnsPasswordMatch(string password, string salt, string hashedPassword)
{
HashProvider hashProvider = new HashProvider();
Assert.IsTrue(hashProvider.VerifyPasswordMatch(hashedPassword, password, salt));
}
/// <summary>
/// Initializes a new instance of the Hash class with the specified hash provider.
/// </summary>
public Hash(HashProvider provider)
{
_hash = HashingFactory.Create(provider);
}
Hash[] allKeys = null; //cache the ordered keys for better performance
public ConsistentHash(HashProvider _Provider)
{
Provider = _Provider;
}
private string GetResultString(HashProvider Provider, long ItemCount)
{
var perSec = (ItemCount / TestLength.TotalSeconds);
return($"{Provider}: added {ItemCount.ToString("n0")} items, replication count: {replicationCount.ToString("n0")}, ({perSec.ToString("n0")} unique per sec, {(perSec * replicationCount).ToString("n0")} replicated)\r\n");
}
public void when_bytes_is_empty_should_throw_ArgumentNullException()
{
byte[] bytes = new byte[0];
Assert.Throws <ArgumentNullException>(() => HashProvider.New(bytes));
}
/// <summary>
/// Creates a new instance of the HashAlgorithm class based on the specified provider.
/// </summary>
/// <param name="provider">Provides the type of hash algorithm to create.</param>
/// <returns>The HashAlgorithm object.</returns>
/// <exception cref="T:System.ArgumentException">The provider is unknown.</exception>
public static HashAlgorithm Create(HashProvider provider)
{
switch (provider)
{
case HashProvider.CRC32:
return new CRC32();
case HashProvider.SHA1:
return SHA1.Create();
case HashProvider.SHA256:
return SHA256.Create();
case HashProvider.SHA384:
return SHA384.Create();
case HashProvider.SHA512:
return SHA512.Create();
case HashProvider.MD5:
return MD5.Create();
}
throw new ArgumentException("Unknown HashProvider.", "provider");
}
/// <summary>
/// Initializes a new instance of the Hash class with the specified hash provider.
/// </summary>
public Hash(HashProvider provider)
{
_hash = HashAlgorithmFactory.Create(provider);
}
public void should_call_hash_provider_for_each_file()
{
HashProvider.Verify(x => x.hash_file(It.IsAny <string>()), Times.Exactly(files.Count));
}
private Data DoSaltedHash(HashProvider p, Data salt)
{
using (var h = new Hash(p))
{
return h.Calculate(new Data(_targetString), salt);
}
}
public static string ComputeHash(HashProvider hashAlgorithm, string plainText, int saltSize = 0)
{
// Random salt.
byte[] salt = saltSize > 0 ? Random.RNGCrypto(saltSize) : new byte[0];
return ComputeHash(hashAlgorithm, plainText, salt);
}
/// <summary>
/// Creates a Hasher, configuring it to use the specified hashing provider
/// </summary>
/// <param name="provider">Hash algorithm to use by default</param>
public Hasher(HashProvider provider)
{
Provider = provider;
}
/// <summary>
/// Creates a SaltedHasher, configuring it to use the specified hashing provider, salt position and salt length
/// </summary>
/// <param name="provider">Hash algorithm to use by default</param>
/// <param name="saltLength">Length for the salt</param>
/// <param name="saltPosition">Position for the salt</param>
public SaltedHasher(HashProvider provider, int saltLength, SaltPosition saltPosition)
: this(provider, saltLength, saltPosition, new PasswordGenerator())
{
}
/// <summary>
/// Get hash text with encoding and provider
/// </summary>
/// <param name="text">Text</param>
/// <param name="encoding">Encoding</param>
/// <param name="provider">Provider</param>
/// <returns>Hash</returns>
public static string Hash(this string text, Encoding encoding, HashProvider provider)
{
var hash = new Hash(provider) {Encoding = encoding};
return hash.Get(text);
}
/// <summary>
/// Compute a hash for this object and optionally signs it
/// </summary>
/// <param name="Provider">The hash provider to use</param>
/// <param name="SigningCert">If provided the cert to sign the hash with</param>
public void ComputeHash(HashProvider Provider, Cert SigningCert = null)
{
ComputedHash = Hash.Compute(GetHashableData(), Provider, SigningCert);
}