Rsa 对称加密类

最新推荐文章于 2024-07-26 15:15:40 发布
最新推荐文章于 2024-07-26 15:15:40 发布
阅读量519 收藏
点赞数

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Gd.Security
{
    /// <summary>
    /// Rsa 对称加密类
    /// </summary>
    // Token: 0x02000017 RID: 23
    public sealed class GdRsa
    {
        /// <summary>
        /// 针对Silverlight RSA解密
        /// </summary>
        /// <param name="encryptedStr">加密字符串</param>
        /// <param name="privateXmlKey">密钥</param>
        /// <param name="errMsg">错误消息</param>
        /// <param name="dwKeySize">要使用的密钥的大小（以位为单位）</param>
        /// <returns></returns>
        // Token: 0x06000090 RID: 144 RVA: 0x000084C4 File Offset: 0x000066C4
        public static string DecryptFormXmlKey(string encryptedStr, string privateXmlKey, ref string errMsg, int dwKeySize = 1024)
        {
            string result = string.Empty;
            using (RSACryptoServiceProvider rsacryptoServiceProvider = new RSACryptoServiceProvider(dwKeySize))
            {
                try
                {
                    rsacryptoServiceProvider.FromXmlString(privateXmlKey);
                    byte[] rgb = Convert.FromBase64String(encryptedStr);
                    byte[] bytes = rsacryptoServiceProvider.Decrypt(rgb, true);
                    result = Encoding.UTF8.GetString(bytes);
                }
                catch (Exception ex)
                {
                    errMsg = ex.ToString();
                }
                finally
                {
                    rsacryptoServiceProvider.PersistKeyInCsp = false;
                }
            }
            return result;
        }

        /// <summary>
        /// 针对Silverlight RSA加密
        /// </summary>
        /// <param name="encryStr">字符串</param>
        /// <param name="publicXmlKey">公钥</param>
        /// <param name="errMsg">错误消息</param>
        /// <param name="dwKeySize">要使用的密钥的大小（以位为单位）</param>
        /// <returns></returns>
        // Token: 0x06000091 RID: 145 RVA: 0x0000856C File Offset: 0x0000676C
        public static string EncryptFormXmlKey(string encryStr, string publicXmlKey, ref string errMsg, int dwKeySize = 1024)
        {
            string result = string.Empty;
            using (RSACryptoServiceProvider rsacryptoServiceProvider = new RSACryptoServiceProvider(dwKeySize))
            {
                try
                {
                    rsacryptoServiceProvider.FromXmlString(publicXmlKey);
                    byte[] inArray = rsacryptoServiceProvider.Encrypt(Encoding.UTF8.GetBytes(encryStr), true);
                    result = Convert.ToBase64String(inArray);
                }
                catch (Exception ex)
                {
                    errMsg = ex.ToString();
                }
                finally
                {
                    rsacryptoServiceProvider.PersistKeyInCsp = false;
                }
            }
            return result;
        }

        /// <summary>
        /// 加密字符串
        /// </summary>
        /// <param name="resData">字符串</param>
        /// <param name="publicKey">密钥</param>
        /// <param name="errMsg">错误消息</param>
        /// <returns></returns>
        // Token: 0x06000092 RID: 146 RVA: 0x00008610 File Offset: 0x00006810
        public static string EncryptData(string resData, string publicKey, ref string errMsg)
        {
            string result = null;
            try
            {
                byte[] bytes = Encoding.UTF8.GetBytes(resData);
                result = GdRsa.Encrypt(bytes, publicKey, "UTF-8");
            }
            catch (Exception ex)
            {
                errMsg = ex.ToString();
            }
            return result;
        }

        /// <summary>
        /// 解密字符串
        /// </summary>
        /// <param name="resData">加密数据</param>
        /// <param name="privateKey">密钥</param>
        /// <param name="errMsg">错误消息</param>
        /// <returns></returns>
        // Token: 0x06000093 RID: 147 RVA: 0x00008660 File Offset: 0x00006860
        public static string DecryptData(string resData, string privateKey, ref string errMsg)
        {
            string text = null;
            try
            {
                byte[] array = Convert.FromBase64String(resData);
                for (int i = 0; i < array.Length / 128; i++)
                {
                    byte[] array2 = new byte[128];
                    for (int j = 0; j < 128; j++)
                    {
                        array2[j] = array[j + 128 * i];
                    }
                    text += GdRsa.Decrypt(array2, privateKey, "UTF-8", ref errMsg);
                    if (!string.IsNullOrEmpty(errMsg))
                    {
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                errMsg = string.Concat(new string[]
                {
                    "RSA解密出错,详情:",
                    ex.ToString(),
                    "解密字符串:",
                    resData,
                    ",解密私钥：",
                    privateKey
                });
            }
            return text;
        }

        /// <summary>
        /// 签名,失败抛出异常
        /// </summary>
        /// <param name="content">待签名字符串</param>
        /// <param name="privateKey">私钥</param>
        /// <param name="input_charset">编码格式</param>
        /// <param name="errMsg">错误信息</param>
        /// <returns>签名后字符串</returns>
        // Token: 0x06000094 RID: 148 RVA: 0x00008754 File Offset: 0x00006954
        public static string Sign(string content, string privateKey, ref string errMsg, string input_charset = "UTF-8")
        {
            try
            {
                byte[] bytes = Encoding.GetEncoding(input_charset).GetBytes(content);
                RSACryptoServiceProvider rsacryptoServiceProvider = GdRsa.DecodePemPrivateKey(privateKey, ref errMsg);
                if (string.IsNullOrEmpty(errMsg))
                {
                    SHA1 halg = new SHA1CryptoServiceProvider();
                    byte[] inArray = rsacryptoServiceProvider.SignData(bytes, halg);
                    string asciiString = Convert.ToBase64String(inArray);
                    return GdRsa.StringToHex(asciiString);
                }
            }
            catch (Exception ex)
            {
                errMsg = "DecodePrivateKeyInfo:" + ex.ToString();
                return string.Empty;
            }
            return string.Empty;
        }

        /// <summary>
        /// 验签,失败抛出异常
        /// </summary>
        /// <param name="content">待验签字符串</param>
        /// <param name="signedString">签名</param>
        /// <param name="publicKey">公钥</param>
        /// <param name="input_charset">编码格式</param>
        /// <param name="errMsg">错误信息</param>
        /// <returns>true(通过)，false(不通过)</returns>
        // Token: 0x06000095 RID: 149 RVA: 0x000087EC File Offset: 0x000069EC
        public static bool Verify(string content, string signedString, string publicKey, ref string errMsg, string input_charset = "UTF-8")
        {
            bool result = false;
            try
            {
                signedString = GdRsa.HexToString(signedString);
                byte[] signature = Convert.FromBase64String(signedString);
                byte[] bytes = Encoding.GetEncoding(input_charset).GetBytes(content);
                RSAParameters parameters = GdRsa.ConvertFromPublicKey(publicKey);
                RSACryptoServiceProvider rsacryptoServiceProvider = new RSACryptoServiceProvider();
                rsacryptoServiceProvider.ImportParameters(parameters);
                SHA1 halg = new SHA1CryptoServiceProvider();
                result = rsacryptoServiceProvider.VerifyData(bytes, halg, signature);
                return result;
            }
            catch (Exception ex)
            {
                errMsg = "Verify:" + ex.ToString();
            }
            return result;
        }

        // Token: 0x06000096 RID: 150 RVA: 0x0000887C File Offset: 0x00006A7C
        private static string Encrypt(byte[] data, string publicKey, string input_charset)
        {
            RSACryptoServiceProvider rsa = GdRsa.DecodePemPublicKey(publicKey);
            return GdRsa.Encrypt2(rsa, data);
        }

        // Token: 0x06000097 RID: 151 RVA: 0x0000889C File Offset: 0x00006A9C
        private static string Decrypt(byte[] data, string privateKey, string input_charset, ref string errMsg)
        {
            string result = "";
            RSACryptoServiceProvider rsa = GdRsa.DecodePemPrivateKey(privateKey, ref errMsg);
            if (string.IsNullOrEmpty(errMsg))
            {
                result = GdRsa.Decrypt2(rsa, data);
            }
            return result;
        }

        // Token: 0x06000098 RID: 152 RVA: 0x000088D8 File Offset: 0x00006AD8
        private static string Encrypt2(RSACryptoServiceProvider rsa, byte[] PlaintextData)
        {
            int num = rsa.KeySize / 8 - 11;
            string result;
            if (PlaintextData.Length <= num)
            {
                result = Convert.ToBase64String(rsa.Encrypt(PlaintextData, false));
            }
            else
            {
                string text;
                using (MemoryStream memoryStream = new MemoryStream(PlaintextData))
                {
                    using (MemoryStream memoryStream2 = new MemoryStream())
                    {
                        byte[] array = new byte[num];
                        for (int i = memoryStream.Read(array, 0, num); i > 0; i = memoryStream.Read(array, 0, num))
                        {
                            byte[] array2 = new byte[i];
                            Array.Copy(array, 0, array2, 0, i);
                            byte[] array3 = rsa.Encrypt(array2, false);
                            memoryStream2.Write(array3, 0, array3.Length);
                        }
                        text = Convert.ToBase64String(memoryStream2.ToArray(), Base64FormattingOptions.None);
                    }
                }
                result = text;
            }
            return result;
        }

        // Token: 0x06000099 RID: 153 RVA: 0x000089E0 File Offset: 0x00006BE0
        private static string Decrypt2(RSACryptoServiceProvider rsa, byte[] CiphertextData)
        {
            int num = rsa.KeySize / 8;
            string result;
            if (CiphertextData.Length <= num)
            {
                result = Encoding.UTF8.GetString(rsa.Decrypt(CiphertextData, false));
            }
            else
            {
                string @string;
                using (MemoryStream memoryStream = new MemoryStream(CiphertextData))
                {
                    using (MemoryStream memoryStream2 = new MemoryStream())
                    {
                        byte[] array = new byte[num];
                        for (int i = memoryStream.Read(array, 0, num); i > 0; i = memoryStream.Read(array, 0, num))
                        {
                            byte[] array2 = new byte[i];
                            Array.Copy(array, 0, array2, 0, i);
                            byte[] array3 = rsa.Decrypt(array2, false);
                            memoryStream2.Write(array3, 0, array3.Length);
                        }
                        @string = Encoding.UTF8.GetString(memoryStream2.ToArray());
                    }
                }
                result = @string;
            }
            return result;
        }

        // Token: 0x0600009A RID: 154 RVA: 0x00008AEC File Offset: 0x00006CEC
        private static RSACryptoServiceProvider DecodePemPublicKey(string pemstr)
        {
            byte[] array = Convert.FromBase64String(pemstr);
            RSACryptoServiceProvider result;
            if (array != null)
            {
                result = GdRsa.DecodeRSAPublicKey(array);
            }
            else
            {
                result = null;
            }
            return result;
        }

        // Token: 0x0600009B RID: 155 RVA: 0x00008B18 File Offset: 0x00006D18
        private static RSACryptoServiceProvider DecodePemPrivateKey(string pemstr, ref string errMsg)
        {
            byte[] array = Convert.FromBase64String(pemstr);
            RSACryptoServiceProvider result;
            if (array != null)
            {
                result = GdRsa.DecodePrivateKeyInfo(array, ref errMsg);
            }
            else
            {
                result = null;
            }
            return result;
        }

        // Token: 0x0600009C RID: 156 RVA: 0x00008B58 File Offset: 0x00006D58
        private static RSACryptoServiceProvider DecodePrivateKeyInfo(byte[] pkcs8, ref string errMsg)
        {
            BinaryReader binaryReader = null;
            RSACryptoServiceProvider result;
            try
            {
                byte[] b = new byte[]
                {
                    48,
                    13,
                    6,
                    9,
                    42,
                    134,
                    72,
                    134,
                    247,
                    13,
                    1,
                    1,
                    1,
                    5,
                    0
                };
                byte[] a = new byte[15];
                MemoryStream memoryStream = new MemoryStream(pkcs8);
                int num = (int)memoryStream.Length;
                binaryReader = new BinaryReader(memoryStream);
                ushort num2 = binaryReader.ReadUInt16();
                if (num2 == 33072)
                {
                    binaryReader.ReadByte();
                }
                else
                {
                    if (num2 != 33328)
                    {
                        result = null;
                        return result;
                    }
                    binaryReader.ReadInt16();
                }
                byte b2 = binaryReader.ReadByte();
                if (b2 != 2)
                {
                    result = null;
                }
                else
                {
                    num2 = binaryReader.ReadUInt16();
                    if (num2 != 1)
                    {
                        result = null;
                    }
                    else
                    {
                        a = binaryReader.ReadBytes(15);
                        if (!GdRsa.CompareBytearrays(a, b))
                        {
                            result = null;
                        }
                        else
                        {
                            b2 = binaryReader.ReadByte();
                            if (b2 != 4)
                            {
                                result = null;
                            }
                            else
                            {
                                b2 = binaryReader.ReadByte();
                                if (b2 == 129)
                                {
                                    binaryReader.ReadByte();
                                }
                                else if (b2 == 130)
                                {
                                    binaryReader.ReadUInt16();
                                }
                                byte[] privkey = binaryReader.ReadBytes((int)((long)num - memoryStream.Position));
                                RSACryptoServiceProvider rsacryptoServiceProvider = GdRsa.DecodeRSAPrivateKey(privkey);
                                result = rsacryptoServiceProvider;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                errMsg = "DecodePrivateKeyInfo:" + ex.ToString();
                result = null;
            }
            finally
            {
                if (binaryReader != null)
                {
                    binaryReader.Close();
                }
            }
            return result;
        }

        // Token: 0x0600009D RID: 157 RVA: 0x00008D34 File Offset: 0x00006F34
        private static bool CompareBytearrays(byte[] a, byte[] b)
        {
            bool result;
            if (a.Length != b.Length)
            {
                result = false;
            }
            else
            {
                int num = 0;
                foreach (byte b2 in a)
                {
                    if (b2 != b[num])
                    {
                        return false;
                    }
                    num++;
                }
                result = true;
            }
            return result;
        }

        // Token: 0x0600009E RID: 158 RVA: 0x00008DA0 File Offset: 0x00006FA0
        private static RSACryptoServiceProvider DecodeRSAPublicKey(byte[] publickey)
        {
            byte[] b = new byte[]
            {
                48,
                13,
                6,
                9,
                42,
                134,
                72,
                134,
                247,
                13,
                1,
                1,
                1,
                5,
                0
            };
            byte[] a = new byte[15];
            MemoryStream input = new MemoryStream(publickey);
            BinaryReader binaryReader = new BinaryReader(input);
            RSACryptoServiceProvider result;
            try
            {
                ushort num = binaryReader.ReadUInt16();
                if (num == 33072)
                {
                    binaryReader.ReadByte();
                }
                else
                {
                    if (num != 33328)
                    {
                        result = null;
                        return result;
                    }
                    binaryReader.ReadInt16();
                }
                a = binaryReader.ReadBytes(15);
                if (!GdRsa.CompareBytearrays(a, b))
                {
                    result = null;
                }
                else
                {
                    num = binaryReader.ReadUInt16();
                    if (num == 33027)
                    {
                        binaryReader.ReadByte();
                    }
                    else
                    {
                        if (num != 33283)
                        {
                            result = null;
                            return result;
                        }
                        binaryReader.ReadInt16();
                    }
                    byte b2 = binaryReader.ReadByte();
                    if (b2 != 0)
                    {
                        result = null;
                    }
                    else
                    {
                        num = binaryReader.ReadUInt16();
                        if (num == 33072)
                        {
                            binaryReader.ReadByte();
                        }
                        else
                        {
                            if (num != 33328)
                            {
                                result = null;
                                return result;
                            }
                            binaryReader.ReadInt16();
                        }
                        num = binaryReader.ReadUInt16();
                        byte b3 = 0;
                        byte b4;
                        if (num == 33026)
                        {
                            b4 = binaryReader.ReadByte();
                        }
                        else
                        {
                            if (num != 33282)
                            {
                                result = null;
                                return result;
                            }
                            b3 = binaryReader.ReadByte();
                            b4 = binaryReader.ReadByte();
                        }
                        byte[] array = new byte[4];
                        array[0] = b4;
                        array[1] = b3;
                        byte[] value = array;
                        int num2 = BitConverter.ToInt32(value, 0);
                        byte b5 = binaryReader.ReadByte();
                        binaryReader.BaseStream.Seek(-1L, SeekOrigin.Current);
                        if (b5 == 0)
                        {
                            binaryReader.ReadByte();
                            num2--;
                        }
                        byte[] modulus = binaryReader.ReadBytes(num2);
                        if (binaryReader.ReadByte() != 2)
                        {
                            result = null;
                        }
                        else
                        {
                            int count = (int)binaryReader.ReadByte();
                            byte[] exponent = binaryReader.ReadBytes(count);
                            RSACryptoServiceProvider rsacryptoServiceProvider = new RSACryptoServiceProvider();
                            rsacryptoServiceProvider.ImportParameters(new RSAParameters
                            {
                                Modulus = modulus,
                                Exponent = exponent
                            });
                            result = rsacryptoServiceProvider;
                        }
                    }
                }
            }
            catch (Exception)
            {
                result = null;
            }
            finally
            {
                binaryReader.Close();
            }
            return result;
        }

        // Token: 0x0600009F RID: 159 RVA: 0x00009060 File Offset: 0x00007260
        private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey)
        {
            MemoryStream input = new MemoryStream(privkey);
            BinaryReader binaryReader = new BinaryReader(input);
            RSACryptoServiceProvider result;
            try
            {
                ushort num = binaryReader.ReadUInt16();
                if (num == 33072)
                {
                    binaryReader.ReadByte();
                }
                else
                {
                    if (num != 33328)
                    {
                        result = null;
                        return result;
                    }
                    binaryReader.ReadInt16();
                }
                num = binaryReader.ReadUInt16();
                if (num != 258)
                {
                    result = null;
                }
                else
                {
                    byte b = binaryReader.ReadByte();
                    if (b != 0)
                    {
                        result = null;
                    }
                    else
                    {
                        int integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] modulus = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] exponent = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] d = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] p = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] q = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] dp = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] dq = binaryReader.ReadBytes(integerSize);
                        integerSize = GdRsa.GetIntegerSize(binaryReader);
                        byte[] inverseQ = binaryReader.ReadBytes(integerSize);
                        RSACryptoServiceProvider rsacryptoServiceProvider = new RSACryptoServiceProvider();
                        rsacryptoServiceProvider.ImportParameters(new RSAParameters
                        {
                            Modulus = modulus,
                            Exponent = exponent,
                            D = d,
                            P = p,
                            Q = q,
                            DP = dp,
                            DQ = dq,
                            InverseQ = inverseQ
                        });
                        result = rsacryptoServiceProvider;
                    }
                }
            }
            catch (Exception)
            {
                result = null;
            }
            finally
            {
                binaryReader.Close();
            }
            return result;
        }

        // Token: 0x060000A0 RID: 160 RVA: 0x00009248 File Offset: 0x00007448
        private static int GetIntegerSize(BinaryReader binr)
        {
            byte b = binr.ReadByte();
            int result;
            if (b != 2)
            {
                result = 0;
            }
            else
            {
                b = binr.ReadByte();
                int num;
                if (b == 129)
                {
                    num = (int)binr.ReadByte();
                }
                else if (b == 130)
                {
                    byte b2 = binr.ReadByte();
                    byte b3 = binr.ReadByte();
                    byte[] array = new byte[4];
                    array[0] = b3;
                    array[1] = b2;
                    byte[] value = array;
                    num = BitConverter.ToInt32(value, 0);
                }
                else
                {
                    num = (int)b;
                }
                while (binr.ReadByte() == 0)
                {
                    num--;
                }
                binr.BaseStream.Seek(-1L, SeekOrigin.Current);
                result = num;
            }
            return result;
        }

        // Token: 0x060000A1 RID: 161 RVA: 0x00009308 File Offset: 0x00007508
        private static string ConvertStringToHex(string asciiString)
        {
            string text = "";
            foreach (char value in asciiString)
            {
                int num = Convert.ToInt32(value);
                text += string.Format("{0:X2}", num);
            }
            return text.ToUpper();
        }

        // Token: 0x060000A2 RID: 162 RVA: 0x00009368 File Offset: 0x00007568
        private static string ConvertHexToString(string HexValue)
        {
            string text = "";
            while (HexValue.Length > 0)
            {
                text += Convert.ToChar(Convert.ToUInt32(HexValue.Substring(0, 2), 16)).ToString();
                HexValue = HexValue.Substring(2, HexValue.Length - 2);
            }
            return text;
        }

        // Token: 0x060000A3 RID: 163 RVA: 0x000093C8 File Offset: 0x000075C8
        private static RSAParameters ConvertFromPublicKey(string pemFileConent)
        {
            byte[] array = Convert.FromBase64String(pemFileConent);
            if (array.Length < 162)
            {
                throw new ArgumentException("pem file content is incorrect.");
            }
            byte[] array2 = new byte[128];
            byte[] array3 = new byte[3];
            Array.Copy(array, 29, array2, 0, 128);
            Array.Copy(array, 159, array3, 0, 3);
            return new RSAParameters
            {
                Modulus = array2,
                Exponent = array3
            };
        }

        // Token: 0x060000A4 RID: 164 RVA: 0x0000944C File Offset: 0x0000764C
        private static RSAParameters ConvertFromPrivateKey(string pemFileConent)
        {
            byte[] array = Convert.FromBase64String(pemFileConent);
            if (array.Length < 609)
            {
                throw new ArgumentException("pem file content is incorrect.");
            }
            int num = 11;
            byte[] array2 = new byte[128];
            Array.Copy(array, num, array2, 0, 128);
            num += 128;
            num += 2;
            byte[] array3 = new byte[3];
            Array.Copy(array, num, array3, 0, 3);
            num += 3;
            num += 4;
            byte[] array4 = new byte[128];
            Array.Copy(array, num, array4, 0, 128);
            num += 128;
            num += ((array[num + 1] == 64) ? 2 : 3);
            byte[] array5 = new byte[64];
            Array.Copy(array, num, array5, 0, 64);
            num += 64;
            num += ((array[num + 1] == 64) ? 2 : 3);
            byte[] array6 = new byte[64];
            Array.Copy(array, num, array6, 0, 64);
            num += 64;
            num += ((array[num + 1] == 64) ? 2 : 3);
            byte[] array7 = new byte[64];
            Array.Copy(array, num, array7, 0, 64);
            num += 64;
            num += ((array[num + 1] == 64) ? 2 : 3);
            byte[] array8 = new byte[64];
            Array.Copy(array, num, array8, 0, 64);
            num += 64;
            num += ((array[num + 1] == 64) ? 2 : 3);
            byte[] array9 = new byte[64];
            Array.Copy(array, num, array9, 0, 64);
            return new RSAParameters
            {
                Modulus = array2,
                Exponent = array3,
                D = array4,
                P = array5,
                Q = array6,
                DP = array7,
                DQ = array8,
                InverseQ = array9
            };
        }

        /// <summary>
        ///             字符串转换验签字符
        /// </summary>
        /// <param name="asciiString">编码字符</param>
        /// <returns></returns>
        // Token: 0x060000A5 RID: 165 RVA: 0x00009614 File Offset: 0x00007814
        private static string StringToHex(string asciiString)
        {
            string text = "";
            foreach (char value in asciiString)
            {
                int num = Convert.ToInt32(value);
                text += string.Format("{0:X2}", num);
            }
            return text.ToUpper();
        }

        /// <summary>
        /// 转换验签字符为字符串
        /// </summary>
        /// <param name="HexValue">验签字符串</param>
        /// <returns></returns>
        // Token: 0x060000A6 RID: 166 RVA: 0x0000967C File Offset: 0x0000787C
        private static string HexToString(string HexValue)
        {
            string text = "";
            while (HexValue.Length > 0)
            {
                text += Convert.ToChar(Convert.ToUInt32(HexValue.Substring(0, 2), 16)).ToString();
                HexValue = HexValue.Substring(2, HexValue.Length - 2);
            }
            return text;
        }
    }
}
 

Lucky社长大人
关注
对称加密与非对称加密（RSA）
weixin_44039270的博客
06-27 1399
对称加密与非对称加密前言对称加密非对称加密神奇的问题 前言 这是我学习https遇到的问题。我刷面经的时候在好多地方都看到了面试官问一些https的知识，搞得我很难受，根本就不懂啥是https，只知道它比http安全，但究竟是怎么个安全法，不晓得啊。网上说它用了加密算法，那咱们就一起了解一下，加密算法里都有哪些东西。 对称加密 啥叫对称加密呢？ 其实很好理解。这是最开始被使用的一种加密算法。假设A和B要一起传递一些消息。但是总有一些人会偷偷监听他俩的消息，比如A对B说：我的银行卡号是xxxxxxxx，密码是
RSA加密算法的实现（c语言源程序&可执行文件）.rar
09-11
博文---信息安全实践二之密码与隐藏技术2【数字水印&RSA加密算法实现】 RSA加密算法的实现，利用C语言改正博文中的错误程序。
[密码学]对称加密-RSA算法
王洛宾-信息安全
03-04 1295
RSA算法是一种常用的非对称加密算法，主要用于数据加密、数字签名、密钥交换、身份验证和数字证书等安全应用，其安全性基于大数的质因数分解困难性，但加密和解密效率相对较低。
对称（DES/AES）与非对称（RSA/SSL/数字证书）加密介绍及实际应用
最新发布
u013712343的博客
07-26 338
对称（DES/AES）与非对称（RSA/SSL/数字证书）加密介绍及实际应用
对称加密与非对称加密，以及RSA的原理
热门推荐
LeeLu的博客
03-10 2万+
一 ， 概述 在现代密码学诞生以前，就已经有很多的加密方法了。例如，最古老的斯巴达加密棒，广泛应用于公元前7世纪的古希腊。16世纪意大利数学家卡尔达诺发明的栅格密码，基于单表代换的凯撒密码、猪圈密码，基于多表代换的维吉尼亚密码，二战中德军广泛使用的恩格玛加密机….但最终都找到了有效的破解算法。 现代密码学的诞生标志是1977年1月由美国国家标准局公布的数据加密标准(Data Encryptio...
RSA对称加密（JS加密，C#、Java解密）
清山博客
09-07 7608
常见的渗透测试会将网站登录时密码使用明文传输视为风险。推荐使用国密算法或者RSA算法对密码进行加密传输。
ThinkPHP实现的rsa非对称加密类示例
10-18
综上所述，通过ThinkPHP实现的RSA非对称加密类示例向我们展示了如何在PHP环境下使用openssl扩展库生成密钥对，存储和引入密钥文件，以及如何利用密钥对进行数据的加密和解密操作。同时，还说明了RSA加密在安全应用中...
.net RSA对称加密 解决加密长度限制
06-11
.net c# RSA对称加密， 解决加密长度限制，可以直接使用
RSA非对称加密算法
02-14
RSA 非对称加密算法 RSA 非对称加密算法是一种经典的非对称加密算法，由罗纳德·李维斯特、阿迪·萨莫尔和伦纳德·阿德曼三人于 1977 年共同提出的。该算法的主要思想是基于大素数的乘积和因式分解之间的关系，通过...
rsa对称加密C++实现
02-21
总的来说，C++实现RSA非对称加密算法是一项复杂但重要的任务，它涉及到数学、安全性和编码等多个领域。通过理解和实现这样的算法，开发者能够更深入地理解公钥密码学的基础，同时增强他们在实际项目中的安全编码能力...
Crypto-RSA加密
qwzf
08-06 4333
参考博客 RSA算法原理(一) RSA算法原理(二)
RSA加密算法（c语言）
06-03
个人编的RSA加密程序，要想了解具体算法说明或者其他加密算法请关注我的博客----适合任何对算法理解不透彻的密码初学者和爱好者。
RSA加密算法的实现
11-04
此算法的根据学习的密码学，按照自我个人多RSA算法的理解，通过编程实现的，有不完善的地方，请多多包含，且代码仅供参考。
RSA加密算法C语言实现
11-11
RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。 RSA的算法涉及三个参数，n、e1、e2。 其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。 e1和e2是一对相关的值，e1可以任意取，但要求e1与(p-1)*(q-1)互质;再选择e2，要求(e2×e1)≡1(mod(p-1)×(q-1))。 (n，e1),(n，e2)就是密钥对。其中(n，e1)为公钥，(n，e2)为私钥。 RSA加解密的算法完全相同，设A为明文，B为密文，则:A≡B^e2( mod n);B≡A^e1 (mod n);(公钥加密体制中，一般用公钥加密，私钥解密) e1和e2可以互换使用，即: A≡B^e1 (mod n);B≡A^e2( mod n);
RSA加密算法源码
02-23
RSA加密算法源码 详情参见：http://blog.csdn.net/lemon_tree12138/article/details/50696926
浅谈对称加密与非对称加密
筱葭的博客
03-06 597
1、对称加密（Symmetric Cryptography） 对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）,这种方法在密码学中叫做对称加密算法。对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。 对称加密通常使用的是相对较小的密钥，一般小于256 bit。因为密钥越大，加密
RSA公钥、私钥、签名和验签
WGH100817的博客
12-05 609
1 RSA加密算法介绍RSA又叫非对称加密算法，这类加密算法有一对秘钥，其中一个用来加密一个用来解密。这一对秘钥中你可以选择一个作为私钥（自己保存），另一个作为公钥（对外公开）。用私钥加密的内容只能用对应的公钥解密，反之用公钥加密的内容只能用对应的私钥解密。还有一种对称加密算法，其加密秘钥和解密秘钥为同一个秘钥，比如DES。2 RSA加密过程假设A 产生了一对秘...
RSA加密算法
weixin_30298497的博客
08-18 216
1.什么是RSA 　　RSA是一种公钥加密算法，可用于公钥加密和数字签名 2.RSA加密 RSA加密过程可用下面的公式表达 密文=(明文^E) mod N RSA的密文等于明文代表数字的E次方除以N 的余数 整个过程十分简单，只要知道E,N就能对明文进行加密。所以E,N的组合就是公钥。写成“公钥是{E,N}” 3.RSA解密过程 RSA解密也十分简单可用下面公式表达：...
RSA对称加密算法
Black Monkey
07-07 3271
import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputSt
pythonrsa对称加密
10-19
很抱歉，引用内容中提到的是Python3的非对称加密算法RSA，而不是对称加密算法。对称加密算法和非对称加密算法的区别在于加密和解密所使用的密钥是否相同。对称加密算法使用相同的密钥进行加密和解密，而非对称加密算法使用不同的密钥进行加密和解密。如果您需要了解Python中的对称加密算法，可以参考Python标准库中的cryptography模块。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值