ASP.NET&Spring.NET&NHibernate最佳实践(二十一)——第4章权限子系统（14）

成员资格信息提供类（HibernateMembershipProvider.cs）

        /**//// <summary>
        /// 将用户密码重置为一个自动生成的新密码
        /// </summary>
        /// <param name="username"></param>
        /// <param name="answer"></param>
        /// <returns></returns>
        public override string ResetPassword(string username, string passwordAnswer)
        {
            if (!this.EnablePasswordReset)
            {
                throw new NotSupportedException("Not configured to support password resets.");
            }

            SecUtility.CheckParameter(ref username, true, true, true, 255, "username");

            int status;
            string password;
            MembershipPasswordFormat passwordFormat;
            string salt;
            int failedPasswordAttemptCount;
            int failedPasswordAnswerAttemptCount;
            bool isApproved;
            DateTime lastLoginDate;
            DateTime lastActivityDate;

            GetPasswordWithFormat(this._applicationName, username, false, out status, out password, out passwordFormat,
                out salt, out failedPasswordAttemptCount, out failedPasswordAnswerAttemptCount, out isApproved,
                out lastLoginDate, out lastActivityDate);

            if (status == 0)
            {
                if (passwordAnswer != null)
                {
                    passwordAnswer = passwordAnswer.Trim();
                }

                string answer;

                if (!String.IsNullOrEmpty(passwordAnswer))
                {
                    answer = EncodePassword(passwordAnswer.ToLower(CultureInfo.InvariantCulture), passwordFormat, salt);
                }
                else
                {
                    answer = passwordAnswer;
                }

                SecUtility.CheckParameter(ref answer, this._requiresQuestionAndAnswer, this._requiresQuestionAndAnswer, false, 128, "passwordAnswer");

                string newPassword = GeneratePassword();

                ValidatePasswordEventArgs args = new ValidatePasswordEventArgs(username, newPassword, false);
                this.OnValidatingPassword(args);

                if (args.Cancel)
                {
                    if (args.FailureInformation != null)
                    {
                        throw args.FailureInformation;
                    }

                    throw new ProviderException("Membership custom password validation failure.");
                }

                status = ServiceLocator.UserService.ResetPassword(this._applicationName, username, newPassword,
                    this._maxInvalidPasswordAttempts, this._passwordAttemptWindow, salt, passwordFormat, answer,
                     DateTime.UtcNow);

                if (status != 0)
                {
                    string errText = this.GetExceptionText(status);

                    if (this.IsStatusDueToBadPassword(status))
                    {
                        throw new MembershipPasswordException(errText);
                    }

                    throw new ProviderException(errText);
                }

            }

            if (IsStatusDueToBadPassword(status))
            {
                throw new MembershipPasswordException(GetExceptionText(status));
            }

            throw new ProviderException(this.GetExceptionText(status));
        }

        /**//// <summary>
        /// 清除用户的锁定状态，以便可以验证该成员资格用户
        /// </summary>
        /// <param name="username"></param>
        /// <returns></returns>
        public override bool UnlockUser(string username)
        {
            SecUtility.CheckParameter(ref username, true, true, true, 255, "username");

            int status = ServiceLocator.UserService.UnlockUser(this._applicationName, username);

            if (status == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /**//// <summary>
        /// 更新成员资格数据库中用户的信息
        /// </summary>
        /// <param name="user"></param>
        public override void UpdateUser(MembershipUser user)
        {
            if (user == null)
            {
                throw new ArgumentNullException("user.");
            }

            string email = user.Email;
            SecUtility.CheckParameter(ref email, this._requiresUniqueEmail, this._requiresUniqueEmail, false, 255, "email");
            user.Email = email;

            int status = ServiceLocator.UserService.UpdateUser(this._applicationName, user.UserName, user.Email,
                user.Comment, user.IsApproved, user.LastLoginDate.ToUniversalTime(), user.LastActivityDate.ToUniversalTime(),
                this._requiresUniqueEmail);

            if (status != 0)
            {
                throw new ProviderException(GetExceptionText(status));
            }
        }

        /**//// <summary>
        /// 验证成员资格数据库中是否存在指定的用户名和密码
        /// </summary>
        /// <param name="username"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public override bool ValidateUser(string username, string password)
        {
            if ((SecUtility.ValidateParameter(ref username, true, true, true, 255) &&
                SecUtility.ValidateParameter(ref password, true, true, false, 128)) &&
                CheckPassword(username, password, true, true))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        #endregion 方法

        private bool IsStatusDueToBadPassword(int status)
        {
            if ((status >= 2) && (status <= 6))
            {
                return true;
            }
            return (status == 99);
        }

        private string GenerateSalt()
        {
            byte[] buffer = new byte[16];
            new RNGCryptoServiceProvider().GetBytes(buffer);
            return Convert.ToBase64String(buffer);
        }

        private DateTime RoundToSeconds(DateTime dt)
        {
            return new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
        }

        private string GetEncodedPasswordAnswer(string username, string passwordAnswer)
        {
            if (passwordAnswer != null)
            {
                passwordAnswer = passwordAnswer.Trim();
            }

            if (!String.IsNullOrEmpty(passwordAnswer))
            {
                int status;
                string password;
                MembershipPasswordFormat passwordFormat;
                string salt;
                int failedPasswordAttemptCount;
                int failedPasswordAnswerAttemptCount;
                bool isApproved;
                DateTime lastLoginDate;
                DateTime lastActivityDate;

                GetPasswordWithFormat(this._applicationName, username, false, out status, out password,
                    out passwordFormat, out salt, out failedPasswordAttemptCount, out failedPasswordAnswerAttemptCount,
                    out isApproved, out lastLoginDate, out lastActivityDate);

                if (status != 0)
                {
                    throw new ProviderException(GetExceptionText(status));
                }

                return EncodePassword(passwordAnswer.ToLower(CultureInfo.InvariantCulture), passwordFormat, salt);
            }

            return passwordAnswer;
        }

        private string GeneratePassword()
        {
            return Membership.GeneratePassword((this._minRequiredPasswordLength < 14) ? 14 : this._minRequiredPasswordLength,
                this._minRequiredNonAlphanumericCharacters);
        }


        private string EncodePassword(string pass, MembershipPasswordFormat passwordFormat, string salt)
        {
            if (passwordFormat == MembershipPasswordFormat.Clear)
            {
                return pass;
            }

            byte[] bIn = Encoding.Unicode.GetBytes(pass);
            byte[] bSalt = Convert.FromBase64String(salt);
            byte[] bAll = new byte[bSalt.Length + bIn.Length];
            byte[] bRet = null;

            Buffer.BlockCopy(bSalt, 0, bAll, 0, bSalt.Length);
            Buffer.BlockCopy(bIn, 0, bAll, bSalt.Length, bIn.Length);
            if (passwordFormat == MembershipPasswordFormat.Hashed)
            {
                HashAlgorithm s = HashAlgorithm.Create(Membership.HashAlgorithmType);

                if (s == null)
                {
                    throw new ProviderException("Could not create a hash algorithm");
                }
                bRet = s.ComputeHash(bAll);
            }
            else
            {
                bRet = base.EncryptPassword(bAll);
            }

            return Convert.ToBase64String(bRet);
        }

        private string UnEncodePassword(string pass, MembershipPasswordFormat passwordFormat)
        {
            switch (passwordFormat)
            {
                case MembershipPasswordFormat.Clear:
                    return pass;

                case MembershipPasswordFormat.Hashed:
                    throw new ProviderException("Provider can not decode hashed password");
            }

            byte[] buffer = this.DecryptPassword(Convert.FromBase64String(pass));

            if (buffer == null)
            {
                return null;
            }

            return Encoding.Unicode.GetString(buffer, 16, buffer.Length - 16);
        }

        private bool CheckPassword(string username, string password, bool updateLastLoginActivityDate, bool failIfNotApproved)
        {
            string salt;
            MembershipPasswordFormat passwordFormat;
            return CheckPassword(username, password, updateLastLoginActivityDate, failIfNotApproved,
                out salt, out passwordFormat);
        }

        private bool CheckPassword(string username, string password, bool updateLastLoginActivityDate, bool failIfNotApproved,
            out string salt, out MembershipPasswordFormat passwordFormat)
        {
            int status;
            string pass;
            int failedPasswordAttemptCount;
            int failedPasswordAnswerAttemptCount;
            bool isApproved;
            DateTime lastLoginDate;
            DateTime lastActivityDate;


            GetPasswordWithFormat(this._applicationName, username, updateLastLoginActivityDate, out status,
                out pass, out passwordFormat, out salt, out failedPasswordAttemptCount,
                out failedPasswordAnswerAttemptCount, out isApproved, out lastLoginDate, out  lastActivityDate);

            if (status != 0)
            {
                return false;
            }
            if (!isApproved && failIfNotApproved)
            {
                return false;
            }

            password = EncodePassword(password, passwordFormat, salt);

            bool isPasswordCorrect = password.Equals(pass);

            if ((isPasswordCorrect && (failedPasswordAttemptCount == 0)) && (failedPasswordAnswerAttemptCount == 0))
            {
                return true;
            }

            ServiceLocator.UserService.UpdateUserInfo(this._applicationName, username, isPasswordCorrect,
                this._passwordAttemptWindow, this._maxInvalidPasswordAttempts,
                updateLastLoginActivityDate, DateTime.UtcNow);

            return isPasswordCorrect;

        }

        private string GetExceptionText(int status)
        {
            string errText;
            switch (status)
            {
                case 0:
                    return String.Empty;

                case 1:
                    errText = "Membership user not found.";
                    break;

                case 2:
                    errText = "Membership wrong password.";
                    break;

                case 3:
                    errText = "Membership wrong answer.";
                    break;

                case 4:
                    errText = "Membership invalid password.";
                    break;

                case 5:
                    errText = "Membership invalid question.";
                    break;

                case 6:
                    errText = "Membership invalid answer.";
                    break;

                case 7:
                    errText = "Membership invalid email.";
                    break;

                case 99:
                    errText = "Membership account lock out.";
                    break;

                default:
                    errText = "Provider error.";
                    break;
            }
            return errText;
        }

        private int CreateUser(string applicationName, string username, string password, string passwordSalt,
            string email, string passwordQuestion, string passwordAnswer, bool isApproved, bool uniqueEmail,
            MembershipPasswordFormat passwordFormat, DateTime currentTimeUtc, out int userID)
        {
            userID = -1;


            if (ServiceLocator.UserService.GetUserByName(applicationName, username) != null)
            {
                return 6; //MembershipCreateStatus.DuplicateUserName
            }

            if (uniqueEmail && ServiceLocator.UserService.GetUsersByEmail(applicationName, email).Count > 0)
            {
                return 7; //MembershipCreateStatus.DuplicateEmail
            }

            User user = new User();
            user.Username = username;
            user.Email = email;
            user.Password = password;
            user.PasswordFormat = passwordFormat;
            user.PasswordSalt = passwordSalt;
            user.PasswordQuestion = passwordQuestion;
            user.PasswordAnswer = passwordAnswer;
            user.IsAnonymous = false;
            user.IsApproved = isApproved;
            user.IsLockedOut = false;
            user.CreateDate = currentTimeUtc;
            user.LastActivityDate = currentTimeUtc;
            user.LastLoginDate = currentTimeUtc;
            user.LastPasswordChangedDate = currentTimeUtc;
            user.LastLockoutDate = new DateTime(1754, 1, 1);
            user.FailedPasswordAttemptCount = 0;
            user.FailedPasswordAttemptWindowStart = new DateTime(1754, 1, 1);
            user.FailedPasswordAnswerAttemptCount = 0;
            user.FailedPasswordAnswerAttemptWindowStart = new DateTime(1754, 1, 1);
            user.Application = ServiceLocator.ApplicationService.GetApplication(applicationName);

            ServiceLocator.UserService.CreateUser(user);

            if (user.ID > 0)
            {
                userID = user.ID;
                return 0;//MembershipCreateStatus.Success
            }
            else
            {
                return 11;//MembershipCreateStatus.ProviderError
            }
        }


        private void GetPasswordWithFormat(string applicationName, string username, bool updateLastLoginActivityDate, out int status,
             out string password, out MembershipPasswordFormat passwordFormat, out string passwordSalt,
             out int failedPasswordAttemptCount, out int failedPasswordAnswerAttemptCount, out bool isApproved,
             out DateTime lastLoginDate, out DateTime lastActivityDate)
        {
            User user = ServiceLocator.UserService.GetUserByName(applicationName, username);

            if (user != null)
            {
                if (updateLastLoginActivityDate && user.IsApproved)
                {
                    user.LastActivityDate = DateTime.UtcNow;
                    user.LastLoginDate = DateTime.UtcNow;

                    ServiceLocator.UserService.UpdateUser(user);
                }

                password = user.Password;
                passwordFormat = user.PasswordFormat;
                passwordSalt = user.PasswordSalt;
                failedPasswordAttemptCount = user.FailedPasswordAttemptCount;
                failedPasswordAnswerAttemptCount = user.FailedPasswordAnswerAttemptCount;
                isApproved = user.IsApproved;
                lastLoginDate = user.LastLoginDate;
                lastActivityDate = user.LastActivityDate;

                status = 0;
            }
            else
            {
                password = null;
                passwordFormat = MembershipPasswordFormat.Clear;
                passwordSalt = null;
                failedPasswordAttemptCount = 0;
                failedPasswordAnswerAttemptCount = 0;
                isApproved = false;
                lastLoginDate = DateTime.UtcNow;
                lastActivityDate = DateTime.UtcNow;

                status = 1;
            }
        }
    }
}