public void UniqueSaltedHashes()
{
IHashProvider hashProviderWithSalt = SaltedHashProvider;
byte[] providerHash1 = hashProviderWithSalt.CreateHash(plainText);
byte[] providerHash2 = hashProviderWithSalt.CreateHash(plainText);
Assert.IsFalse(CryptographyUtility.CompareBytes(providerHash1, providerHash2), "compare");
}
public async Task <User> AddUserAsync(ShortUserModel userModel)
{
if (await AnyAsync(a => a.Login == userModel.Login))
{
throw new Exception("User exist");
}
userModel.Password = _hashProvider.CreateHash(userModel.Password);
var user = _mapper.Map <User>(userModel);
return(await AddAsync(user));
}
internal static string CreateHash(IHashProvider provider, string plaintext)
{
byte[] bytes = Encoding.Unicode.GetBytes(plaintext);
byte[] inArray = provider.CreateHash(bytes);
CryptographyUtility.GetRandomBytes(bytes);
return(Convert.ToBase64String(inArray));
}
internal static string CreateHash(IHashProvider provider, string plaintext)
{
byte[] plainTextBytes = UnicodeEncoding.Unicode.GetBytes(plaintext);
byte[] resultBytes = provider.CreateHash(plainTextBytes);
CryptographyUtility.GetRandomBytes(plainTextBytes);
return(Convert.ToBase64String(resultBytes));
}
private void btnSave_Click(object sender, EventArgs e)
{
if (tbxPassword1.Text != tbxPassword2.Text)
{
MessageBox.Show(SR.PasswordsMustMatch);
return;
}
byte[] password = hashProvider.CreateHash(Encoding.Unicode.GetBytes(tbxPassword1.Text));
if (editMode)
{
userRoleMgr.ChangeUserPassword(tbxUser.Text, password);
}
else if (userRoleMgr.UserExists(tbxUser.Text))
{
MessageBox.Show(SR.UserAlreadyExists);
return;
}
else
{
userRoleMgr.CreateUser(tbxUser.Text, password);
}
DialogResult = DialogResult.OK;
}
public void HashSha1()
{
IHashProvider hashProvider = HashProviderHelper.DefaultHashProvider;
SHA1 sha1 = SHA1Managed.Create();
byte[] origHash = sha1.ComputeHash(plainText);
byte[] providerHash = hashProvider.CreateHash(plainText);
Assert.IsTrue(CryptographyUtility.CompareBytes(origHash, providerHash));
}
internal static byte[] CreateHash(string hashInstance, byte[] plaintext, ConfigurationContext context)
{
ArgumentValidation.CheckForNullReference(hashInstance, "hashInstance");
ArgumentValidation.CheckForEmptyString(hashInstance, "hashInstance");
HashProviderFactory factory = new HashProviderFactory(context);
IHashProvider hashProvider = factory.CreateHashProvider(hashInstance);
return(hashProvider.CreateHash(plaintext));
}
public void CompareHashWithSalt()
{
IHashProvider hashProvider = SaltedHashProvider;
byte[] providerHash = hashProvider.CreateHash(plainText);
Assert.IsTrue(hashProvider.CompareHash(plainText, providerHash), "true");
byte[] badHash = new byte[50];
RNGCryptoServiceProvider.Create().GetBytes(badHash);
Assert.IsFalse(hashProvider.CompareHash(plainText, badHash), "false");
}
public void HashWithSalt()
{
IHashProvider hashProviderWithSalt = SaltedHashProvider;
IHashProvider hashProvider = DefaultHashProvider;
byte[] origHash1 = hashProvider.CreateHash(plainText);
byte[] providerHash1 = hashProviderWithSalt.CreateHash(plainText);
Assert.IsFalse(CryptographyUtility.CompareBytes(origHash1, providerHash1), "original");
Assert.IsFalse(CryptographyUtility.CompareBytes(plainText, providerHash1), "plain");
}
/// <summary>
/// Hash all entities based off <see cref="HashAttribute"/> on property
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entities">Entities to hash</param>
/// <returns>Hashed entities</returns>
public IEnumerable <T> Hash <T>(IEnumerable <T> entities) where T : IEntity
{
if (!_hashEnabled)
{
return(entities);
}
var type = typeof(T);
var hashProperties = GetPropertiesToHash(type);
if (hashProperties.IsNullOrEmpty())
{
return(entities);
}
var hashPropertyKey = GetHashKeyProperty(type);
var hashedEntities = entities.AsParallel().Select(e =>
{
var hashKey = type.GetProperty(hashPropertyKey).GetValue(e).ToString();
foreach (var propertyName in hashProperties)
{
// Read the unhashed property
var unhashed = type.GetProperty(propertyName).GetValue(e).ToString();
var existingSalt = _saltCache.Get(hashKey);
var hash = _hashAlgorithm.CreateHash(unhashed, existingSalt);
// Set the hashed value onto the property and add the salt too
type.GetProperty(propertyName).SetValue(e, hash.Hash);
type.GetProperty("Salt").SetValue(e, hash.Salt);
}
return(e);
});
// Add salt to cache
foreach (var entity in hashedEntities)
{
var salt = type.GetProperty("Salt").GetValue(entity);
if (salt != null)
{
_saltCache.TryAdd(entity.Word, salt.ToString());
}
}
return(entities);
}
/// <overrides>
/// Computes the hash value of plain text using the given hash provider instance
/// </overrides>
/// <summary>
/// Computes the hash value of plain text using the given hash provider instance
/// </summary>
/// <param name="hashInstance">A hash instance from configuration.</param>
/// <param name="plaintext">The input for which to compute the hash.</param>
/// <returns>The computed hash code.</returns>
public static byte[] CreateHash(string hashInstance, byte[] plaintext)
{
if (string.IsNullOrEmpty(hashInstance))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "hashInstance");
}
try
{
HashProviderFactory factory = new HashProviderFactory(ConfigurationSourceFactory.Create());
IHashProvider hashProvider = factory.Create(hashInstance);
return(hashProvider.CreateHash(plaintext));
}
catch (ConfigurationErrorsException configurationException)
{
TryLogHashConfigurationError(configurationException, hashInstance);
throw;
}
}
public void ThrowExceptionWhenByteArrayIsNull()
{
defaultHashProvider.CreateHash(null);
}
/// <overrides>
/// Computes the hash value of plain text using the given hash provider instance
/// </overrides>
/// <summary>
/// Computes the hash value of plain text using the given hash provider instance
/// </summary>
/// <param name="hashInstance">A hash instance from configuration.</param>
/// <param name="plaintext">The input for which to compute the hash.</param>
/// <returns>The computed hash code.</returns>
public override byte[] CreateHash(string hashInstance, byte[] plaintext)
{
IHashProvider hashProvider = GetHashProvider(hashInstance);
return(hashProvider.CreateHash(plaintext));
}
/// <summary> Creates the hash code for specified object. </summary>
/// <param name="obj">The obj.</param>
/// <returns></returns>
public string CreateHash(object obj)
{
return((obj != null) ? HashProvider.CreateHash(obj) : null);
}
internal static string CreateHash(IHashProvider provider, string plaintext)
{
byte[] plainTextBytes = UnicodeEncoding.Unicode.GetBytes(plaintext);
byte[] resultBytes = provider.CreateHash(plainTextBytes);
CryptographyUtility.GetRandomBytes(plainTextBytes);
return Convert.ToBase64String(resultBytes);
}
internal static string CreateHash(IHashProvider provider, string plaintext)
{
byte[] bytes = Encoding.Unicode.GetBytes(plaintext);
byte[] inArray = provider.CreateHash(bytes);
CryptographyUtility.GetRandomBytes(bytes);
return Convert.ToBase64String(inArray);
}
