Masuit.Tools/Masuit.Tools.Abstractions/Security/RSA.cs

using Masuit.Tools.Systems;
using System;
using System.Security.Cryptography;
using System.Text;

namespace Masuit.Tools.Security
{
    /// <summary>
    /// RSA操作类
    /// </summary>
    internal class RSA
    {
        /// <summary>
        /// 导出XML格式密钥对，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
        /// </summary>
        public string ToXML(bool convertToPublic = false)
        {
            return RSAObject.ToXmlString(!RSAObject.PublicOnly && !convertToPublic);
        }

        /// <summary>
        /// 导出PEM PKCS#1格式密钥对，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
        /// </summary>
        public string ToPEM_PKCS1(bool convertToPublic = false)
        {
            return new RsaPem(RSAObject).ToPEM(convertToPublic, false);
        }

        /// <summary>
        /// 导出PEM PKCS#8格式密钥对，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
        /// </summary>
        public string ToPEM_PKCS8(bool convertToPublic = false)
        {
            return new RsaPem(RSAObject).ToPEM(convertToPublic, true);
        }

        /// <summary>
        /// 将密钥对导出成PEM对象，如果convertToPublic含私钥的RSA将只返回公钥，仅含公钥的RSA不受影响
        /// </summary>
        public RsaPem ToPEM(bool convertToPublic = false)
        {
            return new RsaPem(RSAObject, convertToPublic);
        }

        /// <summary>
        /// 加密字符串（utf-8），出错抛异常
        /// </summary>
        public string Encrypt(string str)
        {
            return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(str)));
        }

        /// <summary>
        /// 加密数据，出错抛异常
        /// </summary>
        public byte[] Encrypt(byte[] data)
        {
            int blockLen = RSAObject.KeySize / 8 - 11;
            if (data.Length <= blockLen)
            {
                return RSAObject.Encrypt(data, false);
            }

            using var dataStream = new PooledMemoryStream(data);
            using var enStream = new PooledMemoryStream();
            var buffer = new byte[blockLen];
            int len = dataStream.Read(buffer, 0, blockLen);

            while (len > 0)
            {
                var block = new byte[len];
                Array.Copy(buffer, 0, block, 0, len);
                var enBlock = RSAObject.Encrypt(block, false);
                enStream.Write(enBlock, 0, enBlock.Length);
                len = dataStream.Read(buffer, 0, blockLen);
            }

            return enStream.ToArray();
        }

        /// <summary>
        /// 解密字符串（utf-8），解密异常返回null
        /// </summary>
        public string DecryptOrNull(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return null;
            }

            try
            {
                var bytes = Convert.FromBase64String(str);
                var val = DecryptOrNull(bytes);
                return val == null ? null : Encoding.UTF8.GetString(val);
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 解密数据，解密异常返回null
        /// </summary>
        public byte[] DecryptOrNull(byte[] data)
        {
            try
            {
                int blockLen = RSAObject.KeySize / 8;
                if (data.Length <= blockLen)
                {
                    return RSAObject.Decrypt(data, false);
                }

                using var dataStream = new PooledMemoryStream(data);
                using var deStream = new PooledMemoryStream();
                byte[] buffer = new byte[blockLen];
                int len = dataStream.Read(buffer, 0, blockLen);

                while (len > 0)
                {
                    var block = new byte[len];
                    Array.Copy(buffer, 0, block, 0, len);
                    var deBlock = RSAObject.Decrypt(block, false);
                    deStream.Write(deBlock, 0, deBlock.Length);
                    len = dataStream.Read(buffer, 0, blockLen);
                }

                return deStream.ToArray();
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 对str进行签名，并指定hash算法（如：SHA256）
        /// </summary>
        public string Sign(string hash, string str)
        {
            return Convert.ToBase64String(Sign(hash, Encoding.UTF8.GetBytes(str)));
        }

        /// <summary>
        /// 对data进行签名，并指定hash算法（如：SHA256）
        /// </summary>
        public byte[] Sign(string hash, byte[] data)
        {
            return RSAObject.SignData(data, hash);
        }

        /// <summary>
        /// 验证字符串str的签名是否是sgin，并指定hash算法（如：SHA256）
        /// </summary>
        public bool Verify(string hash, string sgin, string str)
        {
            byte[] bytes = null;
            try
            {
                bytes = Convert.FromBase64String(sgin);
            }
            catch
            {
            }

            return bytes != null && Verify(hash, bytes, Encoding.UTF8.GetBytes(str));
        }

        /// <summary>
        /// 验证data的签名是否是sgin，并指定hash算法（如：SHA256）
        /// </summary>
        public bool Verify(string hash, byte[] sgin, byte[] data)
        {
            try
            {
                return RSAObject.VerifyData(data, hash, sgin);
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 最底层的RSACryptoServiceProvider对象
        /// </summary>
        public RSACryptoServiceProvider RSAObject { get; }

        /// <summary>
        /// 密钥位数
        /// </summary>
        public int KeySize => RSAObject.KeySize;

        /// <summary>
        /// 是否包含私钥
        /// </summary>
        public bool HasPrivate => !RSAObject.PublicOnly;

        /// <summary>
        /// 用指定密钥大小创建一个新的RSA，出错抛异常
        /// </summary>
        public RSA(int keySize)
        {
            RSAObject = new RSACryptoServiceProvider(keySize);
        }

        /// <summary>
        /// 通过公钥或私钥创建RSA，出错抛异常
        /// </summary>
        public RSA(string key)
        {
            if (!key.StartsWith("<"))
            {
                RSAObject = RsaPem.FromPEM(key).GetRSA();
            }
            else
            {
                RSAObject = new RSACryptoServiceProvider();
                RSAObject.FromXmlString(key);
            }
        }

        /// <summary>
        /// 通过一个pem对象创建RSA，pem为公钥或私钥，出错抛异常
        /// </summary>
        public RSA(RsaPem pem)
        {
            RSAObject = pem.GetRSA();
        }
    }
}