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

namespace Masuit.Tools.Security;

/// <summary>
/// 常用的加密解密算法
/// </summary>
public static class Encrypt
{
    #region DES对称加密解密

    /// <summary>
    /// 加密字符串
    /// 加密密钥必须为8位
    /// </summary>
    /// <param name="strText">被加密的字符串</param>
    /// <param name="strEncrKey">8位长度密钥</param>
    /// <returns>加密后的数据</returns>
    public static string DesEncrypt(this string strText, string strEncrKey)
    {
        if (strEncrKey.Length < 8)
        {
            throw new Exception("密钥长度无效，密钥必须是8位！");
        }

        using var des = DES.Create();
        byte[] inputByteArray = Encoding.Default.GetBytes(strText);
        des.Key = Encoding.ASCII.GetBytes(strEncrKey.Substring(0, 8));
        des.IV = Encoding.ASCII.GetBytes(strEncrKey.Substring(0, 8));
        using var encryptor = des.CreateEncryptor();
        return ToHexString(encryptor.TransformFinalBlock(inputByteArray, 0, inputByteArray.Length));
    }

    /// <summary>
    /// 加密字符串
    /// 加密密钥必须为8位
    /// </summary>
    /// <param name="strText">被加密的字符串</param>
    /// <param name="desKey"></param>
    /// <param name="desIV"></param>
    /// <returns>加密后的数据</returns>
    public static string DesEncrypt(this string strText, byte[] desKey, byte[] desIV)
    {
        using var des = DES.Create();
        byte[] inputByteArray = Encoding.Default.GetBytes(strText);
        des.Key = desKey;
        des.IV = desIV;
        using var encryptor = des.CreateEncryptor();
        return ToHexString(encryptor.TransformFinalBlock(inputByteArray, 0, inputByteArray.Length));
    }

    /// <summary>
    /// DES加密文件
    /// </summary>
    /// <param name="fin">文件输入流</param>
    /// <param name="outFilePath">文件输出路径</param>
    /// <param name="strEncrKey">加密密钥</param>
    public static void DesEncrypt(this FileStream fin, string outFilePath, string strEncrKey)
    {
        byte[] iv = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
        var byKey = Encoding.UTF8.GetBytes(strEncrKey.Substring(0, 8));
        using var fout = new FileStream(outFilePath, FileMode.OpenOrCreate, FileAccess.Write);
        fout.SetLength(0);
        using var des = DES.Create();
        using var encStream = new CryptoStream(fout, des.CreateEncryptor(byKey, iv), CryptoStreamMode.Write);
        fin.CopyTo(encStream);
    }

    /// <summary>
    /// DES加密文件
    /// </summary>
    /// <param name="fin">文件输入流</param>
    /// <param name="outFilePath">文件输出路径</param>
    /// <param name="desKey"></param>
    /// <param name="desIV"></param>
    public static void DesEncrypt(this FileStream fin, string outFilePath, byte[] desKey, byte[] desIV)
    {
        using var fout = new FileStream(outFilePath, FileMode.Create, FileAccess.Write);
        using var des = DES.Create();
        using var encStream = new CryptoStream(fout, des.CreateEncryptor(desKey, desIV), CryptoStreamMode.Write);
        fin.CopyTo(encStream);
    }

    /// <summary>
    /// DES解密文件
    /// </summary>
    /// <param name="fin">输入文件流</param>
    /// <param name="outFilePath">文件输出路径</param>
    /// <param name="sDecrKey">解密密钥</param>
    public static void DesDecrypt(this FileStream fin, string outFilePath, string sDecrKey)
    {
        byte[] iv = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
        var byKey = Encoding.UTF8.GetBytes(sDecrKey.Substring(0, 8));
        using var fout = new FileStream(outFilePath, FileMode.Create, FileAccess.Write);
        using var des = DES.Create();
        using var encStream = new CryptoStream(fout, des.CreateDecryptor(byKey, iv), CryptoStreamMode.Write);
        fin.CopyTo(encStream);
    }

    /// <summary>
    /// DES解密文件
    /// </summary>
    /// <param name="fin">输入文件流</param>
    /// <param name="outFilePath">文件输出路径</param>
    /// <param name="desKey"></param>
    /// <param name="desIV"></param>
    public static void DesDecrypt(this FileStream fin, string outFilePath, byte[] desKey, byte[] desIV)
    {
        using var fout = new FileStream(outFilePath, FileMode.Create, FileAccess.Write);
        using var des = DES.Create();
        using var encStream = new CryptoStream(fout, des.CreateDecryptor(desKey, desIV), CryptoStreamMode.Write);
        fin.CopyTo(encStream);
    }

    /// <summary>
    ///     DES解密算法
    ///     密钥为8位
    /// </summary>
    /// <param name="pToDecrypt">需要解密的字符串</param>
    /// <param name="sKey">密钥</param>
    /// <returns>解密后的数据</returns>
    public static string DesDecrypt(this string pToDecrypt, string sKey)
    {
        if (sKey.Length < 8)
        {
            throw new Exception("密钥长度无效，密钥必须是8位！");
        }

        using var des = DES.Create();
        byte[] inputByteArray = FromHexString(pToDecrypt);
        des.Key = Encoding.ASCII.GetBytes(sKey.Substring(0, 8));
        des.IV = Encoding.ASCII.GetBytes(sKey.Substring(0, 8));
        using var decryptor = des.CreateDecryptor();
        return Encoding.Default.GetString(decryptor.TransformFinalBlock(inputByteArray, 0, inputByteArray.Length));
    }

    /// <summary>
    ///     DES解密算法
    ///     密钥为8位
    /// </summary>
    /// <param name="pToDecrypt">需要解密的字符串</param>
    /// <param name="desKey"></param>
    /// <param name="desIV"></param>
    /// <returns>解密后的数据</returns>
    public static string DesDecrypt(this string pToDecrypt, byte[] desKey, byte[] desIV)
    {
        using var des = DES.Create();
        byte[] inputByteArray = FromHexString(pToDecrypt);
        des.Key = desKey;
        des.IV = desIV;
        using var decryptor = des.CreateDecryptor();
        return Encoding.Default.GetString(decryptor.TransformFinalBlock(inputByteArray, 0, inputByteArray.Length));
    }

    private static string ToHexString(byte[] data) => BitConverter.ToString(data).Replace("-", string.Empty);

    private static byte[] FromHexString(string hex)
    {
        if (hex.Length % 2 != 0)
        {
            throw new FormatException("加密数据必须由成对的十六进制字符组成。");
        }

        var bytes = new byte[hex.Length / 2];
        for (int i = 0; i < bytes.Length; i++)
        {
            bytes[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
        }

        return bytes;
    }

    #endregion DES对称加密解密

    #region 对称加密算法AES加密解密

    private static readonly byte[] AesEnvelopeMagic = Encoding.ASCII.GetBytes("MTA1");
    private static readonly byte[] AesAuthenticationContext = Encoding.UTF8.GetBytes("Masuit.Tools AES-CBC-HMAC v1");
    private const int AesIvSize = 16;
    private const int AesTagSize = 32;
    private const int AesEnvelopeHeaderSize = 4 + AesIvSize;

    /// <summary>
    /// 生成符合AES加密规则的密钥
    /// </summary>
    /// <param name="length"></param>
    /// <returns></returns>
    public static string GenerateAesKey(int length)
    {
        using var aes = Aes.Create();
        aes.KeySize = length;
        aes.GenerateKey();
        return Convert.ToBase64String(aes.Key);
    }

#if NET8_0_OR_GREATER
    private const int AesGcmNonceSize = 12;
    private const int AesGcmTagSize = 16;

    /// <summary>
    /// 使用 AES-GCM 加密字符串。返回值为 Base64 编码的 nonce、认证标签和密文。
    /// </summary>
    /// <remarks>该方法仅在 .NET Standard 2.1 及以上目标框架中提供。</remarks>
    /// <param name="plainText">待加密字符串</param>
    /// <param name="key">UTF-8 编码后长度为 16、24 或 32 字节的 AES 密钥</param>
    /// <param name="associatedData">可选的附加认证数据，解密时必须提供相同数据</param>
    /// <returns>Base64 编码的加密结果</returns>
    public static string AesGcmEncrypt(this string plainText, string key, byte[] associatedData = null)
    {
        if (plainText == null)
        {
            throw new ArgumentNullException(nameof(plainText));
        }

        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }

        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] nonce = new byte[AesGcmNonceSize];
        using (var randomNumberGenerator = RandomNumberGenerator.Create())
        {
            randomNumberGenerator.GetBytes(nonce);
        }

        byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
        byte[] cipherBytes = new byte[plainBytes.Length];
        byte[] tag = new byte[AesGcmTagSize];
        using (var aesGcm = new AesGcm(keyBytes, AesGcmTagSize))
        {
            aesGcm.Encrypt(nonce, plainBytes, cipherBytes, tag, associatedData ?? Array.Empty<byte>());
        }

        byte[] result = new byte[nonce.Length + tag.Length + cipherBytes.Length];
        Buffer.BlockCopy(nonce, 0, result, 0, nonce.Length);
        Buffer.BlockCopy(tag, 0, result, nonce.Length, tag.Length);
        Buffer.BlockCopy(cipherBytes, 0, result, nonce.Length + tag.Length, cipherBytes.Length);
        return Convert.ToBase64String(result);
    }

    /// <summary>
    /// 使用 AES-GCM 解密字符串。输入须为 AES-GCM 加密方法生成的 Base64 字符串。
    /// </summary>
    /// <remarks>该方法仅在 .NET Standard 2.1 及以上目标框架中提供。</remarks>
    /// <param name="cipherText">Base64 编码的 nonce、认证标签和密文</param>
    /// <param name="key">UTF-8 编码后长度为 16、24 或 32 字节的 AES 密钥</param>
    /// <param name="associatedData">加密时使用的附加认证数据</param>
    /// <returns>解密后的字符串；认证失败时抛出 <see cref="CryptographicException"/></returns>
    public static string AesGcmDecrypt(this string cipherText, string key, byte[] associatedData = null)
    {
        if (cipherText == null)
        {
            throw new ArgumentNullException(nameof(cipherText));
        }

        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }

        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] encryptedBytes = Convert.FromBase64String(cipherText);
        if (encryptedBytes.Length < AesGcmNonceSize + AesGcmTagSize)
        {
            throw new CryptographicException("AES-GCM 密文格式无效。");
        }

        byte[] nonce = new byte[AesGcmNonceSize];
        byte[] tag = new byte[AesGcmTagSize];
        int cipherLength = encryptedBytes.Length - nonce.Length - tag.Length;
        byte[] cipherBytes = new byte[cipherLength];
        Buffer.BlockCopy(encryptedBytes, 0, nonce, 0, nonce.Length);
        Buffer.BlockCopy(encryptedBytes, nonce.Length, tag, 0, tag.Length);
        Buffer.BlockCopy(encryptedBytes, nonce.Length + tag.Length, cipherBytes, 0, cipherLength);
        byte[] plainBytes = new byte[cipherLength];
        using (var aesGcm = new AesGcm(keyBytes, AesGcmTagSize))
        {
            aesGcm.Decrypt(nonce, cipherBytes, tag, plainBytes, associatedData ?? Array.Empty<byte>());
        }

        return Encoding.UTF8.GetString(plainBytes);
    }

#endif

    /// <summary>
    /// 对称加密算法AES(块式加密算法)
    /// </summary>
    /// <param name="encryptString">待加密字符串</param>
    /// <param name="encryptKey">加密密钥，须半角字符</param>
    /// <param name="mode">加密模式</param>
    /// <returns>包含版本标识、随机IV、密文和认证标签的Base64字符串</returns>
    /// <remarks>仅支持CBC模式；输出格式与旧版固定IV密文不兼容。</remarks>
    public static string AESEncrypt(this string encryptString, string encryptKey, CipherMode mode = CipherMode.CBC)
    {
        return AesEncrypt(Encoding.UTF8.GetBytes(encryptString), Encoding.UTF8.GetBytes(encryptKey), mode);
    }

    /// <summary>
    /// 对称加密算法AES加密(块式加密算法)
    /// </summary>
    /// <param name="encryptString">待加密字符串</param>
    /// <param name="options">加密选项</param>
    /// <returns>包含版本标识、随机IV、密文和认证标签的Base64字符串</returns>
    /// <remarks>仅支持CBC模式；输出格式与旧版固定IV密文不兼容。</remarks>
    public static string AESEncrypt(this string encryptString, Aes options)
    {
        return AesEncrypt(Encoding.UTF8.GetBytes(encryptString), options.Key, options.Mode);
    }

    /// <summary>
    /// 对称加密算法AES加密(块式加密算法)
    /// </summary>
    /// <param name="encryptString">待加密字符串</param>
    /// <param name="encryptKey">加密密钥，须半角字符</param>
    /// <param name="mode">加密模式</param>
    /// <returns>包含版本标识、随机IV、密文和认证标签的Base64字符串</returns>
    /// <remarks>仅支持CBC模式；输出格式与旧版固定IV密文不兼容。</remarks>
    public static string AESEncrypt(this string encryptString, byte[] encryptKey, CipherMode mode = CipherMode.CBC)
    {
        return AesEncrypt(Encoding.UTF8.GetBytes(encryptString), encryptKey, mode);
    }

    /// <summary>
    /// 对称加密算法AES解密字符串
    /// </summary>
    /// <param name="decryptString">待解密的字符串</param>
    /// <param name="decryptKey">解密密钥,和加密密钥相同</param>
    /// <param name="mode">加密模式</param>
    /// <returns>解密后的字符串</returns>
    /// <remarks>仅接受当前版本的认证密文；旧版固定IV密文需在升级前迁移。</remarks>
    public static string AESDecrypt(this string decryptString, string decryptKey, CipherMode mode = CipherMode.CBC)
    {
        return Encoding.UTF8.GetString(AesDecrypt(decryptString, Encoding.UTF8.GetBytes(decryptKey), mode));
    }

    /// <summary>
    /// 对称加密算法AES解密字符串
    /// </summary>
    /// <param name="decryptString">待解密的字符串</param>
    /// <param name="options">加密选项</param>
    /// <returns>解密后的字符串</returns>
    /// <remarks>仅接受当前版本的认证密文；旧版固定IV密文需在升级前迁移。</remarks>
    public static string AESDecrypt(this string decryptString, Aes options)
    {
        return Encoding.UTF8.GetString(AesDecrypt(decryptString, options.Key, options.Mode));
    }

    /// <summary>
    /// 对称加密算法AES解密字符串
    /// </summary>
    /// <param name="decryptString">待解密的字符串</param>
    /// <param name="decryptKey">解密密钥,和加密密钥相同</param>
    /// <param name="mode">加密模式</param>
    /// <returns>解密后的字符串</returns>
    /// <remarks>仅接受当前版本的认证密文；旧版固定IV密文需在升级前迁移。</remarks>
    public static string AESDecrypt(this string decryptString, byte[] decryptKey, CipherMode mode = CipherMode.CBC)
    {
        return Encoding.UTF8.GetString(AesDecrypt(decryptString, decryptKey, mode));
    }

    private static string AesEncrypt(byte[] plainText, byte[] key, CipherMode mode)
    {
        using var aes = Aes.Create();
        aes.Key = key;
        aes.Mode = mode;
        aes.Padding = PaddingMode.PKCS7;
        var iv = new byte[AesIvSize];
        using (var randomNumberGenerator = RandomNumberGenerator.Create())
        {
            randomNumberGenerator.GetBytes(iv);
        }

        aes.IV = iv;
        byte[] cipherText;
        using (var encryptor = aes.CreateEncryptor())
        {
            cipherText = encryptor.TransformFinalBlock(plainText, 0, plainText.Length);
        }

        var authenticatedData = new byte[AesEnvelopeHeaderSize + cipherText.Length];
        Buffer.BlockCopy(AesEnvelopeMagic, 0, authenticatedData, 0, AesEnvelopeMagic.Length);
        Buffer.BlockCopy(iv, 0, authenticatedData, AesEnvelopeMagic.Length, iv.Length);
        Buffer.BlockCopy(cipherText, 0, authenticatedData, AesEnvelopeHeaderSize, cipherText.Length);
        byte[] tag = ComputeAesAuthenticationTag(authenticatedData, key);
        var envelope = new byte[authenticatedData.Length + tag.Length];
        Buffer.BlockCopy(authenticatedData, 0, envelope, 0, authenticatedData.Length);
        Buffer.BlockCopy(tag, 0, envelope, authenticatedData.Length, tag.Length);
        return Convert.ToBase64String(envelope);
    }

    private static byte[] AesDecrypt(string encryptedText, byte[] key, CipherMode mode)
    {
        byte[] envelope = Convert.FromBase64String(encryptedText);
        int cipherLength = envelope.Length - AesEnvelopeHeaderSize - AesTagSize;
        if (cipherLength < AesIvSize || cipherLength % AesIvSize != 0 || !HasAesEnvelopeMagic(envelope))
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        int authenticatedLength = envelope.Length - AesTagSize;
        var authenticatedData = new byte[authenticatedLength];
        Buffer.BlockCopy(envelope, 0, authenticatedData, 0, authenticatedLength);
        byte[] expectedTag = ComputeAesAuthenticationTag(authenticatedData, key);
        var actualTag = new byte[AesTagSize];
        Buffer.BlockCopy(envelope, authenticatedLength, actualTag, 0, actualTag.Length);
        if (!FixedTimeEquals(expectedTag, actualTag))
        {
            throw new CryptographicException("AES密文认证失败。");
        }

        var iv = new byte[AesIvSize];
        Buffer.BlockCopy(envelope, AesEnvelopeMagic.Length, iv, 0, iv.Length);
        var cipherText = new byte[cipherLength];
        Buffer.BlockCopy(envelope, AesEnvelopeHeaderSize, cipherText, 0, cipherText.Length);
        using var aes = Aes.Create();
        aes.Key = key;
        aes.IV = iv;
        aes.Mode = mode;
        aes.Padding = PaddingMode.PKCS7;
        using var decryptor = aes.CreateDecryptor();
        return decryptor.TransformFinalBlock(cipherText, 0, cipherText.Length);
    }

    private static byte[] ComputeAesAuthenticationTag(byte[] authenticatedData, byte[] key)
    {
        using var hmac = new HMACSHA256(DeriveAesAuthenticationKey(key));
        return hmac.ComputeHash(authenticatedData);
    }

    private static byte[] DeriveAesAuthenticationKey(byte[] key)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }

        using var hmac = new HMACSHA256(key);
        return hmac.ComputeHash(AesAuthenticationContext);
    }

    private static bool HasAesEnvelopeMagic(byte[] envelope)
    {
        if (envelope.Length < AesEnvelopeHeaderSize)
        {
            return false;
        }

        for (int i = 0; i < AesEnvelopeMagic.Length; i++)
        {
            if (envelope[i] != AesEnvelopeMagic[i])
            {
                return false;
            }
        }

        return true;
    }

    private static bool FixedTimeEquals(byte[] left, byte[] right)
    {
        if (left.Length != right.Length)
        {
            return false;
        }

        int difference = 0;
        for (int i = 0; i < left.Length; i++)
        {
            difference |= left[i] ^ right[i];
        }

        return difference == 0;
    }

    /// <summary>
    /// 按字节长度(按字节,一个汉字为2个字节)取得某字符串的一部分
    /// </summary>
    /// <param name="sourceString">源字符串</param>
    /// <param name="length">所取字符串字节长度</param>
    /// <param name="tailString">附加字符串(当字符串不够长时，尾部所添加的字符串，一般为"...")</param>
    /// <returns>某字符串的一部分</returns>
    private static string GetSubString(this string sourceString, int length, string tailString)
    {
        return GetSubString(sourceString, 0, length, tailString);
    }

    /// <summary>
    /// 按字节长度(按字节,一个汉字为2个字节)取得某字符串的一部分
    /// </summary>
    /// <param name="sourceString">源字符串</param>
    /// <param name="startIndex">索引位置，以0开始</param>
    /// <param name="length">所取字符串字节长度</param>
    /// <param name="tailString">附加字符串(当字符串不够长时，尾部所添加的字符串，一般为"...")</param>
    /// <returns>某字符串的一部分</returns>
    private static string GetSubString(this string sourceString, int startIndex, int length, string tailString)
    {
        //当是日文或韩文时(注:中文的范围:\u4e00 - \u9fa5, 日文在\u0800 - \u4e00, 韩文为\xAC00-\xD7A3)
        if (Regex.IsMatch(sourceString, "[\u0800-\u4e00]+") || Regex.IsMatch(sourceString, "[\xAC00-\xD7A3]+"))
        {
            //当截取的起始位置超出字段串长度时
            if (startIndex >= sourceString.Length)
            {
                return string.Empty;
            }

            return sourceString.Substring(startIndex, length + startIndex > sourceString.Length ? (sourceString.Length - startIndex) : length);
        }

        //中文字符，如"中国人民abcd123"
        if (length <= 0)
        {
            return string.Empty;
        }

        byte[] bytesSource = Encoding.Default.GetBytes(sourceString);

        //当字符串长度大于起始位置
        if (bytesSource.Length > startIndex)
        {
            int endIndex = bytesSource.Length;

            //当要截取的长度在字符串的有效长度范围内
            if (bytesSource.Length > (startIndex + length))
            {
                endIndex = length + startIndex;
            }
            else
            {
                //当不在有效范围内时,只取到字符串的结尾
                length = bytesSource.Length - startIndex;
                tailString = "";
            }

            var anResultFlag = new int[length];
            int nFlag = 0;

            //字节大于127为双字节字符
            for (int i = startIndex; i < endIndex; i++)
            {
                if (bytesSource[i] > 127)
                {
                    nFlag++;
                    if (nFlag == 3)
                    {
                        nFlag = 1;
                    }
                }
                else
                {
                    nFlag = 0;
                }

                anResultFlag[i] = nFlag;
            }

            //最后一个字节为双字节字符的一半
            if ((bytesSource[endIndex - 1] > 127) && (anResultFlag[length - 1] == 1))
            {
                length++;
            }

            byte[] bsResult = new byte[length];
            Array.Copy(bytesSource, startIndex, bsResult, 0, length);
            var myResult = Encoding.Default.GetString(bsResult);
            myResult += tailString;
            return myResult;
        }

        return string.Empty;
    }

    /// <summary>
    /// 加密文件流
    /// </summary>
    /// <param name="fs">需要加密的文件流</param>
    /// <param name="decryptKey">加密密钥</param>
    /// <param name="mode">加密模式</param>
    /// <returns>加密流</returns>
    public static CryptoStream AESEncryptStrream(this FileStream fs, string decryptKey, CipherMode mode = CipherMode.CBC)
    {
        using var aes = Aes.Create();
        aes.Key = Encoding.UTF8.GetBytes(decryptKey);
        aes.IV = AesEnvelopeMagic;
        aes.Mode = mode;
        return new CryptoStream(fs, aes.CreateEncryptor(), CryptoStreamMode.Write);
    }

    /// <summary>
    /// 加密文件流
    /// </summary>
    /// <param name="fs">需要加密的文件流</param>
    /// <param name="decryptKey">加密密钥</param>
    /// <param name="mode">加密模式</param>
    /// <returns>加密流</returns>
    public static Stream AESEncryptStrream(this FileStream fs, byte[] decryptKey, CipherMode mode = CipherMode.CBC)
    {
        using var aes = Aes.Create();
        aes.Key = decryptKey;
        aes.Mode = mode;
        aes.Padding = PaddingMode.PKCS7;
        var iv = new byte[AesIvSize];
        using (var randomNumberGenerator = RandomNumberGenerator.Create())
        {
            randomNumberGenerator.GetBytes(iv);
        }

        aes.IV = iv;
        var output = new PooledMemoryStream();
        output.Write(AesEnvelopeMagic, 0, AesEnvelopeMagic.Length);
        output.Write(iv, 0, iv.Length);
        using (var encryptedStream = new CryptoStream(output, aes.CreateEncryptor(), CryptoStreamMode.Write))
        {
            fs.CopyTo(encryptedStream);
            encryptedStream.FlushFinalBlock();
        }

        long authenticatedLength = output.Position;
        output.Position = 0;
        byte[] tag;
        using (var hmac = new HMACSHA256(DeriveAesAuthenticationKey(decryptKey)))
        {
            tag = hmac.ComputeHash(output);
        }

        output.Position = authenticatedLength;
        output.Write(tag, 0, tag.Length);
        return output;
    }

    /// <summary>
    /// 解密文件流
    /// </summary>
    /// <param name="input">需要解密的文件流</param>
    /// <param name="decryptKey">解密密钥</param>
    /// <param name="mode">加密模式</param>
    /// <returns>加密流</returns>
    public static Stream AESDecryptStream(this FileStream input, string decryptKey, CipherMode mode = CipherMode.CBC)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(decryptKey);
        return input.AESDecryptStream(keyBytes, mode);
    }

    /// <summary>
    /// 解密文件流
    /// </summary>
    /// <param name="input">需要解密的文件流</param>
    /// <param name="decryptKey">解密密钥</param>
    /// <param name="mode">加密模式</param>
    /// <returns>加密流</returns>
    public static Stream AESDecryptStream(this FileStream input, byte[] decryptKey, CipherMode mode = CipherMode.CBC)
    {
        using var aes = Aes.Create();
        aes.Key = decryptKey;
        aes.Mode = mode;
        aes.Padding = PaddingMode.PKCS7;
        long startPosition = input.Position;
        long envelopeLength = input.Length - startPosition;
        if (envelopeLength < AesEnvelopeHeaderSize + AesIvSize + AesTagSize)
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        var header = new byte[AesEnvelopeHeaderSize];
        ReadExactly(input, header, 0, header.Length);
        if (!HasAesEnvelopeMagic(header))
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        long cipherLength = envelopeLength - AesEnvelopeHeaderSize - AesTagSize;
        if (cipherLength < AesIvSize || cipherLength % AesIvSize != 0)
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        long authenticatedLength = envelopeLength - AesTagSize;
        byte[] expectedTag = ComputeAesAuthenticationTag(input, startPosition, authenticatedLength, decryptKey);
        input.Position = startPosition + authenticatedLength;
        var actualTag = new byte[AesTagSize];
        ReadExactly(input, actualTag, 0, actualTag.Length);
        if (!FixedTimeEquals(expectedTag, actualTag))
        {
            throw new CryptographicException("AES密文认证失败。");
        }

        var iv = new byte[AesIvSize];
        Buffer.BlockCopy(header, AesEnvelopeMagic.Length, iv, 0, iv.Length);
        input.Position = startPosition + AesEnvelopeHeaderSize;
        using var boundedInput = new LimitedReadStream(input, cipherLength);
        var output = new PooledMemoryStream();
        aes.IV = iv;
        using var decryptedStream = new CryptoStream(boundedInput, aes.CreateDecryptor(), CryptoStreamMode.Read);
        decryptedStream.CopyTo(output);
        return output;
    }

    /// <summary>
    /// 对指定文件AES加密
    /// </summary>
    /// <param name="input">源文件流</param>
    /// <param name="key">加密密钥</param>
    /// <param name="mode">加密模式</param>
    /// <param name="outputPath">输出文件路径</param>
    /// <remarks>输出采用带随机IV和认证标签的版本化格式。</remarks>
    public static void AESEncryptFile(this FileStream input, string outputPath, string key, CipherMode mode = CipherMode.CBC)
    {
        EnsureDifferentFile(input, outputPath);
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        using var aes = Aes.Create();
        aes.Key = keyBytes;
        aes.Mode = mode;
        aes.Padding = PaddingMode.PKCS7;
        var iv = new byte[AesIvSize];
        using (var randomNumberGenerator = RandomNumberGenerator.Create())
        {
            randomNumberGenerator.GetBytes(iv);
        }

        aes.IV = iv;
        using var output = new FileStream(outputPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
        output.Write(AesEnvelopeMagic, 0, AesEnvelopeMagic.Length);
        output.Write(iv, 0, iv.Length);
        using (var encryptedStream = new CryptoStream(new NonClosingStream(output), aes.CreateEncryptor(), CryptoStreamMode.Write))
        {
            input.CopyTo(encryptedStream);
            encryptedStream.FlushFinalBlock();
        }

        long authenticatedLength = output.Position;
        output.Position = 0;
        byte[] tag;
        using (var hmac = new HMACSHA256(DeriveAesAuthenticationKey(keyBytes)))
        {
            tag = hmac.ComputeHash(output);
        }

        output.Position = authenticatedLength;
        output.Write(tag, 0, tag.Length);
    }

    /// <summary>
    /// 对指定的文件AES解密
    /// </summary>
    /// <param name="input">源文件流</param>
    /// <param name="key">解密密钥</param>
    /// <param name="mode">加密模式</param>
    /// <param name="outputPath">输出文件路径</param>
    /// <remarks>仅接受带认证标签的版本化密文，输入流必须可读取且可定位。</remarks>
    public static void AESDecryptFile(this FileStream input, string outputPath, string key, CipherMode mode = CipherMode.CBC)
    {
        EnsureDifferentFile(input, outputPath);
        if (!input.CanRead || !input.CanSeek)
        {
            throw new ArgumentException("The encrypted file stream must be readable and seekable.", nameof(input));
        }

        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        using var aes = Aes.Create();
        aes.Key = keyBytes;
        aes.Mode = mode;
        aes.Padding = PaddingMode.PKCS7;
        long startPosition = input.Position;
        long envelopeLength = input.Length - startPosition;
        if (envelopeLength < AesEnvelopeHeaderSize + AesIvSize + AesTagSize)
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        var header = new byte[AesEnvelopeHeaderSize];
        ReadExactly(input, header, 0, header.Length);
        if (!HasAesEnvelopeMagic(header))
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        long cipherLength = envelopeLength - AesEnvelopeHeaderSize - AesTagSize;
        if (cipherLength < AesIvSize || cipherLength % AesIvSize != 0)
        {
            throw new CryptographicException("AES密文格式无效。");
        }

        long authenticatedLength = envelopeLength - AesTagSize;
        byte[] expectedTag = ComputeAesAuthenticationTag(input, startPosition, authenticatedLength, keyBytes);
        input.Position = startPosition + authenticatedLength;
        var actualTag = new byte[AesTagSize];
        ReadExactly(input, actualTag, 0, actualTag.Length);
        if (!FixedTimeEquals(expectedTag, actualTag))
        {
            throw new CryptographicException("AES密文认证失败。");
        }

        var iv = new byte[AesIvSize];
        Buffer.BlockCopy(header, AesEnvelopeMagic.Length, iv, 0, iv.Length);
        input.Position = startPosition + AesEnvelopeHeaderSize;
        using var boundedInput = new LimitedReadStream(input, cipherLength);
        using var output = new FileStream(outputPath, FileMode.Create, FileAccess.Write, FileShare.None);
        aes.IV = iv;
        using var decryptedStream = new CryptoStream(boundedInput, aes.CreateDecryptor(), CryptoStreamMode.Read);
        decryptedStream.CopyTo(output);
    }

    private static byte[] ComputeAesAuthenticationTag(Stream input, long startPosition, long length, byte[] key)
    {
        input.Position = startPosition;
        using var hmac = new HMACSHA256(DeriveAesAuthenticationKey(key));
        var buffer = new byte[81920];
        long remaining = length;
        while (remaining > 0)
        {
            int bytesToRead = (int)Math.Min(buffer.Length, remaining);
            int bytesRead = input.Read(buffer, 0, bytesToRead);
            if (bytesRead == 0)
            {
                throw new CryptographicException("AES密文格式无效。");
            }

            hmac.TransformBlock(buffer, 0, bytesRead, buffer, 0);
            remaining -= bytesRead;
        }

        hmac.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
        return hmac.Hash;
    }

    private static void ReadExactly(Stream input, byte[] buffer, int offset, int count)
    {
        while (count > 0)
        {
            int bytesRead = input.Read(buffer, offset, count);
            if (bytesRead == 0)
            {
                throw new CryptographicException("AES密文格式无效。");
            }

            offset += bytesRead;
            count -= bytesRead;
        }
    }

    private static void EnsureDifferentFile(FileStream input, string outputPath)
    {
        if (input == null)
        {
            throw new ArgumentNullException(nameof(input));
        }

        var comparison = Path.DirectorySeparatorChar == '\\' ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
        if (string.Equals(Path.GetFullPath(input.Name), Path.GetFullPath(outputPath), comparison))
        {
            throw new ArgumentException("The input and output files must be different.", nameof(outputPath));
        }
    }

    private sealed class LimitedReadStream : Stream
    {
        private readonly Stream input;
        private long remaining;

        public LimitedReadStream(Stream input, long length)
        {
            this.input = input;
            remaining = length;
        }

        public override bool CanRead => input.CanRead;

        public override bool CanSeek => false;

        public override bool CanWrite => false;

        public override long Length => throw new NotSupportedException();

        public override long Position
        {
            get => throw new NotSupportedException();
            set => throw new NotSupportedException();
        }

        public override void Flush()
        {
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            if (remaining == 0)
            {
                return 0;
            }

            int bytesToRead = (int)Math.Min(count, remaining);
            int bytesRead = input.Read(buffer, offset, bytesToRead);
            remaining -= bytesRead;
            return bytesRead;
        }

        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();

        public override void SetLength(long value) => throw new NotSupportedException();

        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }
    }

    private sealed class NonClosingStream : Stream
    {
        private readonly Stream inner;

        public NonClosingStream(Stream inner)
        {
            this.inner = inner;
        }

        public override bool CanRead => inner.CanRead;

        public override bool CanSeek => inner.CanSeek;

        public override bool CanWrite => inner.CanWrite;

        public override long Length => inner.Length;

        public override long Position
        {
            get => inner.Position;
            set => inner.Position = value;
        }

        public override void Flush() => inner.Flush();

        public override int Read(byte[] buffer, int offset, int count) => inner.Read(buffer, offset, count);

        public override long Seek(long offset, SeekOrigin origin) => inner.Seek(offset, origin);

        public override void SetLength(long value) => inner.SetLength(value);

        public override void Write(byte[] buffer, int offset, int count) => inner.Write(buffer, offset, count);

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }
    }

    #endregion 对称加密算法AES加密解密

    #region Base64加密解密

    /// <summary>
    /// Base64加密
    /// </summary>
    /// <param name="str">需要加密的字符串</param>
    /// <returns>加密后的数据</returns>
    public static string Base64Encrypt(this string str)
    {
        byte[] encbuff = Encoding.UTF8.GetBytes(str);
        return Convert.ToBase64String(encbuff);
    }

    /// <summary>
    /// Base64解密
    /// </summary>
    /// <param name="str">需要解密的字符串</param>
    /// <returns>解密后的数据</returns>
    public static string Base64Decrypt(this string str)
    {
        try
        {
            byte[] decbuff = Convert.FromBase64String(str);
            return Encoding.UTF8.GetString(decbuff);
        }
        catch
        {
            return str;
        }
    }

    #endregion Base64加密解密

    /// <summary>
    /// SHA256函数
    /// </summary>
    /// <param name="str">原始字符串</param>
    /// <returns>SHA256结果(返回长度为44字节的字符串)</returns>
    public static string SHA256(this string str)
    {
        byte[] sha256Data = Encoding.UTF8.GetBytes(str);
        using var sha256 = System.Security.Cryptography.SHA256.Create();
        byte[] result = sha256.ComputeHash(sha256Data);
        return Convert.ToBase64String(result); //返回长度为44字节的字符串
    }

    /// <summary>
    /// SHA512函数
    /// </summary>
    /// <param name="str">原始字符串</param>
    /// <returns>SHA512结果(返回长度为44字节的字符串)</returns>
    public static string SHA512(this string str)
    {
        byte[] shaData = Encoding.UTF8.GetBytes(str);
        using var sha512 = System.Security.Cryptography.SHA512.Create();
        byte[] result = sha512.ComputeHash(shaData);
        return Convert.ToBase64String(result); //返回长度为44字节的字符串
    }

    #region MD5摘要算法

    #region 对字符串进行MD5摘要

    /// <summary>
    ///     对字符串进行MD5摘要
    /// </summary>
    /// <param name="message">需要摘要的字符串</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString(this string message)
    {
        MD5 md5 = MD5.Create();
        byte[] buffer = Encoding.Default.GetBytes(message);
        byte[] bytes = md5.ComputeHash(buffer);
        return GetHexString(bytes);
    }

    /// <summary>
    ///     对字符串进行MD5二次摘要
    /// </summary>
    /// <param name="message">需要摘要的字符串</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString2(this string message) => MDString(MDString(message));

    /// <summary>
    /// MD5 三次摘要算法
    /// </summary>
    /// <param name="s">需要摘要的字符串</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString3(this string s)
    {
        using MD5 md5 = MD5.Create();
        byte[] bytes = Encoding.ASCII.GetBytes(s);
        byte[] bytes1 = md5.ComputeHash(bytes);
        byte[] bytes2 = md5.ComputeHash(bytes1);
        byte[] bytes3 = md5.ComputeHash(bytes2);
        return GetHexString(bytes3);
    }

    /// <summary>
    ///     对字符串进行MD5加盐摘要
    /// </summary>
    /// <param name="message">需要摘要的字符串</param>
    /// <param name="salt">盐</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString(this string message, string salt) => MDString(message + salt);

    /// <summary>
    ///     对字符串进行MD5二次加盐摘要
    /// </summary>
    /// <param name="message">需要摘要的字符串</param>
    /// <param name="salt">盐</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString2(this string message, string salt) => MDString(MDString(message + salt), salt);

    /// <summary>
    /// MD5 三次摘要算法
    /// </summary>
    /// <param name="s">需要摘要的字符串</param>
    /// <param name="salt">盐</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString3(this string s, string salt)
    {
        using MD5 md5 = MD5.Create();
        byte[] bytes = Encoding.ASCII.GetBytes(s + salt);
        byte[] bytes1 = md5.ComputeHash(bytes);
        byte[] bytes2 = md5.ComputeHash(bytes1);
        byte[] bytes3 = md5.ComputeHash(bytes2);
        return GetHexString(bytes3);
    }

    #endregion 对字符串进行MD5摘要

    #region 获取文件的MD5值

    /// <summary>
    /// 获取文件的MD5值
    /// </summary>
    /// <param name="fileName">需要求MD5值的文件的文件名及路径</param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDFile(this string fileName)
    {
        var fs = new BufferedStream(File.Open(fileName, FileMode.Open, FileAccess.Read), 1048576);
        using MD5 md5 = MD5.Create();
        byte[] bytes = md5.ComputeHash(fs);
        return GetHexString(bytes);
    }

    /// <summary>
    /// 计算文件的sha256
    /// </summary>
    /// <param name="stream"></param>
    /// <returns></returns>
    public static string SHA256(this Stream stream)
    {
        var fs = new BufferedStream(stream, 1048576);
        using var sha = System.Security.Cryptography.SHA256.Create();
        byte[] checksum = sha.ComputeHash(fs);
        return BitConverter.ToString(checksum).Replace("-", string.Empty);
    }

    /// <summary>
    /// 计算文件的sha512
    /// </summary>
    /// <param name="stream"></param>
    /// <returns></returns>
    public static string SHA512(this Stream stream)
    {
        var fs = new BufferedStream(stream, 1048576);
        using var sha = System.Security.Cryptography.SHA512.Create();
        byte[] checksum = sha.ComputeHash(fs);
        return BitConverter.ToString(checksum).Replace("-", string.Empty);
    }

    /// <summary>
    /// 获取数据流的MD5摘要值
    /// </summary>
    /// <param name="stream"></param>
    /// <returns>MD5摘要字符串</returns>
    public static string MDString(this Stream stream)
    {
        var fs = new BufferedStream(stream, 1048576);
        using MD5 md5 = MD5.Create();
        byte[] bytes = md5.ComputeHash(fs);
        var mdstr = GetHexString(bytes);
        stream.Position = 0;
        return mdstr;
    }

    public static string GetHexString(byte[] bytes)
    {
        var hexArray = new char[bytes.Length << 1];
        for (var i = 0; i < hexArray.Length; i += 2)
        {
            var b = bytes[i >> 1];
            hexArray[i] = GetHexValue(b >> 4);       // b / 16
            hexArray[i + 1] = GetHexValue(b & 0xF);  // b % 16
        }
        return new string(hexArray, 0, hexArray.Length);

        static char GetHexValue(int i)
        {
            if (i < 10)
            {
                return (char)(i + '0');
            }
            return (char)(i - 10 + 'a');
        }
    }

    #endregion 获取文件的MD5值

    #endregion MD5摘要算法
}

/// <summary>
///     RC2加密解密算法
/// </summary>
public static class RC2Crypt
{
    private static ASCIIEncoding _asciiEncoding;
    private static byte[] _iv;
    private static byte[] _key;
    private static RC2 _rc2Csp;
    private static UnicodeEncoding _textConverter;

    static RC2Crypt()
    {
        InitializeComponent();
    }

    private static void InitializeComponent()
    {
        _key = new byte[]
        {
            106,
            51,
            25,
            141,
            157,
            142,
            23,
            111,
            234,
            159,
            187,
            154,
            215,
            34,
            37,
            204
        };
        _iv = new byte[]
        {
            135,
            186,
            133,
            136,
            184,
            149,
            153,
            144
        };
        _asciiEncoding = new ASCIIEncoding();
        _textConverter = new UnicodeEncoding();
        _rc2Csp = RC2.Create();
    }

    #region 将文本数据加密后写入一个文件

    /// <summary>
    ///     将文本数据加密后写入一个文件，其中，这个文件是用InitBinFile建立的，这个文件将被分成十块，
    ///     用来分别保存10组不同的数据，第一个byte位保留，第2位到第21位分别用来存放每块数据的长度，但
    ///     一个byte的取值为0-127，所以，用两个byte来存放一个长度。
    /// </summary>
    /// <param name="toEncryptText">要加密的文本数据</param>
    /// <param name="filePath">要写入的文件</param>
    /// <param name="dataIndex">写入第几块，取值为1--10</param>
    /// <returns>是否操作成功</returns>
    public static bool EncryptToFile(this string toEncryptText, string filePath, int dataIndex)
    {
        var r = false;
        if (dataIndex is > 10 or < 1)
        {
            return r;
        }

        //打开要写入的文件，主要是为了保持原文件的内容不丢失
        var tmpFileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 1024, true);
        var index = new byte[10261];

        //将读取的内容写到byte数组
        tmpFileStream.Read(index, 0, 10261);
        tmpFileStream.Close();

        //定义基本的加密转换运算
        using var encryptor = _rc2Csp.CreateEncryptor(_key, _iv);
        using var msEncrypt = new PooledMemoryStream();

        //在此加密转换流中，加密将从csEncrypt，加密后，结果在msEncrypt流中。
        using var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);

        //将要加密的文本转换成UTF-16 编码，保存在tmp数组。
        var tmp = _textConverter.GetBytes(toEncryptText);

        //将tmp输入csEncrypt,将通过Encryptor来加密。
        csEncrypt.Write(tmp, 0, tmp.Length);

        //输出到msEnctypt
        csEncrypt.FlushFinalBlock();

        //将流转成byte[]
        var encrypted = msEncrypt.ToArray();
        if (encrypted.Length > 1024)
            return false;

        //得到加密后数据的大小，将结果存在指定的位置。
        index[dataIndex * 2 - 1] = Convert.ToByte(Convert.ToString(encrypted.Length / 128));
        index[dataIndex * 2] = Convert.ToByte(Convert.ToString(encrypted.Length % 128));

        //将加密后的结果写入index（覆盖）
        for (var i = 0; i < encrypted.Length; i++)
            index[1024 * (dataIndex - 1) + 21 + i] = encrypted[i];

        //建立文件流
        tmpFileStream = new FileStream(filePath, FileMode.Truncate, FileAccess.Write, FileShare.None, 1024, true);

        //写文件
        tmpFileStream.Write(index, 0, 10261);
        tmpFileStream.Flush();
        r = true;
        tmpFileStream.Close();
        return r;
    }

    #endregion 将文本数据加密后写入一个文件

    #region 从一个文件中解密出一段文本，其中，这个文件是由InitBinFile建立的，并且由 EncryptToFile加密的

    /// <summary>
    ///     从一个文件中解密出一段文本，其中，这个文件是由InitBinFile建立的，并且由 EncryptToFile加密的
    /// </summary>
    /// <param name="filePath">要解密的文件</param>
    /// <param name="dataIndex">要从哪一个块中解密</param>
    /// <returns>解密后的文本</returns>
    public static string DecryptFromFile(this string filePath, int dataIndex)
    {
        if (dataIndex is > 10 or < 1)
        {
            return "";
        }

        using var tmpFileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 1024, true);
        using var decryptor = _rc2Csp.CreateDecryptor(_key, _iv);
        using var msDecrypt = new PooledMemoryStream();
        using var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write);
        var index = new byte[10261];
        tmpFileStream.Read(index, 0, 10261);
        var count = index[dataIndex * 2 - 1] * 128 + index[dataIndex * 2];
        var tmp = new byte[count];
        Array.Copy(index, 1024 * (dataIndex - 1) + 21, tmp, 0, count);
        csDecrypt.Write(tmp, 0, count);
        csDecrypt.FlushFinalBlock();
        var decrypted = msDecrypt.ToArray();
        return _textConverter.GetString(decrypted, 0, decrypted.Length);
    }

    #endregion 从一个文件中解密出一段文本，其中，这个文件是由InitBinFile建立的，并且由 EncryptToFile加密的

    #region 将一段文本加密后保存到一个文件

    /// <summary>
    ///     将一段文本加密后保存到一个文件
    /// </summary>
    /// <param name="toEncryptText">要加密的文本数据</param>
    /// <param name="filePath">要保存的文件</param>
    /// <returns>是否加密成功</returns>
    public static void EncryptToFile(this string toEncryptText, string filePath)
    {
        using var tmpFileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 1024, true);
        using var encryptor = _rc2Csp.CreateEncryptor(_key, _iv);
        using var msEncrypt = new PooledMemoryStream();
        using var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
        var tmp = _textConverter.GetBytes(toEncryptText);
        csEncrypt.Write(tmp, 0, tmp.Length);
        csEncrypt.FlushFinalBlock();
        var encrypted = msEncrypt.ToArray();
        tmpFileStream.Write(encrypted, 0, encrypted.Length);
    }

    #endregion 将一段文本加密后保存到一个文件

    #region 将一个被加密的文件解密

    /// <summary>
    ///     将一个被加密的文件解密
    /// </summary>
    /// <param name="filePath">要解密的文件</param>
    /// <returns>解密后的文本</returns>
    public static string DecryptFromFile(this string filePath)
    {
        using var tmpFileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 1024, true);
        using var decryptor = _rc2Csp.CreateDecryptor(_key, _iv);
        using var msDecrypt = new PooledMemoryStream();
        using var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write);
        var tmp = new byte[tmpFileStream.Length];
        tmpFileStream.Read(tmp, 0, tmp.Length);
        csDecrypt.Write(tmp, 0, tmp.Length);
        csDecrypt.FlushFinalBlock();
        var decrypted = msDecrypt.ToArray();
        return _textConverter.GetString(decrypted, 0, decrypted.Length);
    }

    #endregion 将一个被加密的文件解密

    #region 将文本数据加密后写入一个文件

    /// <summary>
    ///     将文本数据加密后写入一个文件，其中，这个文件是用InitBinFile建立的，这个文件将被分成十块，
    ///     用来分别保存10组不同的数据，第一个byte位保留，第2位到第21位分别用来存放每块数据的长度，但
    ///     一个byte的取值为0-127，所以，用两个byte来存放一个长度。
    /// </summary>
    /// <param name="toEncryptText">要加密的文本数据</param>
    /// <param name="filePath">要写入的文件</param>
    /// <param name="dataIndex">写入第几块，取值为1--10</param>
    /// <param name="IV">初始化向量</param>
    /// <param name="Key">加密密匙</param>
    /// <returns>是否操作成功</returns>
    public static void EncryptToFile(this string toEncryptText, string filePath, int dataIndex, byte[] IV, byte[] Key)
    {
        if (dataIndex is > 10 or < 1)
        {
            return;
        }

        //打开要写入的文件，主要是为了保持原文件的内容不丢失
        using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 1024, true);
        var index = new byte[10261];

        //将读取的内容写到byte数组
        fs.Read(index, 0, 10261);

        //定义基本的加密转换运算
        using var encryptor = _rc2Csp.CreateEncryptor(Key, IV);
        using var msEncrypt = new PooledMemoryStream();

        //在此加密转换流中，加密将从csEncrypt，加密后，结果在msEncrypt流中。
        using var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
        var tmp = _textConverter.GetBytes(toEncryptText);

        //将tmp输入csEncrypt,将通过Encryptor来加密。
        csEncrypt.Write(tmp, 0, tmp.Length);

        //输出到msEnctypt
        csEncrypt.FlushFinalBlock();

        //将流转成byte[]
        var encrypted = msEncrypt.ToArray();
        if (encrypted.Length > 1024)
        {
            return;
        }

        //得到加密后数据的大小，将结果存在指定的位置。
        index[dataIndex * 2 - 1] = Convert.ToByte(Convert.ToString(encrypted.Length / 128));
        index[dataIndex * 2] = Convert.ToByte(Convert.ToString(encrypted.Length % 128));

        //将加密后的结果写入index（覆盖）
        for (int i = 0; i < encrypted.Length; i++)
        {
            index[1024 * (dataIndex - 1) + 21 + i] = encrypted[i];
        }

        //建立文件流
        using var newStream = new FileStream(filePath, FileMode.Truncate, FileAccess.Write, FileShare.None, 1024, true);
        newStream.Write(index, 0, 10261);
        newStream.Flush();
    }

    #endregion 将文本数据加密后写入一个文件

    #region 从一个文件中解密出一段文本

    /// <summary>
    ///     从一个文件中解密出一段文本，其中，这个文件是由InitBinFile建立的，并且由 EncryptToFile加密的
    /// </summary>
    /// <param name="filePath">要解密的文件</param>
    /// <param name="dataIndex">要从哪一个块中解密</param>
    /// <param name="iv">初始化向量</param>
    /// <param name="key">解密密匙</param>
    /// <returns>解密后的文本</returns>
    public static string DecryptFromFile(this string filePath, int dataIndex, byte[] iv, byte[] key)
    {
        if (dataIndex is > 10 or < 1)
        {
            return "";
        }

        using var tmpFileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 1024, true);
        using var decryptor = _rc2Csp.CreateDecryptor(key, iv);
        using var msDecrypt = new PooledMemoryStream();
        using var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write);
        var index = new byte[10261];
        tmpFileStream.Read(index, 0, 10261);
        var count = index[dataIndex * 2 - 1] * 128 + index[dataIndex * 2];
        var tmp = new byte[count];
        Array.Copy(index, 1024 * (dataIndex - 1) + 21, tmp, 0, count);
        csDecrypt.Write(tmp, 0, count);
        csDecrypt.FlushFinalBlock();
        var decrypted = msDecrypt.ToArray();
        return _textConverter.GetString(decrypted, 0, decrypted.Length);
    }

    #endregion 从一个文件中解密出一段文本

    #region 将一段文本加密后保存到一个文件

    /// <summary>
    ///     将一段文本加密后保存到一个文件
    /// </summary>
    /// <param name="toEncryptText">要加密的文本数据</param>
    /// <param name="filePath">要保存的文件</param>
    /// <param name="iv">初始化向量</param>
    /// <param name="key">加密密匙</param>
    /// <returns>是否加密成功</returns>
    public static void EncryptToFile(this string toEncryptText, string filePath, byte[] iv, byte[] key)
    {
        using var tmpFileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 1024, true);
        using var encryptor = _rc2Csp.CreateEncryptor(key, iv);
        using var msEncrypt = new PooledMemoryStream();
        using var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
        var tmp = _textConverter.GetBytes(toEncryptText);
        csEncrypt.Write(tmp, 0, tmp.Length);
        csEncrypt.FlushFinalBlock();
        var encrypted = msEncrypt.ToArray();
        tmpFileStream.Write(encrypted, 0, encrypted.Length);
        tmpFileStream.Flush();
    }

    #endregion 将一段文本加密后保存到一个文件

    #region 将一个被加密的文件解密

    /// <summary>
    ///     将一个被加密的文件解密
    /// </summary>
    /// <param name="filePath">要解密的文件</param>
    /// <param name="iv">初始化向量</param>
    /// <param name="key">解密密匙</param>
    /// <returns>解密后的文本</returns>
    public static string DecryptFromFile(this string filePath, byte[] iv, byte[] key)
    {
        using var tmpFileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None, 1024, true);
        using var decryptor = _rc2Csp.CreateDecryptor(key, iv);
        using var msDecrypt = new PooledMemoryStream();
        using var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write);
        var tmp = new byte[tmpFileStream.Length];
        tmpFileStream.Read(tmp, 0, tmp.Length);
        csDecrypt.Write(tmp, 0, tmp.Length);
        csDecrypt.FlushFinalBlock();
        var decrypted = msDecrypt.ToArray();
        return _textConverter.GetString(decrypted, 0, decrypted.Length);
    }

    #endregion 将一个被加密的文件解密

    #region 设置加密或解密的初始化向量

    /// <summary>
    ///     设置加密或解密的初始化向量
    /// </summary>
    /// <param name="s">长度等于8的ASCII字符集的字符串</param>
    public static void SetIV(this string s)
    {
        if (s.Length != 8)
        {
            _iv = null;
            return;
        }

        try
        {
            _iv = _asciiEncoding.GetBytes(s);
        }
        catch (Exception)
        {
            _iv = null;
        }
    }

    #endregion 设置加密或解密的初始化向量

    #region 设置加密或解密的密匙

    /// <summary>
    ///     设置加密或解密的密匙
    /// </summary>
    /// <param name="s">长度等于16的ASCII字符集的字符串</param>
    public static void SetKey(this string s)
    {
        if (s.Length != 16)
        {
            _key = null;
            return;
        }

        try
        {
            _key = _asciiEncoding.GetBytes(s);
        }
        catch (Exception)
        {
            _key = null;
        }
    }

    #endregion 设置加密或解密的密匙
}