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); }
}
