public override async Task <IdentityResult> CreateAsync(ApplicationUser user, string password) { IUserPasswordStore <ApplicationUser> aa = Store as IUserPasswordStore <ApplicationUser>; if ((object)user == null) { // return new IdentityResult(string.Format(SystemMessage.NewException, "CreateAsync User Null")); if (password == null) { return(null); } } // return new IdentityResult(string.Format(SystemMessage.NewException, "CreateAsync Password Null")); IdentityResult sssS = await this.UpdatePassword(aa, user, password); IdentityResult s = await base.CreateAsync(user); //await this.UpdateSecurityStampInternal(user); //IdentityResult identityResult = await this.UserValidator.ValidateAsync(user).WithCurrentCulture<IdentityResult>(); //if (!identityResult.Succeeded) // return identityResult; //if (this.UserLockoutEnabledByDefault && this.SupportsUserLockout) // await this.GetUserLockoutStore().SetLockoutEnabledAsync(user, true).WithCurrentCulture(); await this.Store.CreateAsync(user); //return IdentityResult.Success; //Store.CreateAsync(user); // var ss = _userService; return(null); }
public virtual async Task <bool> CheckPasswordAsync(TUser user, string password) { ThrowIfDisposed(); IUserPasswordStore <TUser> passwordStore = GetPasswordStore(); if (user == null) { return(false); } PasswordVerificationResult result = await VerifyPasswordAsync(passwordStore, user, password); if (result == PasswordVerificationResult.SuccessRehashNeeded) { await UpdatePasswordHash(passwordStore, user, password, validatePassword : false); await UpdateUserAsync(user); } bool success = result != PasswordVerificationResult.Failed; if (!success) { Logger.LogWarning(LoggerEventIds.InvalidPassword, "Invalid password!"); } return(success); }
protected override Task <IdentityResult> UpdatePassword(IUserPasswordStore <ApplicationUser, string> passwordStore, ApplicationUser user, string newPassword) { // update the LastPasswordChangedDate field user.LastPasswordChangedDate = DateTime.Now; return(base.UpdatePassword(passwordStore, user, newPassword)); }
Task <PasswordVerificationResult> IAppUserManager.VerifyPasswordAsync( IUserPasswordStore <User> store, User user, string password) { return(base.VerifyPasswordAsync(store, user, password)); }
protected override async Task <bool> VerifyPasswordAsync(IUserPasswordStore <User, int> store, User user, string password) { string userEnteredPasswordHash = _encryptionService.CreatePasswordHash(password, user.PasswordSalt); return(userEnteredPasswordHash == user.PasswordHash); //return base.VerifyPasswordAsync(store, user, password); }
/// <summary> /// Updates the user password. /// </summary> /// <param name="passwordStore">Unused implementation of UserPasswordStore.</param> /// <param name="user">User.</param> /// <param name="newPassword">New password in plain text format.</param> protected override async Task <IdentityResult> UpdatePassword(IUserPasswordStore <User, int> passwordStore, User user, string newPassword) { if (user == null) { throw new ArgumentNullException(nameof(user)); } var result = await PasswordValidator.ValidateAsync(newPassword); if (!result.Succeeded) { return(result); } UserInfo userInfo = UserInfoProvider.GetUserInfo(user.Id); if (userInfo == null) { user.GUID = Guid.NewGuid(); user.PasswordHash = UserInfoProvider.GetPasswordHash(newPassword, UserInfoProvider.NewPasswordFormat, user.GUID.ToString()); } else { UserInfoProvider.SetPassword(userInfo, newPassword); user.PasswordHash = ValidationHelper.GetString(userInfo.GetValue("UserPassword"), string.Empty); await UpdateSecurityStampInternal(user); } return(IdentityResult.Success); }
public virtual async Task <AuthResult> ChangePasswordAsync(TUser user, string currentPassword, string newPassword) { ThrowIfDisposed(); IUserPasswordStore <TUser> passwordStore = GetPasswordStore(); if (user == null) { throw new ArgumentNullException(nameof(user)); } if (await VerifyPasswordAsync(passwordStore, user, currentPassword) != PasswordVerificationResult.Failed) { AuthResult result = await UpdatePasswordHash(passwordStore, user, newPassword); if (!result.Succeeded) { return(result); } return(await UpdateUserAsync(user)); } Logger.LogWarning(LoggerEventIds.ChangePasswordFailed, "Password change failed!"); return(AuthResult.Failed(ErrorDescriber.PasswordMismath())); }
protected override Task <bool> VerifyPasswordAsync(IUserPasswordStore <User, int> store, User user, string password) { _passwordHasher.Salt = user.PasswordSalt; var result = _passwordHasher.VerifyHashedPassword(user.PasswordHash, password); return(Task.FromResult(result == PasswordVerificationResult.Success)); }
public void Init() { repository = new Mock <IRepository <UserModel> >(); userStore = new UserStore(repository.Object); userStoreMethodLookup = new UserStore(new TestRepository(new SqlMethodLookup())); cancellationTokenSource = new CancellationTokenSource(); }
protected override async Task <bool> VerifyPasswordAsync(IUserPasswordStore <User, int> store, User user, string password) { var hash = await store.GetPasswordHashAsync(user); return(hash == password); }
protected virtual async Task <bool> VerifyPasswordAsync(IUserPasswordStore <ApplicationUser, Guid> store, ApplicationUser user, string password) { var hash = await store.GetPasswordHashAsync(user).WithCurrentCulture(); return(PasswordHasher.VerifyHashedPassword(hash, password) != PasswordVerificationResult.Failed); }
public HomeController( ILogger <HomeController> logger, UserManager <User> userManager, RoleManager <Role> roleManager, SignInManager <User> signInManager, IUserStore <User> userStore, IRoleStore <Role> roleStore, IPasswordHasher <User> passwordHasher, IPasswordValidator <User> passwordValidator, IUserPasswordStore <User> passwordStore //IUserValidator<User> userValidator, //IRoleValidator<User> roleValidator ) { Logger = logger; UserManager = userManager; RoleManager = roleManager; SignInManager = signInManager; UserStore = userStore; RoleStore = roleStore; PasswordHasher = passwordHasher; PasswordValidator = passwordValidator; PasswordStore = passwordStore; //UserValidator = userValidator; //RoleValidator = roleValidator; }
internal async System.Threading.Tasks.Task <IdentityResult> ChangePasswordAsync(int userId, string newPassword) { AppUser user = await this.FindByIdAsync(userId).ConfigureAwait(false); if (user == null) { throw new InvalidOperationException("user not found"); } IdentityResult result = await this.PasswordValidator.ValidateAsync(newPassword).ConfigureAwait(false); IUserPasswordStore <AppUser, int> pwdStore = (IUserPasswordStore <AppUser, int>) this.Store; if (result.Succeeded) { await pwdStore.SetPasswordHashAsync(user, newPassword).ConfigureAwait(false); } if (result.Succeeded) { result = await this.UpdateSecurityStampAsync(user.Id); } if (result.Succeeded) { result = await this.UpdateAsync(user); } return(result); }
public NarikJwtLoginService( IUserPasswordStore <ApplicationUser> userPasswordStore, IPasswordHasher <ApplicationUser> passwordHasher, NarikModulesConfig config) { _userPasswordStore = userPasswordStore; _passwordHasher = passwordHasher; _config = config; }
public ManagerIdentityUser(IUserPasswordStore <User, int> store) : base(store) { UserValidator = new UserValidator <User, int>(this) { AllowOnlyAlphanumericUserNames = false, //RequireUniqueEmail = true }; }
public void SetSpecificationContext() { _passwordStore = RavenUserStore as IUserPasswordStore <RavenIdentityUser>; if (_passwordStore == null) { Assert.Ignore(); } }
private async Task <IdentityResult> UpdatePasswordHash(IUserPasswordStore <TUser> passwordStore, TUser user, string newPassword, bool validatePassword = true) { var hash = newPassword != null?PasswordHasher.HashPassword(user, newPassword) : null; await passwordStore.SetPasswordHashAsync(user, hash, CancellationToken); // await UpdateSecurityStampInternal(user); return(IdentityResult.Success); }
protected async override Task <bool> VerifyPasswordAsync(IUserPasswordStore <AppUser, int> store, AppUser user, string password) { //base.VerifyPasswordAsync 使用的是 Rfc2898DeriveBytes 密码, //而这里传入的 password , 即上面的 CheckPasswordAsync 密码,未加密 //return await base.VerifyPasswordAsync(store, user, password); var hash = await store.GetPasswordHashAsync(user); return(string.Equals(hash, password)); }
protected override async Task <bool> VerifyPasswordAsync(IUserPasswordStore <User, int> store, User user, string password) { var psUser = await store.FindByIdAsync(user.Id); if (psUser != null) { return(psUser.PasswordHash.Equals(password)); } return(false); }
protected override Task <bool> VerifyPasswordAsync(IUserPasswordStore <VistaUser, string> store, VistaUser user, string password) { //Logger.Log("ApplicationUserManager:VerifyPasswordAsync (user = {0}, password = {1})", user, password); //return base.VerifyPasswordAsync(store, user, password); bool retVal = false; retVal = user.PasswordHash == password; return(Task.FromResult <bool>(retVal)); }
private IUserPasswordStore <TUser> GetPasswordStore() { IUserPasswordStore <TUser> store = Store as IUserPasswordStore <TUser>; if (store == null) { throw new NotSupportedException("Store isn't a password store!"); } return(store); }
/// <summary> /// Verifies the user password. /// </summary> /// <param name="store">Unused implementation of UserPasswordStore.</param> /// <param name="user">User.</param> /// <param name="password">Password in plain text format.</param> protected override Task <bool> VerifyPasswordAsync(IUserPasswordStore <User, int> store, User user, string password) { if (user == null) { return(Task.FromResult(false)); } var userInfo = UserInfoProvider.GetUserInfo(user.UserName); return(Task.FromResult(!UserInfoProvider.IsUserPasswordDifferent(userInfo, password))); }
/// <summary> /// Verifies the user password. /// </summary> /// <param name="store">Unused implementation of UserPasswordStore.</param> /// <param name="user">User.</param> /// <param name="password">Password in plain text format.</param> /// <returns><see langword="true"/> if <paramref name="password"/> matches the one in the database. Otherwise <see langword="false"/>.</returns> protected override Task <bool> VerifyPasswordAsync(IUserPasswordStore <MedioClinicUser, int> store, MedioClinicUser user, string password) { if (user == null) { return(Task.FromResult(false)); } var userInfo = UserInfoProvider.GetUserInfo(user.UserName); var result = !userInfo.IsExternal && !userInfo.UserIsDomain && !UserInfoProvider.IsUserPasswordDifferent(userInfo, password); return(Task.FromResult(result)); }
protected override async Task <bool> VerifyPasswordAsync( IUserPasswordStore <ApplicationUser, string> store, ApplicationUser user, string password) { var hash = await store.GetPasswordHashAsync(user); var verifyRes = PasswordHasher.VerifyHashedPassword(hash, password); if (verifyRes == PasswordVerificationResult.SuccessRehashNeeded) { await store.SetPasswordHashAsync(user, PasswordHasher.HashPassword(password)); } return(verifyRes != PasswordVerificationResult.Failed); }
private async Task <IdentityResult> UpdatePasswordInternal(IUserPasswordStore <TUser, TKey> passwordStore, TUser user, string newPassword) { var result = await PasswordValidator.ValidateAsync(newPassword).WithCurrentCulture(); if (!result.Succeeded) { return(result); } await passwordStore.SetPasswordHashAsync(user, PasswordHasher.HashPassword(newPassword)).WithCurrentCulture(); await UpdateSecurityStampInternal(user).WithCurrentCulture(); return(IdentityResult.Success); }
private async Task <IdentityResult> UpdatePasswordInternal(IUserPasswordStore <IdentityUser, long> passwordStore, IdentityUser user, string newPassword) { var result = await PasswordValidator.ValidateAsync(newPassword).ConfigureAwait(false); if (!result.Succeeded) { return(result); } result = null; await passwordStore.SetPasswordHashAsync(user, PasswordHasher.HashPassword(newPassword)).ConfigureAwait(false); //await UpdateSecurityStampInternal(user).ConfigureAwait(false); return(IdentityResult.Success); }
public DiTestController( // the Microsoft.AspNetCore.Identity User and Role Manager classes RoleManager <IdentityRole> roleManager, UserManager <ApplicationUser> userManager, IIdentityDatabaseContext <ApplicationUser, IdentityRole, string> identityDatabaseContext, // if want to use with SOLID and Interface Segregation Principle, then can just use the specific interface that need // these interfaces are all implemented by UserStore IUserStore <ApplicationUser> userStore, IUserLoginStore <ApplicationUser> userLoginStore, IUserRoleStore <ApplicationUser> userRoleStore, IUserClaimStore <ApplicationUser> userClaimStore, IUserPasswordStore <ApplicationUser> userPasswordStore, IUserSecurityStampStore <ApplicationUser> userSecurityStampStore, IUserEmailStore <ApplicationUser> userEmailStore, IUserLockoutStore <ApplicationUser> userLockoutStore, IUserPhoneNumberStore <ApplicationUser> userPhoneNumberStore, IUserTwoFactorStore <ApplicationUser> userTwoFactorStore, IQueryableUserStore <ApplicationUser> queryableUserStore, // these interfaces are all implemented by RoleStore IRoleStore <IdentityRole> roleStore, IRoleClaimStore <IdentityRole> roleClaimStore, IQueryableRoleStore <IdentityRole> queryableRoleStore ) { _roleManager = roleManager; _userManager = userManager; _identityDatabaseContext = identityDatabaseContext; _userStore = userStore; _userLoginStore = userLoginStore; _userRoleStore = userRoleStore; _userClaimStore = userClaimStore; _userPasswordStore = userPasswordStore; _userSecurityStampStore = userSecurityStampStore; _userEmailStore = userEmailStore; _userLockoutStore = userLockoutStore; _userPhoneNumberStore = userPhoneNumberStore; _userTwoFactorStore = userTwoFactorStore; _queryableUserStore = queryableUserStore; _roleStore = roleStore; _roleClaimStore = roleClaimStore; _queryableRoleStore = queryableRoleStore; }
protected async override Task <IdentityResult> UpdatePassword(IUserPasswordStore <ApplicationUser, int> passwordStore, ApplicationUser user, string newPassword) { try { user.Password = newPassword; user.PasswordHash = PasswordHasher.HashPassword(newPassword); user.ResetPasswordToken = await GeneratePasswordResetTokenAsync(user.Id); await base.UpdateAsync(user); return(IdentityResult.Success); } catch (Exception ex) { return(IdentityResult.Failed(ex.Message)); } }
protected override async Task <bool> VerifyPasswordAsync(IUserPasswordStore <CustomUser, int> store, CustomUser user, string password) { var hash = await store.GetPasswordHashAsync(user).WithCurrentCulture(); var pwdResult = PasswordHasher.VerifyHashedPassword(hash, password); if (pwdResult == PasswordVerificationResult.SuccessRehashNeeded) { var newHashedPwd = PasswordHasher.HashPassword(password); await store.SetPasswordHashAsync(user, newHashedPwd); await store.UpdateAsync(user); } return(pwdResult != PasswordVerificationResult.Failed); }
private async Task <IdentityResult> UpdatePasswordHash(IUserPasswordStore <TUser> passwordStore, TUser user, string newPassword, bool validatePassword = true) { if (validatePassword) { var validate = await ValidatePasswordAsync(user, newPassword); if (!validate.Succeeded) { return(validate); } } var hash = newPassword != null?PasswordHasher.HashPassword(user, newPassword) : null; await passwordStore.SetPasswordHashAsync(user, hash, CancellationToken); return(IdentityResult.Success); }
public AccountController(IUserLoginStore<User, Guid> userLoginStore, IUserPasswordStore<User, Guid> userPasswordStore, IPasswordHasher passwordHasher) { if (userLoginStore == null) { throw new ArgumentNullException("userLoginStore"); } if (userPasswordStore == null) { throw new ArgumentNullException("userPasswordStore"); } if (passwordHasher == null) { throw new ArgumentNullException("passwordHasher"); } _userLoginStore = userLoginStore; _userPasswordStore = userPasswordStore; _passwordHasher = passwordHasher; }