MVC.NET Core应用加密方案咨询：替换MD5与GDPR合规加密

Hey Dave, let's break down your requirements step by step—you've got two critical priorities here: upgrading password hashing to something secure, and encrypting sensitive data to meet GDPR compliance, all within your existing MVC .NET Core 2 + WCF + SQL Server 2017 Express stack. Here's a practical, compliant approach with recommendations tailored to your setup:

MD5 is long outdated and cryptographically broken—it's trivial to crack with modern tools, so ditching it is non-negotiable. The best fit for your .NET Core app is ASP.NET Core's built-in PasswordHasher<T> for a few key reasons:

• It uses PBKDF2 with HMAC-SHA256, which meets NIST security standards and is designed specifically for password storage (slow to brute-force).
• It handles salt generation automatically (no need to manage separate salt columns—hashes include the salt internally).
• It's fully integrated with .NET Core's identity system, making it easy to drop into your existing code.

Implementation Steps: #

1. Update your password handling logic:

   // Inject or instantiate PasswordHasher in your MVC controller/service
   private readonly PasswordHasher<AppUser> _passwordHasher = new PasswordHasher<AppUser>();
   
   // Hash a new password (registration/reset flow)
   var newUser = new AppUser
   {
       LoginName = model.LoginName,
       Pass = _passwordHasher.HashPassword(newUser, model.Password),
       CreatedDate = DateTime.UtcNow
   };
   
   // Validate login (with gradual MD5 migration)
   var existingUser = _userRepo.GetByLoginName(model.LoginName);
   var hashResult = _passwordHasher.VerifyHashedPassword(existingUser, existingUser.Pass, model.Password);
   
   if (hashResult == PasswordVerificationResult.Success)
   {
       // Login successful
   }
   // Handle legacy MD5 hashes
   else if (hashResult == PasswordVerificationResult.Failed && VerifyMd5Hash(model.Password, existingUser.Pass))
   {
       // Rehash with PBKDF2 and update the database
       var newSecureHash = _passwordHasher.HashPassword(existingUser, model.Password);
       _userRepo.UpdatePassword(existingUser.Id, newSecureHash);
       // Proceed with login
   }
   

2. Gradual migration: Since MD5 is one-way, you can't convert existing hashes directly. Instead, rehash passwords when users next log in—this avoids forcing a password reset for all users.

GDPR requires protecting sensitive personal data (like customer PII) even when it's stored at rest. SQL Server 2017 Express has limitations (no Transparent Data Encryption/TDE), so your best options are:

Option 1: Always Encrypted (Recommended) #

Always Encrypted is ideal for GDPR because it encrypts sensitive data at the application layer—database administrators can't access plaintext data, which aligns with GDPR's "least privilege" principle. It's supported in SQL Server 2017 Express, and works seamlessly with .NET apps.

Key Benefits: #

• Separates encryption keys from data (keys are stored outside the database, e.g., Azure Key Vault or Windows Certificate Store).
• Automatic encryption/decryption in the .NET data provider—you don't need to modify most of your code.
• Supports both deterministic encryption (for equality searches) and randomized encryption (for stronger security on non-searchable fields).

Implementation Steps: #

1. Identify sensitive columns: Map out all fields that qualify as personal data under GDPR (e.g., customer names, emails, addresses, IDs from CRM/ERP).
2. Configure Always Encrypted via SSMS:
   • Create a Column Master Key (CMK) stored in a secure location (Azure Key Vault is preferred for cloud/hybrid setups; Windows Certificate Store works for on-prem).
   • Create a Column Encryption Key (CEK) encrypted with the CMK.
   • Encrypt your target columns using the CEK.
3. Update your connection strings: Add Column Encryption Setting=Enabled to enable encryption/decryption in your WCF service's database connection:

   Server=YOUR_SERVER;Database=YOUR_DB;Column Encryption Setting=Enabled;User Id=YOUR_USER;Password=YOUR_PASS;
   

4. Grant key access: Ensure your WCF service's identity has permission to access the CMK (e.g., assign a managed identity in Azure Key Vault).

Option 2: Column-Level Encryption (CLE) #

If Always Encrypted isn't feasible for some reason, you can use SQL Server's built-in functions like EncryptByCert or EncryptByKey to encrypt specific columns. However, this is less ideal for GDPR because:

• Encryption keys are stored in the database, so DBAs can access them (violating least privilege).
• You'll need to modify your SQL queries to explicitly encrypt/decrypt data, adding code complexity.

Your MVC → WCF → REST/DB stack requires a few additional checks to maintain security and compliance:

• Passwords should be hashed in the MVC layer: Never send plaintext passwords to your WCF service—hash them upfront to minimize exposure during transit (even with HTTPS).
• Secure transit for all data: Ensure all communication between MVC ↔ WCF, WCF ↔ REST APIs, and WCF ↔ DB uses HTTPS (TLS 1.2+). This meets GDPR's requirement to protect data in transit.
• Third-party system integration: For data pulled from DMS/CRM/ERP, confirm those systems meet GDPR standards (e.g., they encrypt data at rest and in transit). If you store this data locally, encrypt it using the same Always Encrypted approach as your internal DB data.
• Key management: Follow GDPR's key lifecycle requirements—rotate keys regularly, revoke access when needed, and never hardcode keys in your app. Use a centralized key management system (like Azure Key Vault) instead.

To fully align with GDPR, don't forget these critical steps:

• Data minimization: Audit your database and third-party integrations to remove any unnecessary personal data.
• Audit logging: Enable SQL Server Audit to track access to sensitive columns, and add logging in your WCF service to record data access/modification events. This helps with breach response and compliance audits.
• Breach response plan: Document a plan to detect, contain, and report data breaches within 72 hours (as required by GDPR).

内容的提问来源于stack exchange，提问作者Davecz