RuoVea.ExCrypt 10.0.0

📋 RuoVea.ExCrypt 组件概览

RuoVea.ExCrypt 是一个功能全面的加密工具类库，集成了多种常用的加密算法，支持多语言字符处理。

🏗️ 加密算法体系

1. 对称加密算法

AES 加解密 (AESCrypt)

// AES 加密
string encrypted = AESCrypt.AESEncrypt("明文数据", "加密密钥");
// 或使用扩展方法
string encrypted = "明文数据".ToAESEncrypt("加密密钥");

// AES 解密  
string decrypted = AESCrypt.AESDecrypt(encrypted, "加密密钥");
// 或使用扩展方法
string decrypted = encrypted.ToAESDecrypt("加密密钥");

特点：

• 支持 128/192/256 位密钥
• CBC 加密模式
• PKCS7 填充
• 自动生成 IV（初始化向量）

DESC 加解密 (DESCCrypt)

// DESC 加密
string encrypted = DESCCrypt.DESEncrypt("明文数据", "8位密钥");
// 或使用扩展方法
string encrypted = "明文数据".ToDESCEncrypt("8位密钥");

// DESC 解密
string decrypted = DESCCrypt.DESDecrypt(encrypted, "8位密钥");  
// 或使用扩展方法
string decrypted = encrypted.ToDESCDecrypt("8位密钥");

特点：

• 56位有效密钥长度
• 需要8位字符的密钥
• ECB 加密模式

2. 非对称加密算法

RSA 加解密 (RSACrypt)

// RSA 加密（使用公钥）
string encrypted = RSACrypt.Encrypt("明文数据", "公钥字符串");
// 或使用扩展方法  
string encrypted = "明文数据".ToRSAEncrpyt("公钥字符串");

// RSA 解密（使用私钥）
string decrypted = RSACrypt.Decrypt(encrypted, "私钥字符串");
// 或使用扩展方法
string decrypted = encrypted.ToRSADecrypt("私钥字符串");

特点：

• 支持 PKCS1 填充
• 支持 XML 格式密钥
• 自动处理长文本分段加密

3. 哈希算法

MD5 加密 (Md5Crypt)

// MD5 加密，支持 16位 和 32位
string md32 = Md5Crypt.Encrypt("原始数据", EnumMD5Length.L32);
string md16 = Md5Crypt.Encrypt("原始数据", EnumMD5Length.L16);

// 扩展方法
string md32 = "原始数据".ToMD5Encrypt(EnumMD5Length.L32);
string md16 = "原始数据".ToMD5Encrypt(EnumMD5Length.L16);

SHA 系列加密

// SHA1
string sha1 = SHA1Crypt.Encrypt("原始数据");

// SHA256  
string sha256 = SHA256Crypt.Encrypt("原始数据");

// SHA384
string sha384 = SHA384Crypt.Encrypt("原始数据");

// SHA512
string sha512 = SHA512Crypt.Encrypt("原始数据");

4. HMAC 消息认证码

HMAC 系列

// HMAC-SHA1
string hmacSha1 = HMACSHA1Crypt.Encrypt("原始数据", "密钥");

// HMAC-SHA256
string hmacSha256 = HMACSHA256Crypt.Encrypt("原始数据", "密钥");

// HMAC-SHA384  
string hmacSha384 = HMACSHA384Crypt.Encrypt("原始数据", "密钥");

// HMAC-SHA512
string hmacSha512 = HMACSHA512Crypt.Encrypt("原始数据", "密钥");

5. 其他加密算法

Base64 编码解码

// Base64 编码
string encoded = Base64Crypt.Encode("原始数据");

// Base64 解码  
string decoded = Base64Crypt.Decode(encoded);

PBKDF2 密钥派生

// PBKDF2 密钥生成
string derivedKey = PBKDF2Crypt.DeriveKey("密码", "盐值", 迭代次数);

机器密钥 (MachineKey)

// 生成机器特定的加密密钥
string machineKey = MachineKey.Generate();

🚀 完整使用示例

1. 密码安全存储

public class PasswordService
{
    // 密码加盐哈希存储
    public string HashPassword(string password)
    {
        // 生成随机盐值
        string salt = GenerateSalt();
        
        // 使用 PBKDF2 进行密钥派生
        string hashedPassword = PBKDF2Crypt.DeriveKey(password, salt, 10000);
        
        // 返回 盐值:哈希值 格式
        return $"{salt}:{hashedPassword}";
    }
    
    // 验证密码
    public bool VerifyPassword(string password, string storedHash)
    {
        var parts = storedHash.Split(':');
        if (parts.Length != 2) return false;
        
        string salt = parts[0];
        string expectedHash = parts[1];
        
        string actualHash = PBKDF2Crypt.DeriveKey(password, salt, 10000);
        
        return actualHash == expectedHash;
    }
    
    private string GenerateSalt()
    {
        byte[] saltBytes = new byte[16];
        using (var rng = new RNGCryptoServiceProvider())
        {
            rng.GetBytes(saltBytes);
        }
        return Convert.ToBase64String(saltBytes);
    }
}

2. 敏感数据加密

public class DataEncryptionService
{
    private readonly string _encryptionKey;
    
    public DataEncryptionService(string encryptionKey)
    {
        _encryptionKey = encryptionKey;
    }
    
    // 加密用户敏感数据
    public string EncryptSensitiveData(string sensitiveData)
    {
        try
        {
            return AESCrypt.AESEncrypt(sensitiveData, _encryptionKey);
        }
        catch (Exception ex)
        {
            throw new Exception("数据加密失败", ex);
        }
    }
    
    // 解密用户敏感数据
    public string DecryptSensitiveData(string encryptedData)
    {
        try
        {
            return AESCrypt.AESDecrypt(encryptedData, _encryptionKey);
        }
        catch (Exception ex)
        {
            throw new Exception("数据解密失败", ex);
        }
    }
    
    // 加密数据库连接字符串
    public string EncryptConnectionString(string connectionString)
    {
        return DESCCrypt.DESEncrypt(connectionString, _encryptionKey.Substring(0, 8));
    }
}

3. API 签名验证

public class ApiSignatureService
{
    private readonly string _apiSecret;
    
    public ApiSignatureService(string apiSecret)
    {
        _apiSecret = apiSecret;
    }
    
    // 生成 API 请求签名
    public string GenerateSignature(string method, string path, string queryString, string body, long timestamp)
    {
        var signContent = $"{method}\n{path}\n{queryString}\n{body}\n{timestamp}";
        return HMACSHA256Crypt.Encrypt(signContent, _apiSecret);
    }
    
    // 验证 API 请求签名
    public bool VerifySignature(string signature, string method, string path, string queryString, string body, long timestamp)
    {
        var expectedSignature = GenerateSignature(method, path, queryString, body, timestamp);
        return signature == expectedSignature;
    }
}

4. 文件完整性校验

public class FileIntegrityService
{
    // 计算文件 MD5 校验和
    public string CalculateFileChecksum(string filePath)
    {
        using var stream = File.OpenRead(filePath);
        using var md5 = MD5.Create();
        byte[] hash = md5.ComputeHash(stream);
        return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
    }
    
    // 验证文件完整性
    public bool VerifyFileIntegrity(string filePath, string expectedChecksum)
    {
        string actualChecksum = CalculateFileChecksum(filePath);
        return actualChecksum == expectedChecksum;
    }
    
    // 生成文件的 SHA256 哈希
    public string CalculateFileSHA256(string filePath)
    {
        using var stream = File.OpenRead(filePath);
        using var sha256 = SHA256.Create();
        byte[] hash = sha256.ComputeHash(stream);
        return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
    }
}

5. 安全令牌生成

public class TokenService
{
    private readonly string _secretKey;
    
    public TokenService(string secretKey)
    {
        _secretKey = secretKey;
    }
    
    // 生成安全访问令牌
    public string GenerateAccessToken(string userId, string userRole, TimeSpan expiry)
    {
        var payload = new
        {
            UserId = userId,
            Role = userRole,
            Expiry = DateTime.UtcNow.Add(expiry).Ticks
        };
        
        string payloadJson = JsonConvert.SerializeObject(payload);
        string encryptedPayload = AESCrypt.AESEncrypt(payloadJson, _secretKey);
        
        return Base64Crypt.Encode(encryptedPayload);
    }
    
    // 验证并解析访问令牌
    public (string UserId, string Role) ValidateAccessToken(string token)
    {
        try
        {
            string encryptedPayload = Base64Crypt.Decode(token);
            string payloadJson = AESCrypt.AESDecrypt(encryptedPayload, _secretKey);
            
            var payload = JsonConvert.DeserializeObject<dynamic>(payloadJson);
            long expiryTicks = payload.Expiry;
            
            if (DateTime.UtcNow.Ticks > expiryTicks)
            {
                throw new Exception("令牌已过期");
            }
            
            return (payload.UserId, payload.Role);
        }
        catch
        {
            throw new Exception("无效的访问令牌");
        }
    }
}

6. 多语言支持加密

public class MultiLanguageEncryptionService
{
    // 支持多种语言的加密处理
    public string EncryptForLanguage(string text, string language)
    {
        // 根据语言调整编码方式
        Encoding encoding = language.ToLower() switch
        {
            "zh-cn" => Encoding.UTF8,      // 简体中文
            "zh-tw" => Encoding.UTF8,      // 繁体中文
            "yue" => Encoding.UTF8,        // 粤语
            "ja" => Encoding.UTF8,         // 日语
            "fr" => Encoding.UTF8,         // 法语
            "en" => Encoding.ASCII,        // 英语
            _ => Encoding.UTF8
        };
        
        byte[] textBytes = encoding.GetBytes(text);
        string base64Text = Convert.ToBase64String(textBytes);
        
        return AESCrypt.AESEncrypt(base64Text, "encryption-key");
    }
    
    public string DecryptForLanguage(string encryptedText, string language)
    {
        string base64Text = AESCrypt.AESDecrypt(encryptedText, "encryption-key");
        byte[] textBytes = Convert.FromBase64String(base64Text);
        
        Encoding encoding = language.ToLower() switch
        {
            "zh-cn" => Encoding.UTF8,      // 简体中文
            "zh-tw" => Encoding.UTF8,      // 繁体中文  
            "yue" => Encoding.UTF8,        // 粤语
            "ja" => Encoding.UTF8,         // 日语
            "fr" => Encoding.UTF8,         // 法语
            "en" => Encoding.ASCII,        // 英语
            _ => Encoding.UTF8
        };
        
        return encoding.GetString(textBytes);
    }
}

7. 综合加密工具类

public class ComprehensiveCryptoService
{
    private readonly string _aesKey;
    private readonly string _rsaPublicKey;
    private readonly string _rsaPrivateKey;
    
    public ComprehensiveCryptoService(string aesKey, string rsaPublicKey, string rsaPrivateKey)
    {
        _aesKey = aesKey;
        _rsaPublicKey = rsaPublicKey;
        _rsaPrivateKey = rsaPrivateKey;
    }
    
    // 混合加密：使用 RSA 加密 AES 密钥，再用 AES 加密数据
    public (string EncryptedData, string EncryptedKey) HybridEncrypt(string data)
    {
        // 生成随机的 AES 密钥
        string randomAesKey = GenerateRandomKey(32);
        
        // 使用 AES 加密数据
        string encryptedData = AESCrypt.AESEncrypt(data, randomAesKey);
        
        // 使用 RSA 加密 AES 密钥
        string encryptedKey = RSACrypt.Encrypt(randomAesKey, _rsaPublicKey);
        
        return (encryptedData, encryptedKey);
    }
    
    // 混合解密
    public string HybridDecrypt(string encryptedData, string encryptedKey)
    {
        // 使用 RSA 解密 AES 密钥
        string aesKey = RSACrypt.Decrypt(encryptedKey, _rsaPrivateKey);
        
        // 使用 AES 解密数据
        return AESCrypt.AESDecrypt(encryptedData, aesKey);
    }
    
    // 生成安全随机密钥
    private string GenerateRandomKey(int length)
    {
        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        var random = new Random();
        return new string(Enumerable.Repeat(chars, length)
            .Select(s => s[random.Next(s.Length)]).ToArray());
    }
    
    // 生成数字签名
    public string GenerateSignature(string data)
    {
        string hash = SHA256Crypt.Encrypt(data);
        return RSACrypt.Encrypt(hash, _rsaPrivateKey);
    }
    
    // 验证数字签名
    public bool VerifySignature(string data, string signature)
    {
        string dataHash = SHA256Crypt.Encrypt(data);
        string decryptedSignature = RSACrypt.Decrypt(signature, _rsaPublicKey);
        return dataHash == decryptedSignature;
    }
}

🎯 加密算法选择指南

根据场景选择加密算法：

1. 密码存储：PBKDF2 + 盐值
2. 敏感数据加密：AES-256
3. API 通信：RSA + AES 混合加密
4. 数据完整性：SHA-256 或 HMAC
5. 文件校验：MD5 或 SHA-256
6. 快速哈希：MD5（非安全场景）
7. 安全哈希：SHA-256 或 SHA-512
8. 消息认证：HMAC-SHA256

安全建议：

• 使用足够长的密钥（AES 至少 128位，RSA 至少 2048位）
• 定期更换加密密钥
• 使用安全的随机数生成器
• 对敏感数据实施多层加密
• 妥善保管私钥和密钥

这个加密组件库提供了企业级应用所需的各种加密功能，从基础的哈希计算到复杂的非对称加密，满足不同安全级别的需求。