C# MembershipPasswordFormat类代码示例

        /// <summary>
        /// Creates the membership user.
        /// </summary>
        /// <param name="userName">Name of the user.</param>
        /// <param name="password">The password.</param>
        /// <param name="emailAddress">The email address.</param>
        /// <param name="passwordQuestion">The password question.</param>
        /// <param name="passwordAnswer">The password answer.</param>
        /// <param name="isApproved">if set to <c>true</c> [is approved].</param>
        /// <param name="passwordFormat">The password format.</param>
        /// <returns></returns>
        /// <exception cref="ParameterNullException">userName
        /// or
        /// password
        /// or
        /// passwordQuestion
        /// or
        /// passwordAnswer</exception>
        /// <exception cref="System.ArgumentNullException">userName
        /// or
        /// password
        /// or
        /// passwordQuestion
        /// or
        /// passwordAnswer</exception>
        public IMembership CreateMembershipUser(string userName, string password, string emailAddress, string passwordQuestion,
                                            string passwordAnswer, bool isApproved, MembershipPasswordFormat passwordFormat)
        {
            if (string.IsNullOrEmpty(userName))
            {
                throw new ParameterNullException("userName");
            }

            if (string.IsNullOrEmpty(password))
            {
                throw new ParameterNullException("password");
            }

            if (string.IsNullOrEmpty(passwordQuestion))
            {
                throw new ParameterNullException("passwordQuestion");
            }

            if (string.IsNullOrEmpty(passwordAnswer))
            {
                throw new ParameterNullException("passwordAnswer");
            }

            IMembership membership = this.membershipFactory.Create(password, isApproved, passwordQuestion, passwordAnswer, passwordFormat);
            var newMembership = this.membershipRepository.Add(membership, userName);

            return newMembership;
        }

        public override void Initialize(string name, NameValueCollection config)
        {
            if (config == null) throw new ArgumentException("config");
            if (String.IsNullOrEmpty(name)) name = DEFAULT_PROVIDER_NAME;
            
            base.Initialize(name, config);

            applicationName = ConfigurationHelper.GetConfigStringValueOrDefault(config, ConfigurationHelper.CONFIG_APPLICATION_NAME_FIELD, System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath);
            description = ConfigurationHelper.GetConfigStringValueOrDefault(config, ConfigurationHelper.CONFIG_DESCRIPTION_FIELD, "Couch DB Membership Provider");
            enablePasswordReset = ConfigurationHelper.GetConfigBoolValueOrDefault(config, ConfigurationHelper.CONFIG_ENABLE_PASSWORD_RESET, false);
            enablePasswordRetrieval = false;
            maxInvalidPasswordAttempts = ConfigurationHelper.GetConfigIntValueOrDefault(config, ConfigurationHelper.CONFIG_MAX_INVALID_PASSWORD_ATTEMPTS, 5);
            minRequiredNonAlphanumericCharacters = ConfigurationHelper.GetConfigIntValueOrDefault(config, ConfigurationHelper.CONFIG_MIN_REQUIRED_NON_ALPHANUMERIC_CHARACTERS, 0);
            minRequiredPasswordLength = ConfigurationHelper.GetConfigIntValueOrDefault(config, ConfigurationHelper.CONFIG_MIN_REQUIRED_PASSWORD_LENGTH, 8);
            passwordAttemptWindow = ConfigurationHelper.GetConfigIntValueOrDefault(config, ConfigurationHelper.CONFIG_PASSWORD_ATTEMPT_WINDOW, 10);
            passwordFormat = MembershipPasswordFormat.Hashed;
            passwordStrengthRegularExpression = ConfigurationHelper.GetConfigStringValueOrDefault(config, ConfigurationHelper.CONFIG_PASSWORD_STRENGTH_REGULAR_EXPRESSION, String.Empty);
            requiresQuestionAndAnswer = ConfigurationHelper.GetConfigBoolValueOrDefault(config, ConfigurationHelper.CONFIG_REQUIRES_QUESTION_AND_ANSWER, false);
            requiresUniqueEmail = true;
            providerName = name;

            couchDbServerName = ConfigurationHelper.MembershipCouchDbServerName;
            couchDbServerPort = ConfigurationHelper.MembershipCouchDbServerPort;
            couchDbDatabaseName = ConfigurationHelper.MembershipCouchDbDatabaseName;

            if (String.IsNullOrEmpty(couchDbDatabaseName))
                throw new ProviderException(Strings.CouchDbConfigurationDatabaseNameMissing);

            machineKeySection = (MachineKeySection)WebConfigurationManager.GetWebApplicationSection("system.web/machineKey");
            if(machineKeySection == null)
                throw new ProviderException(Strings.HashedPasswordsRequireMachineKey);

            if (machineKeySection.ValidationKey.ToLower().Contains("Autogenerate".ToLower()))
                throw new ProviderException(Strings.HashedPasswordsRequireMachineKey);
        }

 public PasswordSettings(IPasswordResetRetrievalSettings resetOrRetrieval, int minimumLength, int minimumNonAlphanumericCharacters, string regularExpressionToMatch, MembershipPasswordFormat storageFormat)
 {
     ResetOrRetrieval = resetOrRetrieval;
     MinimumLength = minimumLength;
     MinimumNonAlphanumericCharacters = minimumNonAlphanumericCharacters;
     RegularExpressionToMatch = regularExpressionToMatch;
     StorageFormat = storageFormat;
 }

        public void VerifyPasswordTest(string password, MembershipPasswordFormat format)
        {
            string salt;
            var encoded = password.Encode(out salt, format);

            var result = password.VerifyPassword(encoded, format, salt);

            result.Should().BeTrue();
        }

        private string getValidationKey(MembershipPasswordFormat passwordFormat)
        {
            // Get encryption and decryption key information from the configuration.
            Configuration cfg = WebConfigurationManager.OpenWebConfiguration(HostingEnvironment.ApplicationVirtualPath);
            var machineKey = (MachineKeySection)cfg.GetSection("system.web/machineKey");

            if (machineKey.ValidationKey.Contains("AutoGenerate"))
                if (passwordFormat != MembershipPasswordFormat.Clear)
                    throw new ProviderException("Hashed or Encrypted passwords " +
                                                "are not supported with auto-generated keys.");

            return machineKey.ValidationKey;
        }

        /// <summary>
        /// Initializes a new <see cref="SqlMembershipProviderPasswordService"/> using the provided password format.
        /// </summary>
        /// <param name="passwordFormat">The password encryption method.</param>
        public SqlMembershipProviderPasswordService(MembershipPasswordFormat passwordFormat)
        {
            this.passwordFormat = passwordFormat;
             this.provider = new SqlMembershipProvider();

             var config = new NameValueCollection {
            { "minRequiredPasswordLength", "1" },
            { "minRequiredNonalphanumericCharacters", "0" },
            { "passwordFormat", passwordFormat.ToString() },
            { "passwordCompatMode", "Framework40" },
            { "connectionString" , "__foo__" }
             };

             this.provider.Initialize(null, config);
        }

        public static string EncodePassword(MembershipPasswordFormat format, string cleanString, string salt)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(salt.ToLower() + cleanString);

            switch (format)
            {
                case MembershipPasswordFormat.Clear:
                    return cleanString;

                case MembershipPasswordFormat.Hashed:
                    return BitConverter.ToString(((HashAlgorithm)CryptoConfig.CreateFromName("SHA1")).ComputeHash(bytes));
            }

            return BitConverter.ToString(((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(bytes));
        }

        public override void Initialize(string name, NameValueCollection config)
        {
            // 
            // Initialize values from web.config. 
            // 

            // Initialize the abstract base class. 
            base.Initialize(name, config);

            _applicationName = GetConfigValue(config["applicationName"],
                                            System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath);
            _maxInvalidPasswordAttempts = Convert.ToInt32(GetConfigValue(config["maxInvalidPasswordAttempts"], "5"));
            _passwordAttemptWindow = Convert.ToInt32(GetConfigValue(config["passwordAttemptWindow"], "10"));
            _minRequiredNonAlphanumericCharacters = Convert.ToInt32(GetConfigValue(config["minRequiredNonAlphanumericCharacters"], "1"));
            _minRequiredPasswordLength = Convert.ToInt32(GetConfigValue(config["minRequiredPasswordLength"], "7"));
            _passwordStrengthRegularExpression = Convert.ToString(GetConfigValue(config["passwordStrengthRegularExpression"], ""));
            _enablePasswordReset = Convert.ToBoolean(GetConfigValue(config["enablePasswordReset"], "true"));
            _enablePasswordRetrieval = Convert.ToBoolean(GetConfigValue(config["enablePasswordRetrieval"], "true"));
            _requiresQuestionAndAnswer = Convert.ToBoolean(GetConfigValue(config["requiresQuestionAndAnswer"], "false"));
            _requiresUniqueEmail = Convert.ToBoolean(GetConfigValue(config["requiresUniqueEmail"], "true"));

            string tempFormat = config["passwordFormat"];
            if (tempFormat == null)
            {
                tempFormat = "Hashed";
            }

            switch (tempFormat)
            {
                case "Hashed":
                    _passwordFormat = MembershipPasswordFormat.Hashed;
                    break;
                case "Encrypted":
                    _passwordFormat = MembershipPasswordFormat.Encrypted;
                    break;
                case "Clear":
                    _passwordFormat = MembershipPasswordFormat.Clear;
                    break;
                default:
                    throw new ProviderException("Password format not supported.");
            }

            // 
            // Initialize OdbcConnection. 
            //
        }

		public static string EncodePassword(string salt, string password, MembershipPasswordFormat passwordFormat = MembershipPasswordFormat.Hashed)
		{
			switch (passwordFormat)
			{
				case MembershipPasswordFormat.Clear:
					return password;
				case MembershipPasswordFormat.Hashed:

					byte[] bytes = Encoding.Unicode.GetBytes(salt.ToLower() + password);
					byte[] inArray = null;
					HashAlgorithm algorithm = HashAlgorithm.Create(Membership.HashAlgorithmType);
					inArray = algorithm.ComputeHash(bytes);
					return Convert.ToBase64String(inArray);
				default:
					throw new NotSupportedException(String.Format("PasswordFormat is [{0}]", passwordFormat));
			}
		}

 public static String Decrypt(String encryptedValue, MembershipPasswordFormat format)
 {
     String decryptedValue = null;
     switch (format)
     {
         case MembershipPasswordFormat.Encrypted:
             CryptoManager cryptoManager = new CryptoManager();
             decryptedValue = cryptoManager.Decrypt(encryptedValue);
             break;
         case MembershipPasswordFormat.Hashed:
             throw new NotSupportedException("Hashed encrypted values cannot be decrypted");
         case MembershipPasswordFormat.Clear:
             decryptedValue = encryptedValue;
             break;
     }
     return decryptedValue;
 }

 public static String Encrypt(String value, MembershipPasswordFormat format)
 {
     String encryptedValue = null;
     switch (format)
     {
         case MembershipPasswordFormat.Encrypted:
             CryptoManager cryptoManager = new CryptoManager();
             encryptedValue = cryptoManager.Encrypt(value);
             break;
         case MembershipPasswordFormat.Hashed:
             encryptedValue = SHA1Manager.Encript(value);
             break;
         case MembershipPasswordFormat.Clear:
             encryptedValue = value;
             break;
     }
     return encryptedValue;
 }

        internal string UnEncodePassword(string encodedPassword, MembershipPasswordFormat passwordFormat)
        {
            throw new ProviderException(Strings.CanNotUnencodeHashedPassword);
            //string password = encodedPassword;

            //switch (passwordFormat)
            //{
            //    case MembershipPasswordFormat.Clear:
            //        throw new ProviderException(Strings.UnsupportedPasswordFormat);
            //    case MembershipPasswordFormat.Encrypted:
            //        throw new ProviderException(Strings.UnsupportedPasswordFormat);
            //    case MembershipPasswordFormat.Hashed:
            //        throw new ProviderException(Strings.CanNotUnencodeHashedPassword);
            //    default:
            //        throw new ProviderException(Strings.UnsupportedPasswordFormat);
            //}

            //return password;
        }

        public WinNtMembershipProvider()
        {
            _strName = "WinNTMembershipProvider";
            _strApplicationName = "DefaultApp";
            _userDomain = "";
            _logonType = 2; // Interactive by default

            _boolEnablePasswordReset = false;
            _boolEnablePasswordRetrieval = false;
            _boolRequiresQuestionAndAnswer = false;
            _boolRequiresUniqueEMail = false;

            _intMaxInvalidPasswordAttempts = 3;
            _intMinRequiredAlphanumericCharacters = 1;
            _intMinRequiredPasswordLength = 5;
            _strPasswordStrengthRegularExpression = @"[\w| !§$%&/()=\-?\*]*";

            _oPasswordFormat = MembershipPasswordFormat.Clear;
        }

        public CreateUserViewModel CreateUser(string salt, string pass, string encodedPasswordAnswer,
            string username, string email, string passwordQuestion, object providerUserKey,
            bool isApproved, bool requiresUniqueEmail, MembershipPasswordFormat passwordFormat)
        {
            DateTime dt = DataProviderHelper.RoundToSeconds(DateTime.UtcNow);
            var cmd = new SqlCommand("dbo.aspnet_Membership_CreateUser", Holder.Connection)
            {
                CommandTimeout = CommandTimeout,
                CommandType = CommandType.StoredProcedure
            };

            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@ApplicationName", SqlDbType.NVarChar, ApplicationName));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@UserName", SqlDbType.NVarChar, username));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@Password", SqlDbType.NVarChar, pass));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@PasswordSalt", SqlDbType.NVarChar, salt));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@Email", SqlDbType.NVarChar, email));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@PasswordQuestion", SqlDbType.NVarChar, passwordQuestion));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@PasswordAnswer", SqlDbType.NVarChar, encodedPasswordAnswer));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@IsApproved", SqlDbType.Bit, isApproved));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@UniqueEmail", SqlDbType.Int, requiresUniqueEmail ? 1 : 0));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@PasswordFormat", SqlDbType.Int, (int)passwordFormat));
            cmd.Parameters.Add(DataProviderHelper.CreateInputParam("@CurrentTimeUtc", SqlDbType.DateTime, dt));
            SqlParameter p = DataProviderHelper.CreateInputParam("@UserId", SqlDbType.UniqueIdentifier, providerUserKey);
            p.Direction = ParameterDirection.InputOutput;
            cmd.Parameters.Add(p);

            p = new SqlParameter("@ReturnValue", SqlDbType.Int) { Direction = ParameterDirection.ReturnValue };
            cmd.Parameters.Add(p);

            cmd.ExecuteNonQuery();
            var iStatus = ((p.Value != null) ? ((int)p.Value) : -1);
            if (iStatus < 0 || iStatus > (int)MembershipCreateStatus.ProviderError)
                iStatus = (int)MembershipCreateStatus.ProviderError;
            return new CreateUserViewModel
                       {
                Status = iStatus,
                UserId = new Guid(cmd.Parameters["@UserId"].Value.ToString()),
                Date = dt
            };
        }

        internal string EncodePassword(string password, MembershipPasswordFormat passwordFormat, string key)
        {
            string encodedPassword = password;

            switch (passwordFormat)
            {
                case MembershipPasswordFormat.Clear:
                    throw new ProviderException(Strings.UnsupportedPasswordFormat);
                case MembershipPasswordFormat.Encrypted:
                    throw new ProviderException(Strings.UnsupportedPasswordFormat);
                case MembershipPasswordFormat.Hashed:
                    var hash = new HMACSHA1();
                    hash.Key = HexToByte(key);
                    encodedPassword =
                      Convert.ToBase64String(hash.ComputeHash(Encoding.Unicode.GetBytes(password)));
                    break;
                default:
                    throw new ProviderException(Strings.UnsupportedPasswordFormat);
            }

            return encodedPassword;
        }