Python密码验证器实战：从正则到可配置类的安全策略实现

1. 项目概述：为什么密码规则验证是每个开发者的必修课

最近在做一个用户注册模块，产品经理提了个需求，要求密码必须包含大小写字母、数字和特殊字符，长度在8到20位之间。这听起来是个很常见的需求，对吧？但当我开始写代码时，发现事情没那么简单。一个看似简单的密码规则验证，背后涉及到字符串处理、正则表达式、逻辑判断，甚至还有用户体验和安全性的权衡。我见过太多项目里，密码验证逻辑要么写得冗长不堪，要么存在逻辑漏洞，要么就是错误提示语焉不详，让用户摸不着头脑。

密码规则验证，本质上是一套用于检查用户输入的密码字符串是否符合预设安全策略的规则引擎。它不仅仅是前端的一个pattern属性，更是后端数据安全的第一道防线。一个健壮的验证逻辑，能有效过滤掉“123456”、“password”这类弱密码，提升系统的整体安全水位。对于Python开发者来说，无论是开发Web应用、桌面工具还是自动化脚本，只要涉及用户认证，这就是一个绕不开的基础功能点。

这个项目适合所有阶段的Python开发者。如果你是新手，可以通过它扎实地练习字符串操作和条件判断；如果你是有经验的开发者，可以深入思考如何设计更优雅、可扩展的验证器，以及如何平衡安全性与用户体验。接下来，我会把我踩过的坑、优化的思路以及最终的实现方案，毫无保留地分享给你。

2. 密码规则验证的核心逻辑与设计思路

2.1 常见密码规则要素拆解

在设计验证器之前，我们得先搞清楚到底要验证什么。通常，一套中等安全强度的密码规则会包含以下几个维度：

1. 长度规则：这是最基本的要求。太短的密码容易被暴力破解，太长的密码可能影响用户体验并增加存储负担。常见的范围是8-20位或8-16位。
2. 字符类型规则：强制密码必须由多种字符类型组合而成，以增加熵值（即随机性）。主要包括：
   • 大写字母：A-Z
   • 小写字母：a-z
   • 数字：0-9
   • 特殊字符：例如!@#$%^&*()_+-=[]{}|;:'\",.<>/?等。这里需要注意，有些系统会限制可用的特殊字符子集，避免与SQL注入或系统命令混淆。
3. 连续性规则：禁止密码中包含过于简单的连续字符，例如“12345”、“abcde”、“qwerty”等键盘连续序列。
4. 重复性规则：禁止密码中单个字符重复次数过多，例如“aaaaa111”。
5. 字典规则：禁止使用常见的弱密码、用户名、公司名等。这通常需要一个外部的弱密码字典进行比对。

对于大多数应用场景，满足前两条（长度+字符类型组合）已经能抵御大部分自动化攻击。我们的项目将重点实现一个灵活、可配置的规则验证器，核心覆盖长度和字符类型验证，并会探讨如何扩展以支持连续性和重复性检查。

2.2 技术方案选型：正则表达式 vs. 逐字符扫描

实现密码验证，主要有两种技术路线：

方案一：正则表达式这是最直观、代码最简洁的方法。我们可以为每条规则编写一个正则表达式，然后逐一检查。

import re def validate_by_regex(password): # 检查长度 if not 8 <= len(password) <= 20: return False, \"密码长度需在8-20位之间\" # 检查包含小写字母 if not re.search(r'[a-z]', password): return False, \"密码必须包含小写字母\" # 检查包含大写字母 if not re.search(r'[A-Z]', password): return False, \"密码必须包含大写字母\" # 检查包含数字 if not re.search(r'\\d', password): return False, \"密码必须包含数字\" # 检查包含特殊字符 if not re.search(r'[!@#$%^&*()_+\\-=\\[\\]{}|;\':\",.<>/?]', password): return False, \"密码必须包含特殊字符(!@#$%等)\" return True, \"密码强度合格\"

注意：正则表达式虽然写起来快，但在处理复杂规则（如“至少包含n种字符类型”）时，表达式会变得复杂难懂。而且，当需要返回具体的错误原因时，需要执行多次re.search，对超长字符串可能有效率问题，不过对于密码这种短字符串完全可忽略。

方案二：逐字符扫描通过一次遍历密码字符串，统计各类字符出现的次数，最后根据统计结果判断。

def validate_by_scan(password): if not 8 <= len(password) <= 20: return False, \"密码长度需在8-20位之间\" has_lower = has_upper = has_digit = has_special = False special_char_set = set(\"!@#$%^&*()_+-=[]{}|;:'\",.<>/?\") for ch in password: if ch.islower(): has_lower = True elif ch.isupper(): has_upper = True elif ch.isdigit(): has_digit = True elif ch in special_char_set: has_special = True errors = [] if not has_lower: errors.append(\"小写字母\") if not has_upper: errors.append(\"大写字母\") if not has_digit: errors.append(\"数字\") if not has_special: errors.append(\"特殊字符\") if errors: return False, f\"密码必须包含{‘、’.join(errors)}\" return True, \"密码强度合格\"

实操心得：我强烈推荐逐字符扫描方案。理由有三：第一，一次遍历，效率更优，无论规则多少，都只遍历字符串一次；第二，扩展性强，在遍历过程中可以轻松加入对连续字符、重复字符的检查逻辑；第三，错误信息更友好，可以一次性收集所有未满足的规则，而不是像正则方案那样遇到第一个错误就返回。这对于用户体验至关重要——用户都希望一次被告知所有问题，而不是改一次提交一次，再报一个错。

基于以上分析，我们的项目将采用“逐字符扫描统计”作为核心框架，并在此基础上设计一个可配置的验证器类。

3. 构建可配置的密码验证器类

一个优秀的验证器不应该把规则硬编码在函数里。我们应该设计一个类，允许在初始化时灵活配置各种规则参数，这样同一套代码就能适应不同项目、不同安全等级的需求。

3.1 验证器类的设计与初始化

我们来设计一个PasswordValidator类。它的初始化参数应该包含所有可配置的规则。

class PasswordValidator: \"\"\" 密码规则验证器 \"\"\" def __init__(self, min_length=8, max_length=20, require_lower=True, require_upper=True, require_digit=True, require_special=True, special_chars=\"!@#$%^&*()_+-=[]{}|;:'\",.<>/?\"): \"\"\" 初始化验证器规则 :param min_length: 密码最小长度 :param max_length: 密码最大长度 :param require_lower: 是否必须包含小写字母 :param require_upper: 是否必须包含大写字母 :param require_digit: 是否必须包含数字 :param require_special: 是否必须包含特殊字符 :param special_chars: 认可的特殊字符字符串 \"\"\" self.min_length = min_length self.max_length = max_length self.require_lower = require_lower self.require_upper = require_upper self.require_digit = require_digit self.require_special = require_special # 将特殊字符字符串转换为集合，便于使用`in`操作符进行O(1)复杂度查找 self.special_char_set = set(special_chars) # 内部校验：确保认可的字符集没有重复，并且不为空（如果要求特殊字符） if require_special and not self.special_char_set: raise ValueError(\"当要求特殊字符时，special_chars参数不能为空字符串\")

关键点解析：这里将special_chars参数在初始化时就转换为set集合。这是因为在后续的逐字符检查中，我们需要频繁判断一个字符是否属于特殊字符集合。使用set的in操作符，其时间复杂度是O(1)，而如果使用字符串的in操作（如ch in special_chars），时间复杂度是O(n)，在字符集较大时效率有差异。虽然密码短，差别不大，但养成使用合适数据结构的习惯很重要。

3.2 核心验证方法的实现

接下来实现核心的validate方法。它将执行一次遍历，完成所有统计和检查。

def validate(self, password): \"\"\" 验证密码是否符合所有规则 :param password: 待验证的密码字符串 :return: (is_valid, message_list) is_valid: 布尔值，表示是否通过验证 message_list: 列表，包含所有验证失败的具体信息，通过时为空列表 \"\"\" # 初始化错误信息列表和字符类型标志 errors = [] has_lower = has_upper = has_digit = has_special = False # 1. 长度检查（优先检查，因为这是最基本的） if not (self.min_length <= len(password) <= self.max_length): errors.append(f\"密码长度需在{self.min_length}到{self.max_length}位之间\") # 2. 单次遍历，统计字符类型 for ch in password: if ch.islower(): has_lower = True elif ch.isupper(): has_upper = True elif ch.isdigit(): has_digit = True elif ch in self.special_char_set: # 使用集合进行快速查找 has_special = True # 如果已经发现所有要求的类型，可以提前终止遍历以优化性能（对于长字符串） # 但密码通常不长，此优化意义不大，保持逻辑清晰更重要。 # 3. 根据规则检查字符类型是否满足 if self.require_lower and not has_lower: errors.append(\"必须包含至少一个小写字母(a-z)\") if self.require_upper and not has_upper: errors.append(\"必须包含至少一个大写字母(A-Z)\") if self.require_digit and not has_digit: errors.append(\"必须包含至少一个数字(0-9)\") if self.require_special and not has_special: # 提示用户认可的特殊字符范围，提升体验 special_preview = ''.join(list(self.special_char_set)[:5]) # 展示前5个 preview_msg = f\"如{special_preview}...\" if len(self.special_char_set) > 5 else f\"如{''.join(self.special_char_set)}\" errors.append(f\"必须包含至少一个特殊字符{preview_msg}\") # 4. 返回结果 is_valid = len(errors) == 0 return is_valid, errors

避坑技巧：在返回错误信息时，我特意将特殊字符集的一部分展示给用户。例如，提示“必须包含至少一个特殊字符如!@#$%...”。这是一个很小的细节，但能极大改善用户体验。用户不再需要去翻找帮助文档，一眼就知道哪些符号是合法的。注意，如果特殊字符集很大，只预览前几个即可，避免提示信息过长。

3.3 验证器的基本使用示例

现在，我们可以像使用一个标准库一样使用这个验证器了。

# 创建一个严格规则的验证器（默认规则） strict_validator = PasswordValidator() # 测试用例 test_passwords = [ \"abc123\", # 太短，缺大写和特殊字符 \"ABCDEFGH123!\", # 缺小写字母 \"abcdefgh123!\", # 缺大写字母 \"ABCDefghij!\", # 缺数字 \"ABCDefgh123\", # 缺特殊字符 \"ABcdef123!@#\", # 符合所有规则 ] for pwd in test_passwords: is_ok, msgs = strict_validator.validate(pwd) status = \"通过\" if is_ok else \"失败\" print(f\"密码 ‘{pwd}’: {status}\") if msgs: for msg in msgs: print(f\" - {msg}\") # 输出示例： # 密码 ‘abc123’: 失败 # - 密码长度需在8到20位之间 # - 必须包含至少一个大写字母(A-Z) # - 必须包含至少一个特殊字符如!@#$%^... # 密码 ‘ABcdef123!@#’: 通过

你也可以创建不同安全策略的验证器：

# 一个内部系统用的宽松验证器，只要求长度和数字 internal_validator = PasswordValidator( min_length=6, require_upper=False, require_special=False ) # 一个金融级的高安全验证器 financial_validator = PasswordValidator( min_length=12, max_length=32, special_chars=\"!@#$%^&*()_+-=[]{}|;:'\",.<>?~`\" # 更丰富的特殊字符 )

通过这样的设计，验证逻辑和规则配置完全解耦，代码复用性极高。

4. 高级功能扩展：提升验证强度与用户体验

基础的字符类型和长度验证已经能满足大部分需求。但如果你的系统对安全有更高要求，或者你想提供更积极的强度反馈，可以考虑以下扩展。

4.1 实现密码强度评分

与其只返回“通过/失败”，不如给密码评个分，让用户直观感受到密码的强弱。我们可以设计一个简单的评分算法：

• 基础分：长度分（例如，达到最小长度给10分，每多一位加1分，上限20分）。
• 加分项：
  • 包含小写字母：+10分
  • 包含大写字母：+15分（因为用户更少主动使用）
  • 包含数字：+10分
  • 包含特殊字符：+20分（因为最不常用，安全性贡献最大）
• 减分项（可选）：
  • 纯数字或纯字母：-20分
  • 连续字符（如123， abc）：每出现一组-5分
  • 重复字符（如aaa）：每出现一组-5分

在PasswordValidator类中添加一个get_strength_score方法：

def get_strength_score(self, password): \"\"\"计算密码强度分数（0-100）\"\"\" score = 0 has_lower = has_upper = has_digit = has_special = False # 1. 长度分 (最高30分) length = len(password) if length >= self.min_length: score += 10 # 达到最低要求基础分 score += min(length - self.min_length, 10) # 每多一位加1分，最多加10分 if length > 20: # 额外奖励超长密码 score += 5 # 2. 遍历并统计字符类型，同时检查连续/重复（简化版） prev_char = None repeat_count = 1 for i, ch in enumerate(password): # 字符类型判断 if ch.islower(): has_lower = True elif ch.isupper(): has_upper = True elif ch.isdigit(): has_digit = True elif ch in self.special_char_set: has_special = True # 简单连续字符检查（例如‘123’， ‘abc’） if prev_char is not None and ord(ch) == ord(prev_char) + 1: # 连续字符，轻微扣分（这里简化处理，实际应检查连续序列长度） score -= 2 # 简单重复字符检查 if ch == prev_char: repeat_count += 1 if repeat_count >= 3: # 同一字符连续出现3次以上 score -= 5 else: repeat_count = 1 prev_char = ch # 3. 字符类型加分 if has_lower: score += 10 if has_upper: score += 15 if has_digit: score += 10 if has_special: score += 20 # 4. 组合单一性惩罚（如果只包含一种或两种字符类型） type_count = sum([has_lower, has_upper, has_digit, has_special]) if type_count == 1: score -= 20 elif type_count == 2: score -= 10 # 5. 确保分数在0-100之间 return max(0, min(100, score))

使用评分功能：

validator = PasswordValidator() pwd = \"MyP@ssw0rd2024\" is_valid, errors = validator.validate(pwd) score = validator.get_strength_score(pwd) print(f\"验证结果: {‘通过’ if is_valid else ‘失败’}\") print(f\"强度评分: {score}/100\") if score < 40: print(\"强度: 弱\") elif score < 70: print(\"强度: 中\") else: print(\"强度: 强\")

注意事项：这个评分算法只是一个示例，并非工业标准。在实际项目中，你可以参考像zxcvbn（Dropbox开源）这样的专业密码强度估算库，它们考虑了模式匹配、字典词、空间性等更多因素，评估结果更准确。

4.2 禁止常见弱密码与模式匹配

禁止使用“password”、“123456”、“qwerty”这样的常见弱密码，是提升安全性的有效手段。我们可以维护一个弱密码列表（可以从网上下载或自己收集），在验证时进行比对。

此外，还可以加入简单的模式检查，比如禁止密码中包含用户名、邮箱本地部分等个人信息。

在PasswordValidator类中扩展：

class PasswordValidator: def __init__(self, min_length=8, max_length=20, require_lower=True, require_upper=True, require_digit=True, require_special=True, special_chars=\"!@#$%^&*()_+-=[]{}|;:'\",.<>/?\", weak_password_list=None, # 新增：弱密码列表 forbid_username_in_password=True): # 新增：是否禁止包含用户名 # ... 其他初始化代码 ... self.weak_password_list = set(weak_password_list) if weak_password_list else set() self.forbid_username = forbid_username_in_password def validate(self, password, username=None): # 增加可选用户名参数 \"\"\" :param username: 可选，当前注册的用户名，用于检查密码是否包含用户名 \"\"\" errors = [] # ... 原有的长度、字符类型检查代码 ... # 新增：弱密码检查 if password.lower() in self.weak_password_list: errors.append(\"密码过于常见，请勿使用常见词汇或序列\") # 新增：禁止密码中包含用户名（不区分大小写） if self.forbid_username and username: if username.lower() in password.lower(): errors.append(\"密码中不应包含您的用户名\") # ... 返回结果 ...

初始化时加载弱密码列表：

# 示例：从一个文件加载弱密码列表 def load_weak_passwords(filepath): with open(filepath, 'r', encoding='utf-8') as f: # 假设每行一个弱密码 return [line.strip().lower() for line in f if line.strip()] weak_list = load_weak_passwords(\"common_weak_passwords.txt\") validator = PasswordValidator(weak_password_list=weak_list) is_valid, errors = validator.validate(\"password123\", username=\"john_doe\") # 预期结果：失败，错误信息包含“密码过于常见...”和“密码中不应包含您的用户名”（如果用户名是‘john’）

实操心得：弱密码列表不宜过大，通常包含前1000或前10000个最常用的弱密码即可。过大的列表会占用内存并略微影响检查速度。可以考虑使用Bloom Filter这种概率型数据结构来高效判断一个密码是否可能在弱密码集中，但实现复杂度会提高。对于绝大多数应用，一个内存中的set集合已经足够快。

5. 工程化实践：集成测试与性能考量

写完核心代码后，我们还需要确保它的可靠性和可用性。这意味着要编写测试，并考虑在真实环境中的性能表现。

5.1 为验证器编写单元测试

使用Python内置的unittest模块为我们的PasswordValidator类编写测试用例。好的测试应该覆盖正常情况、边界情况和异常情况。

import unittest class TestPasswordValidator(unittest.TestCase): def setUp(self): \"\"\"在每个测试方法前运行，创建验证器实例\"\"\" self.validator = PasswordValidator() # 使用默认严格规则 def test_valid_password(self): \"\"\"测试符合所有规则的密码\"\"\" is_valid, errors = self.validator.validate(\"StrongP@ss1\") self.assertTrue(is_valid) self.assertEqual(len(errors), 0) def test_too_short(self): \"\"\"测试过短密码\"\"\" is_valid, errors = self.validator.validate(\"Short1!\") self.assertFalse(is_valid) self.assertIn(\"密码长度需在8到20位之间\", errors) def test_no_uppercase(self): \"\"\"测试缺少大写字母\"\"\" is_valid, errors = self.validator.validate(\"lowercase123!\") self.assertFalse(is_valid) self.assertIn(\"必须包含至少一个大写字母(A-Z)\", errors) def test_multiple_errors(self): \"\"\"测试同时触发多个错误\"\"\" is_valid, errors = self.validator.validate(\"abc\") # 短、缺大写、缺数字、缺特殊 self.assertFalse(is_valid) # 检查错误列表是否包含了预期的所有错误类型（至少4条） self.assertGreaterEqual(len(errors), 4) def test_custom_special_chars(self): \"\"\"测试自定义特殊字符集\"\"\" custom_validator = PasswordValidator(special_chars=\"@#$\") # 密码包含认可的特殊字符‘@’，应通过 is_valid, errors = custom_validator.validate(\"Passw0rd@\") self.assertTrue(is_valid) # 密码包含不在认可集合的特殊字符‘!’，应失败 is_valid, errors = custom_validator.validate(\"Passw0rd!\") self.assertFalse(is_valid) self.assertIn(\"必须包含至少一个特殊字符\", errors) def test_strength_score(self): \"\"\"测试强度评分逻辑\"\"\" # 弱密码：纯数字，短 score = self.validator.get_strength_score(\"123\") self.assertLess(score, 30) # 强密码：长，包含所有类型 score = self.validator.get_strength_score(\"ThisIsAVeryStrongP@ssw0rd!\") self.assertGreater(score, 70) def test_weak_password_check(self): \"\"\"测试弱密码检测\"\"\" validator_with_list = PasswordValidator(weak_password_list=[\"password\", \"123456\", \"qwerty\"]) is_valid, errors = validator_with_list.validate(\"password\") self.assertFalse(is_valid) self.assertIn(\"密码过于常见\", errors) if __name__ == '__main__': unittest.main()

运行这些测试，可以确保我们的验证器在各种情况下都能按预期工作，并且在后续修改代码时，能快速发现是否引入了回归错误。

5.2 性能分析与优化建议

密码验证通常在用户注册或修改密码时调用，频率不高，但对响应速度有一定要求。我们来简单分析一下性能：

1. 时间复杂度：核心的validate方法主要是一次O(n)的字符串遍历（n为密码长度），以及若干次O(1)的集合查找和列表操作。对于最大长度（如20）的密码，这个开销微乎其微，完全不用担心。
2. 空间复杂度：我们主要存储了规则配置和弱密码集合。规则配置是常量。弱密码集合如果很大（例如10万条），会占用几十MB内存。这是主要的性能考量点。
3. 优化建议：
   • 懒加载弱密码列表：如果弱密码列表很大，可以考虑在首次使用时从文件或数据库加载，并缓存起来。
   • 使用更高效的数据结构：如前所述，对于超大弱密码库，可以考虑Bloom Filter。它用很小的内存空间和极快的速度告诉你“这个密码肯定不在弱密码集”或“这个密码可能在弱密码集”。对于“可能在”的情况，可以再走一次精确查询（如查数据库）。
   • 避免在验证方法中创建大量临时对象：我们的代码中，每次验证只创建了一个错误信息列表，这是可以接受的。

一个简单的性能测试脚本：

import time validator = PasswordValidator() # 模拟一个较长的密码 test_password = \"A\" * 1000 + \"b1!\" # 一个1003位的密码 start = time.perf_counter() for _ in range(10000): # 执行一万次验证 validator.validate(test_password) end = time.perf_counter() print(f\"验证10000次长密码耗时: {end - start:.4f} 秒\") print(f\"平均每次验证耗时: {(end - start)/10000 * 1000:.4f} 毫秒\")

在我的普通开发机上，验证一个1000多位的密码一万次，总耗时也不过零点几秒，平均每次不到0.1毫秒。所以，对于正常长度的密码，性能完全不是瓶颈。

6. 常见问题与实战排查技巧

在实际开发和运维中，你可能会遇到下面这些问题。这里是我总结的一些排查思路和解决方案。

6.1 用户反馈“我的密码明明符合要求，却提示错误”

这是最常遇到的问题。排查步骤如下：

1. 检查空格：用户可能在密码开头或结尾无意中输入了空格。在验证前使用password.strip()处理输入，或者在验证逻辑中明确拒绝包含空格（if ' ' in password: errors.append(\"密码中不能包含空格\")）。
2. 检查特殊字符集：你的验证器认可的特殊字符，和前端提示给用户的字符集是否一致？特别是那些容易混淆的字符，比如反斜杠\\、单引号'、双引号\"。最好在用户输入框附近直接显示允许的特殊字符示例。
3. 检查编码问题：在Web应用中，确保前后端字符编码一致（通常都是UTF-8）。一个中文字符或全角符号可能会被误判。
4. 开启详细日志：在验证器内部临时添加日志，打印出传入的密码字符串、每个字符的ASCII码、以及每一步检查的结果。这是定位问题的终极武器。

   import logging logging.basicConfig(level=logging.DEBUG) def validate(self, password): logging.debug(f\"验证密码: {repr(password)}\") # 使用repr显示转义字符 logging.debug(f\"密码长度: {len(password)}\") # ... 后续检查中也可以加入日志 for i, ch in enumerate(password): logging.debug(f\"字符[{i}]: ‘{ch}‘ (ASCII: {ord(ch)})\")

6.2 规则变更导致存量用户密码失效

当产品安全策略升级，比如要求新增特殊字符时，老用户的密码就失效了。粗暴地要求所有用户立即修改密码体验极差。正确的做法是：

1. 渐进式验证：在用户登录时，如果密码验证通过，但用新规则验证不通过，则系统可以标记该用户“密码强度不足”。在用户下次登录时，友好地提示“为提升账户安全，建议您修改密码”，并引导至密码修改页面，此时强制使用新规则。
2. 双规则并行：系统同时保存两套验证逻辑。对新注册和主动修改密码的用户，使用新规则。对老用户登录，暂时仍使用旧规则验证，直到他们修改密码。
3. 关键操作前强制升级：当用户进行敏感操作（如修改支付密码、提现）时，强制要求其先升级登录密码至符合新规则。

6.3 如何平衡安全性与用户体验

过于复杂的规则会导致用户忘记密码、频繁找回，反而降低安全性。以下是一些平衡建议：

6.4 验证逻辑在Web前后端的部署

一个完整的密码验证通常涉及前端和后端：

• 前端验证：用于即时反馈，提升用户体验。在用户输入时或提交表单前，用JavaScript（或Wasm版的Python库）执行规则检查，实时显示错误或强度。但前端验证可以被绕过，绝不能作为唯一的安全屏障。
• 后端验证：用于最终保障，是必须的。在服务器端收到注册或改密请求后，必须用我们写的Python验证器（或更严格的逻辑）再次检查。所有业务逻辑和持久化操作，必须在后端验证通过后进行。

部署模式：可以将PasswordValidator类打包成一个独立的Python模块或包。前端通过构建工具（如Webpack）可能无法直接使用，但可以：

1. 在后端提供密码强度检查的API端点，前端通过AJAX调用。
2. 对于纯Python桌面应用或后端服务，直接导入模块使用即可。

最后，别忘了密码存储的安全原则：永远不要明文存储密码。即使密码通过了再复杂的规则，存储时也必须使用加盐的、强哈希算法（如Argon2, bcrypt, PBKDF2）进行处理。验证规则和哈希存储是相辅相成的两道安全关卡。