A:Common配置

test/Common.Test/CryptoHelperTests.cs

@@ -0,0 +1,748 @@
+using System.Security.Cryptography;
+using Common.Utils;
+
+namespace Common.Test;
+
+/// <summary>
+/// CryptoHelper 加密工具测试
+/// 展示各种加密、哈希、编码功能
+/// </summary>
+[TestClass]
+public class CryptoHelperTests
+{
+    #region AES 加密解密测试
+
+    /// <summary>
+    /// 测试：AES 加密和解密
+    /// </summary>
+    [TestMethod]
+    public void AesEncrypt_AndDecrypt_ReturnsOriginalText()
+    {
+        // Arrange
+        var plainText = "Hello, World! 你好世界！";
+        var password = "MySecretPassword123";
+
+        // Act
+        var encrypted = CryptoHelper.AesEncrypt(plainText, password);
+        var decrypted = CryptoHelper.AesDecrypt(encrypted, password);
+
+        // Assert
+        Assert.AreNotEqual(plainText, encrypted);
+        Assert.AreEqual(plainText, decrypted);
+    }
+
+    /// <summary>
+    /// 测试：相同内容使用相同密码多次加密，结果应该不同（因为 Salt 随机）
+    /// </summary>
+    [TestMethod]
+    public void AesEncrypt_SameTextSamePassword_ProducesDifferentCiphertext()
+    {
+        // Arrange
+        var plainText = "Test Message";
+        var password = "password";
+
+        // Act
+        var encrypted1 = CryptoHelper.AesEncrypt(plainText, password);
+        var encrypted2 = CryptoHelper.AesEncrypt(plainText, password);
+
+        // Assert: 密文应该不同（因为使用了随机 Salt）
+        Assert.AreNotEqual(encrypted1, encrypted2);
+
+        // 但都应该能正确解密
+        Assert.AreEqual(plainText, CryptoHelper.AesDecrypt(encrypted1, password));
+        Assert.AreEqual(plainText, CryptoHelper.AesDecrypt(encrypted2, password));
+    }
+
+    /// <summary>
+    /// 测试：使用错误密码解密失败
+    /// </summary>
+    [TestMethod]
+    public void AesDecrypt_WrongPassword_ThrowsException()
+    {
+        // Arrange
+        var plainText = "Secret Message";
+        var correctPassword = "correct";
+        var wrongPassword = "wrong";
+
+        var encrypted = CryptoHelper.AesEncrypt(plainText, correctPassword);
+
+        // Act & Assert
+        Assert.ThrowsException<CryptographicException>(() =>
+        {
+            CryptoHelper.AesDecrypt(encrypted, wrongPassword);
+        });
+    }
+
+    /// <summary>
+    /// 测试：加密空字符串抛出异常
+    /// </summary>
+    [TestMethod]
+    public void AesEncrypt_EmptyString_ThrowsException()
+    {
+        Assert.ThrowsException<ArgumentNullException>(() =>
+        {
+            CryptoHelper.AesEncrypt("", "password");
+        });
+    }
+
+    #endregion
+
+    #region RSA 加密解密测试
+
+    /// <summary>
+    /// 测试：生成 RSA 密钥对
+    /// </summary>
+    [TestMethod]
+    public void GenerateRsaKeys_ReturnsPublicAndPrivateKeys()
+    {
+        // Act
+        var (publicKey, privateKey) = CryptoHelper.GenerateRsaKeys();
+
+        // Assert
+        Assert.IsFalse(string.IsNullOrEmpty(publicKey));
+        Assert.IsFalse(string.IsNullOrEmpty(privateKey));
+        Assert.AreNotEqual(publicKey, privateKey);
+    }
+
+    /// <summary>
+    /// 测试：RSA 公钥加密，私钥解密
+    /// </summary>
+    [TestMethod]
+    public void RsaEncrypt_AndDecrypt_ReturnsOriginalText()
+    {
+        // Arrange
+        var plainText = "RSA Test Message";
+        var (publicKey, privateKey) = CryptoHelper.GenerateRsaKeys();
+
+        // Act
+        var encrypted = CryptoHelper.RsaEncrypt(plainText, publicKey);
+        var decrypted = CryptoHelper.RsaDecrypt(encrypted, privateKey);
+
+        // Assert
+        Assert.AreNotEqual(plainText, encrypted);
+        Assert.AreEqual(plainText, decrypted);
+    }
+
+    /// <summary>
+    /// 测试：RSA 加密相同内容产生不同密文（OAEP 填充）
+    /// </summary>
+    [TestMethod]
+    public void RsaEncrypt_SameText_ProducesDifferentCiphertext()
+    {
+        // Arrange
+        var plainText = "Test";
+        var (publicKey, _) = CryptoHelper.GenerateRsaKeys();
+
+        // Act
+        var encrypted1 = CryptoHelper.RsaEncrypt(plainText, publicKey);
+        var encrypted2 = CryptoHelper.RsaEncrypt(plainText, publicKey);
+
+        // Assert: 由于 OAEP 填充使用随机数，密文应该不同
+        Assert.AreNotEqual(encrypted1, encrypted2);
+    }
+
+    /// <summary>
+    /// 测试：使用错误的私钥解密失败
+    /// </summary>
+    [TestMethod]
+    public void RsaDecrypt_WrongPrivateKey_ThrowsException()
+    {
+        // Arrange
+        var plainText = "Secret";
+        var (publicKey1, _) = CryptoHelper.GenerateRsaKeys();
+        var (_, privateKey2) = CryptoHelper.GenerateRsaKeys(); // 不同的密钥对
+
+        var encrypted = CryptoHelper.RsaEncrypt(plainText, publicKey1);
+
+        // Act & Assert
+        Assert.ThrowsException<CryptographicException>(() =>
+        {
+            CryptoHelper.RsaDecrypt(encrypted, privateKey2);
+        });
+    }
+
+    #endregion
+
+    #region 哈希函数测试
+
+    /// <summary>
+    /// 测试：MD5 哈希
+    /// </summary>
+    [TestMethod]
+    public void Md5Hash_ProducesCorrectHash()
+    {
+        // Arrange
+        var input = "Hello, World!";
+
+        // Act
+        var hash = CryptoHelper.Md5Hash(input);
+
+        // Assert
+        Assert.AreEqual(32, hash.Length); // MD5 产生 32 位十六进制字符串
+        Assert.AreEqual("65a8e27d8879283831b664bd8b7f0ad4", hash);
+    }
+
+    /// <summary>
+    /// 测试：SHA256 哈希
+    /// </summary>
+    [TestMethod]
+    public void Sha256Hash_ProducesCorrectHash()
+    {
+        // Arrange
+        var input = "Hello, World!";
+
+        // Act
+        var hash = CryptoHelper.Sha256Hash(input);
+
+        // Assert
+        Assert.AreEqual(64, hash.Length); // SHA256 产生 64 位十六进制字符串
+        Assert.AreEqual("dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f", hash);
+    }
+
+    /// <summary>
+    /// 测试：SHA512 哈希
+    /// </summary>
+    [TestMethod]
+    public void Sha512Hash_ProducesCorrectHash()
+    {
+        // Arrange
+        var input = "Hello, World!";
+
+        // Act
+        var hash = CryptoHelper.Sha512Hash(input);
+
+        // Assert
+        Assert.AreEqual(128, hash.Length); // SHA512 产生 128 位十六进制字符串
+    }
+
+    /// <summary>
+    /// 测试：相同输入产生相同哈希
+    /// </summary>
+    [TestMethod]
+    public void Hash_SameInput_ProducesSameHash()
+    {
+        // Arrange
+        var input = "Test Input";
+
+        // Act
+        var md5_1 = CryptoHelper.Md5Hash(input);
+        var md5_2 = CryptoHelper.Md5Hash(input);
+        var sha256_1 = CryptoHelper.Sha256Hash(input);
+        var sha256_2 = CryptoHelper.Sha256Hash(input);
+
+        // Assert
+        Assert.AreEqual(md5_1, md5_2);
+        Assert.AreEqual(sha256_1, sha256_2);
+    }
+
+    /// <summary>
+    /// 测试：不同输入产生不同哈希
+    /// </summary>
+    [TestMethod]
+    public void Hash_DifferentInput_ProducesDifferentHash()
+    {
+        // Arrange
+        var input1 = "Input1";
+        var input2 = "Input2";
+
+        // Act
+        var hash1 = CryptoHelper.Sha256Hash(input1);
+        var hash2 = CryptoHelper.Sha256Hash(input2);
+
+        // Assert
+        Assert.AreNotEqual(hash1, hash2);
+    }
+
+    #endregion
+
+    #region Base64 编解码测试
+
+    /// <summary>
+    /// 测试：Base64 编码和解码
+    /// </summary>
+    [TestMethod]
+    public void Base64Encode_AndDecode_ReturnsOriginalText()
+    {
+        // Arrange
+        var input = "Hello, World! 你好世界！";
+
+        // Act
+        var encoded = CryptoHelper.Base64Encode(input);
+        var decoded = CryptoHelper.Base64Decode(encoded);
+
+        // Assert
+        Assert.AreNotEqual(input, encoded);
+        Assert.AreEqual(input, decoded);
+        Assert.AreEqual("SGVsbG8sIFdvcmxkISDkvaDlpb3kuJbnlYzvvIE=", encoded);
+    }
+
+    /// <summary>
+    /// 测试：URL 安全的 Base64 编码
+    /// </summary>
+    [TestMethod]
+    public void Base64UrlEncode_ProducesUrlSafeString()
+    {
+        // Arrange
+        var input = "Hello+World/Test=";
+
+        // Act
+        var encoded = CryptoHelper.Base64UrlEncode(input);
+        var decoded = CryptoHelper.Base64UrlDecode(encoded);
+
+        // Assert
+        Assert.IsFalse(encoded.Contains('+')); // 不包含 +
+        Assert.IsFalse(encoded.Contains('/')); // 不包含 /
+        Assert.IsFalse(encoded.Contains('=')); // 不包含 =
+        Assert.AreEqual(input, decoded);
+    }
+
+    /// <summary>
+    /// 测试：URL Base64 编解码
+    /// </summary>
+    [TestMethod]
+    public void Base64UrlEncode_AndDecode_ReturnsOriginalText()
+    {
+        // Arrange
+        var testCases = new[]
+        {
+            "test",
+            "test1",
+            "test12",
+            "test123",
+            "Hello, World!",
+            "特殊字符 !@#$%^&*()"
+        };
+
+        foreach (var input in testCases)
+        {
+            // Act
+            var encoded = CryptoHelper.Base64UrlEncode(input);
+            var decoded = CryptoHelper.Base64UrlDecode(encoded);
+
+            // Assert
+            Assert.AreEqual(input, decoded, $"Failed for input: {input}");
+        }
+    }
+
+    #endregion
+
+    #region 密码哈希测试
+
+    /// <summary>
+    /// 测试：哈希密码并验证
+    /// </summary>
+    [TestMethod]
+    public void HashPassword_AndVerify_ReturnsTrue()
+    {
+        // Arrange
+        var password = "MySecurePassword123!";
+
+        // Act
+        var hashed = CryptoHelper.HashPassword(password);
+        var isValid = CryptoHelper.VerifyPassword(password, hashed);
+
+        // Assert
+        Assert.IsTrue(isValid);
+        Assert.AreNotEqual(password, hashed);
+        Assert.IsTrue(hashed.StartsWith("$pbkdf2-sha256$"));
+    }
+
+    /// <summary>
+    /// 测试：验证错误密码返回 false
+    /// </summary>
+    [TestMethod]
+    public void VerifyPassword_WrongPassword_ReturnsFalse()
+    {
+        // Arrange
+        var correctPassword = "correct";
+        var wrongPassword = "wrong";
+        var hashed = CryptoHelper.HashPassword(correctPassword);
+
+        // Act
+        var isValid = CryptoHelper.VerifyPassword(wrongPassword, hashed);
+
+        // Assert
+        Assert.IsFalse(isValid);
+    }
+
+    /// <summary>
+    /// 测试：相同密码多次哈希产生不同结果
+    /// </summary>
+    [TestMethod]
+    public void HashPassword_SamePassword_ProducesDifferentHashes()
+    {
+        // Arrange
+        var password = "password123";
+
+        // Act
+        var hash1 = CryptoHelper.HashPassword(password);
+        var hash2 = CryptoHelper.HashPassword(password);
+
+        // Assert
+        Assert.AreNotEqual(hash1, hash2); // 不同的 Salt
+
+        // 但都应该能验证通过
+        Assert.IsTrue(CryptoHelper.VerifyPassword(password, hash1));
+        Assert.IsTrue(CryptoHelper.VerifyPassword(password, hash2));
+    }
+
+    /// <summary>
+    /// 测试：自定义哈希参数
+    /// </summary>
+    [TestMethod]
+    public void HashPassword_CustomParameters_Works()
+    {
+        // Arrange
+        var password = "test";
+
+        // Act
+        var hash = CryptoHelper.HashPassword(password, saltSize: 32, iterations: 50000, hashSize: 64);
+        var isValid = CryptoHelper.VerifyPassword(password, hash);
+
+        // Assert
+        Assert.IsTrue(isValid);
+    }
+
+    #endregion
+
+    #region HMAC 签名测试
+
+    /// <summary>
+    /// 测试：HMAC-SHA256 签名和验证
+    /// </summary>
+    [TestMethod]
+    public void HmacSha256_AndVerify_ReturnsTrue()
+    {
+        // Arrange
+        var message = "Important message";
+        var secret = "secret-key";
+
+        // Act
+        var signature = CryptoHelper.HmacSha256(message, secret);
+        var isValid = CryptoHelper.VerifyHmacSha256(message, signature, secret);
+
+        // Assert
+        Assert.IsTrue(isValid);
+        Assert.AreEqual(64, signature.Length); // SHA256 产生 64 位十六进制
+    }
+
+    /// <summary>
+    /// 测试：验证错误签名返回 false
+    /// </summary>
+    [TestMethod]
+    public void VerifyHmacSha256_WrongSignature_ReturnsFalse()
+    {
+        // Arrange
+        var message = "message";
+        var secret = "secret";
+        var wrongSignature = "wrong_signature";
+
+        // Act
+        var isValid = CryptoHelper.VerifyHmacSha256(message, wrongSignature, secret);
+
+        // Assert
+        Assert.IsFalse(isValid);
+    }
+
+    /// <summary>
+    /// 测试：修改消息后签名无效
+    /// </summary>
+    [TestMethod]
+    public void VerifyHmacSha256_ModifiedMessage_ReturnsFalse()
+    {
+        // Arrange
+        var originalMessage = "Original message";
+        var modifiedMessage = "Modified message";
+        var secret = "secret";
+
+        var signature = CryptoHelper.HmacSha256(originalMessage, secret);
+
+        // Act
+        var isValid = CryptoHelper.VerifyHmacSha256(modifiedMessage, signature, secret);
+
+        // Assert
+        Assert.IsFalse(isValid);
+    }
+
+    /// <summary>
+    /// 测试：HMAC-SHA512 签名
+    /// </summary>
+    [TestMethod]
+    public void HmacSha512_ProducesCorrectSignature()
+    {
+        // Arrange
+        var message = "Test message";
+        var secret = "secret";
+
+        // Act
+        var signature = CryptoHelper.HmacSha512(message, secret);
+        var isValid = CryptoHelper.VerifyHmacSha512(message, signature, secret);
+
+        // Assert
+        Assert.IsTrue(isValid);
+        Assert.AreEqual(128, signature.Length); // SHA512 产生 128 位十六进制
+    }
+
+    /// <summary>
+    /// 测试：相同消息和密钥产生相同签名
+    /// </summary>
+    [TestMethod]
+    public void HmacSha256_SameInputs_ProducesSameSignature()
+    {
+        // Arrange
+        var message = "message";
+        var secret = "secret";
+
+        // Act
+        var signature1 = CryptoHelper.HmacSha256(message, secret);
+        var signature2 = CryptoHelper.HmacSha256(message, secret);
+
+        // Assert
+        Assert.AreEqual(signature1, signature2);
+    }
+
+    #endregion
+
+    #region 辅助方法测试
+
+    /// <summary>
+    /// 测试：生成随机字符串
+    /// </summary>
+    [TestMethod]
+    public void GenerateRandomString_ProducesCorrectLength()
+    {
+        // Arrange & Act
+        var str10 = CryptoHelper.GenerateRandomString(10);
+        var str20 = CryptoHelper.GenerateRandomString(20);
+        var strWithSpecial = CryptoHelper.GenerateRandomString(15, useSpecialChars: true);
+
+        // Assert
+        Assert.AreEqual(10, str10.Length);
+        Assert.AreEqual(20, str20.Length);
+        Assert.AreEqual(15, strWithSpecial.Length);
+    }
+
+    /// <summary>
+    /// 测试：生成随机密码
+    /// </summary>
+    [TestMethod]
+    public void GeneratePassword_MeetsRequirements()
+    {
+        // Act
+        var password = CryptoHelper.GeneratePassword(16);
+
+        // Assert
+        Assert.AreEqual(16, password.Length);
+        Assert.IsTrue(password.Any(char.IsDigit), "Should contain digit");
+        Assert.IsTrue(password.Any(char.IsLower), "Should contain lowercase");
+        Assert.IsTrue(password.Any(char.IsUpper), "Should contain uppercase");
+        Assert.IsTrue(password.Any(c => !char.IsLetterOrDigit(c)), "Should contain special char");
+    }
+
+    /// <summary>
+    /// 测试：生成仅包含字母和数字的密码
+    /// </summary>
+    [TestMethod]
+    public void GeneratePassword_OnlyAlphanumeric_NoSpecialChars()
+    {
+        // Act
+        var password = CryptoHelper.GeneratePassword(
+            12,
+            requireDigit: true,
+            requireLowercase: true,
+            requireUppercase: true,
+            requireSpecialChar: false
+        );
+
+        // Assert
+        Assert.AreEqual(12, password.Length);
+        Assert.IsTrue(password.All(c => char.IsLetterOrDigit(c)), "Should only contain alphanumeric");
+    }
+
+    /// <summary>
+    /// 测试：生成多个随机字符串应该不同
+    /// </summary>
+    [TestMethod]
+    public void GenerateRandomString_MultipleCalls_ProducesDifferentResults()
+    {
+        // Act
+        var strings = Enumerable.Range(0, 10)
+            .Select(_ => CryptoHelper.GenerateRandomString(20))
+            .ToList();
+
+        // Assert: 所有字符串应该不同
+        Assert.AreEqual(10, strings.Distinct().Count());
+    }
+
+    #endregion
+
+    #region 实际应用场景测试
+
+    /// <summary>
+    /// 场景测试：用户密码存储和验证
+    /// </summary>
+    [TestMethod]
+    public void Scenario_UserPasswordStorageAndVerification()
+    {
+        // 模拟用户注册
+        var userPassword = "SecurePassword123!";
+        var hashedPassword = CryptoHelper.HashPassword(userPassword);
+
+        // 存储 hashedPassword 到数据库...
+
+        // 模拟用户登录
+        var loginPassword = "SecurePassword123!";
+        var isAuthenticated = CryptoHelper.VerifyPassword(loginPassword, hashedPassword);
+
+        Assert.IsTrue(isAuthenticated);
+
+        // 错误密码
+        var wrongPassword = "WrongPassword";
+        var isFailed = CryptoHelper.VerifyPassword(wrongPassword, hashedPassword);
+
+        Assert.IsFalse(isFailed);
+    }
+
+    /// <summary>
+    /// 场景测试：API 签名验证
+    /// </summary>
+    [TestMethod]
+    public void Scenario_ApiSignatureVerification()
+    {
+        // 客户端准备 API 请求
+        var apiKey = "client-api-key";
+        var apiSecret = "client-api-secret";
+        var requestBody = "{\"userId\":123,\"action\":\"purchase\"}";
+        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
+
+        // 生成签名
+        var signatureData = $"{apiKey}{requestBody}{timestamp}";
+        var signature = CryptoHelper.HmacSha256(signatureData, apiSecret);
+
+        // 发送请求（包含 signature 和 timestamp）...
+
+        // 服务器端验证签名
+        var receivedSignatureData = $"{apiKey}{requestBody}{timestamp}";
+        var isValidSignature = CryptoHelper.VerifyHmacSha256(
+            receivedSignatureData,
+            signature,
+            apiSecret
+        );
+
+        Assert.IsTrue(isValidSignature);
+    }
+
+    /// <summary>
+    /// 场景测试：敏感数据加密存储
+    /// </summary>
+    [TestMethod]
+    public void Scenario_EncryptSensitiveData()
+    {
+        // 加密敏感数据（如信用卡号）
+        var creditCardNumber = "4532-1234-5678-9010";
+        var encryptionKey = "DataEncryptionKey123!";
+
+        var encrypted = CryptoHelper.AesEncrypt(creditCardNumber, encryptionKey);
+
+        // 存储加密后的数据...
+        Console.WriteLine($"Encrypted: {encrypted}");
+
+        // 需要使用时解密
+        var decrypted = CryptoHelper.AesDecrypt(encrypted, encryptionKey);
+
+        Assert.AreEqual(creditCardNumber, decrypted);
+    }
+
+    /// <summary>
+    /// 场景测试：文件完整性验证
+    /// </summary>
+    [TestMethod]
+    public void Scenario_FileIntegrityVerification()
+    {
+        // 模拟文件内容
+        var fileContent = "Important file content that should not be modified";
+
+        // 计算文件哈希
+        var originalHash = CryptoHelper.Sha256Hash(fileContent);
+
+        // 存储哈希值...
+
+        // 后续验证文件是否被篡改
+        var currentHash = CryptoHelper.Sha256Hash(fileContent);
+
+        Assert.AreEqual(originalHash, currentHash, "File has not been modified");
+
+        // 模拟文件被修改
+        var modifiedContent = fileContent + " (modified)";
+        var modifiedHash = CryptoHelper.Sha256Hash(modifiedContent);
+
+        Assert.AreNotEqual(originalHash, modifiedHash, "File has been modified");
+    }
+
+    /// <summary>
+    /// 场景测试：JWT Token 签名（简化版）
+    /// </summary>
+    [TestMethod]
+    public void Scenario_JwtTokenSignature()
+    {
+        // JWT Header 和 Payload
+        var header = "{\"alg\":\"HS256\",\"typ\":\"JWT\"}";
+        var payload = "{\"userId\":123,\"exp\":1234567890}";
+
+        var headerEncoded = CryptoHelper.Base64UrlEncode(header);
+        var payloadEncoded = CryptoHelper.Base64UrlEncode(payload);
+
+        var tokenWithoutSignature = $"{headerEncoded}.{payloadEncoded}";
+
+        // 使用 HMAC 签名
+        var secret = "jwt-secret-key";
+        var signature = CryptoHelper.HmacSha256(tokenWithoutSignature, secret);
+        var signatureEncoded = CryptoHelper.Base64UrlEncode(signature);
+
+        var fullToken = $"{tokenWithoutSignature}.{signatureEncoded}";
+
+        Console.WriteLine($"JWT Token: {fullToken}");
+
+        // 验证 Token
+        var parts = fullToken.Split('.');
+        var receivedSignature = CryptoHelper.Base64UrlDecode(parts[2]);
+        var expectedSignature = CryptoHelper.HmacSha256($"{parts[0]}.{parts[1]}", secret);
+
+        Assert.AreEqual(expectedSignature, receivedSignature);
+    }
+
+    /// <summary>
+    /// 场景测试：安全通信（RSA + AES 混合加密）
+    /// </summary>
+    [TestMethod]
+    public void Scenario_HybridEncryption()
+    {
+        // 场景：发送大量数据，使用混合加密（RSA 加密 AES 密钥，AES 加密数据）
+
+        // 1. 接收方生成 RSA 密钥对
+        var (publicKey, privateKey) = CryptoHelper.GenerateRsaKeys();
+
+        // 2. 发送方生成随机 AES 密钥
+        var aesKey = CryptoHelper.GenerateRandomString(32);
+
+        // 3. 使用 RSA 公钥加密 AES 密钥
+        var encryptedAesKey = CryptoHelper.RsaEncrypt(aesKey, publicKey);
+
+        // 4. 使用 AES 加密大量数据
+        var largeData = "This is a large amount of data that would be inefficient to encrypt with RSA directly...";
+        var encryptedData = CryptoHelper.AesEncrypt(largeData, aesKey);
+
+        // 5. 发送 encryptedAesKey 和 encryptedData...
+
+        // 6. 接收方使用 RSA 私钥解密 AES 密钥
+        var decryptedAesKey = CryptoHelper.RsaDecrypt(encryptedAesKey, privateKey);
+
+        // 7. 使用解密的 AES 密钥解密数据
+        var decryptedData = CryptoHelper.AesDecrypt(encryptedData, decryptedAesKey);
+
+        Assert.AreEqual(aesKey, decryptedAesKey);
+        Assert.AreEqual(largeData, decryptedData);
+    }
+
+    #endregion
+}