public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = "Error changing email.";
return(Page());
}
// In our UI email and user name are one and the same, so when we update the email
// we need to update the user name.
var setUserNameResult = await _userManager.SetUserNameAsync(user, email);
if (!setUserNameResult.Succeeded)
{
StatusMessage = "Error changing user name.";
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Thank you for confirming your email change.";
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Невозможно загрузить пользователя с идентификатором '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = "Ошибка изменения email.";
return(Page());
}
// In our UI email and user name are one and the same, so when we update the email
// we need to update the user name.
var setUserNameResult = await _userManager.SetUserNameAsync(user, email);
if (!setUserNameResult.Succeeded)
{
StatusMessage = "Ошибка изменения имени пользователя.";
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Благодарим Вас за подтверждение изменения email.";
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"No se puede cargar el usuario con ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = "Error al cambiar email.";
return(Page());
}
// In our UI email and user name are one and the same, so when we update the email
// we need to update the user name.
var setUserNameResult = await _userManager.SetUserNameAsync(user, email);
if (!setUserNameResult.Succeeded)
{
StatusMessage = "Error al cambiar nombre de usuario.";
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Gracias por confirmar el cambio de email.";
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Kullanıcı Bulunamadı #'{_userManager.GetUserId(User)}'.\n Bu kodu destek birimimize bildirerek yardım alabilirsiniz."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = "Eposta değişirken HATA.";
return(Page());
}
// In our UI email and user name are one and the same, so when we update the email
// we need to update the user name.
var setUserNameResult = await _userManager.SetUserNameAsync(user, email);
if (!setUserNameResult.Succeeded)
{
StatusMessage = "Kullanıcı Adı Değişirken HATA.";
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Eposta değişimini kabul ettin.";
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = identityLocalizationService.GetLocalizedHtmlString("CONFIRM_EMAIL_CHANGE_ERROR");
return(Page());
}
// // In our UI email and user name are one and the same, so when we update the email
// // we need to update the user name.
// var setUserNameResult = await userManager.SetUserNameAsync(user, email);
// if (!setUserNameResult.Succeeded)
// {
// StatusMessage = "Error changing user name.";
// return Page();
// }
await signInManager.RefreshSignInAsync(user);
StatusMessage = identityLocalizationService.GetLocalizedHtmlString("CONFIRM_EMAIL_CHANGE_TEXT");
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Nepavyksta įkelti vartotojo, kurio ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = "Elektroninio pašto pakeisti nepavyko.";
return(Page());
}
// In our UI email and user name are one and the same, so when we update the email
// we need to update the user name.
var setUserNameResult = await _userManager.SetUserNameAsync(user, email);
if (!setUserNameResult.Succeeded)
{
StatusMessage = "Vartotojo vardo pakeisti nepavyko.";
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Elektroninis paštas pakeistas sėkmingai.";
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
{
if (userId == null || email == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Non è stato possibile trovare l'utente con ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ChangeEmailAsync(user, email, code);
if (!result.Succeeded)
{
StatusMessage = "Errore nel cambio email.";
return(Page());
}
// In our UI email and user name are one and the same, so when we update the email
// we need to update the user name.
var setUserNameResult = await _userManager.SetUserNameAsync(user, email);
if (!setUserNameResult.Succeeded)
{
StatusMessage = "Errore nel cambio del nome utente.";
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Grazie per aver confermato il cambio email.";
return(Page());
}
public async Task <Result> ConfirmEmailAsync(string userId, string token)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(Result.GeneralFailure("User Not Found"));
}
if (user.EmailConfirmed)
{
return(Result.GeneralFailure("This Email Has Confirmed Already"));
}
var decodedToken = WebEncoders.Base64UrlDecode(token);
string normalToken = Encoding.UTF8.GetString(decodedToken);
var result = await _userManager.ConfirmEmailAsync(user, normalToken);
if (result.Succeeded)
{
return(Result.Success("Email Confirmed Successfully"));
}
return(Result.Failure(result.Errors.Select(x => x.Description)));
}
public async Task <IActionResult> VerifyEmail(string userId, string code)
{
if (string.IsNullOrEmpty(userId) || string.IsNullOrEmpty(code))
{
return(RedirectToAction("Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
if (result.Succeeded)
{
return(View());
}
}
return(BadRequest());
}
public async Task <ApiResponse> ConfirmEmailAddress(EmailConfirmationVm model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
throw new MyNotFoundException(ApiResponseDescription.USER_NOT_FOUND);
}
var codeDecodedBytes = WebEncoders.Base64UrlDecode(model.Token);
var codeDecoded = Encoding.UTF8.GetString(codeDecodedBytes);
var result = await _userManager.ConfirmEmailAsync(user, codeDecoded);
if (result.Succeeded)
{
return(new ApiResponse(true));
}
else
{
throw new MyException(ApiResponseDescription.EMAIL_ADDRESS_COULD_NOT_BE_CONFIRMED);
}
}
/// <summary>
/// 解密JWT
/// </summary>
/// <param name="jwt">jwt</param>
/// <returns></returns>
public IActionResult Decode(string jwt)
{
string[] arrayJwt = jwt.Split('.');
string decodeJwt = "";
for (int i = 0; i < arrayJwt.Length; i++)
{
if (i == arrayJwt.Length - 1)
{
decodeJwt += "加密签名无法解密";
}
else
{
// 不能直接用Convert.FromBase64String，会报错，微软二逼，必须对base64加密字符串按照规则整理一下，具体怎么整理看这个方法的内容
var decodeBytes = WebEncoders.Base64UrlDecode(arrayJwt[i]);
//var decodeBytes = ConvertFromBase64String(arrayJwt[i]);
decodeJwt += Encoding.UTF8.GetString(decodeBytes);
}
}
return(Ok(decodeJwt));
}
public async Task <IActionResult> OnGetAsync(string userId, string code)
{
ViewData["HeaderImage"] = "/Img/nemuel-sereti-unsplash.jpg";
ViewData["HeaderText"] = "Welcome to Code Cache";
if (userId == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
StatusMessage = result.Succeeded ? "Thank you for confirming your email." : "Error confirming your email.";
return(Page());
}
public async Task <IActionResult> OnGetAsync(string userId, string code)
{
if (code == null || userId == null)
{
return(BadRequest("A code must be supplied for authenticator reset."));
}
else
{
var token = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _identityService.ResetAuthenticatorAsync(userId, token);
if (result.Succeeded)
{
_logger.LogInformation("User with ID {UserId} reseted his authenticator", userId);
return(RedirectToPage("/Login"));
}
else
{
_logger.LogError("Error occured resetting authenticator of user with Id {UserId}", userId);
return(Page());
}
}
}
public async Task <ActionResult <UserDto> > VerifyEmail(string emailVerificationToken, string email)
{
var user = await this._userManager.FindByEmailAsync(email);
if (user == null)
{
return(Unauthorized());
}
var decodedTokenBytes = WebEncoders.Base64UrlDecode(emailVerificationToken);
var decodedToken = Encoding.UTF8.GetString(decodedTokenBytes);
var result = await this._userManager.ConfirmEmailAsync(user, decodedToken);
if (result.Succeeded)
{
return(Ok("Email Confirmed! You can now login"));
}
else
{
return(BadRequest("Error verifying email"));
}
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account"));
}
var code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(model.Code));
var result = await _userManager.ResetPasswordAsync(user, code, model.Password);
if (result.Succeeded)
{
return(RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account"));
}
AddErrors(result);
return(View());
}
public async Task <IActionResult> OnGetAsync(string userId, string code)
{
if (userId == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
StatusMessage = result.Succeeded ? "Udało się zaakceptować konto." : "Nie udało się zaakceptować konta.";
TempData["CheckConfirm"] = StatusMessage.ToString();
return(RedirectToPage("/Account/Login", new { area = "Identity" }));
}
public async Task <IActionResult> SignUpConfirmEmail(string userId, string code)
{
AccountSignUpConfirmEmailViewModel model = new AccountSignUpConfirmEmailViewModel();
if (userId == null || code == null)
{
return(RedirectToAction("Index", "Home"));
}
var user = await UserManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await UserManager.ConfirmEmailAsync(user, code);
model.StatusMessage = result.Succeeded ? "Thank you for confirming your email." : "Error confirming your email.";
return(View(model));
}
public async Task <IActionResult> OnGetAsync(string userId, string code)
{
if (userId == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{userId}'."));
}
UserId = userId;
//confirm user (workshop) email
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
StatusMessage = result.Succeeded ? "Thank you for confirming your email." : "Error confirming your email.";
return(Page());
}
public async Task <IActionResult> ResetPassword(ResetPasswordModel model)
{
if (ModelState.IsValid)
{
var user = await _manager.FindByIdAsync(model.Id);
if (user == null)
{
return(NotFound());
}
var newToken = WebEncoders.Base64UrlDecode(model.Token);
var encodeToken = Encoding.UTF8.GetString(newToken);
var result = await _manager.ResetPasswordAsync(user, encodeToken, model.Password);
if (result.Succeeded)
{
return(Ok());
}
}
return(BadRequest());
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel resetPasswordModel)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByNameAsync(resetPasswordModel.Username);
var token = System.Text.Encoding.ASCII.GetString(WebEncoders.Base64UrlDecode(resetPasswordModel.Token));
var identityResult = await this.UserManager.ResetPasswordAsync(user, token, resetPasswordModel.Password);
if (identityResult.Succeeded)
{
this.CacheManager.ClearRegion(EntityControllerBase.ControllerCacheRegionUrn);
await SignInManager.SignInAsync(user, isPersistent : false);
var avatarUrl = $"{ this.RoadieHttpContext.ImageBaseUrl }/user/{ user.RoadieId }/{ this.RoadieSettings.ThumbnailImageSize.Width }/{ this.RoadieSettings.ThumbnailImageSize.Height }";
var t = await this.TokenService.GenerateToken(user, this.UserManager);
return(Ok(new
{
Username = user.UserName,
RecentLimit = user.RecentlyPlayedLimit,
user.RemoveTrackFromQueAfterPlayed,
user.Email,
user.LastLogin,
avatarUrl,
Token = t,
user.Timeformat,
user.Timezone
}));
}
else
{
return(BadRequest(identityResult.Errors));
}
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> ConfirmEmail([FromBody] EmailConfirmationDTO emailConfirmation)
{
try
{
if (!ModelState.IsValid)
{
_logger.LogTrace("Email confirmation failed due to missing parameters.", emailConfirmation);
return(BadRequest("Confirmation details required."));
}
var user = await _unitOfWork.UserManager.FindByIdAsync(emailConfirmation.UserId).ConfigureAwait(false);
if (user == null)
{
_logger.LogWarning("Email confirmation attempted with bad user ID.");
return(StatusCode(500, "Email confirmation unsuccessful."));
}
emailConfirmation.Token = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(emailConfirmation.Token));
var result = await _unitOfWork.UserManager.ConfirmEmailAsync(user, emailConfirmation.Token).ConfigureAwait(false);
if (!result.Succeeded)
{
_logger.LogInformation("Email confirmation failed due to invalid code.");
return(BadRequest("Email confirmation failed: validation code invalid."));
}
_logger.LogInformation($"Email confirmation succeeded for {user.UserName}.");
return(NoContent());
}
catch (Exception ex)
{
_logger.LogError(ex, "Exception thrown attempting to confirm email.");
return(StatusCode(500, "Email confirmation unsuccessful."));
}
}
public async Task <RespostaViewModel> ConfirmarEmailAsync(string userId, string token)
{
var usuario = await userManager.FindByIdAsync(userId);
if (usuario == null)
{
return(new RespostaViewModel
{
Mensagem = "Não foi possível confirmar o email.",
Objeto = null,
Success = false
});
}
var decodedToken = WebEncoders.Base64UrlDecode(token);
string normalToken = Encoding.UTF8.GetString(decodedToken);
var result = await userManager.ConfirmEmailAsync(usuario, normalToken);
if (result.Succeeded)
{
return(new RespostaViewModel
{
Mensagem = "E-mail confirmado com sucesso!",
Objeto = null,
Success = true
});
}
return(new RespostaViewModel
{
Mensagem = "Erro! O e-mail não foi confirmado.",
Objeto = null,
Success = false
});
}
public async Task <UserManagerResponse> ConfirmEmailAsync(string userId, string token)
{
var user = await _userManger.FindByIdAsync(userId);
if (user == null)
{
return new UserManagerResponse
{
IsSuccess = false,
Message = "User not found"
}
}
;
var decodedToken = WebEncoders.Base64UrlDecode(token);
string normalToken = Encoding.UTF8.GetString(decodedToken);
var result = await _userManger.ConfirmEmailAsync(user, normalToken);
if (result.Succeeded)
{
return new UserManagerResponse
{
Message = "Email confirmed successfully!",
IsSuccess = true,
}
}
;
return(new UserManagerResponse
{
IsSuccess = false,
Message = "Email did not confirm",
Errors = result.Errors.Select(e => e.Description)
});
}
public IActionResult Get(string id, string parameters)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
#pragma warning disable CS1701 // Assuming assembly reference matches identity
var documentUrl = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(id));
var providerParameters = string.IsNullOrEmpty(parameters) ? string.Empty : Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(parameters));
var documentBytes = System.IO.File.ReadAllBytes(@"d:\test\sample.pdf");
#pragma warning restore CS1701 // Assuming assembly reference matches identity
GetSigningDocumentResponse response = new GetSigningDocumentResponse();
response.DettachedSignature = null;
response.Document = documentBytes;
response.HashAlgorithm = HashAlgorithm.Default;
response.Options = SignatureFlags.PDFAdESUseParametersInWidget | SignatureFlags.PDFAdESIncludeFontInWidget;
response.Parameters = new SignatureParameters();
response.Parameters.header = "ÑEÉâññsE(E)EE";
response.Parameters.signerCaption = "This \u03C0";
response.Parameters.signerInfo = "ÑñÑñÑñÑñ";
response.Parameters.algorithmCaption = "ÑñÑñÑñÑ";
response.Parameters.algorithmInfo = "Ñañañañañañañ";
response.SignatureProfile = SignatureProfile.PDF;
response.SignatureType = SignatureType.Default;
#pragma warning disable CS1701 // Assuming assembly reference matches identity
return(Ok(response));
#pragma warning restore CS1701 // Assuming assembly reference matches identity
}
/// <summary>
/// Cryptographically unprotects a piece of protected data.
/// </summary>
/// <param name="protector">The data protector to use for this operation.</param>
/// <param name="protectedData">The protected data to unprotect.</param>
/// <returns>The plaintext form of the protected data.</returns>
/// <exception cref="System.Security.Cryptography.CryptographicException">
/// Thrown if <paramref name="protectedData"/> is invalid or malformed.
/// </exception>
public static string Unprotect(this IDataProtector protector, string protectedData)
{
if (protector == null)
{
throw new ArgumentNullException(nameof(protector));
}
if (protectedData == null)
{
throw new ArgumentNullException(nameof(protectedData));
}
try
{
byte[] protectedDataAsBytes = WebEncoders.Base64UrlDecode(protectedData);
byte[] plaintextAsBytes = protector.Unprotect(protectedDataAsBytes);
return(EncodingUtil.SecureUtf8Encoding.GetString(plaintextAsBytes));
}
catch (Exception ex) when(ex.RequiresHomogenization())
{
// Homogenize exceptions to CryptographicException
throw Error.CryptCommon_GenericError(ex);
}
}
public void RejectsDamagedTokens(AccessToken accessToken)
{
// Arrange
var factory = CreateFactory();
var target = factory.Create(CreateSettings());
// Act
var tokenStr = target.Issue(accessToken);
var tokenSplitted = tokenStr.Split(".");
for (int i = 0; i < tokenSplitted.Length; i++)
{
var item = tokenSplitted[i];
var tokenSplittedCopy = tokenSplitted.Clone() as string[];
var bits = new BitArray(WebEncoders.Base64UrlDecode(item));
Parallel.For(
0,
bits.Count,
(j) =>
{
var bitsCopy = new BitArray(bits);
bitsCopy[j] = !bitsCopy[j];
tokenSplittedCopy[i] = WebEncoders.Base64UrlEncode(bitsCopy.ToByteArray());
var invalidToken = string.Join(".", tokenSplittedCopy);
var result = target.TryVerify(invalidToken, out AccessToken actual);
// Assert
Assert.False(result);
Assert.Null(actual);
});
}
}
public async Task <ActionResult> ConfirmEmail(string userId, string code)
{
if (userId == null || code == null)
{
return(BadRequest());
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(BadRequest("User Não Existe!"));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest("Erro"));
}
public async Task <UserDto> Handle(Command request, CancellationToken cancellationToken)
{
var user = await userManager.FindByIdAsync(userAccessor.GetCurrentUserId());
if (user == null)
{
return(null);
}
var role = await roleAccessor.GetUserRoleAsync(user);
var tokenBytes = WebEncoders.Base64UrlDecode(request.RefreshToken);
var decodedToken = Encoding.UTF8.GetString(tokenBytes);
var result = await userAccessor.ConfirmRefreshTokenAsync(user, userManager, decodedToken);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
var newRefreshToken = await userManager.GenerateUserTokenAsync(user, TokenOptions.DefaultProvider, "RefreshToken");
return(new UserDto(user, role, tokenGenerator, newRefreshToken));
}
/// <summary>
/// Decrypts the message
/// </summary>
public string?Decrypt(string inputText, string key)
{
if (string.IsNullOrWhiteSpace(inputText))
{
throw new ArgumentNullException(nameof(inputText));
}
try
{
var inputBytes = WebEncoders.Base64UrlDecode(inputText);
var bytes = decrypt(inputBytes, key);
return(Encoding.UTF8.GetString(bytes));
}
catch (FormatException ex)
{
_logger.LogError(ex.Demystify(), "Invalid base 64 string. Fall through.");
}
catch (CryptographicException ex)
{
_logger.LogError(ex.Demystify(), "Invalid protected payload. Fall through.");
}
return(null);
}
/// <summary>
/// Decrypts the message
/// </summary>
public string Decrypt(string inputText)
{
if (inputText == null)
{
throw new ArgumentNullException(nameof(inputText));
}
try
{
var inputBytes = WebEncoders.Base64UrlDecode(inputText);
var bytes = _dataProtector.Unprotect(inputBytes);
return(Encoding.UTF8.GetString(bytes));
}
catch (FormatException ex)
{
_logger.LogError(ex.Message, "Invalid base 64 string. Fall through.");
}
catch (CryptographicException ex)
{
_logger.LogError(ex.Message, "Invalid protected payload. Fall through.");
}
return(null);
}