ZLPMS/PMS.WebUI/App_Start/stack/EncryptionAttribute.cs

using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Encodings;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using QWPlatform.SystemLibrary.Utils;
using Org.BouncyCastle.X509;
using PMS.WebUI.Controllers;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;

namespace PMS.WebUI
{

    /// <summary>
    /// 加密解密特性
    /// 支持Post入参 并且是DecryInput<>的加密 请求值必须是{"Str":"加密值"}
    /// 支持完全的出参加密
    /// </summary>
    public class EncryptionAttribute : ActionFilterAttribute
    {
        private static RSATool rsa = new RSATool();
        private static string privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJPfIxM/cGiMPSrR7v+H7Kbjpeo41GAryvetr8L6kzgGifGzv3IW/EMm/bWLW7lD8yp0ilwvELo6DaxZhzzeflJzd6AI+2zGcMAKunHalXjsYeg2SSROvk750Pfu7v/x0BiYGlRwb+zmFuEArCMmjSSIFE7aZjff9lczJecQDufbAgEDAoGAGKUwgzU9ZsIKMc2n1UFSG9Cbpwl4urH3KUedSynDNAEW/Z31Pa5/YIZ/nkHknuCohxNsZLKCybRXnLmWiiUVDXxiwcObqIrsK0Gr5v5Y+n8WfHlPAF5lBPg6twjjZCBqrnWNXbsy5mdpG1gacIv2V3E5wwAZwh2FQpGD5uK6Ug8CQQDgocjYzvU1tg8f916z+9gDk7TW/K+CCKpGDByo0GxZJAi4vTRiX82EtiE8hPvXmAcJdAFHFQfPV8P1HgMaIml1AkEAqIVMmoaETzGtYLupMIPB7kdIh3JylleG4mSREMo61iv5Hgztqt649Oobs4iEBy8Q10W7krajX38D1PB6pY6SDwJBAJXBMJCJ+M55X2qk6c1SkAJieI9TH6wFxtldaHCK8uYYBdB+Iuw/3lh5a32t/TplWgZNVi9jWoo6gqNpV2bBm6MCQHBY3bxZrYohHkB9G3WtK/Qvha+hobmPr0GYYLXcJzlyphQInnHp0KNGvSJbAq90teTZJ7ckbOpUrTigUcO0YV8CQQDeM10N8XhwkZ1nIXcSGqnkJHp7a9hRtXK8HtWkjeV5sNGPvOSIlL8aMVmcIso0vdLG5LnV+OFXOGOkHwD3qtn3";

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            base.OnActionExecuting(filterContext);
            var para = filterContext.ActionParameters;
            if (para != null && para.Count > 0)
            {
                foreach (var item in para)
                {
                    var objectType = item.Value.GetType();
                    // 检查 item.Value 是否是泛型类型 DecryInput<>
                    if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(DecryInput<>))
                    {
                        // 获取 DecryInput<> 的类型参数，即 baseType
                        var baseType = item.Value.GetType().GetGenericArguments()[0];
                        var input = item.Value;
                        // 使用 dynamic 以便在运行时解析 Str 属性
                        var content = ((dynamic)input).Str; 
                        if (!string.IsNullOrEmpty(content))
                        {
                            // 使用 rsa.DecryptByKey 方法解密 content
                            var newContent = rsa.DecryptByKey(content, privateKey, false);
                            // 使用反射获取 Strings 类中的 JsonToModel<T> 方法的 MethodInfo
                            var valueType = typeof(Strings).GetMethod("JsonToModel")
                                                         // 将 baseType 作为泛型参数传递给 JsonToModel<T>
                                                         .MakeGenericMethod(baseType)
                                                         // 调用 JsonToModel<T>(newContent)
                                                         .Invoke(null, new[] { newContent });
                            // 设置 input 对象的 Value 属性为转换后的值
                            input.GetType().GetProperty("Value").SetValue(input, valueType);
                            //这两句等价于    input.Value = Strings.JsonToModel<T>(newContent);
                        }
                    }
                }
            }
        }

        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            base.OnResultExecuting(filterContext);
            var result = filterContext.Result;
            if (result is ContentResult)
            {
                var contentResult = (result as ContentResult);
                var content = contentResult.Content;
                if (!string.IsNullOrEmpty(content))
                {
                    contentResult.Content = rsa.EncryptByKey(content, privateKey, false);
                }
            }
        }
    }

    public class DecryInput<T>
    {
        public string Str { get; set; }
        public T Value { get; set; }
    }

    public class RSATool
    {
        /// <summary>
        /// KEY 结构体
        /// </summary>
        public struct RSAKEY
        {
            /// <summary>
            /// 公钥
            /// </summary>
            public string PublicKey { get; set; }
            /// <summary>
            /// 私钥
            /// </summary>
            public string PrivateKey { get; set; }
        }
        public RSAKEY GetKey()
        {
            //RSA密钥对的构造器  
            RsaKeyPairGenerator keyGenerator = new RsaKeyPairGenerator();

            //RSA密钥构造器的参数  
            RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(
                Org.BouncyCastle.Math.BigInteger.ValueOf(3),
                new Org.BouncyCastle.Security.SecureRandom(),
                1024,   //密钥长度  
                25);
            //用参数初始化密钥构造器  
            keyGenerator.Init(param);
            //产生密钥对  
            AsymmetricCipherKeyPair keyPair = keyGenerator.GenerateKeyPair();
            //获取公钥和密钥  
            AsymmetricKeyParameter publicKey = keyPair.Public;
            AsymmetricKeyParameter privateKey = keyPair.Private;

            SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
            PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);


            Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();

            byte[] publicInfoByte = asn1ObjectPublic.GetEncoded("UTF-8");
            Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
            byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded("UTF-8");

            RSAKEY item = new RSAKEY()
            {
                PublicKey = Convert.ToBase64String(publicInfoByte),
                PrivateKey = Convert.ToBase64String(privateInfoByte)
            };
            return item;
        }
        private AsymmetricKeyParameter GetPublicKeyParameter(string s)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] publicInfoByte = Convert.FromBase64String(s);
            Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);//这里也可以从流中读取，从本地导入   
            AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(publicInfoByte);
            return pubKey;
        }
        private AsymmetricKeyParameter GetPrivateKeyParameter(string s)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] privateInfoByte = Convert.FromBase64String(s);
            // Asn1Object priKeyObj = Asn1Object.FromByteArray(privateInfoByte);//这里也可以从流中读取，从本地导入   
            // PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
            AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(privateInfoByte);
            return priKey;
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="s"></param>
        /// <param name="key"></param>
        /// <param name="isPublic"></param>
        /// <returns></returns>
        public string EncryptByKey(string s, string key, bool isPublic)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //加密  
            try
            {
                engine.Init(true, isPublic ? GetPublicKeyParameter(key) : GetPrivateKeyParameter(key));
                byte[] byteData = System.Text.Encoding.UTF8.GetBytes(s);

                int inputLen = byteData.Length;
                MemoryStream ms = new MemoryStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段加密
                while (inputLen - offSet > 0)
                {
                    if (inputLen - offSet > 117)
                    {
                        cache = engine.ProcessBlock(byteData, offSet, 117);
                    }
                    else
                    {
                        cache = engine.ProcessBlock(byteData, offSet, inputLen - offSet);
                    }
                    ms.Write(cache, 0, cache.Length);
                    i++;
                    offSet = i * 117;
                }
                byte[] encryptedData = ms.ToArray();

                //var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(encryptedData);
                //Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
            }
            catch (Exception ex)
            {
                return ex.Message;

            }
        }
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="s"></param>
        /// <param name="key"></param>
        /// <param name="isPublic"></param>
        /// <returns></returns>
        public string DecryptByKey(string s, string key, bool isPublic)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());


            //加密  

            try
            {
                engine.Init(false, isPublic ? GetPublicKeyParameter(key) : GetPrivateKeyParameter(key));
                byte[] byteData = Convert.FromBase64String(s);

                int inputLen = byteData.Length;
                MemoryStream ms = new MemoryStream();
                int offSet = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段加密
                while (inputLen - offSet > 0)
                {
                    if (inputLen - offSet > 128)
                    {
                        cache = engine.ProcessBlock(byteData, offSet, 128);
                    }
                    else
                    {
                        cache = engine.ProcessBlock(byteData, offSet, inputLen - offSet);
                    }
                    ms.Write(cache, 0, cache.Length);
                    i++;
                    offSet = i * 128;
                }
                byte[] encryptedData = ms.ToArray();

                //var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Encoding.UTF8.GetString(ms.ToArray());
                //Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
            }
            catch (Exception ex)
            {
                return ex.Message;

            }
        }
        /// <summary>
        /// 签名
        /// </summary>
        /// <param name="data">数据</param>
        /// <param name="key">密匙</param>
        /// <returns></returns>
        public string SignByPrivateKey(string data, string key)
        {
            AsymmetricKeyParameter priKey = GetPrivateKeyParameter(key);
            byte[] byteData = System.Text.Encoding.UTF8.GetBytes(data);

            ISigner normalSig = SignerUtilities.GetSigner("SHA1WithRSA");
            normalSig.Init(true, priKey);
            normalSig.BlockUpdate(byteData, 0, data.Length);
            byte[] normalResult = normalSig.GenerateSignature(); //签名结果
            return Convert.ToBase64String(normalResult);
            //return System.Text.Encoding.UTF8.GetString(normalResult);
        }

        /// <summary>
        /// 验签
        /// </summary>
        /// <param name="plainData">验证数据</param>
        /// <param name="sign">签名</param>
        /// <param name="key">公匙</param>
        /// <returns></returns>
        public bool ValidationPublicKey(string plainData, string sign, string key)
        {
            AsymmetricKeyParameter priKey = GetPublicKeyParameter(key);

            byte[] signBytes = Convert.FromBase64String(sign);
            byte[] plainBytes = Encoding.UTF8.GetBytes(plainData);


            ISigner verifier = SignerUtilities.GetSigner("SHA1WithRSA");
            verifier.Init(false, priKey);
            verifier.BlockUpdate(plainBytes, 0, plainBytes.Length);

            return verifier.VerifySignature(signBytes); //验签结果
        }
    }
}