添加项目文件。

UFIDA.U8.Framework.Api.Common/Properties/AssemblyInfo.cs

@@ -0,0 +1,37 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("UFIDA.U8.Framework.Api.Common")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("UFIDA.U8.Framework.Api.Common")]
+[assembly: AssemblyCopyright("Copyright ©  2024")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: log4net.Config.XmlConfigurator(ConfigFile = "log4net.config", ConfigFileExtension = "config", Watch = true)]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("0682dc28-d5f7-4a10-bd3d-20ecd1fc987e")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

UFIDA.U8.Framework.Api.Common/UFIDA.U8.Framework.Api.Common.csproj

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0682DC28-D5F7-4A10-BD3D-20ECD1FC987E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>UFIDA.U8.Framework.Api.Common</RootNamespace>
+    <AssemblyName>UFIDA.U8.Framework.Api.Common</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="BouncyCastle.Cryptography, Version=2.0.0.0, Culture=neutral, PublicKeyToken=072edcf4a5328938, processorArchitecture=MSIL">
+      <HintPath>..\packages\BouncyCastle.Cryptography.2.4.0\lib\net461\BouncyCastle.Cryptography.dll</HintPath>
+    </Reference>
+    <Reference Include="log4net, Version=2.0.17.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
+      <HintPath>..\packages\log4net.2.0.17\lib\net45\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Unit\GM\GM.cs" />
+    <Compile Include="Unit\GM\GMUtil.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

UFIDA.U8.Framework.Api.Common/Unit/GM/GM.cs

@@ -0,0 +1,471 @@
+using Org.BouncyCastle.Asn1.GM;
+using Org.BouncyCastle.Asn1.X9;
+using Org.BouncyCastle.Asn1;
+using Org.BouncyCastle.Crypto.Digests;
+using Org.BouncyCastle.Crypto.Engines;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.X509;
+using System;
+using System.Collections.Generic;
+using System.IO;
+// ReSharper disable InconsistentNaming
+// ReSharper disable IdentifierTypo
+
+namespace UFIDA.U8.Framework.Api.Common.Unit.GM
+{
+    /**
+     *
+     * 用BC的注意点：
+     * 这个版本的BC对SM3withSM2的结果为asn1格式的r和s，如果需要直接拼接的r||s需要自己转换。下面rsAsn1ToPlainByteArray、rsPlainByteArrayToAsn1就在干这事。
+     * 这个版本的BC对SM2的结果为C1||C2||C3，据说为旧标准，新标准为C1||C3||C2，用新标准的需要自己转换。下面（被注释掉的）changeC1C2C3ToC1C3C2、changeC1C3C2ToC1C2C3就在干这事。java版的高版本有加上C1C3C2，csharp版没准以后也会加，但目前还没有，java版的目前可以初始化时“ SM2Engine sm2Engine = new SM2Engine(SM2Engine.Mode.C1C3C2);”。
+     *
+     */
+
+    public class GM
+    {
+        private static readonly X9ECParameters x9ECParameters = GMNamedCurves.GetByName("sm2p256v1");
+        private static readonly ECDomainParameters ecDomainParameters = new ECDomainParameters(x9ECParameters.Curve, x9ECParameters.G, x9ECParameters.N);
+
+        /**
+         *
+         * @param msg
+         * @param userId
+         * @param privateKey
+         * @return r||s，直接拼接byte数组的rs
+         */
+
+        public static byte[] SignSm3WithSm2(byte[] msg, byte[] userId, AsymmetricKeyParameter privateKey)
+        {
+            return RsAsn1ToPlainByteArray(SignSm3WithSm2Asn1Rs(msg, userId, privateKey));
+        }
+
+        /**
+          * @param msg
+          * @param userId
+          * @param privateKey
+          * @return rs in <b>asn1 format</b>
+          */
+
+        public static byte[] SignSm3WithSm2Asn1Rs(byte[] msg, byte[] userId, AsymmetricKeyParameter privateKey)
+        {
+            var signer = SignerUtilities.GetSigner("SM3withSM2");
+            signer.Init(true, new ParametersWithID(privateKey, userId));
+            signer.BlockUpdate(msg, 0, msg.Length);
+            var sig = signer.GenerateSignature();
+            return sig;
+        }
+
+        /**
+        *
+        * @param msg
+        * @param userId
+        * @param rs r||s，直接拼接byte数组的rs
+        * @param publicKey
+        * @return
+        */
+
+        public static bool VerifySm3WithSm2(byte[] msg, byte[] userId, byte[] rs, AsymmetricKeyParameter publicKey)
+        {
+            if (rs == null || msg == null || userId == null) return false;
+            if (rs.Length != RS_LEN * 2) return false;
+            return VerifySm3WithSm2Asn1Rs(msg, userId, RsPlainByteArrayToAsn1(rs), publicKey);
+        }
+
+        /**
+         *
+         * @param msg
+         * @param userId
+         * @param rs in <b>asn1 format</b>
+         * @param publicKey
+         * @return
+         */
+
+        public static bool VerifySm3WithSm2Asn1Rs(byte[] msg, byte[] userId, byte[] sign, AsymmetricKeyParameter publicKey)
+        {
+            var signer = SignerUtilities.GetSigner("SM3withSM2");
+            signer.Init(false, new ParametersWithID(publicKey, userId));
+            signer.BlockUpdate(msg, 0, msg.Length);
+            return signer.VerifySignature(sign);
+        }
+
+        /**
+         * bc加解密使用旧标c1||c2||c3，此方法在加密后调用，将结果转化为c1||c3||c2
+         * @param c1c2c3
+         * @return
+         */
+
+        private static byte[] ChangeC1C2C3ToC1C3C2(byte[] c1c2c3)
+        {
+            var c1Len = (x9ECParameters.Curve.FieldSize + 7) / 8 * 2 + 1; //sm2p256v1的这个固定65。可看GMNamedCurves、ECCurve代码。
+            const int c3Len = 32; //new SM3Digest().getDigestSize();
+            var result = new byte[c1c2c3.Length];
+            Buffer.BlockCopy(c1c2c3, 0, result, 0, c1Len); //c1
+            Buffer.BlockCopy(c1c2c3, c1c2c3.Length - c3Len, result, c1Len, c3Len); //c3
+            Buffer.BlockCopy(c1c2c3, c1Len, result, c1Len + c3Len, c1c2c3.Length - c1Len - c3Len); //c2
+            return result;
+        }
+
+        /**
+         * bc加解密使用旧标c1||c3||c2，此方法在解密前调用，将密文转化为c1||c2||c3再去解密
+         * @param c1c3c2
+         * @return
+         */
+
+        private static byte[] ChangeC1C3C2ToC1C2C3(byte[] c1c3c2)
+        {
+            var c1Len = (x9ECParameters.Curve.FieldSize + 7) / 8 * 2 + 1; //sm2p256v1的这个固定65。可看GMNamedCurves、ECCurve代码。
+            const int c3Len = 32; //new SM3Digest().GetDigestSize();
+            var result = new byte[c1c3c2.Length];
+            Buffer.BlockCopy(c1c3c2, 0, result, 0, c1Len); //c1: 0->65
+            Buffer.BlockCopy(c1c3c2, c1Len + c3Len, result, c1Len, c1c3c2.Length - c1Len - c3Len); //c2
+            Buffer.BlockCopy(c1c3c2, c1Len, result, c1c3c2.Length - c3Len, c3Len); //c3
+            return result;
+        }
+
+        /**
+         * c1||c3||c2
+         * @param data
+         * @param key
+         * @return
+         */
+
+        public static byte[] Sm2Decrypt(byte[] data, AsymmetricKeyParameter key)
+        {
+            return Sm2DecryptOld(ChangeC1C3C2ToC1C2C3(data), key);
+        }
+
+        /**
+         * c1||c3||c2
+         * @param data
+         * @param key
+         * @return
+         */
+
+        public static byte[] Sm2Encrypt(byte[] data, AsymmetricKeyParameter key)
+        {
+            return ChangeC1C2C3ToC1C3C2(Sm2EncryptOld(data, key));
+        }
+
+        /**
+         * c1||c2||c3
+         * @param data
+         * @param key
+         * @return
+         */
+
+        public static byte[] Sm2EncryptOld(byte[] data, AsymmetricKeyParameter pubkey)
+        {
+            var sm2Engine = new SM2Engine();
+            sm2Engine.Init(true, new ParametersWithRandom(pubkey, new SecureRandom()));
+            return sm2Engine.ProcessBlock(data, 0, data.Length);
+        }
+
+        /**
+         * c1||c2||c3
+         * @param data
+         * @param key
+         * @return
+         */
+
+        public static byte[] Sm2DecryptOld(byte[] data, AsymmetricKeyParameter key)
+        {
+            var sm2Engine = new SM2Engine();
+            sm2Engine.Init(false, key);
+            return sm2Engine.ProcessBlock(data, 0, data.Length);
+        }
+
+        /**
+         * @param bytes
+         * @return
+         */
+
+        public static byte[] Sm3(byte[] bytes)
+        {
+            var digest = new SM3Digest();
+            digest.BlockUpdate(bytes, 0, bytes.Length);
+            var result = DigestUtilities.DoFinal(digest);
+            return result;
+        }
+
+        private const int RS_LEN = 32;
+
+        private static byte[] BigIntToFixexLengthBytes(BigInteger rOrS)
+        {
+            // for sm2p256v1, n is 00fffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123,
+            // r and s are the result of mod n, so they should be less than n and have length<=32
+            var rs = rOrS.ToByteArray();
+            if (rs.Length == RS_LEN) return rs;
+            else if (rs.Length == RS_LEN + 1 && rs[0] == 0) return Arrays.CopyOfRange(rs, 1, RS_LEN + 1);
+            else if (rs.Length < RS_LEN)
+            {
+                var result = new byte[RS_LEN];
+                Arrays.Fill(result, (byte)0);
+                Buffer.BlockCopy(rs, 0, result, RS_LEN - rs.Length, rs.Length);
+                return result;
+            }
+            else
+            {
+                throw new ArgumentException("err rs: " + Hex.ToHexString(rs));
+            }
+        }
+
+        /**
+         * BC的SM3withSM2签名得到的结果的rs是asn1格式的，这个方法转化成直接拼接r||s
+         * @param rsDer rs in asn1 format
+         * @return sign result in plain byte array
+         */
+
+        private static byte[] RsAsn1ToPlainByteArray(byte[] rsDer)
+        {
+            var seq = Asn1Sequence.GetInstance(rsDer);
+            var r = BigIntToFixexLengthBytes(DerInteger.GetInstance(seq[0]).Value);
+            var s = BigIntToFixexLengthBytes(DerInteger.GetInstance(seq[1]).Value);
+            var result = new byte[RS_LEN * 2];
+            Buffer.BlockCopy(r, 0, result, 0, r.Length);
+            Buffer.BlockCopy(s, 0, result, RS_LEN, s.Length);
+            return result;
+        }
+
+        /**
+         * BC的SM3withSM2验签需要的rs是asn1格式的，这个方法将直接拼接r||s的字节数组转化成asn1格式
+         * @param sign in plain byte array
+         * @return rs result in asn1 format
+         */
+
+        private static byte[] RsPlainByteArrayToAsn1(byte[] sign)
+        {
+            if (sign.Length != RS_LEN * 2) throw new ArgumentException("err rs. ");
+            var r = new BigInteger(1, Arrays.CopyOfRange(sign, 0, RS_LEN));
+            var s = new BigInteger(1, Arrays.CopyOfRange(sign, RS_LEN, RS_LEN * 2));
+            var v = new Asn1EncodableVector
+        {
+            new DerInteger(r),
+            new DerInteger(s)
+        };
+
+            return new DerSequence(v).GetEncoded("DER");
+        }
+
+        // 生成公私匙对
+        public static AsymmetricCipherKeyPair GenerateKeyPair()
+        {
+            var kpGen = new ECKeyPairGenerator();
+            kpGen.Init(new ECKeyGenerationParameters(ecDomainParameters, new SecureRandom()));
+            return kpGen.GenerateKeyPair();
+        }
+
+        public static ECPrivateKeyParameters GetPrivatekeyFromD(BigInteger d)
+        {
+            return new ECPrivateKeyParameters(d, ecDomainParameters);
+        }
+
+        public static ECPublicKeyParameters GetPublickeyFromXY(BigInteger x, BigInteger y)
+        {
+            return new ECPublicKeyParameters(x9ECParameters.Curve.CreatePoint(x, y), ecDomainParameters);
+        }
+
+        public static AsymmetricKeyParameter GetPublickeyFromX509File(FileInfo file)
+        {
+            FileStream fileStream = null;
+            try
+            {
+                //file.DirectoryName + "\\" + file.Name
+                fileStream = new FileStream(file.FullName, FileMode.Open, FileAccess.Read);
+                var certificate = new X509CertificateParser().ReadCertificate(fileStream);
+                return certificate.GetPublicKey();
+            }
+            catch (Exception)
+            {
+                //log.Error(file.Name + "读取失败，异常：" + e);
+            }
+            finally
+            {
+                if (fileStream != null)
+                    fileStream.Close();
+            }
+            return null;
+        }
+
+        public class Sm2Cert
+        {
+            public AsymmetricKeyParameter privateKey;
+            public AsymmetricKeyParameter publicKey;
+            public string certId;
+        }
+
+        private static byte[] ToByteArray(int i)
+        {
+            var byteArray = new byte[4];
+            byteArray[0] = (byte)(i >> 24);
+            byteArray[1] = (byte)((i & 0xFFFFFF) >> 16);
+            byteArray[2] = (byte)((i & 0xFFFF) >> 8);
+            byteArray[3] = (byte)(i & 0xFF);
+            return byteArray;
+        }
+
+        /**
+         * 字节数组拼接
+         *
+         * @param params
+         * @return
+         */
+
+        private static byte[] Join(params byte[][] byteArrays)
+        {
+            var byteSource = new List<byte>();
+            for (var i = 0; i < byteArrays.Length; i++)
+            {
+                byteSource.AddRange(byteArrays[i]);
+            }
+            var data = byteSource.ToArray();
+            return data;
+        }
+
+        /**
+         * 密钥派生函数
+         *
+         * @param Z
+         * @param klen
+         * 生成klen字节数长度的密钥
+         * @return
+         */
+
+        private static byte[] KDF(byte[] Z, int klen)
+        {
+            var ct = 1;
+            var end = (int)Math.Ceiling(klen * 1.0 / 32);
+            var byteSource = new List<byte>();
+
+            for (var i = 1; i < end; i++)
+            {
+                byteSource.AddRange(Sm3(Join(Z, ToByteArray(ct))));
+                ct++;
+            }
+            var last = Sm3(Join(Z, ToByteArray(ct)));
+            if (klen % 32 == 0)
+            {
+                byteSource.AddRange(last);
+            }
+            else
+                byteSource.AddRange(Arrays.CopyOfRange(last, 0, klen % 32));
+            return byteSource.ToArray();
+        }
+
+        public static byte[] Sm4DecryptCBC(byte[] keyBytes, byte[] cipher, byte[] iv, string algo)
+        {
+            if (keyBytes.Length != 16) throw new ArgumentException("err key length");
+            if (cipher.Length % 16 != 0 && algo.Contains("NoPadding")) throw new ArgumentException("err data length");
+
+            var key = ParameterUtilities.CreateKeyParameter("SM4", keyBytes);
+            var c = CipherUtilities.GetCipher(algo);
+            if (iv == null) iv = ZeroIv(algo);
+            c.Init(false, new ParametersWithIV(key, iv));
+            return c.DoFinal(cipher);
+        }
+
+        public static byte[] Sm4EncryptCBC(byte[] keyBytes, byte[] plain, byte[] iv, string algo)
+        {
+            if (keyBytes.Length != 16) throw new ArgumentException("err key length");
+            if (plain.Length % 16 != 0 && algo.Contains("NoPadding")) throw new ArgumentException("err data length");
+
+            var key = ParameterUtilities.CreateKeyParameter("SM4", keyBytes);
+            var c = CipherUtilities.GetCipher(algo);
+            if (iv == null) iv = ZeroIv(algo);
+            c.Init(true, new ParametersWithIV(key, iv));
+            return c.DoFinal(plain);
+        }
+
+        public static byte[] Sm4EncryptECB(byte[] keyBytes, byte[] plain, string algo)
+        {
+            if (keyBytes.Length != 16) throw new ArgumentException("err key length");
+            //NoPadding 的情况下需要校验数据长度是16的倍数.
+            if (plain.Length % 16 != 0 && algo.Contains("NoPadding")) throw new ArgumentException("err data length");
+
+            var key = ParameterUtilities.CreateKeyParameter("SM4", keyBytes);
+            var c = CipherUtilities.GetCipher(algo);
+            c.Init(true, key);
+            return c.DoFinal(plain);
+        }
+
+        public static byte[] Sm4DecryptECB(byte[] keyBytes, byte[] cipher, string algo)
+        {
+            if (keyBytes.Length != 16) throw new ArgumentException("err key length");
+            if (cipher.Length % 16 != 0 && algo.Contains("NoPadding")) throw new ArgumentException("err data length");
+
+            var key = ParameterUtilities.CreateKeyParameter("SM4", keyBytes);
+            var c = CipherUtilities.GetCipher(algo);
+            c.Init(false, key);
+            return c.DoFinal(cipher);
+        }
+
+        public const string SM4_ECB_NOPADDING = "SM4/ECB/NoPadding";
+        public const string SM4_CBC_NOPADDING = "SM4/CBC/NoPadding";
+        public const string SM4_ECB_PKCS7PADDING = "SM4/ECB/PKCS7Padding";
+        public const string SM4_CBC_PKCS7PADDING = "SM4/CBC/PKCS7Padding";
+
+        /**
+         * cfca官网CSP沙箱导出的sm2文件
+         * @param pem 二进制原文
+         * @param pwd 密码
+         * @return
+         */
+
+        public static Sm2Cert ReadSm2File(byte[] pem, string pwd)
+        {
+            var sm2Cert = new Sm2Cert();
+
+            var asn1Sequence = (Asn1Sequence)Asn1Object.FromByteArray(pem);
+            //            ASN1Integer asn1Integer = (ASN1Integer) asn1Sequence.getObjectAt(0); //version=1
+            var priSeq = (Asn1Sequence)asn1Sequence[1];//private key
+            var pubSeq = (Asn1Sequence)asn1Sequence[2];//public key and x509 cert
+
+            //            ASN1ObjectIdentifier sm2DataOid = (ASN1ObjectIdentifier) priSeq.getObjectAt(0);
+            //            ASN1ObjectIdentifier sm4AlgOid = (ASN1ObjectIdentifier) priSeq.getObjectAt(1);
+            var priKeyAsn1 = (Asn1OctetString)priSeq[2];
+            var key = KDF(System.Text.Encoding.UTF8.GetBytes(pwd), 32);
+            var priKeyD = Sm4DecryptCBC(Arrays.CopyOfRange(key, 16, 32),
+                    priKeyAsn1.GetOctets(),
+                    Arrays.CopyOfRange(key, 0, 16), SM4_CBC_PKCS7PADDING);
+            sm2Cert.privateKey = GetPrivatekeyFromD(new BigInteger(1, priKeyD));
+            //            log.Info(Hex.toHexString(priKeyD));
+
+            //            ASN1ObjectIdentifier sm2DataOidPub = (ASN1ObjectIdentifier) pubSeq.getObjectAt(0);
+            var pubKeyX509 = (Asn1OctetString)pubSeq[1];
+            var x509 = new X509CertificateParser().ReadCertificate(pubKeyX509.GetOctets());
+            sm2Cert.publicKey = x509.GetPublicKey();
+            sm2Cert.certId = x509.SerialNumber.ToString(10); //这里转10进制，有啥其他进制要求的自己改改
+            return sm2Cert;
+        }
+
+        /**
+         *
+         * @param cert
+         * @return
+         */
+
+        public static Sm2Cert ReadSm2X509Cert(byte[] cert)
+        {
+            var sm2Cert = new Sm2Cert();
+
+            var x509 = new X509CertificateParser().ReadCertificate(cert);
+            sm2Cert.publicKey = x509.GetPublicKey();
+            sm2Cert.certId = x509.SerialNumber.ToString(10); //这里转10进制，有啥其他进制要求的自己改改
+            return sm2Cert;
+        }
+
+        public static byte[] ZeroIv(string algo)
+        {
+            var cipher = CipherUtilities.GetCipher(algo);
+            var blockSize = cipher.GetBlockSize();
+            var iv = new byte[blockSize];
+            Arrays.Fill(iv, (byte)0);
+            return iv;
+        }
+    }
+}

UFIDA.U8.Framework.Api.Common/Unit/GM/GMUtil.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Text;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities.Encoders;
+// ReSharper disable InconsistentNaming
+
+namespace UFIDA.U8.Framework.Api.Common.Unit.GM
+{
+    /// <summary>
+    /// GM工具类
+    /// </summary>
+    public class GMUtil
+    {
+        /// <summary>
+        /// SM2加密
+        /// </summary>
+        /// <param name="publicKeyHex"></param>
+        /// <param name="data_string"></param>
+        /// <returns></returns>
+        public static string SM2Encrypt(string publicKeyHex, string data_string)
+        {
+            // 如果是130位公钥，.NET使用的话，把开头的04截取掉
+            if (publicKeyHex.Length == 130)
+            {
+                publicKeyHex = publicKeyHex.Substring(2, 128);
+            }
+            // 公钥X，前64位
+            var x = publicKeyHex.Substring(0, 64);
+            // 公钥Y，后64位
+            var y = publicKeyHex.Substring(64);
+            // 获取公钥对象
+            AsymmetricKeyParameter publicKey1 = GM.GetPublickeyFromXY(new BigInteger(x, 16), new BigInteger(y, 16));
+            // Sm2Encrypt: C1C3C2
+            // Sm2EncryptOld: C1C2C3
+            var digestByte = GM.Sm2Encrypt(Encoding.UTF8.GetBytes(data_string), publicKey1);
+            var strSM2 = Hex.ToHexString(digestByte);
+            return strSM2;
+        }
+
+        /// <summary>
+        /// SM2解密
+        /// </summary>
+        /// <param name="privateKey_string"></param>
+        /// <param name="encryptedData_string"></param>
+        /// <returns></returns>
+        public static string SM2Decrypt(string privateKey_string, string encryptedData_string)
+        {
+            if (!encryptedData_string.StartsWith("04"))
+                encryptedData_string = "04" + encryptedData_string;
+            var d = new BigInteger(privateKey_string, 16);
+            // 先拿到私钥对象，用ECPrivateKeyParameters 或 AsymmetricKeyParameter 都可以
+            // ECPrivateKeyParameters bcecPrivateKey = GmUtil.GetPrivatekeyFromD(d);
+            AsymmetricKeyParameter bcecPrivateKey = GM.GetPrivatekeyFromD(d);
+            var byToDecrypt = Hex.Decode(encryptedData_string);
+            var byDecrypted = GM.Sm2Decrypt(byToDecrypt, bcecPrivateKey);
+            var strDecrypted = Encoding.UTF8.GetString(byDecrypted);
+            return strDecrypted;
+        }
+
+        /// <summary>
+        /// SM4加密（ECB）
+        /// </summary>
+        /// <param name="key_string"></param>
+        /// <param name="plainText"></param>
+        /// <returns></returns>
+        public static string SM4EncryptECB(string key_string, string plainText)
+        {
+            var key = Hex.Decode(key_string);
+            var bs = GM.Sm4EncryptECB(key, Encoding.UTF8.GetBytes(plainText), GM.SM4_ECB_PKCS7PADDING);//NoPadding 的情况下需要校验数据长度是16的倍数. 使用 HandleSm4Padding 处理
+            return Hex.ToHexString(bs);
+        }
+
+        /// <summary>
+        /// SM4解密（ECB）
+        /// </summary>
+        /// <param name="key_string"></param>
+        /// <param name="cipherText"></param>
+        /// <returns></returns>
+        public static string SM4DecryptECB(string key_string, string cipherText)
+        {
+            var key = Hex.Decode(key_string);
+            var bs = GM.Sm4DecryptECB(key, Hex.Decode(cipherText), GM.SM4_ECB_PKCS7PADDING);
+            return Encoding.UTF8.GetString(bs);
+        }
+
+        /// <summary>
+        /// SM4加密（CBC）
+        /// </summary>
+        /// <param name="key_string"></param>
+        /// <param name="iv_string"></param>
+        /// <param name="plainText"></param>
+        /// <returns></returns>
+        public static string SM4EncryptCBC(string key_string, string iv_string, string plainText)
+        {
+            var key = Hex.Decode(key_string);
+            var iv = Hex.Decode(iv_string);
+            var bs = GM.Sm4EncryptCBC(key, Encoding.UTF8.GetBytes(plainText), iv, GM.SM4_CBC_PKCS7PADDING);
+            return Hex.ToHexString(bs);
+        }
+
+        /// <summary>
+        /// SM4解密（CBC）
+        /// </summary>
+        /// <param name="key_string"></param>
+        /// <param name="iv_string"></param>
+        /// <param name="cipherText"></param>
+        /// <returns></returns>
+        public static string SM4DecryptCBC(string key_string, string iv_string, string cipherText)
+        {
+            var key = Hex.Decode(key_string);
+            var iv = Hex.Decode(iv_string);
+            var bs = GM.Sm4DecryptCBC(key, Hex.Decode(cipherText), iv, GM.SM4_CBC_PKCS7PADDING);
+            return Encoding.UTF8.GetString(bs);
+        }
+
+        /// <summary>
+        /// 补足 16 进制字符串的 0 字符，返回不带 0x 的16进制字符串
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="mode">1表示加密，0表示解密</param>
+        /// <returns></returns>
+        private static byte[] HandleSm4Padding(byte[] input, int mode)
+        {
+            if (input == null)
+            {
+                return null;
+            }
+            byte[] ret;
+            if (mode == 1)
+            {
+                var p = 16 - input.Length % 16;
+                ret = new byte[input.Length + p];
+                Array.Copy(input, 0, ret, 0, input.Length);
+                for (var i = 0; i < p; i++)
+                {
+                    ret[input.Length + i] = (byte)p;
+                }
+            }
+            else
+            {
+                int p = input[input.Length - 1];
+                ret = new byte[input.Length - p];
+                Array.Copy(input, 0, ret, 0, input.Length - p);
+            }
+            return ret;
+        }
+    }
+}

UFIDA.U8.Framework.Api.Common/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="BouncyCastle.Cryptography" version="2.4.0" targetFramework="net48" />
+  <package id="log4net" version="2.0.17" targetFramework="net48" />
+</packages>