企业官网建设流程全解析

1. 项目概述：为什么选择 Argon2 作为 .NET Core 的密码守护者？

在构建现代应用时，用户密码的安全存储是开发者必须跨过的第一道门槛。过去，我们可能习惯性地使用 MD5、SHA-1 这类快速哈希算法，但在算力爆炸的今天，它们早已变得不堪一击。GPU 和专用硬件可以轻松实现每秒数十亿次的哈希计算，让“彩虹表”攻击变得触手可及。这时，你需要的是一个专为抵御现代攻击而设计的密码哈希算法，而 Argon2 正是这个领域的王者。它不仅是 2015 年密码哈希竞赛的冠军，更因其对内存和计算资源的“高要求”特性，使得大规模并行破解变得极其昂贵和缓慢。

在 .NET Core 的生态里，虽然框架本身提供了Rfc2898DeriveBytes用于实现 PBKDF2，但如果你想直接使用 Argon2，官方库并未内置。这就需要我们引入一个可靠、高效且维护良好的第三方库。本指南将带你一步步完成在 .NET Core 项目中集成 Argon2 加密库的全过程，从理解其核心优势，到选择正确的 NuGet 包，再到进行细致的配置和实战编码。无论你是在开发一个全新的用户系统，还是打算对旧有系统进行安全升级，这份指南都将提供从理论到实践的完整路径。我会结合自己多次在微服务和安全组件中集成 Argon2 的经验，分享那些官方文档里不会写的配置陷阱和性能调优心得。

2. 核心需求解析：Argon2 究竟解决了什么问题？

在深入安装配置之前，我们必须先搞清楚 Argon2 的核心价值。它不是一个简单的“加密”函数，而是一个密码哈希函数，其设计目标与对称加密（如 AES）或非对称加密（如 RSA）截然不同。密码哈希的核心要求是单向性和抗碰撞性，但 Argon2 在此基础上，重点强化了抗硬件加速破解的能力。

传统的哈希算法如 SHA-256，速度很快，但这恰恰是它的弱点。攻击者可以使用廉价的 GPU 或 ASIC 芯片进行海量试错。Argon2 引入了几个关键维度来增加攻击成本：

1. 时间成本（迭代次数）：通过多次迭代来消耗计算时间。
2. 内存成本（内存大小）：要求算法在运行期间占用大量内存。GPU 和 ASIC 通常拥有强大的算力但内存带宽有限，高内存需求能有效抑制这类硬件的优势。
3. 并行度成本（并行线程）：可以配置使用的线程数，增加多核 CPU 环境下的计算复杂度。

这三个参数（时间、内存、并行度）使得 Argon2 可以根据当前硬件水平进行“参数调优”，确保验证一个密码对合法用户而言只需可接受的短暂延迟（如 0.5 秒），但对试图暴力破解的攻击者来说，则意味着天文数字般的资源和时间成本。

在 .NET Core 场景下，我们的需求具体化为：

• 安全性：替换项目中过时或不安全的密码哈希方式。
• 易用性：找到 API 设计友好、与 .NET Core 依赖注入等模式兼容的库。
• 可配置性：能够灵活调整 Argon2 的参数，以适应从移动应用到后端服务器的不同性能环境。
• 未来兼容性：确保选择的库积极维护，能跟上 .NET 版本的升级。

理解了这些，我们选择库和进行配置时，目标就会非常明确。

3. 工具选型：.NET Core 生态中的 Argon2 库对比

在 NuGet 上搜索 “Argon2”，你会发现不止一个选择。选择一个“正确”的库，能避免后续无数的坑。我主要评估过以下几个主流库，并将在生产环境中使用过的经验分享给你。

3.1 Konscious.Security.Cryptography.Argon2

这是目前 .NET 平台上最受欢迎、最活跃的 Argon2 实现之一。它是对 libsodium 库中 Argon2 实现的纯 C# 移植，不依赖任何本地库（Native DLL），这意味着它具有完美的跨平台兼容性，在 Windows、Linux、macOS 上都能无缝运行。

• 优点：
  • 纯托管代码：无需处理平台特定的原生依赖，部署简单。
  • API 直观：提供了Argon2id等类，使用方法接近其他 .NET 加密原语。
  • 活跃维护：GitHub 项目更新及时，社区支持较好。
  • 功能完整：支持 Argon2i, Argon2d, Argon2id 三种变体。
• 缺点：
  • 由于是纯 C# 实现，在极端性能场景下，可能比调用优化过的本地库（如通过 P/Invoke）略慢一些，但对于绝大多数密码哈希场景（每秒几次操作），这个差异完全可以忽略不计。
• 适用场景：绝大多数 .NET Core/.NET 5+ 的 Web 应用、API 服务和桌面应用。这也是本指南主要采用的库。

3.2 Isopoh.Cryptography.Argon2

这是另一个流行的纯 C# 实现。它与 Konscious 的实现类似，也是跨平台的。两者在功能和性能上相差无几。选择它还是 Konscious 更多是个人偏好和 API 设计风格的差异。Isopoh 的 API 可能在某些细节上略有不同。

3.3 其他通过 P/Invoke 调用本地库的方案

有些库会封装诸如libsodium或libargon2等 C 语言库。它们可能提供极限性能，但引入了原生依赖，使得部署变得复杂（你需要确保目标机器上有对应版本的原生库），跨平台一致性维护成本高。对于 .NET Core 强调的“一次构建，到处运行”的理念而言，这通常不是首选。

实操心得：选型结论对于 99% 的项目，我强烈推荐直接使用Konscious.Security.Cryptography.Argon2。它的纯托管特性消除了部署的复杂性，其性能完全满足密码哈希的需求，且社区活跃度能保证长期支持。除非你有非常特殊的、经过验证的性能瓶颈，否则不要轻易引入原生依赖的复杂性。

4. 环境准备与库安装

假设你已经有了一个 .NET Core 项目（这里以 .NET 6 为例）。我们将通过 NuGet 包管理器来安装库。

4.1 使用 .NET CLI 安装（推荐）

打开你的终端（PowerShell, CMD, bash 等），导航到你的项目文件（.csproj）所在目录，执行以下命令：

dotnet add package Konscious.Security.Cryptography.Argon2

这个命令会自动下载并安装最新稳定版本的库，并更新你的项目文件。这是最干净、最可重复的方式。

4.2 使用 Visual Studio 的 NuGet 包管理器

如果你使用 Visual Studio：

1. 在“解决方案资源管理器”中，右键点击你的项目。
2. 选择“管理 NuGet 程序包”。
3. 在打开的窗口中，切换到“浏览”选项卡。
4. 在搜索框中输入 “Konscious.Security.Cryptography.Argon2”。
5. 找到该包，选择正确的版本，点击“安装”。

4.3 验证安装

安装完成后，你的.csproj文件中应该会增加类似这样的一行：

<PackageReference Include="Konscious.Security.Cryptography.Argon2" Version="x.x.x" />

你可以在代码文件中尝试添加using Konscious.Security.Cryptography;，如果编译器不报错，说明安装成功。

注意事项：版本兼容性确保你安装的库版本与你的 .NET 目标框架兼容。Konscious.Security.Cryptography.Argon2通常支持 .NET Standard 2.0 及以上，这意味着它兼容 .NET Core 2.0、.NET 5/6/7/8 等。如果你在非常古老的项目中遇到问题，请检查 NuGet 包页面上的依赖信息。

5. Argon2 核心配置参数详解

安装好库之后，在使用之前，我们必须理解并慎重设置 Argon2 的几个核心参数。这些参数直接决定了安全性和性能的平衡点。错误的配置可能导致系统脆弱或用户体验不佳。

5.1 变体选择：Argon2i, Argon2d, Argon2id

这是第一个关键选择。

• Argon2i：对侧信道攻击（如缓存计时攻击）具有最强的抵抗力，适用于可能面临此类威胁的环境（如多用户共享的服务器）。它是密码哈希竞赛的默认推荐。
• Argon2d：提供更强的抗 GPU 破解能力，但更容易受到侧信道攻击。适用于数据来源完全可信的环境（如加密货币挖矿）。
• Argon2id：这是目前绝大多数场景的默认推荐。它在内部混合使用了 Argon2i 和 Argon2d，试图在抵抗侧信道攻击和抵抗 GPU 破解之间取得最佳平衡。从 2017 年开始，官方推荐使用 Argon2id。

结论：除非你有非常特殊的、明确的安全模型要求，否则始终使用Argon2id。

5.2 核心参数：时间、内存、并行度

这三个参数需要一起调整，它们共同定义了哈希一次的“成本”。

1. DegreeOfParallelism (并行度， p)：

   • 定义：计算哈希时使用的线程数。
   • 影响：增加p可以提高在多核系统上的计算速度（对攻击者和防御者同时生效），但也增加了 CPU 的调度开销。设置过高可能不会带来线性性能提升。
   • 建议初始值：设置为等于或略低于你目标部署环境 CPU 的物理核心数。例如，对于一台 4 核服务器，可以设置为 4。

2. MemorySize (内存大小， m)：

   • 定义：算法运行期间需要使用的 KiB（Kibibyte）数。这是增加攻击成本最有效的参数，因为 GPU/ASIC 的内存带宽是瓶颈。
   • 影响：内存越大，抗破解能力越强，但消耗的服务器内存也越多。这是需要重点调优的参数。
   • 建议初始值：这是一个需要权衡的值。OWASP 等安全组织曾推荐 37 MiB (约 37888 KiB) 到 1 GiB 不等。一个常见的、平衡的起点是65536 KiB (64 MiB)。对于高安全等级的应用，可以考虑 128 MiB 或 256 MiB。

3. Iterations (迭代次数， t)：

   • 定义：哈希算法循环执行的次数。
   • 影响：增加迭代次数会线性增加计算时间。在内存成本已经很高的情况下，它是微调验证延迟的第二个杠杆。
   • 建议初始值：通常设置为一个较小的值，如2或3。因为内存成本 (m) 是主要的防御手段，t可以用来进行“微调”。

5.3 盐（Salt）和密钥（Secret）

• 盐（Salt）：这是必须的。它是一个随机生成的、每个密码独一无二的数据。它的作用是确保即使两个用户密码相同，其哈希值也完全不同，并能有效防御彩虹表攻击。盐不需要保密，可以明文和哈希值一起存储。长度推荐 16 字节（128 位）。
• 密钥（Secret）/关联数据（Associated Data）：这是一个可选的、需要保密的额外输入。它可以用于在算法级别实现“胡椒”（Pepper）的效果，即即使哈希数据库泄露，攻击者没有这个密钥也无法进行验证。管理这个密钥本身是一个额外的安全挑战（如使用硬件安全模块 HSM）。

5.4 哈希输出长度

通常固定为 32 字节（256 位）或 16 字节（128 位）即可。32 字节更常见，能提供足够的输出空间。

配置心法：如何确定我的参数？不要盲目抄写参数。正确的做法是进行基准测试。

1. 在你的生产环境同等规格的服务器上（或 Docker 容器中）编写一个测试程序。
2. 设定一个目标延迟，例如“密码验证时间应在 500ms 到 1000ms 之间”。这是用户体验的上限。
3. 从一个合理的初始配置（如p=4, m=65536, t=2）开始。
4. 运行哈希函数多次（如 100 次），取平均时间。
5. 如果时间太短，优先增加m（内存），因为它对防御的贡献最大。如果内存增加到硬件限制或你觉得过大，再适当增加t。
6. 反复调整并测试，直到哈希时间稳定在你的目标延迟范围内。 记住这个最终参数组合，它就是你当前硬件和安全需求下的“黄金配置”。

6. 实战：封装一个可复用的 Argon2 密码服务

理论说完了，我们开始写代码。一个好的实践是将密码哈希逻辑封装成一个服务，方便在应用中进行依赖注入和统一管理。

6.1 定义密码哈希接口

首先，我们定义一个接口，这样以后如果想换算法（虽然可能性不大），也会很方便。

// IPasswordHasher.cs public interface IPasswordHasher { string HashPassword(string password); bool VerifyPassword(string hashedPassword, string providedPassword); }

6.2 实现 Argon2id 密码哈希器

接下来，我们实现这个接口。这里会用到前面讨论的所有配置。

// Argon2idPasswordHasher.cs using System; using System.Security.Cryptography; using System.Text; using Konscious.Security.Cryptography; public class Argon2idPasswordHasher : IPasswordHasher { // 配置参数 - 这些值应该根据你的基准测试结果进行调整！ private const int DegreeOfParallelism = 4; // 并行度 p private const int MemorySize = 65536; // 内存大小 m (单位: KiB)，即 64 MB private const int Iterations = 3; // 迭代次数 t private const int SaltSize = 16; // 盐的长度 (字节) private const int HashLength = 32; // 哈希输出长度 (字节) public string HashPassword(string password) { // 1. 生成随机盐 byte[] salt = GenerateRandomSalt(); // 2. 将密码转换为字节数组 byte[] passwordBytes = Encoding.UTF8.GetBytes(password); // 3. 创建 Argon2id 实例并配置 var argon2 = new Argon2id(passwordBytes) { Salt = salt, DegreeOfParallelism = DegreeOfParallelism, MemorySize = MemorySize, Iterations = Iterations, AssociatedData = null, // 可选：关联数据（密钥/胡椒） KnownSecret = null // 可选：密钥 }; // 4. 计算哈希 byte[] hash = argon2.GetBytes(HashLength); // 5. 组合盐和哈希，便于存储 // 格式: [盐 (16字节)] + [哈希 (32字节)] byte[] combinedBytes = new byte[SaltSize + HashLength]; Buffer.BlockCopy(salt, 0, combinedBytes, 0, SaltSize); Buffer.BlockCopy(hash, 0, combinedBytes, SaltSize, HashLength); // 6. 转换为Base64字符串存储 return Convert.ToBase64String(combinedBytes); } public bool VerifyPassword(string hashedPassword, string providedPassword) { // 1. 从Base64字符串解码出组合字节 byte[] combinedBytes = Convert.FromBase64String(hashedPassword); // 2. 分离出盐和之前存储的哈希 byte[] salt = new byte[SaltSize]; byte[] storedHash = new byte[HashLength]; Buffer.BlockCopy(combinedBytes, 0, salt, 0, SaltSize); Buffer.BlockCopy(combinedBytes, SaltSize, storedHash, 0, HashLength); // 3. 用提供的密码和存储的盐重新计算哈希 byte[] providedPasswordBytes = Encoding.UTF8.GetBytes(providedPassword); var argon2 = new Argon2id(providedPasswordBytes) { Salt = salt, DegreeOfParallelism = DegreeOfParallelism, MemorySize = MemorySize, Iterations = Iterations, AssociatedData = null, KnownSecret = null }; byte[] computedHash = argon2.GetBytes(HashLength); // 4. 使用恒定时间比较来防止计时攻击 return CryptographicOperations.FixedTimeEquals(storedHash, computedHash); } private static byte[] GenerateRandomSalt() { byte[] salt = new byte[SaltSize]; using (var rng = RandomNumberGenerator.Create()) { rng.GetBytes(salt); } return salt; } }

6.3 在 .NET Core 依赖注入中注册服务

在Program.cs或Startup.cs中，将这个服务注册为单例（Singleton）。因为哈希器是无状态的，且创建成本低，单例模式是合适的。

// Program.cs (.NET 6+ 风格) var builder = WebApplication.CreateBuilder(args); // 添加服务到容器 builder.Services.AddSingleton<IPasswordHasher, Argon2idPasswordHasher>(); // ... 其他服务配置 var app = builder.Build(); // ... 中间件和端点配置 app.Run();

6.4 在应用中使用密码服务

现在，你可以在控制器、应用服务或其他地方通过构造函数注入IPasswordHasher来使用了。

// AuthController.cs 示例 [ApiController] [Route("api/[controller]")] public class AuthController : ControllerBase { private readonly IPasswordHasher _passwordHasher; private readonly IUserRepository _userRepository; // 假设的用户仓库 public AuthController(IPasswordHasher passwordHasher, IUserRepository userRepository) { _passwordHasher = passwordHasher; _userRepository = userRepository; } [HttpPost("register")] public async Task<IActionResult> Register([FromBody] RegisterDto model) { // ... 验证模型等逻辑 var hashedPassword = _passwordHasher.HashPassword(model.Password); var user = new User { Username = model.Username, PasswordHash = hashedPassword }; await _userRepository.AddAsync(user); return Ok(); } [HttpPost("login")] public async Task<IActionResult> Login([FromBody] LoginDto model) { var user = await _userRepository.GetByUsernameAsync(model.Username); if (user == null) { return Unauthorized(); } if (_passwordHasher.VerifyPassword(user.PasswordHash, model.Password)) { // 密码正确，生成Token等... return Ok(new { token = "..." }); } return Unauthorized(); } }

7. 高级配置与存储策略

基本的封装完成后，我们来看看一些更进阶的配置和最佳实践。

7.1 参数的可配置化

将硬编码的参数移到配置文件中（如appsettings.json）是一个好习惯，这样可以在不同环境（开发、测试、生产）中灵活调整，而无需重新编译代码。

// appsettings.json { "Argon2Settings": { "DegreeOfParallelism": 4, "MemorySize": 65536, "Iterations": 3, "SaltSize": 16, "HashLength": 32 } }

然后修改Argon2idPasswordHasher，通过IOptions<Argon2Settings>来注入配置。

7.2 哈希值的存储格式

上面的示例使用了简单的盐+哈希的二进制拼接然后转 Base64。这是一种常见方式。另一种更“自描述”的格式是遵循 Modular Crypt Format (MCF) 或 PHC 字符串格式，类似于$argon2id$v=19$m=65536,t=3,p=4$c2FsdHlzYWx0$哈希值。这种格式将参数、盐和哈希值都编码在一个字符串里，便于识别和未来可能的参数升级。

实现 MCF 格式会更复杂一些，需要按照特定规则进行编码。除非你有很强的兼容性需求（比如需要与其他遵循 PHC 格式的系统交互），否则简单的自定义格式（像我们上面做的）完全够用，只要你在验证时能正确解析出盐和参数即可。关键在于，一旦选定一种存储格式，就不要轻易更改。

7.3 使用“胡椒”（Pepper）增强安全

“胡椒”是一个全局的、保密的密钥，它被混合到哈希计算中。即使你的数据库完全泄露，攻击者没有“胡椒”也无法验证密码猜测。实现“胡椒”有两种常见方式：

1. 算法级胡椒：使用 Argon2 的KnownSecret或AssociatedData参数。这是最安全的方式，因为胡椒参与了哈希核心计算。
2. 应用级胡椒：在将密码传给 Argon2 之前，先用 HMAC 等算法将密码与胡椒组合。

管理胡椒本身是个挑战：它必须保密，不能放在代码或配置文件中（除非加密），理想情况是放在硬件安全模块（HSM）或云服务提供的密钥管理服务（如 AWS KMS, Azure Key Vault）中。对于大多数应用，优先确保数据库访问安全、使用强盐和合适的 Argon2 参数，其安全性已经足够。引入胡椒会显著增加系统的复杂性。

8. 性能测试、监控与参数调优实战

将服务部署到生产环境后，工作并未结束。你需要监控其表现，并根据实际情况进行微调。

8.1 编写基准测试

创建一个简单的控制台程序来测试你的参数配置。

// Benchmark.cs using System; using System.Diagnostics; using System.Text; using Konscious.Security.Cryptography; class Program { static void Main() { int degreeOfParallelism = 4; int memorySize = 65536; // KiB int iterations = 3; int hashLength = 32; byte[] password = Encoding.UTF8.GetBytes("MySuperSecurePassword123!"); byte[] salt = new byte[16]; new Random().NextBytes(salt); // 仅为测试，生产环境用 Crypto RNG var stopwatch = Stopwatch.StartNew(); int runs = 100; for (int i = 0; i < runs; i++) { var argon2 = new Argon2id(password) { Salt = salt, DegreeOfParallelism = degreeOfParallelism, MemorySize = memorySize, Iterations = iterations }; argon2.GetBytes(hashLength); } stopwatch.Stop(); double averageTime = (double)stopwatch.ElapsedMilliseconds / runs; Console.WriteLine($"参数: p={degreeOfParallelism}, m={memorySize} KiB, t={iterations}"); Console.WriteLine($"运行 {runs} 次，平均耗时: {averageTime:F2} ms"); Console.WriteLine($"预估单次验证延迟: ~{averageTime:F0} ms"); } }

在你的生产等效服务器上运行这个测试，观察平均耗时是否在你的目标范围内（如 500ms）。

8.2 监控与告警

在你的应用日志中，记录密码验证操作的耗时（注意不要记录密码本身）。如果发现耗时异常增长（例如，因为服务器负载过高导致内存访问变慢），可以设置告警。同时，监控服务器的内存使用情况，确保 Argon2 配置的内存大小不会导致内存压力。

8.3 参数调优实战案例

假设你的基准测试显示平均耗时是 200ms，而你的目标是 700ms 以内以提供更强的安全性。你可以按照以下步骤调整：

1. 优先大幅增加MemorySize(m)：这是最有效的防御杠杆。将m从 65536 (64 MiB) 增加到 131072 (128 MiB)。重新运行基准测试，耗时可能增加到 400ms。
2. 微调Iterations(t)：如果还没达到目标，将t从 3 增加到 4。测试后耗时可能变为 550ms。
3. 评估DegreeOfParallelism(p)：检查服务器 CPU 使用率。如果增加p能有效利用多核且不引起资源争用，可以适当增加。但通常p对最终延迟的影响不如m和t线性。

经过调整，你得到了一组新参数：p=4, m=131072, t=4，平均耗时 550ms，符合安全目标。务必将这些最终参数更新到你的生产配置中。

踩坑记录：参数不是一成不变的我曾经在一个项目中，将开发机上调好的参数（m=65536）直接部署到一台内存带宽较小的廉价云服务器上，导致登录接口超时。教训是：必须在与生产环境硬件尽可能相同的环境中进行基准测试。虚拟机、容器、物理机，不同的 CPU 架构（x86 vs ARM）和内存类型，都会显著影响 Argon2 的性能。

9. 常见问题排查与解决方案

在实际集成和使用过程中，你可能会遇到以下问题。

9.1 性能问题：登录接口响应慢

• 症状：用户登录时，API 响应时间很长（超过 2-3 秒）。
• 排查：
  1. 检查 Argon2 的参数（尤其是MemorySize）是否设置过高。在生产环境进行基准测试。
  2. 检查服务器当时的 CPU 和内存负载。高负载下，内存访问延迟会增加。
  3. 确认没有在用户请求路径中同步调用大量耗时的哈希操作（如批量用户导入）。
• 解决：
  • 根据生产服务器性能重新调低参数。
  • 考虑对密码验证这类 CPU/内存密集型操作进行限流或放入后台队列（但这会改变登录的同步体验，需谨慎）。
  • 确保服务器有足够的、空闲的物理内存供 Argon2 使用。

9.2 内存不足异常（OutOfMemoryException）

• 症状：应用在哈希密码时抛出OutOfMemoryException。
• 排查：
  1. 检查MemorySize参数。如果设置为 1 GiB (1048576 KiB)，而你的应用是 32 位进程或运行在内存受限的容器中（如 Docker 内存限制为 512MB），则很容易触发。
  2. 检查应用池或容器的内存限制。
  3. 检查是否同时处理了大量并发的登录请求，导致总内存申请超过限制。
• 解决：
  • 降低MemorySize到一个安全值。例如，在 1GB 内存限制的容器中，为 Argon2 设置不超过 256 MiB 的内存。
  • 增加应用的内存配额。
  • 在代码层面限制并发执行密码哈希的线程数。

9.3 哈希验证失败（即使密码正确）

• 症状：用户使用正确密码无法登录，VerifyPassword返回false。
• 排查：
  1. 盐的存储和提取不一致：这是最常见的原因。确保HashPassword和VerifyPassword中组合/分离盐和哈希的算法完全一致。一个字节错位就会导致失败。
  2. 参数不一致：确保验证时使用的DegreeOfParallelism、MemorySize、Iterations与创建哈希时完全一致。如果参数来自配置，要确保配置已正确加载且没有环境差异。
  3. 编码问题：确保密码字符串在转换为字节数组时使用相同的编码（始终使用UTF-8）。
  4. 数据损坏：检查数据库字段长度是否足够存储 Base64 字符串，在保存和读取时是否有意外的截断或转义。
• 解决：
  • 编写单元测试，用固定的密码、盐和参数生成哈希，然后验证，确保基础逻辑正确。
  • 在验证失败时，记录下（不要记录密码）输入的哈希字符串长度、提取出的盐的长度等调试信息进行比对。
  • 检查数据库迁移历史，确认存储哈希值的字段类型和长度没有改变。

9.4 如何升级现有系统的哈希算法？

如果你有一个正在运行的系统，里面存储着用 MD5、SHA1 或 PBKDF2 哈希的密码，直接切换到 Argon2 会导致所有老用户无法登录。

• 双哈希策略：
  1. 在用户登录时，先用旧算法验证密码。
  2. 如果验证成功，立即用 Argon2 对明文密码重新计算哈希，并用新的哈希值替换数据库中旧的哈希值。同时，可以在用户记录中设置一个标志（如PasswordHashVersion = 2）。
  3. 下次该用户登录时，直接使用新算法验证。
• 渐进式迁移：通过上述方法，在用户每次成功登录时逐步将密码哈希迁移到新算法。对于长期不活跃的用户，可以强制其在下次登录时重置密码。

集成 Argon2 到 .NET Core 项目，远不止是安装一个 NuGet 包那么简单。它要求开发者从“算法崇拜”转向“工程化安全思维”。理解参数背后的安全含义，在目标硬件上进行严谨的基准测试，设计可维护的服务封装，并制定好长期的监控和升级策略，这才是构建真正坚固身份验证系统的完整闭环。当你看到登录接口那几百毫秒的“延迟”时，应该感到安心——那正是 Argon2 在为你的用户数据构筑起一道昂贵的、攻击者难以逾越的内存高墙。