public async Task PostPassword([FromBody] PasswordRequestModel model)
{
var user = await _userService.GetUserByPrincipalAsync(User);
if (user == null)
{
throw new UnauthorizedAccessException();
}
var result = await _userService.ChangePasswordAsync(user, model.MasterPasswordHash,
model.NewMasterPasswordHash, model.Key);
if (result.Succeeded)
{
return;
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
await Task.Delay(2000);
throw new BadRequestException(ModelState);
}
public async Task <IActionResult> ChangePassword(PasswordRequestModel passwordRqModel)
{
var user = await userManager.GetUser(User);
var result = await userManager.ChangePasswordAsync(user, passwordRqModel.OldPassword,
passwordRqModel.NewPassword);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
if (error.Code == "PasswordMismatch")
{
ModelState.AddModelError("OldPassword", error.Description);
}
else if (error.Code.StartsWith("Password"))
{
ModelState.AddModelError("NewPassword", error.Description);
}
else
{
ModelState.AddModelError("", error.Description);
}
}
return(BadRequest(ModelState));
}
await signInManager.RefreshSignInAsync(user);
return(NoContent());
}
public async Task PutPassword([FromBody] PasswordRequestModel model)
{
var user = await _userService.GetUserByPrincipalAsync(User);
// NOTE: It is assumed that the eventual repository call will make sure the updated
// ciphers belong to user making this call. Therefore, no check is done here.
var ciphers = model.Data.Ciphers.Select(c => c.ToCipher(user.Id));
var folders = model.Data.Folders.Select(c => c.ToFolder(user.Id));
var result = await _userService.ChangePasswordAsync(
user,
model.MasterPasswordHash,
model.NewMasterPasswordHash,
ciphers,
folders,
model.Data.PrivateKey);
if (result.Succeeded)
{
return;
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
await Task.Delay(2000);
throw new BadRequestException(ModelState);
}
public async Task <Response <string> > Password([FromBody] PasswordRequestModel request)
{
const string errorMessage = "Неверный email или логин";
var user = await _signInManager.UserManager.Users
.Where(x => x.NormalizedEmail == request.Email.ToUpper())
.Where(x => !x.IsDeleted)
.SingleOrDefaultAsync()
?? throw new InvalidRequestDataException(errorMessage);
var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, _configuration.AuthOptions.IsLockoutEnable);
if (!result.Succeeded)
{
var lockout = _configuration.AuthOptions.LockoutTimeSec < 60
? $"{_configuration.AuthOptions.LockoutTimeSec} сек"
: $"{_configuration.AuthOptions.LockoutTimeSec/60} мин";
throw new InvalidRequestDataException(result.IsLockedOut
? $"Пользователь заблокирован попробуйте через {lockout}"
: errorMessage);
}
var token = _authService.GenerateToken(user);
_logger.LogInformation($"Пользователь (Id: {user.Id}, Email: \"{user.Email}\") успешно авторизовался по паролю");
return(new Response <string>(token));
}
/// <summary>
/// Creates a random password.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <PasswordResponseModel> CreatePasswordAsync(PasswordRequestModel request)
{
StringBuilder res = new StringBuilder();
Random rnd = new Random();
while (0 < request.Length--)
{
res.Append(_validCharacters[rnd.Next(_validCharacters.Length)]);
}
return(await Task.FromResult(new PasswordResponseModel(res.ToString())));
}
public IActionResult Post([FromBody] PasswordRequestModel passwordData)
{
try
{
if (passwordData == null || String.IsNullOrEmpty(passwordData.PlainText))
{
_logger.Error("Either Password Data is null or Plain text is null");
return(BadRequest(" Either Password Data is null or Plain text is null"));
}
var passwordResponse = _codeRedCrypto.Encrypt(passwordData);
return(Ok(passwordResponse));
}
catch (Exception ex)
{
_logger.Error($"Argon2 error :- {ex}");
return(BadRequest($"Argon2 error :- {ex}"));
}
}
public async Task <ActionResult> CreateRandomPassword(PasswordRequestModel request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
PasswordResponseModel result = await _passwordGenerator.CreatePasswordAsync(request);
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError($"Error while generating random password - {ex}", ex.Message);
return(BadRequest("Please try again."));
}
}
public ActionResult GenerateOneTimePassword([FromBody] PasswordRequestModel passwordRequestModel)
{
try
{
if (passwordRequestModel.UserId == 0)
{
return(BadRequest());
}
if (string.IsNullOrEmpty(passwordRequestModel.DateTime))
{
passwordRequestModel.DateTime = Convert.ToString(DateTime.Now);
}
var password = _passwordGeneratorService.GenerateOneTimePassword(passwordRequestModel.UserId,
passwordRequestModel.DateTime);
return(Ok(new PasswordResponseModel()
{
SecondsValidity = Constants.PASSWORD_LIFETIME_SECONDS, Password = password
}));
}
catch (Exception ex)
{
return(StatusCode(500, "An error occurred"));
}
}
