移动加密方法，测试值转换器ok

IRaCIS.Core.Infrastructure/IRaCIS.Core.Infrastructure.csproj

@@ -18,6 +18,7 @@
 		<PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.8" />
 		<PackageReference Include="SharpCompress" Version="0.38.0" />
 		<PackageReference Include="SharpZipLib" Version="1.4.2" />
+		<PackageReference Include="BouncyCastle.Cryptography" Version="2.4.0" />
 		<PackageReference Include="System.Linq.Dynamic.Core" Version="1.4.5" />
 	</ItemGroup>
 

IRaCIS.Core.Infrastructure/_IRaCIS/Encryption/AesEncryption.cs

@@ -0,0 +1,145 @@
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Modes;
+using Org.BouncyCastle.Crypto.Paddings;
+using Org.BouncyCastle.Crypto.Parameters;
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace IRaCIS.Core.Infrastructure.Encryption;
+
+public class AesEncryption
+{
+    // AES 加密（不带 IV）
+    public static string Encrypt(string plainText, string key)
+    {
+        var keyBytes = Encoding.UTF8.GetBytes(key);
+
+        // 使用 AES 引擎 + PKCS7 填充
+        var engine = new AesEngine();
+        var blockCipher = new PaddedBufferedBlockCipher(engine, new Pkcs7Padding());
+        blockCipher.Init(true, new KeyParameter(keyBytes)); // true 表示加密
+
+        var inputBytes = Encoding.UTF8.GetBytes(plainText);
+        var encryptedBytes = ProcessCipher(blockCipher, inputBytes);
+
+        // 返回 Base64 编码的加密字符串
+        return Convert.ToBase64String(encryptedBytes);
+    }
+
+    // AES 解密（不带 IV）
+    public static string Decrypt(string encryptedText, string key)
+    {
+        var keyBytes = Encoding.UTF8.GetBytes(key);
+        var cipherBytes = Convert.FromBase64String(encryptedText);
+
+        // 使用 AES 引擎 + PKCS7 填充
+        var engine = new AesEngine();
+        var blockCipher = new PaddedBufferedBlockCipher(engine, new Pkcs7Padding());
+        blockCipher.Init(false, new KeyParameter(keyBytes)); // false 表示解密
+
+        var decryptedBytes = ProcessCipher(blockCipher, cipherBytes);
+        return Encoding.UTF8.GetString(decryptedBytes);
+    }
+
+    // AES 加密（带 IV）
+    public static string Encrypt(string plainText, string key, string iv)
+    {
+        var keyBytes = Encoding.UTF8.GetBytes(key);
+        var ivBytes = Encoding.UTF8.GetBytes(iv);
+
+        // 使用 AES 引擎 + PKCS7 填充 + CBC 模式
+        var engine = new AesEngine();
+        var blockCipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(engine), new Pkcs7Padding());
+        blockCipher.Init(true, new ParametersWithIV(new KeyParameter(keyBytes), ivBytes)); // true 表示加密
+
+        var inputBytes = Encoding.UTF8.GetBytes(plainText);
+        var encryptedBytes = ProcessCipher(blockCipher, inputBytes);
+
+        // 返回 Base64 编码的加密字符串
+        return Convert.ToBase64String(encryptedBytes);
+    }
+
+    // AES 解密（带 IV）
+    public static string Decrypt(string encryptedText, string key, string iv)
+    {
+        var keyBytes = Encoding.UTF8.GetBytes(key);
+        var ivBytes = Encoding.UTF8.GetBytes(iv);
+        var cipherBytes = Convert.FromBase64String(encryptedText);
+
+        // 使用 AES 引擎 + PKCS7 填充 + CBC 模式
+        var engine = new AesEngine();
+        var blockCipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(engine), new Pkcs7Padding());
+        blockCipher.Init(false, new ParametersWithIV(new KeyParameter(keyBytes), ivBytes)); // false 表示解密
+
+        var decryptedBytes = ProcessCipher(blockCipher, cipherBytes);
+        return Encoding.UTF8.GetString(decryptedBytes);
+    }
+
+    // 处理加密/解密数据
+    private static byte[] ProcessCipher(IBufferedCipher cipher, byte[] input)
+    {
+        var output = new byte[cipher.GetOutputSize(input.Length)];
+        int length = cipher.ProcessBytes(input, 0, input.Length, output, 0);
+        length += cipher.DoFinal(output, length);
+        Array.Resize(ref output, length); // 调整输出数组大小以适应实际数据长度
+        return output;
+    }
+
+    public static string DefaultKey = "12345678901234567890123456789012";
+
+    public static string EncryptPartial(string plainText, int unencryptedPrefixLength)
+    {
+        if (plainText.Length <= unencryptedPrefixLength)
+        {
+            return Encrypt(plainText, DefaultKey); // 如果文本太短，直接加密
+        }
+
+        var prefix = plainText.Substring(0, unencryptedPrefixLength);
+        var suffix = plainText.Substring(unencryptedPrefixLength);
+
+        return prefix + Encrypt(suffix, DefaultKey); // 前缀保留，后缀加密
+    }
+
+    public static string DecryptPartial(string encryptedText, int unencryptedPrefixLength)
+    {
+        if (encryptedText.Length <= unencryptedPrefixLength)
+        {
+            return Decrypt(encryptedText, DefaultKey); // 如果文本太短，直接解密
+        }
+
+        var prefix = encryptedText.Substring(0, unencryptedPrefixLength);
+        var suffix = encryptedText.Substring(unencryptedPrefixLength);
+
+        return prefix + Decrypt(suffix, DefaultKey); // 前缀保留，后缀解密
+    }
+
+    //public static string Encrypt(string plainText)
+    //{
+    //    using var aes = Aes.Create();
+    //    aes.Key = Encoding.UTF8.GetBytes(EncryptionKey);
+    //    aes.Mode = CipherMode.ECB; // 根据需要选择加密模式，这里使用 ECB 模式
+    //    aes.Padding = PaddingMode.PKCS7;
+
+    //    var encryptor = aes.CreateEncryptor();
+    //    var plainBytes = Encoding.UTF8.GetBytes(plainText);
+    //    var encryptedBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);
+
+    //    return Convert.ToBase64String(encryptedBytes);
+    //}
+
+    //public static string Decrypt(string encryptedText)
+    //{
+    //    using var aes = Aes.Create();
+    //    aes.Key = Encoding.UTF8.GetBytes(EncryptionKey);
+    //    aes.Mode = CipherMode.ECB;
+    //    aes.Padding = PaddingMode.PKCS7;
+
+    //    var decryptor = aes.CreateDecryptor();
+    //    var encryptedBytes = Convert.FromBase64String(encryptedText);
+    //    var decryptedBytes = decryptor.TransformFinalBlock(encryptedBytes, 0, encryptedBytes.Length);
+
+    //    return Encoding.UTF8.GetString(decryptedBytes);
+    //}
+}

IRaCIS.Core.Infrastructure/_IRaCIS/Encryption/RSAEncryption.cs

@@ -0,0 +1,94 @@
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Encodings;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.OpenSsl;
+using Org.BouncyCastle.Security;
+using System;
+using System.IO;
+using System.Text;
+
+namespace IRaCIS.Core.Infrastructure.Encryption;
+
+/// <summary>
+/// https://www.cnblogs.com/NBDWDYS2214143926/p/13329231.html
+/// </summary>
+public class RSAEncryption
+{
+
+    public static AsymmetricCipherKeyPair GenerateRSAKeyPair(int keySize)
+    {
+        var keyGenerationParameters = new KeyGenerationParameters(new SecureRandom(), keySize);
+        var keyPairGenerator = new RsaKeyPairGenerator();
+        keyPairGenerator.Init(keyGenerationParameters);
+        return keyPairGenerator.GenerateKeyPair();
+    }
+
+    public static string ExportPublicKey(AsymmetricKeyParameter publicKey)
+    {
+        using (StringWriter sw = new StringWriter())
+        {
+            PemWriter pw = new PemWriter(sw);
+            pw.WriteObject(publicKey);
+            pw.Writer.Flush();
+            return sw.ToString();
+        }
+    }
+
+    public static string ExportPrivateKey(AsymmetricKeyParameter privateKey)
+    {
+        using (StringWriter sw = new StringWriter())
+        {
+            PemWriter pw = new PemWriter(sw);
+            pw.WriteObject(privateKey);
+            pw.Writer.Flush();
+            return sw.ToString();
+        }
+    }
+
+    /// <summary>
+    /// RSA解密
+    /// </summary>
+    /// <param name="privateKey">私钥</param>
+    /// <param name="decryptstring">待解密的字符串(Base64)</param>
+    /// <returns>解密后的字符串</returns>
+    public static string Decrypt(string privateKey, string decryptstring)
+    {
+        using (TextReader reader = new StringReader(privateKey))
+        {
+            dynamic key = new PemReader(reader).ReadObject();
+            var rsaDecrypt = new Pkcs1Encoding(new RsaEngine());
+            if (key is AsymmetricKeyParameter)
+            {
+                key = (AsymmetricKeyParameter)key;
+            }
+            else if (key is AsymmetricCipherKeyPair)
+            {
+                key = ((AsymmetricCipherKeyPair)key).Private;
+            }
+            rsaDecrypt.Init(false, key);  //这里加密是true；解密是false  
+
+            byte[] entData = Convert.FromBase64String(decryptstring);
+            entData = rsaDecrypt.ProcessBlock(entData, 0, entData.Length);
+            return Encoding.UTF8.GetString(entData);
+        }
+    }/// <summary>
+
+     /// 加密
+     /// </summary>
+     /// <param name="publicKey">公钥</param>
+     /// <param name="encryptstring">待加密的字符串</param>
+     /// <returns>加密后的Base64</returns>
+    public static string Encrypt(string publicKey, string encryptstring)
+    {
+        using (TextReader reader = new StringReader(publicKey))
+        {
+            AsymmetricKeyParameter key = new PemReader(reader).ReadObject() as AsymmetricKeyParameter;
+            Pkcs1Encoding pkcs1 = new Pkcs1Encoding(new RsaEngine());
+            pkcs1.Init(true, key);//加密是true；解密是false;
+            byte[] entData = Encoding.UTF8.GetBytes(encryptstring);
+            entData = pkcs1.ProcessBlock(entData, 0, entData.Length);
+            return Convert.ToBase64String(entData);
+        }
+    }
+}