public async Task ChangeFontStyleAsync_UserFontStyleChange_UsersFontStyleChanges(int userId, string fontStyle) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); bool result = await userAccountSettingsManager.ChangeFontStyleAsync(userId, fontStyle); if (!result) { Assert.IsTrue(false); } string newFontStyle = await userAccountSettingsRepository.GetFontStyleByID(userId); if (fontStyle == newFontStyle) { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public virtual async Task GeneratePasswordResetToken(User user, int expirationInMinutes) { if (user == null) { throw new ArgumentNullException("user"); } if (expirationInMinutes < 1) { throw new ArgumentException( "Token expiration should give the user at least a minute to change their password", "expirationInMinutes"); } if (!user.Confirmed) { throw new InvalidOperationException(Strings.UserIsNotYetConfirmed); } if (!String.IsNullOrEmpty(user.PasswordResetToken) && !user.PasswordResetTokenExpirationDate.IsInThePast()) { return; } user.PasswordResetToken = CryptographyService.GenerateToken(); user.PasswordResetTokenExpirationDate = DateTime.UtcNow.AddMinutes(expirationInMinutes); await Auditing.SaveAuditRecord(new UserAuditRecord(user, UserAuditAction.RequestedPasswordReset)); Entities.SaveChanges(); return; }
public async Task <bool> SaveAppUser(Entities.User user, string newPasswordToHash = null) { bool success = true; if (!String.IsNullOrEmpty(newPasswordToHash)) { user.PasswordSalt = CryptographyService.PasswordSaltInBase64(); user.PasswordHash = CryptographyService.PasswordToHashBase64(newPasswordToHash, user.PasswordSalt); } try { var entity = await _entityRepository .AsReadOnly() .SingleOrDefaultAsync(s => s.Id == user.Id); if (entity == null) { entity = user; _entityRepository.Insert(entity); } await _database.SaveAsync(); } catch { success = false; } return(success); }
public async Task ChangePasswordTest_UserPasswordChanges_PasswordChangeCompletes(int userId, string password, string newPassword) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); bool result = await userAccountSettingsManager.ChangePasswordAsync(password, newPassword, userId); if (!result) { Assert.IsTrue(false); } UserAccountModel model = await userAccountRepository.GetAccountById(userId); UserAccountRepository userAccountRepo = new UserAccountRepository(new SQLServerGateway(), new ConnectionStringData()); string encryptedNewPassword = await cryptographyService.EncryptPasswordAsync(newPassword, userId); if (model.Password == encryptedNewPassword) { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public async Task Authenticate() { // Arrange _appSettings.Secret = "atleast32bitsizedsecretstring"; var authUserDto = new AuthUserDto() { Password = "" }; var password = CryptographyService.HashPassword(""); _userRepository.Setup(x => x.Select(It.IsAny <Expression <Func <UserEntity, bool> > >())) .ReturnsAsync(new List <UserEntity> { new UserEntity { UserName = "******", Password = password, PasswordSalt = "" } }); // Act var service = new AccountService(_appSettings, _logger.Object, _refreshTokenRepository.Object, _userRepository.Object); var result = await service.Authenticate(authUserDto); // Assert Assert.NotNull(result); }
public async Task ChangeThemeColor_UsersThemeColorChanges_UsersThemeColorIsChangedSuccessfully(int userId, string ThemeColor) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); bool result = await userAccountSettingsManager.ChangeThemeColorAsync(userId, ThemeColor); if (!result) { Assert.IsTrue(false); } await userAccountSettingsManager.ChangeThemeColorAsync(userId, ThemeColor); string newThemeColor = await userAccountSettingsRepository.GetThemeColorByID(userId); if (ThemeColor == newThemeColor) { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public async Task ChangeEmail_UserEmailChanges_EmailChangeCompletes(int userId, string password, string email) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); bool result = await userAccountSettingsManager.ChangeEmailAsync(password, email, userId); if (!result) { Assert.IsTrue(false); } UserAccountModel model = await userAccountRepository.GetAccountById(userId); if (model.EmailAddress == email) { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public virtual Task <AuthenticatedUser> Register(string username, string password, string emailAddress) { var hashedPassword = CryptographyService.GenerateSaltedHash(password, Constants.PBKDF2HashAlgorithmId); var passCred = new Credential(CredentialTypes.Password.Pbkdf2, hashedPassword); return(Register(username, emailAddress, passCred)); }
public virtual User GeneratePasswordResetToken(string usernameOrEmail, int expirationInMinutes) { if (String.IsNullOrEmpty(usernameOrEmail)) { throw new ArgumentNullException("usernameOrEmail"); } if (expirationInMinutes < 1) { throw new ArgumentException( "Token expiration should give the user at least a minute to change their password", "expirationInMinutes"); } var user = FindByUserNameOrEmail(usernameOrEmail); if (user == null) { return(null); } if (!user.Confirmed) { throw new InvalidOperationException(Strings.UserIsNotYetConfirmed); } if (!String.IsNullOrEmpty(user.PasswordResetToken) && !user.PasswordResetTokenExpirationDate.IsInThePast()) { return(user); } user.PasswordResetToken = CryptographyService.GenerateToken(); user.PasswordResetTokenExpirationDate = DateTime.UtcNow.AddMinutes(expirationInMinutes); Entities.SaveChanges(); return(user); }
public async Task ChangeFontSize_UsersFontSizeIsChanged_FontSizeSuccessfullyChanges(int userId, int FontSize) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); bool result = await userAccountSettingsManager.ChangeFontSizeAsync(userId, FontSize); if (!result) { Assert.IsTrue(false); } await userAccountSettingsManager.ChangeFontSizeAsync(userId, FontSize); string newFontSize = await userAccountSettingsRepository.GetFontSizeByID(userId); if (FontSize.ToString() == newFontSize) { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public void AuthenticateUserTest_Given_Email_And_Password_Then_True_Should_Be_Returned_If_Password_Match( string inputPassword, bool expectedResult) { //Arrange const string passwordSalt = "passwordSalt"; var cryptographyService = new CryptographyService(); string password = cryptographyService.CreatePasswordHash("password", passwordSalt); _cryptographyServiceMock.Setup(service => service.CreatePasswordHash("password", passwordSalt)) .Returns(password); RecipeManagementContext.PrepareTestData(context => { context.Users.Add(new User { EmailAddress = "*****@*****.**", Password = password, PasswordSalt = passwordSalt }); }); //Act bool isAuthenticated = _userService.AuthenticateUser("*****@*****.**", inputPassword); //Assert Assert.That(isAuthenticated, Is.EqualTo(expectedResult)); }
public async Task <User> RegisterAsync(UserBase model) { model.ValidateIsNotNull(nameof(model)); var userExists = await UserExistsAsync(model.Username); var emailInUse = await EmailInUseAsync(model.Email); if (userExists || emailInUse) { return(null); } var passwordSalt = CryptographyService.CreateSalt(); var passwordHash = CryptographyService.CreateHash(model.Password, passwordSalt); var entity = new Entities.User(); entity.PasswordHash = passwordHash; entity.PasswordSalt = passwordSalt; entity.FirstName = model.FirstName; entity.LastName = model.LastName; entity.Username = model.Username; entity.DateOfBirth = model.DateOfBirth; entity.Email = model.Email; await _genericRepository.InsertAsync(entity); await _databaseScope.SaveChangesAsync(); return(_mapper.Map <User>(entity)); }
public virtual async Task GeneratePasswordResetToken(User user, int expirationInMinutes) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (expirationInMinutes < 1) { throw new ArgumentException( Strings.TokenExpirationShouldGiveUser1MinuteToChangePassword, nameof(expirationInMinutes)); } if (!user.Confirmed) { throw new InvalidOperationException(Strings.UserIsNotYetConfirmed); } if (!string.IsNullOrEmpty(user.PasswordResetToken) && !user.PasswordResetTokenExpirationDate.IsInThePast()) { return; } user.PasswordResetToken = CryptographyService.GenerateToken(); user.PasswordResetTokenExpirationDate = _dateTimeProvider.UtcNow.AddMinutes(expirationInMinutes); await Auditing.SaveAuditRecord(new UserAuditRecord(user, AuditedUserAction.RequestPasswordReset)); await Entities.SaveChangesAsync(); }
public async Task DeleteAccountByUserIDAsync_UserAccountIsDelted_UserAccountSuccessfulyDeletes(int userId, string password) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); bool result = await userAccountSettingsManager.DeleteAccountByUserIDAsync(userId, password); if (!result) { Assert.IsTrue(false); } UserAccountModel model = await userAccountRepository.GetAccountById(userId); if (model.AccountStatus == "Deleted") { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public void EncryptTextTest() { string f = "COMMON"; CryptographyService cryptographyService = new CryptographyService(); string result = cryptographyService.EncryptText(f); Assert.IsNotNull(result); }
public void WhenCheckPasswordGetsCalled() { Setup(); _hashedAndSaltedPassword = BCrypt.Net.BCrypt.HashPassword("somethingelse", BCrypt.Net.BCrypt.GenerateSalt()); _isPasswordCorrect = CryptographyService.CheckPassword(Password, _hashedAndSaltedPassword); }
public void EncryptClearTest_AutoGeneratedSalt_ReturnsEncodedStringContainingSalt() { const string clear = "TooManySecrets"; var srv = new CryptographyService(); var enc = srv.Encrypt(clear); Assert.IsTrue(enc.Contains("#-#")); }
public LineEventMessageHandler( HandleRepository handleRepository, CryptographyService cryptographyService, IHttpClientFactory httpClientFactory) { this.handleRepository = handleRepository; this.cryptographyService = cryptographyService; this.httpClientFactory = httpClientFactory; }
public DocumentApiController( ILogger <DocumentApiController> logger, DocumentRepository documentRepository, CryptographyService cryptographyService) { this.logger = logger; this.documentRepository = documentRepository; this.cryptographyService = cryptographyService; }
public void CreateHash_EmptyData_ThrowsArgumentNullException() { var factory = Substitute.For <ICryptographyProcessorFactory>(); var svc = new CryptographyService(factory); var e = Assert.Throws <ArgumentNullException>(() => svc.CreateHash(string.Empty, out var x, out var y)); Assert.That(e.Message, Does.Contain("data")); }
public void RequiresStringToDecrypt() { //Arrange string stringToDecrypt = null; var cryptoService = new CryptographyService <string>(provider); //Act && Assert Assert.Throws <ArgumentNullException>(() => cryptoService.Decrypt(stringToDecrypt)); }
public void Encrypt_DataListNull_ThrowsArgumentNullException() { var factory = Substitute.For <ICryptographyProcessorFactory>(); var svc = new CryptographyService(factory); var e = Assert.Throws <ArgumentNullException>(() => svc.Encrypt((List <string>)null)); Assert.That(e.Message, Does.Contain("data")); }
public void CreateEncryptedFile(string login, string password) { passwordManager = new PasswordProvider( new Passwords(login, password, Encoding.UTF8.GetString(CryptographyService.GenerateKey()), Encoding.UTF8.GetString(CryptographyService.GenerateKey()))); passwordManager.Encrypt(); passwordManager.Save(PswFileName); }
public IActionResult Register(User user) { user.Password = CryptographyService.Hash(user.Password); //user.Username = _protector.Protect(user.Username); //user.Username = _protector.Protect(user.Username); _context.User.Add(user); _context.SaveChanges(); return(Redirect("/")); }
public void SameInputEncryptedTwiceComparison() { var service = new CryptographyService(); var input = "test"; var encryptOne = service.Encrypt(input); var encryptTwo = service.Encrypt(input); Assert.AreEqual(encryptOne, encryptTwo); }
public void Crypto_Hash_String_test() { var cryptographyService = new CryptographyService(WinRTCrypto.CryptographicEngine, WinRTCrypto.SymmetricKeyAlgorithmProvider, WinRTCrypto.HashAlgorithmProvider, new Logger()); var valueString = "3nNkJ5EcI7yyi56ifLSAA"; var hashedString = cryptographyService.GetHashString(valueString); var hashedStringWithoutPcl = CryptographyHelperWithoutPcl.GetHashString(valueString); Assert.AreEqual(hashedString, hashedStringWithoutPcl); }
public void Encrypt_Settings_test() { var cryptographyService = new CryptographyService(WinRTCrypto.CryptographicEngine, WinRTCrypto.SymmetricKeyAlgorithmProvider, WinRTCrypto.HashAlgorithmProvider, new Logger()); var valueString = "3nNkJ5EcI7yyi56ifLSAA"; var encrypted = cryptographyService.Encrypt(valueString); var encryptedWithoutPcl = SettingsEncryptorWithoutPcl.Encrypt(valueString); Assert.AreEqual(encrypted, encryptedWithoutPcl); }
public void Decrypt_Settings_test() { var cryptographyService = new CryptographyService(WinRTCrypto.CryptographicEngine, WinRTCrypto.SymmetricKeyAlgorithmProvider, WinRTCrypto.HashAlgorithmProvider, new Logger()); var valueByte = new byte[] { 56, 99, 56, 132, 151, 253, 216, 41, 121, 141, 13, 158, 180, 215, 74, 5 }; var decrypted = cryptographyService.Decrypt(valueByte); var decryptedWithoutPcl = SettingsEncryptorWithoutPcl.Decrypt(valueByte); Assert.AreEqual(decrypted, decryptedWithoutPcl); }
public async Task CreateDefaultUserAccountSettings_DefaultUserIsCreated_DefaultUserIsSuccessfulyCreated(int UserId, int FontSize, string ThemeColor, string FontStyle) { IDataGateway dataGateway = new SQLServerGateway(); IConnectionStringData connectionString = new ConnectionStringData(); IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString); int i = 2; UserAccountModel userAccountModel = new UserAccountModel(); userAccountModel.Id = i; userAccountModel.Username = "******" + i; userAccountModel.Password = "" + i; userAccountModel.Salt = "" + i; userAccountModel.EmailAddress = "TestEmailAddress" + i; userAccountModel.AccountType = "TestAccountType" + i; userAccountModel.AccountStatus = "TestAccountStatus" + i; userAccountModel.CreationDate = DateTimeOffset.UtcNow; userAccountModel.UpdationDate = DateTimeOffset.UtcNow; await userAccountRepository.CreateAccount(userAccountModel); UserAccountSettingsModel userAccountSettingsModel = new UserAccountSettingsModel(); IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString); ICryptographyService cryptographyService = new CryptographyService(userAccountRepository); IAuthenticationService authenticationService = new AuthenticationService(userAccountRepository); IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService); UserAccountSettingsModel model = new UserAccountSettingsModel(); userAccountSettingsModel.Id = 0; userAccountSettingsModel.UserId = UserId; userAccountSettingsModel.FontSize = FontSize; userAccountSettingsModel.FontStyle = FontStyle; userAccountSettingsModel.ThemeColor = ThemeColor; bool result = await userAccountSettingsManager.CreateDefaultUserAccountSettingsAsync(userAccountSettingsModel); if (!result) { Assert.IsTrue(false); } await userAccountSettingsManager.CreateDefaultUserAccountSettingsAsync(userAccountSettingsModel); model = await userAccountSettingsRepository.GetUserAccountSettingsByUserId(UserId); if (model.UserId == UserId && model.FontSize == 12 && model.FontStyle == "Defualt Font Style" && model.ThemeColor == "Default Theme Color") { Assert.IsTrue(true); } else { Assert.IsTrue(false); } }
public async Task WhenVerifyUserGetsCalled() { Setup(); UserRepository.Setup(repo => repo.GetUserByEmail(It.IsAny <string>())).Returns(Task.FromResult(new User { Password = "******" })); CryptographyService.Setup(service => service.CheckPassword(It.IsAny <string>(), It.IsAny <string>())).Returns(false); _verifyUserResult = await AuthService.VerifyUser(_email, _password); }