public void SetPassword(string password) { var encrypterService = new EncryptService(); Salt = encrypterService.GenerateSalt(); HashedPassword = encrypterService.Compute(password, Salt); }
private async Task <StringBuilder> GetLitresBookShelfDataAsync() { try { if (string.IsNullOrEmpty(CatalogModel.AuthorizationString)) { throw new CatalogAuthorizationException(CatalogType.Litres, LitresApiConstants.AUTHORIZATION_URL); } var authorizationString = EncryptService.Decrypt(CatalogModel.AuthorizationString); var postParams = CreatePostParamsForBookShelf(authorizationString); var response = await WebClient.DoPostAsync(LitresApiConstants.BOOK_SHELF_URL, postParams); var stream = await response.Content.ReadAsStreamAsync(); using (var reader = new StreamReader(stream)) { return(new StringBuilder(reader.ReadToEnd())); } } catch (WebException) { if (NavigationStack.Any()) { NavigationStack.Pop(); } throw new ReadCatalogException("Unable read Litres catalog"); } }
public async Task <IActionResult> Modified(string idOrCode, ModifiedInfoUserModel user) { if (string.IsNullOrEmpty(idOrCode) || string.IsNullOrWhiteSpace(idOrCode)) { return(BadRequest()); } try { var userEntity = user.Mapping <User, ModifiedInfoUserModel, UserProfile>(_factory); userEntity.Code = idOrCode; userEntity.Password = EncryptService.Encrypt(user.Password); var data = await _userService.UpdateAsync(userEntity); return(Json(data)); } catch (ExceptionError e) { if (e.Error.ErrorCode.Equals((int)ErrorCodeEnum.FailData)) { Log.Error(e.Error.Data); throw; } else { return(NotFound()); } } }
public void Encrypt_Fail() { IEncryptService encryptService = new EncryptService(); var result = encryptService.Encrypt("test"); var dec = encryptService.Decrypt("WrongPassword", result); Assert.Equal("Password incorrect", dec); }
public void Encrypt_Success() { IEncryptService encryptService = new EncryptService(); var result = encryptService.Encrypt("test"); var dec = encryptService.Decrypt("test", result); Assert.Equal("Password correct", dec); }
public RegisterViewModel() { navigationService = new NavigationService(); dialogService = new DialogService(); auth = DependencyService.Get <IAuth>(); encryptService = new EncryptService(); instance = this; }
public void TestEncryptText() { var encryptService = new EncryptService(); var decryptedText = File.ReadAllText(@"../../../TestFiles/Decrypted.txt"); var encryptedText = encryptService.Encrypt("скорпион", decryptedText); Assert.AreEqual(encryptedText, File.ReadAllText(@"../../../TestFiles/Encrypted.txt")); }
public AddCustomer(Container container, EncryptService encryptService) { this.customerContainer = container; this.encryptService = encryptService; this.countries = new List <Country>(); this.regexEmail = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"); this.regexPhone = new Regex(@"^(\(?\+\d{2,3}\)?|\d)(\s|\-)?\d{3,4}(\s|\-)?\d{6,8}$"); }
private byte[] Encrypt(byte[] source) { if (Easy.Builder.Configuration[EncryptWidgetTemplate] == "true") { return(EncryptService.Encrypt(source)); } return(source); }
private byte[] Encrypt(byte[] source) { if (ConfigurationManager.AppSettings[EncryptWidgetTemplate] == "true") { return(EncryptService.Encrypt(source)); } return(source); }
public MyConnection(bool dispose = true) { XmlManager xml = new XmlManager(dispose); ConnectionString = EncryptService.DecryptString(xml[new List <string>() { "myserver" }]); }
public PgConnection() { XmlManager xml = new XmlManager(); ConnectionString = EncryptService.DecryptString(xml[new List <string>() { "pgserver" }]); }
public void ResetPassword([FromBody] Object password) { var jsonString = password.ToString(); PasswordString result = JsonConvert.DeserializeObject <PasswordString>(jsonString); HashSalt hashed = LoginService.GenerateSaltedHash(10, result.Password); string email = EncryptService.Decrypt(result.Encrypt, "astrophile"); UserRepo.UpdatePassword(hashed.Hash, email); UserRepo.UpdateSalt(hashed.Salt, email); }
public async Task <ActionResult <User> > Insert(UserModel user) { var userEntity = user.Mapping <User, UserModel, UserProfile>(_factory); userEntity.Password = EncryptService.Encrypt("Password"); var data = await _userService.AddAsync(userEntity); return(Json(data)); }
private async void GetBlockMethodReturnsOkResponse() { //Arrange string data = Guid.NewGuid().ToString(); EncryptService encryptService = new EncryptService(); string encryptedPass = encryptService.EncryptData("1111"); User user = new User("Dimitry", "Sukalo", encryptedPass); Block genesisBlock = new Block(); UserFile userFile = new UserFile(data, data, new byte[1]); Block block = new Block(userFile, user, genesisBlock); Mock <IQueryable <Block> > blocks = new List <Block>() { genesisBlock, block }.AsQueryable().BuildMock(); Mock <DbSet <Block> > blockMock = new Mock <DbSet <Block> >(); SetSettingsInDb(blockMock, blocks); Mock <IQueryable <User> > users = new List <User>() { user }.AsQueryable().BuildMock(); Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >(); SetSettingsInDb(usersMock, users); Mock <BlockChainContext> db = new Mock <BlockChainContext>(); db.Setup(m => m.Blocks).Returns(blockMock.Object); db.Setup(m => m.Users).Returns(usersMock.Object); Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object, null, null, null, null, null, null, null, null); Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>(); Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >(); Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object, _contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null); Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object); Mock <DecryptService> decryptMock = new Mock <DecryptService>(); GetDataService getDataService = new GetDataService(unitMock.Object, decryptMock.Object); //Act ResultOfApiRequest <UserFile> result = await getDataService.GetFile(user.Token, "1111", data); //Assert Assert.NotNull(result); Assert.Equal(HttpStatusCode.OK, result?.StatusCode); }
private async Task <UserInfoModel> LoginAsync(User user, string password, CancellationToken cancellationToken = default) { if (user != null) { string passEncrypt = EncryptService.Encrypt(password); if (user.Password.Equals(passEncrypt)) { if (user.Status != StatusEnum.Inactive && (user.LoginFailedNumber == null || (user.LoginFailedNumber != null && user.LoginFailedNumber.Value < _maxLogin))) { user.LoginFailedNumber = 0; var model = UserInfoModel.Instance; model.Fullname = user.FullName; model.Id = user.Id; model.UserType = user.UserTypeStr; model.Username = user.Username; model.PasswordLastUpdate = user.PasswordLastUdt; model = await CheckExpiredPass(model); await _userRepo.UpdateAsync(user); // _logService.Synchronization(user.Username); return(model); } else { throw new ExceptionError(ErrorCodeEnum.UserInactive); } } else { if (user.LoginFailedNumber != null && user.LoginFailedNumber.Value >= (_maxLogin - 1) && user.Status != StatusEnum.Inactive) { user.Status = StatusEnum.Inactive; user.LoginFailedNumber = 0; await _userRepo.UpdateAsync(user); throw new ExceptionError(ErrorCodeEnum.LoginFailed3Time); } if (user.Status == StatusEnum.Inactive) { throw new ExceptionError(ErrorCodeEnum.UserInactive); } user.LoginFailedNumber = user.LoginFailedNumber == null ? 1 : user.LoginFailedNumber.Value + 1; await _userRepo.UpdateAsync(user); throw new ExceptionError(ErrorCodeEnum.LoginFailed); } } else { Log.Information("User does not existed!", ErrorCodeEnum.IncorrectUser); throw new ExceptionError(ErrorCodeEnum.IncorrectUser); } }
public void GeneratePasswordSalt_Should_Return_String_Consists_Of_32_Characters() { // Arrange var encryptService = new EncryptService(); // Act var salt = encryptService.GeneratePasswordSalt(); // Assert Assert.AreEqual(32, salt.Length); }
private async Task <StringBuilder> GetOpdsDataAsync(string url, IWebClient webClient) { try { var baseUri = new UriBuilder(url); string queryToAppend = "rand=" + Guid.NewGuid(); baseUri.Query = baseUri.Query.Length > 1 ? baseUri.Query.Substring(1) + "&" + queryToAppend : queryToAppend; string authorizationString = null; if (!string.IsNullOrEmpty(CatalogModel.AuthorizationString)) { authorizationString = EncryptService.Decrypt(CatalogModel.AuthorizationString); } var response = await webClient.DoGetAsync(baseUri.ToString(), authorizationString); if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden) { throw new CatalogAuthorizationException(CatalogType.OPDS, url); } var stream = await response.Content.ReadAsStreamAsync(); using (var reader = new StreamReader(stream)) { return(new StringBuilder(reader.ReadToEnd())); } } catch (WebException exception) { if (exception.Status != WebExceptionStatus.RequestCanceled) { if (NavigationStack.Any()) { NavigationStack.Pop(); } var statusCode = ((HttpWebResponse)exception.Response).StatusCode; if (statusCode == HttpStatusCode.Unauthorized || statusCode == HttpStatusCode.Forbidden) { throw new CatalogAuthorizationException(CatalogModel.Type, url); } throw new ReadCatalogException(string.Format("Unable read catalog {0}", url)); } } catch (DataCorruptedException) { //skip DataCorruptedException } return(await GetOpdsDataAsync(url, webClient)); }
public void Encrypt_Text_ShouldNotReturnSameText() { Account account = new Account() { Password = "******", Username = "******" }; string encryptedText = EncryptService.Encrypt(account.Username); Assert.AreNotEqual(account.Username, encryptedText); }
public void GeneratePasswordSalt_Should_Generate_Random_String() { // Arrange var encryptService = new EncryptService(); // Act var salt1 = encryptService.GeneratePasswordSalt(); var salt2 = encryptService.GeneratePasswordSalt(); // Assert Assert.AreNotEqual(salt1, salt2); }
public LoginViewModel() { navigationService = new NavigationService(); dialogService = new DialogService(); apiService = new ApiService(); encryptService = new EncryptService(); auth = DependencyService.Get <IAuth>(); IsEnabled = true; ColorEntryPhone = "Black"; ColorEntryPassword = "******"; IsVisible = false; }
public ReserveApartment( Container customerContainer, Container apartmentContainer, Container reservationContainer, EncryptService encryptService) { this.customerContainer = customerContainer; this.apartmentContainer = apartmentContainer; this.reservationContainer = reservationContainer; this.encryptService = encryptService; this.customers = new List <Customer>(); this.apartments = new List <Apartment>(); }
public void EncryptPassword_Should_Generate_Password_And_Salt() { // Arrange const string PASSWORD = "******"; var encryptService = new EncryptService(); // Act var passwordData = encryptService.EncryptPassword(PASSWORD); // Assert Assert.AreEqual(PASSWORD, passwordData.Password); Assert.AreEqual(32, passwordData.PasswordSalt.Length); Assert.AreEqual(32, passwordData.PasswordHash.Length); }
private async void RegisterMethodReturnsOkStatusCode() { //Arrange EncryptService encryptService = new EncryptService(); string password = encryptService.EncryptData("1111"); User user = new User("1111", "1111", "1111") { UserName = "******" }; Mock <IQueryable <User> > users = new List <User>().AsQueryable().BuildMock(); Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >(); SetSettingsInDb(usersMock, users); Mock <BlockChainContext> db = new Mock <BlockChainContext>(); db.Setup(m => m.Users).Returns(usersMock.Object); Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object, null, null, null, null, null, null, null, null); Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>(); Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >(); Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object, _contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null); userManagerMock.Setup(m => m.CreateAsync(user, password)).ReturnsAsync(IdentityResult.Success); Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object); Mock <EncryptService> encryptMock = new Mock <EncryptService>(); RegisterService registerService = new RegisterService(unitMock.Object, encryptMock.Object); //Act ResultOfApiRequest <User> result = await registerService.RegisterUser(user); //Assert Assert.NotNull(result); Assert.Equal(user.Id, result?.Data?.Id); Assert.Equal(user.Name, result?.Data?.Name); Assert.Equal(user.Surname, result?.Data?.Surname); Assert.Equal(user.Password, result?.Data?.Password); Assert.Equal(user.Token, result?.Data?.Token); Assert.Equal(HttpStatusCode.OK, result?.StatusCode); }
public static bool IsKeyValid() { string uuid = ""; string key = ""; ReadAuthentication(out uuid, out key); if (string.IsNullOrEmpty(uuid) || string.IsNullOrEmpty(key)) return false; string encodedSN = EncryptService.Encode(uuid); string decoded = EncryptService.Decode(key); return string.Compare(encodedSN, key, StringComparison.Ordinal) == 0; }
private void NavigateToWebBrowser(CatalogItemModel model) { // another hack for improving performance. if (model is LitresTopupCatalogItemModel) { var catalog = CatalogRepository.Get(CatalogId); model.HtmlUrl = string.Format(model.HtmlUrl, EncryptService.Decrypt(catalog.AuthorizationString)); } _navigationService.UriFor <WebBrowserPageViewModel>() .WithParam(vm => vm.WebBrowserUrl, model.HtmlUrl) .WithParam(vm => vm.CatalogId, CatalogId) .WithParam(vm => vm.Title, model.Title) .Navigate(); }
private UserOutput Login(User user, string password) { if (user != null) { string passEncrypt = EncryptService.Encrypt(password); if (user.Password.Equals(passEncrypt)) { if (user.Status != StatusEnum.Inactive && (user.LoginFailedNumber == null || (user.LoginFailedNumber != null && user.LoginFailedNumber.Value < _maxLogin))) { user.LoginFailedNumber = 0; var userOutput = new UserOutput(user); CheckExpiredPass(ref userOutput); _unitOfWork.Update(user); _unitOfWork.Commit(); _logService.Synchronization(user.Username); return(userOutput); } else { throw new DefinedException(ErrorCodeEnum.UserInactive); } } else { if (user.LoginFailedNumber != null && user.LoginFailedNumber.Value >= (_maxLogin - 1) && user.Status != StatusEnum.Inactive) { user.Status = StatusEnum.Inactive; user.LoginFailedNumber = 0; _unitOfWork.Update(user); _unitOfWork.Commit(); throw new DefinedException(ErrorCodeEnum.LoginFailed3Time); } if (user.Status == StatusEnum.Inactive) { throw new DefinedException(ErrorCodeEnum.UserInactive); } user.LoginFailedNumber = user.LoginFailedNumber == null ? 1 : user.LoginFailedNumber.Value + 1; _unitOfWork.Update(user); _unitOfWork.Commit(); throw new DefinedException(ErrorCodeEnum.LoginFailed); } } else { Log.Information("User does not existed!", ErrorCodeEnum.IncorrectUser); throw new DefinedException(ErrorCodeEnum.IncorrectUser); } }
public void EncryptPassword_Should_Generate_The_Same_HashPassword_For_Given_Salt_And_Password() { // Arrange const string PASSWORD = "******"; var encryptService = new EncryptService(); var salt = encryptService.GeneratePasswordSalt(); // Act var passwordData1 = encryptService.EncryptPassword(PASSWORD, salt); var passwordData2 = encryptService.EncryptPassword(PASSWORD, salt); // Assert Assert.AreEqual(passwordData1.Password, passwordData2.Password); Assert.AreEqual(passwordData1.PasswordSalt, passwordData2.PasswordSalt); Assert.AreEqual(passwordData1.PasswordHash, passwordData2.PasswordHash); }
private async void AddDataToTheChainReturnsOkRequest() { //Arrange Mock <IQueryable <Block> > blocks = new List <Block>().AsQueryable().BuildMock(); Mock <DbSet <Block> > blockMock = new Mock <DbSet <Block> >(); SetSettingsInDb(blockMock, blocks); EncryptService encryptService = new EncryptService(); string encryptedPass = encryptService.EncryptData("1111"); User user = new User("Dimitry", "Sukalo", encryptedPass); Mock <IQueryable <User> > users = new List <User>() { user }.AsQueryable().BuildMock(); Mock <DbSet <User> > usersMock = new Mock <DbSet <User> >(); SetSettingsInDb(usersMock, users); Mock <BlockChainContext> db = new Mock <BlockChainContext>(); db.Setup(m => m.Blocks).Returns(blockMock.Object); db.Setup(m => m.Users).Returns(usersMock.Object); Mock <UserManager <User> > userManagerMock = new Mock <UserManager <User> >(new Mock <IUserStore <User> >().Object, null, null, null, null, null, null, null, null); Mock <IHttpContextAccessor> _contextAccessor = new Mock <IHttpContextAccessor>(); Mock <IUserClaimsPrincipalFactory <User> > _userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >(); Mock <SignInManager <User> > signInMock = new Mock <SignInManager <User> >(userManagerMock.Object, _contextAccessor.Object, _userPrincipalFactory.Object, null, null, null, null); Mock <UnitOfWork> unitMock = new Mock <UnitOfWork>(db.Object, signInMock.Object, userManagerMock.Object); Mock <DecryptService> decryptMock = new Mock <DecryptService>(); Mock <PostDataService> postDataService = new Mock <PostDataService>(unitMock.Object, decryptMock.Object); FormFile file = new FormFile(Stream.Null, 1, 1, "testfile", ""); //Act ResultOfApiRequest <string> resultOfApiRequest = await postDataService.Object.AddDataToTheChain(file, user.Token, "1111", true); //Assert Assert.NotNull(resultOfApiRequest); Assert.Equal(HttpStatusCode.OK, resultOfApiRequest?.StatusCode); }
public bool Save() { try { var xml = new XmlManager(false); xml[new List <string>() { "myserver" }] = EncryptService.EncryptString(ConnectionString); xml.Save(); xml.Dispose(); return(true); } catch { return(false); } }