精华内容
下载资源
问答
  • 通过前面的文章我们学会了如何生成公钥和...那么,我们来看在C#中如何实现RSA加密解密。直接上代码,如下类是RSA算法实现的加密,加解密,签名以及签名的验证。 /// <summary> /// 类名:RSACrypt ...
    通过前面的文章我们学会了如何生成公钥和私钥,详见这篇文章:https://blog.csdn.net/yysyangyangyangshan/article/details/80368397。
    那么,我们来看在C#中如何实现RSA加密解密。直接上代码,如下类是RSA算法实现的加密,加解密,签名以及签名的验证。

       /// <summary>  
        /// 类名:RSACrypt  
        /// 功能:RSA加密、解密、签名、验签  
        /// </summary>  
        public sealed class RSACrypt
        {
            /// <summary>  
            /// 签名  
            /// </summary>  
            /// <param name="content">待签名字符串</param>  
            /// <param name="privateKey">私钥</param>  
            /// <param name="input_charset">编码格式</param>  
            /// <returns>签名后字符串</returns>  
            public static string sign(string content, string privateKey, string input_charset)
            {
                byte[] Data = Encoding.GetEncoding(input_charset).GetBytes(content);
                RSACryptoServiceProvider rsa = DecodePemPrivateKey(privateKey);
                SHA1 sh = new SHA1CryptoServiceProvider();
                byte[] signData = rsa.SignData(Data, sh);
                return Convert.ToBase64String(signData);
            }
    
            /// <summary>  
            /// 验签  
            /// </summary>  
            /// <param name="content">待验签字符串</param>  
            /// <param name="signedString">签名</param>  
            /// <param name="publicKey">公钥</param>  
            /// <param name="input_charset">编码格式</param>  
            /// <returns>true(通过),false(不通过)</returns>  
            public static bool verify(string content, string signedString, string publicKey, string input_charset)
            {
                bool result = false;
                byte[] Data = Encoding.GetEncoding(input_charset).GetBytes(content);
                byte[] data = Convert.FromBase64String(signedString);
                RSAParameters paraPub = ConvertFromPublicKey(publicKey);
                RSACryptoServiceProvider rsaPub = new RSACryptoServiceProvider();
                rsaPub.ImportParameters(paraPub);
                SHA1 sh = new SHA1CryptoServiceProvider();
                result = rsaPub.VerifyData(Data, sh, data);
                return result;
            }
    
            /// <summary>  
            /// 加密  
            /// </summary>  
            /// <param name="resData">需要加密的字符串</param>  
            /// <param name="publicKey">公钥</param>  
            /// <param name="input_charset">编码格式</param>  
            /// <returns>明文</returns>  
            public static string encryptData(string resData, string publicKey, string input_charset)
            {
                byte[] DataToEncrypt = Encoding.ASCII.GetBytes(resData);
                string result = encrypt(DataToEncrypt, publicKey, input_charset);
                return result;
            }
    
    
            /// <summary>  
            /// 解密  
            /// </summary>  
            /// <param name="resData">加密字符串</param>  
            /// <param name="privateKey">私钥</param>  
            /// <param name="input_charset">编码格式</param>  
            /// <returns>明文</returns>  
            public static string decryptData(string resData, string privateKey, string input_charset)
            {
                byte[] DataToDecrypt = Convert.FromBase64String(resData);
                string result = "";
                for (int j = 0; j < DataToDecrypt.Length / 128; j++)
                {
                    byte[] buf = new byte[128];
                    for (int i = 0; i < 128; i++)
                    {
    
                        buf[i] = DataToDecrypt[i + 128 * j];
                    }
                    result += decrypt(buf, privateKey, input_charset);
                }
                return result;
            }
    
            private static string encrypt(byte[] data, string publicKey, string input_charset)
            {
                RSACryptoServiceProvider rsa = DecodePemPublicKey(publicKey);
                SHA1 sh = new SHA1CryptoServiceProvider();
                byte[] result = rsa.Encrypt(data, false);
    
                return Convert.ToBase64String(result);
            }
    
            private static string decrypt(byte[] data, string privateKey, string input_charset)
            {
                string result = "";
                RSACryptoServiceProvider rsa = DecodePemPrivateKey(privateKey);
                SHA1 sh = new SHA1CryptoServiceProvider();
                byte[] source = rsa.Decrypt(data, false);
                char[] asciiChars = new char[Encoding.GetEncoding(input_charset).GetCharCount(source, 0, source.Length)];
                Encoding.GetEncoding(input_charset).GetChars(source, 0, source.Length, asciiChars, 0);
                result = new string(asciiChars);
                return result;
            }
    
            private static RSACryptoServiceProvider DecodePemPublicKey(String pemstr)
            {
                byte[] pkcs8publickkey;
                pkcs8publickkey = Convert.FromBase64String(pemstr);
                if (pkcs8publickkey != null)
                {
                    RSACryptoServiceProvider rsa = DecodeRSAPublicKey(pkcs8publickkey);
                    return rsa;
                }
                else
                    return null;
            }
    
            private static RSACryptoServiceProvider DecodePemPrivateKey(String pemstr)
            {
                byte[] pkcs8privatekey;
                pkcs8privatekey = Convert.FromBase64String(pemstr);
                if (pkcs8privatekey != null)
                {
                    RSACryptoServiceProvider rsa = DecodePrivateKeyInfo(pkcs8privatekey);
                    return rsa;
                }
                else
                    return null;
            }
    
            private static RSACryptoServiceProvider DecodePrivateKeyInfo(byte[] pkcs8)
            {
                byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
                byte[] seq = new byte[15];
    
                MemoryStream mem = new MemoryStream(pkcs8);
                int lenstream = (int)mem.Length;
                BinaryReader binr = new BinaryReader(mem);   
                byte bt = 0;
                ushort twobytes = 0;
    
                try
                {
                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8130)   
                        binr.ReadByte();   
                    else if (twobytes == 0x8230)
                        binr.ReadInt16(); 
                    else
                        return null;
    
                    bt = binr.ReadByte();
                    if (bt != 0x02)
                        return null;
    
                    twobytes = binr.ReadUInt16();
    
                    if (twobytes != 0x0001)
                        return null;
    
                    seq = binr.ReadBytes(15); 
                    if (!CompareBytearrays(seq, SeqOID)) 
                        return null;
    
                    bt = binr.ReadByte();
                    if (bt != 0x04) 
                        return null;
    
                    bt = binr.ReadByte();
                    if (bt == 0x81)
                        binr.ReadByte();
                    else
                        if (bt == 0x82)
                            binr.ReadUInt16();
    
                    byte[] rsaprivkey = binr.ReadBytes((int)(lenstream - mem.Position));
                    RSACryptoServiceProvider rsacsp = DecodeRSAPrivateKey(rsaprivkey);
                    return rsacsp;
                }
    
                catch (Exception)
                {
                    return null;
                }
    
                finally { binr.Close(); }
            }
    
            private static bool CompareBytearrays(byte[] a, byte[] b)
            {
                if (a.Length != b.Length)
                    return false;
                int i = 0;
                foreach (byte c in a)
                {
                    if (c != b[i])
                        return false;
                    i++;
                }
                return true;
            }
    
            private static RSACryptoServiceProvider DecodeRSAPublicKey(byte[] publickey)
            {
                byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
                byte[] seq = new byte[15];
                MemoryStream mem = new MemoryStream(publickey);
                BinaryReader binr = new BinaryReader(mem); 
                byte bt = 0;
                ushort twobytes = 0;
    
                try
                {
    
                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8130) 
                        binr.ReadByte(); 
                    else if (twobytes == 0x8230)
                        binr.ReadInt16(); 
                    else
                        return null;
    
                    seq = binr.ReadBytes(15); 
                    if (!CompareBytearrays(seq, SeqOID)) 
                        return null;
    
                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8103) 
                        binr.ReadByte(); 
                    else if (twobytes == 0x8203)
                        binr.ReadInt16(); 
                    else
                        return null;
    
                    bt = binr.ReadByte();
                    if (bt != 0x00) 
                        return null;
    
                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8130) 
                        binr.ReadByte();
                    else if (twobytes == 0x8230)
                        binr.ReadInt16();
                    else
                        return null;
    
                    twobytes = binr.ReadUInt16();
                    byte lowbyte = 0x00;
                    byte highbyte = 0x00;
    
                    if (twobytes == 0x8102) 
                        lowbyte = binr.ReadByte();
                    else if (twobytes == 0x8202)
                    {
                        highbyte = binr.ReadByte();
                        lowbyte = binr.ReadByte();
                    }
                    else
                        return null;
                    byte[] modint = { lowbyte, highbyte, 0x00, 0x00 }; 
                    int modsize = BitConverter.ToInt32(modint, 0);
    
                    byte firstbyte = binr.ReadByte();
                    binr.BaseStream.Seek(-1, SeekOrigin.Current);
    
                    if (firstbyte == 0x00)
                    {   
                        binr.ReadByte();   
                        modsize -= 1;  
                    }
    
                    byte[] modulus = binr.ReadBytes(modsize);  
    
                    if (binr.ReadByte() != 0x02)  
                        return null;
                    int expbytes = (int)binr.ReadByte();   
                    byte[] exponent = binr.ReadBytes(expbytes);
    
                    RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                    RSAParameters RSAKeyInfo = new RSAParameters();
                    RSAKeyInfo.Modulus = modulus;
                    RSAKeyInfo.Exponent = exponent;
                    RSA.ImportParameters(RSAKeyInfo);
                    return RSA;
                }
                catch (Exception)
                {
                    return null;
                }
    
                finally { binr.Close(); }
            }
    
            private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey)
            {
                byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;
    
                MemoryStream mem = new MemoryStream(privkey);
                BinaryReader binr = new BinaryReader(mem); 
                byte bt = 0;
                ushort twobytes = 0;
                int elems = 0;
                try
                {
                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8130)  
                        binr.ReadByte(); 
                    else if (twobytes == 0x8230)
                        binr.ReadInt16();  
                    else
                        return null;
    
                    twobytes = binr.ReadUInt16();
                    if (twobytes != 0x0102) 
                        return null;
                    bt = binr.ReadByte();
                    if (bt != 0x00)
                        return null;
    
                    elems = GetIntegerSize(binr);
                    MODULUS = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    E = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    D = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    P = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    Q = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    DP = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    DQ = binr.ReadBytes(elems);
    
                    elems = GetIntegerSize(binr);
                    IQ = binr.ReadBytes(elems);
    
                    RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                    RSAParameters RSAparams = new RSAParameters();
                    RSAparams.Modulus = MODULUS;
                    RSAparams.Exponent = E;
                    RSAparams.D = D;
                    RSAparams.P = P;
                    RSAparams.Q = Q;
                    RSAparams.DP = DP;
                    RSAparams.DQ = DQ;
                    RSAparams.InverseQ = IQ;
                    RSA.ImportParameters(RSAparams);
                    return RSA;
                }
                catch (Exception)
                {
                    return null;
                }
                finally { binr.Close(); }
            }
    
            private static int GetIntegerSize(BinaryReader binr)
            {
                byte bt = 0;
                byte lowbyte = 0x00;
                byte highbyte = 0x00;
                int count = 0;
                bt = binr.ReadByte();
                if (bt != 0x02) 
                    return 0;
                bt = binr.ReadByte();
    
                if (bt == 0x81)
                    count = binr.ReadByte(); 
                else
                    if (bt == 0x82)
                    {
                        highbyte = binr.ReadByte(); 
                        lowbyte = binr.ReadByte();
                        byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
                        count = BitConverter.ToInt32(modint, 0);
                    }
                    else
                    {
                        count = bt;  
                    }
    
                while (binr.ReadByte() == 0x00)
                {  
                    count -= 1;
                }
                binr.BaseStream.Seek(-1, SeekOrigin.Current);       
                return count;
            }
    
            private static RSAParameters ConvertFromPublicKey(string pemFileConent)
            {
    
                byte[] keyData = Convert.FromBase64String(pemFileConent);
                if (keyData.Length < 162)
                {
                    throw new ArgumentException("pem file content is incorrect.");
                }
                byte[] pemModulus = new byte[128];
                byte[] pemPublicExponent = new byte[3];
                Array.Copy(keyData, 29, pemModulus, 0, 128);
                Array.Copy(keyData, 159, pemPublicExponent, 0, 3);
                RSAParameters para = new RSAParameters();
                para.Modulus = pemModulus;
                para.Exponent = pemPublicExponent;
                return para;
            }
    
            private static RSAParameters ConvertFromPrivateKey(string pemFileConent)
            {
                byte[] keyData = Convert.FromBase64String(pemFileConent);
                if (keyData.Length < 609)
                {
                    throw new ArgumentException("pem file content is incorrect.");
                }
    
                int index = 11;
                byte[] pemModulus = new byte[128];
                Array.Copy(keyData, index, pemModulus, 0, 128);
    
                index += 128;
                index += 2;
                byte[] pemPublicExponent = new byte[3];
                Array.Copy(keyData, index, pemPublicExponent, 0, 3);
    
                index += 3;
                index += 4;
                byte[] pemPrivateExponent = new byte[128];
                Array.Copy(keyData, index, pemPrivateExponent, 0, 128);
    
                index += 128;
                index += ((int)keyData[index + 1] == 64 ? 2 : 3);
                byte[] pemPrime1 = new byte[64];
                Array.Copy(keyData, index, pemPrime1, 0, 64);
    
                index += 64;
                index += ((int)keyData[index + 1] == 64 ? 2 : 3);//346  
                byte[] pemPrime2 = new byte[64];
                Array.Copy(keyData, index, pemPrime2, 0, 64);
    
                index += 64;
                index += ((int)keyData[index + 1] == 64 ? 2 : 3);
                byte[] pemExponent1 = new byte[64];
                Array.Copy(keyData, index, pemExponent1, 0, 64);
    
                index += 64;
                index += ((int)keyData[index + 1] == 64 ? 2 : 3);
                byte[] pemExponent2 = new byte[64];
                Array.Copy(keyData, index, pemExponent2, 0, 64);
    
                index += 64;
                index += ((int)keyData[index + 1] == 64 ? 2 : 3);
                byte[] pemCoefficient = new byte[64];
                Array.Copy(keyData, index, pemCoefficient, 0, 64);
    
                RSAParameters para = new RSAParameters();
                para.Modulus = pemModulus;
                para.Exponent = pemPublicExponent;
                para.D = pemPrivateExponent;
                para.P = pemPrime1;
                para.Q = pemPrime2;
                para.DP = pemExponent1;
                para.DQ = pemExponent2;
                para.InverseQ = pemCoefficient;
                return para;
            }
        }

     测试代码如下,

     

        static void Main(string[] args)
            {
                /**RSA加密测试,RSA中的密钥对通过SSL工具生成,生成命令如下: 
                * 1 生成RSA私钥: 
                * openssl genrsa -out rsa_private_key.pem 1024 
                *2 生成RSA公钥 
                * openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem 
                * 
                * 3 将RSA私钥转换成PKCS8格式 
                * openssl pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt -out rsa_pub_pk8.pem 
                * 
                * 直接打开rsa_private_key.pem和rsa_pub_pk8.pem文件就可以获取密钥对内容,获取密钥对内容组成字符串时,注意将换行符删除 
                * */
                //rsa_pub_pk8.pem内容
                string privatekey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMsrofD5ET//8cozXO6RBNqj/Jt2btGltDZu8NMe0NbKzHjq8gLjCiw1nA/dubESnOrx/oHeNl6q1yjEJZ9U2LVLUU2PIqkLnnGaPOsJM1R72ZKArDKgZT+QelHgXJdOA/TZeS4Ndcms4OUNBCDRQ2uBuQD0FugvF3GRkuynW2yFAgMBAAECgYEAwlEMBOaiqfyIbCTt+Dp5UwhOvP3sBdWfZAR9jt7FTPoP0IKdT0eI3jmz9rTROlub+1XSXrGCfM6XFKVtelNzI1PqEB+QomBhZtwhzSmxrFWCg4q2oeZsqROKlDBDhV8pFhGX9Euo4HxsNJWLcA4Ngt6ZIwV/Drj7uOEA06UxFyECQQD76Fl4rKPOdzC0RBtRZEqxmC32nikwAWz2FqinNzee+tiMeF2OydP1bCTp3R/mo6Li7hqUcV3LjFCf4nFB8K5ZAkEAzniXc7ppAL286XtKlIOVQnxlhL+wDGtbHZ+SppD02OBFoDGPOivYz8yKL7ktgFwfGzRhGKjJXuXgHwmCnvjiDQJAFhgG4OKja1Rg3S6sBrN5KaJjRaIRkrhNSjgqip/5LORrYcaczg09neTiR/Cw/5WSj7y6cBKRW2zvFVbTACmP4QJATgVZzdyKI0KPqXbyhs52T6psPk6lOvwycS5En3a1X2LYTKGNqwC4rEVxjnkeTZwCESio7EWT2q1pFLFmT6Zi3QJBAKwE1Q3l20UikKhDNrAhxv1R3GgLf8d++Oz5nsQL1yL/blwn3/Bm5Zr+S1XYH5Sz7TBitilmFuO2Wy3xI26EQcQ=";
                //rsa_public_key.pem内容
                string publickey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDLK6Hw+RE///HKM1zukQTao/ybdm7RpbQ2bvDTHtDWysx46vIC4wosNZwP3bmxEpzq8f6B3jZeqtcoxCWfVNi1S1FNjyKpC55xmjzrCTNUe9mSgKwyoGU/kHpR4FyXTgP02XkuDXXJrODlDQQg0UNrgbkA9BboLxdxkZLsp1tshQIDAQAB";
                //加密字符串  
                string data = "yangyoushan";
    
                Console.WriteLine("加密前字符串内容:" + data);
                //加密  
                string encrypteddata = RSACrypt.encryptData(data, publickey, "UTF-8");
                Console.WriteLine("加密后的字符串为:" + encrypteddata);
                Console.WriteLine("解密后的字符串内容:" + RSACrypt.decryptData(encrypteddata, privatekey, "UTF-8"));
    
                Console.WriteLine("*****我是分割线******");
    
                //解密  
                string endata = "VbOtmCuc8+8gKXbDyYHAVG6Hnoa7lCphMZePUmxaM7zQ0XD7oTcRY59xNo9xOpwG5YwjbEiHKcuANuKNBlPLkieX5yGSS8iOd1cki+DujqUtffHQicMegubh4vaPhvhBnOflUejtZH1xi2r2a2t8v9xQO+vmZc7gNJ91+3gtFuc=";
                string datamw = RSACrypt.decryptData(endata, privatekey, "UTF-8");
                Console.WriteLine("静态加密后的字符串为:" + endata);
                Console.WriteLine("解密后的字符串内容:" + datamw);
    
                //签名  
                string signdata = "20180522201658IMFINE";
                Console.WriteLine("签名前的字符串内容:" + signdata);
                string sign = RSACrypt.sign(signdata, privatekey, "UTF-8");
                Console.WriteLine("签名后的字符串:" + sign);
    
                string sourceSign = "VEAgvbHavdbOPYSP8jqxJPYTv/FV/Nl3MClHFBN4qvDRM3ixbOKpUY2P1w99edC29C4Q7qNY99jKYJucRM21mBf8RgEnsBqZVIzqnJYafIQ0AFCL7BpNAORM7uns+NxFj2Zse6Kr61lSpEvie1GCzo+iuYYvzPlMlz+W6nScp2A=";
                Console.WriteLine("生成的签名:" + sourceSign);
                bool realSign1 = RSACrypt.verify("20180522201658IMFINE", sign, publickey, "UTF-8");
                Console.WriteLine(realSign1);
    
                bool realSign2 = RSACrypt.verify("20180522201658IMFINEHAHA", sign, publickey, "UTF-8");
                Console.WriteLine(realSign2);
                Console.ReadLine();  
            }

    执行结果如下,

     

    除了算法比较复杂,代码逻辑并无复杂的地方,大家自行下载代码运行即可。

    展开全文
  • // 必须使用RSA/ECB/PKCS1Padding而不是RSA,否则解密会乱码 cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); //Android中错误写法 cipher = Cipher.getInstance("RSA");
  • .NET实现RSA算法加密解密

    千次阅读 2019-06-30 11:36:23
    在项目中经常会使用到一些加密场合,涉及的加密算法常有RSA算法,base32算法,恰好最近有用到RSA加密解密算法,以此篇文章记录一下。 RSA加密是一种非对称加密。可以在不直接传递密钥的情况下,完成解密。这能够...

    在项目中经常会使用到一些加密场合,涉及的加密算法常有RSA算法,base32算法,恰好最近有用到RSA加密解密算法,以此篇文章记录一下。

    RSA加密是一种非对称加密。可以在不直接传递密钥的情况下,完成解密。这能够确保信息的安全性,避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程,分别称为公钥和私钥。两者之间有数学相关,该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥,公钥是公开的(可能同时多人持有)。

    .net实现RSA加密解密算法需要引用System.Security.Cryptography程序集。

    所有的加密解密操作均使用加密服务提供程序 (CSP) 提供的 System.Security.Cryptography.RSA 算法的实现。

    实现加密解密需要执行不对称加密和解密的RSACryptoServiceProvider类的实例

            /// <summary>
            /// 构造函数,初始化不对称加密和解密的RSACryptoServiceProvider类的实例
            /// </summary>
            public RSACrypt()
            {
                if (!string.IsNullOrEmpty(privateKey))
                {
                    _privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
                }
    
                if (!string.IsNullOrEmpty(publicKey))
                {
                    _publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
                }
            }

    其中CreateRsaProviderFromPrivateKey和CreateRsaProviderFromPublicKey方法均需要自己实现,因为RSACryptoServiceProvider提供的加密解密方法,均需把公钥和私钥转换成2进制数据。

    初始化RSACryptoServiceProvider的实例后,我们便可以实现加密和解密操作了。

            /// <summary>
            /// 解密
            /// </summary>
            /// <param name="cipherText"></param>
            /// <returns></returns>
            public string Decrypt(string cipherText)
            {
                if (_privateKeyRsaProvider == null)
                {
                    throw new Exception("_privateKeyRsaProvider is null");
                }
                return Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(System.Convert.FromBase64String(cipherText), false));
            }
    
            /// <summary>
            /// 加密
            /// </summary>
            /// <param name="text"></param>
            /// <returns></returns>
            public string Encrypt(string text)
            {
                if (_publicKeyRsaProvider == null)
                {
                    throw new Exception("_publicKeyRsaProvider is null");
                }
                return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), false));
            }

    实现效果如下:

    展开全文
  • rsa加密解密c语言算法Here you will learn about RSA algorithm in C and C++. 在这里,您将了解C和C ++中的RSA算法。 RSA Algorithm is used to encrypt and decrypt data in modern computer systems and other ...

    rsa加密解密c语言算法

    Here you will learn about RSA algorithm in C and C++.

    在这里,您将了解C和C ++中的RSA算法。

    RSA Algorithm is used to encrypt and decrypt data in modern computer systems and other electronic devices. RSA algorithm is an asymmetric cryptographic algorithm as it creates 2 different keys for the purpose of encryption and decryption. It is public key cryptography as one of the keys involved is made public. RSA stands for Ron Rivest, Adi Shamir and Leonard Adleman who first publicly described it in 1978.

    RSA算法用于在现代计算机系统和其他电子设备中加密和解密数据。 RSA算法是一种非对称密码算法,因为它创建2个不同的密钥用于加密和解密。 这是公钥密码术,因为其中涉及的密钥之一是公开的。 RSA代表Ron Rivest,Adi Shamir和Leonard Adleman,他们于1978年首次公开描述它。

    RSA makes use of prime numbers (arbitrary large numbers) to function. The public key is made available publicly (means to everyone) and only the person having the private key with them can decrypt the original message.

    RSA利用质数(任意大数)起作用。 公钥是公开可用的(对所有人均适用),只有拥有私钥的人才能解密原始消息。

    RSA Algorithm Block Diagram

    Image Source

    图片来源

    RSA算法的工作 (Working of RSA Algorithm)

    RSA involves use of public and private key for its operation. The keys are generated using the following steps:-

    RSA涉及使用公钥和私钥进行操作。 密钥使用以下步骤生成:

    1. Two prime numbers are selected as p and q

      选择两个质数作为pq

    2. n = pq which is the modulus of both the keys.

      n = pq ,这是两个键的模数。

    3. Calculate totient = (p-1)(q-1)

      计算总含量=(p-1)(q-1)

    4. Choose e such that e > 1 and coprime to totient which means gcd (e, totient) must be equal to 1, e is the public key

      选择e ,使e> 1并乘以totoient ,这意味着gcd(e,totient)必须等于1e是公钥

    5. Choose d such that it satisfies the equation de = 1 + k (totient), d is the private key not known to everyone.

      选择d使其满足等式de = 1 + k(totient)d是每个人都不知道的私钥。

    6. Cipher text is calculated using the equation c = m^e mod n where m is the message.

      使用等式c = m ^ e mod n计算密文,其中m是消息。

    7. With the help of c and d we decrypt message using equation m = c^d mod n where d is the private key.

      借助cd,我们使用等式m = c ^ d mod n解密消息,其中d是私钥。

    Note: If we take the two prime numbers very large it enhances security but requires implementation of Exponentiation by squaring algorithm and square and multiply algorithm for effective encryption and decryption. For simplicity the program is designed with relatively small prime numbers.

    注意:如果我们将两个素数取得非常大,则会提高安全性,但需要通过平方算法和平方乘算法来实现幂运算,以实现有效的加密和解密。 为简单起见,程序设计为具有相对较小的质数。

    Below is the implementation of this algorithm in C and C++.

    下面是该算法在C和C ++中的实现。

    C语言RSA算法程序 (Program for RSA Algorithm in C)

    //Program for RSA asymmetric cryptographic algorithm
    //for demonstration values are relatively small compared to practical application
     
    #include<stdio.h>
    #include<math.h>
     
    //to find gcd
    int gcd(int a, int h)
    {
        int temp;
        while(1)
        {
            temp = a%h;
            if(temp==0)
            return h;
            a = h;
            h = temp;
        }
    }
     
    int main()
    {
        //2 random prime numbers
        double p = 3;
        double q = 7;
        double n=p*q;
        double count;
        double totient = (p-1)*(q-1);
     
        //public key
        //e stands for encrypt
        double e=2;
     
        //for checking co-prime which satisfies e>1
        while(e<totient){
        count = gcd(e,totient);
        if(count==1)
            break;
        else
            e++;
        }
     
        //private key
        //d stands for decrypt
        double d;
     
        //k can be any arbitrary value
        double k = 2;
     
        //choosing d such that it satisfies d*e = 1 + k * totient
        d = (1 + (k*totient))/e;
        double msg = 12;
        double c = pow(msg,e);
        double m = pow(c,d);
        c=fmod(c,n);
        m=fmod(m,n);
     
        printf("Message data = %lf",msg);
        printf("\np = %lf",p);
        printf("\nq = %lf",q);
        printf("\nn = pq = %lf",n);
        printf("\ntotient = %lf",totient);
        printf("\ne = %lf",e);
        printf("\nd = %lf",d);
        printf("\nEncrypted data = %lf",c);
        printf("\nOriginal Message Sent = %lf",m);
     
        return 0;
    }

    C ++中的RSA算法程序 (Program for RSA Algorithm in C++)

    //Program for RSA asymmetric cryptographic algorithm
    //for demonstration values are relatively small compared to practical application
     
    #include<iostream>
    #include<math.h>
     
    using namespace std;
     
    //to find gcd
    int gcd(int a, int h)
    {
        int temp;
        while(1)
        {
            temp = a%h;
            if(temp==0)
            return h;
            a = h;
            h = temp;
        }
    }
     
    int main()
    {
        //2 random prime numbers
        double p = 3;
        double q = 7;
        double n=p*q;
        double count;
        double totient = (p-1)*(q-1);
     
        //public key
        //e stands for encrypt
        double e=2;
     
        //for checking co-prime which satisfies e>1
        while(e<totient){
        count = gcd(e,totient);
        if(count==1)
            break;
        else
            e++;
        }
     
        //private key
        //d stands for decrypt
        double d;
     
        //k can be any arbitrary value
        double k = 2;
     
        //choosing d such that it satisfies d*e = 1 + k * totient
        d = (1 + (k*totient))/e;
        double msg = 12;
        double c = pow(msg,e);
        double m = pow(c,d);
        c=fmod(c,n);
        m=fmod(m,n);
     
        cout<<"Message data = "<<msg;
        cout<<"\n"<<"p = "<<p;
        cout<<"\n"<<"q = "<<q;
        cout<<"\n"<<"n = pq = "<<n;
        cout<<"\n"<<"totient = "<<totient;
        cout<<"\n"<<"e = "<<e;
        cout<<"\n"<<"d = "<<d;
        cout<<"\n"<<"Encrypted data = "<<c;
        cout<<"\n"<<"Original Message sent = "<<m;
     
        return 0;
    }

    Output

    输出量

    RSA Algorithm in C and C++ (Encryption and Decryption)

    This article is submitted by Rahul Maheshwari. You can connect with him on facebook.

    本文由Rahul Maheshwari提交 您可以在Facebook上与他建立联系。

    Comment below if you have any queries related to above program for rsa algorithm in C and C++.

    如果您对C和C ++中的rsa算法的上述程序有任何疑问,请在下面评论。

    翻译自: https://www.thecrazyprogrammer.com/2017/03/rsa-algorithm.html

    rsa加密解密c语言算法

    展开全文
  • RSA加密算法加密解密过程解析

    千次阅读 2015-01-28 17:18:53
    RSA加密算法加密解密过程解析 原文 http://blog.csdn.net/firechungelaile/article/details/39974379 1.加密算法概述 加密算法根据内容是否可以还原分为 可逆加密和非可逆加密 。 可逆加密根据...

    RSA加密算法加密与解密过程解析

    1.加密算法概述

    加密算法根据内容是否可以还原分为 可逆加密和非可逆加密 。

    可逆加密根据其加密解密是否使用的同一个密钥而可以分为 对称加密和非对称加密。

    所谓对称加密即是指在加密和解密时使用的是同一个密钥:举个简单的例子,对一个字符串C做简单的加密处理,对于每个字符都和A做异或,形成密文S。解密的时候再用密文S和密钥A做异或,还原为原来的字符串C。这种加密方式有一个很大的缺点就是不安全,因为一旦加密用的密钥泄露了之后,就可以用这个密钥破解其他所有的密文。

    非对称加密在加密和解密过程中使用不同的密钥,即公钥和私钥。公钥用于加密,所有人都可见,私钥用于解密,只有解密者持有。就算在一次加密过程中原文和密文发生泄漏,破解者在知道原文、密文和公钥的情况下无法推理出私钥,很大程度上保证了数据的安全性。

    此处,我们介绍一种非常具有代表性的非对称加密算法,RSA加密算法。RSA算法是1977年发明的,全称是RSA Public Key System,这个Public Key就是指的公共密钥。

    2.密钥的计算获取过程 

    密钥的计算过程为:首先选择两个质数p和q,令n=p*q。

    令k=ϕ(n)=(p−1)(q−1),原理见4的分析

    选择任意整数d,保证其与k互质

    取整数e,使得[de]k=[1]k。也就是说de=kt+1,t为某一整数。

    3.RSA加密算法的使用过程

    同样以一个字符串来进行举例,例如要对字符串the art of programming进行加密,RSA算法会提供两个公钥e和n,其值为两个正整数,解密方持有一个私钥d,然后开始加密解密过程过程。

    1.      首先根据一定的规整将字符串转换为正整数z,例如对应为0到36,转化后形成了一个整数序列。

    2.      对于每个字符对应的正整数映射值z,计算其加密值M=(N^e)%n. 其中N^e表示N的e次方。

    3.      解密方收到密文后开始解密,计算解密后的值为(M^d)%n,可在此得到正整数z。

    4.      根据开始设定的公共转化规则,即可将z转化为对应的字符,获得明文。

    4.RSA加密算法原理解析

    下面分析其内在的数学原理,说到RSA加密算法就不得不说到欧拉定理。

    欧拉定理(Euler’s theorem)是欧拉在证明费马小定理的过程中,发现的一个适用性更广的定理。

    首先定义一个函数,叫做欧拉Phi函数,即ϕ(n),其中,n是一个正整数。

    ϕ(n)=总数(从1到n−1,与n互质整数)

    比如5,那么1,2,3,4,都与5互质。与5互质的数有4个。ϕ(5)=4

    再比如6,与1,5互质,与2,3,4并不互质。因此,ϕ(6)=2

    对于一个质数p来说,它和1, 2, 3, …, p – 1都互质,所以ϕ(p)=p−1。比如ϕ(7)=6,ϕ(11)=10

    欧拉定理叙述如下:

    欧拉定理:如果n是一个正整数,a是任意一个非0整数,且n和a互质。那么,a^ϕ(n)−1可以被n整除。

    推论1:如果m和n是互质的正整数。那么,ϕ(mn)=ϕ(m)ϕ(n)

    推论2:[ab]n=[[a]n[b]n]n

    证明:假设a和b除以n的余数为c1,c2。a和b可以写成a=nt1+c1,b=nt2+c2。那么,ab=n2t1t2+nt1c2+nt2c1+c1c2。因此ab除以n的余数为c1c2。即[ab]n=[a]n[b]n。

    有以上定理后,由此可以推导出RSA算法的内在原理 。

    根据欧拉定理,对于任意z,如果z与n互质,那么:

    [z^ϕ(n)]n=[z^k]n=[1]n

    因此,

    [z^(de)]n=[z^(kt+1)]n=[z^(kt)*z]n=[z^kt]n*[z]n= [z]n   因为[z^k]n = [1]n

    上面主要使用了de=kt+1以及推论2。也就是说:

    [z^(de)]n=[z]n

    根据2的推论,有

    ([z^e]n)^d=[z]n

    即d个余数相乘,因为其乘积可能大于n,所以由[ab]n=[[a]n[b]n]n,例如令a和b都为5,n为3,可知该结论

    故上式可描述为[([z^e]n)^d]n=[z]n=z,就是原数字乘方求余数,然后再乘方求余数后得到原来数字的过程,得证。

    公开的加密方式,私有的解密方式。RSA安全的关键在于很难对一个大的整数进行因子分解。

    5.RSA加密的缺点

    1)产生密钥很麻烦,受到素数产生技术的限制,因而难以做到一次一密。 2)安全性,RSA的安全性依赖于大数的因子分解,但并没有从理论上证明破译RSA的难度与大数分解难度等价,而且密码学界多数人士倾向于因子分解不是NP问题。

    3)速度太慢,由于RSA 的分组长度太大,为保证安全性,n 至少也要 600 bitx以上,使运算代价很高,尤其是速度较慢,较对称密码算法慢几个数量级;且随着大数分解技术的发展,这个长度还在增加,不利于数据格式的标准化。

    展开全文
  • RSA算法是使用整数进行加密解密运算的, 加密:在RSA公钥中包含了两个信息:公钥对应的整数e和用于取模的整数n。对于明文数字m,计算密文的公式是: m^e mod n. 解密:跟加密类似,私钥对应的指数e和用于取模的...
  • 使用PHP实现RSA算法加密解密

    千次阅读 2018-10-11 19:20:24
    本文提供使用RSA算法加密解密数据的PHP程序类(签名和验签的实现方式可以查看使用PHP实现RSA算法的签名和验签 这篇文章),封装了格式化公钥和私钥文件的方法,这样无论使用什么格式的公钥或者私钥都可以正常运行,...
  • RSA算法进行加密解密

    千次阅读 2019-02-11 23:40:52
    一、RSA简介 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。...所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥...①使用RSA算法对字符串进行私钥加密 package ThreadPool; i...
  • RSA加密/解密算法源码 C++类

    热门讨论 2008-10-07 09:56:10
    RSA 加密 解密 算法源码 C++类 RSA 加密 解密 算法源码 C++类
  • Java内置库中的java.security.* 和java.crypto.*这两个包中有很多类可以用来实现RSA算法,主要有如下两个缺陷: ① 速度低下。一个简单的RSA加密解密的程序在一个拥有2.4G Hz的CPU和512M内存的PC机上需要消耗700...
  • RSA算法加密解密

    千次阅读 2018-08-20 16:11:35
     RSA算法即RSA加密算法,这是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起...
  • 前不久移植了支付宝官方的SDK,以适用ASP.NET Core使用支付宝支付,但是最近有好几位用户反应在Linux下使用会出错,调试发现是RSA加密的错误,下面具体讲一讲。 RSA在.NET Core的改动 以前我们使用RSA加密主要是...
  • RSA加密解密算法Java

    千次阅读 2017-12-15 14:34:28
    前言  RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenA dleman开发的。...RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘
  • rsa加密解密算法

    千次阅读 2011-12-06 15:57:56
    实验名称:RSA算法 实验类型: 设计性实验 适用对象: 信息安全 一、实验目的 学习RSA算法,通过编程实现RSA算法,掌握RSA产生公钥和私钥的方法,加深对RSA...RSA算法的实现程序必须提供加密解密两个接口:int e
  • Java中利用RSA算法进行加密解密

    万次阅读 2017-02-15 17:08:05
    * 通过公钥byte[](publicKey.getEncoded())将公钥还原,适用于RSA算法 * * @param keyBytes * @return * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException */ public static PublicKey ...
  •  这篇文章主要介绍使用PHP开发接口,数据实现RSA加密解密后使用,实例分析了PHP自定义RSA类实现加密与解密的技巧,非常具有实用价值,需要的朋友可以参考下。 简单介绍RSA:  RSA加密算法是最常
  • Linux下用openssl的RSA算法对文件加密解密
  • ios下使用RSA算法加密与java后台解密配合demo

    万次阅读 热门讨论 2012-07-21 14:32:17
    RSA算法:1977年由Ron Rivest、Adi Shamirh和LenAdleman发明的,RSA就是取自他们三个人的名字。算法基于一个数论:将两个大素数相乘非常容易,但要对这个乘积的结果进行因式分解却非常困难,因此可以把乘积公开作为...
  • RSA加密解密算法

    2015-09-09 17:20:34
    RSA加密解密算法
  • RSA算法解密的C语言实现

    千次阅读 2019-12-29 21:17:33
    RSA算法解密的C语言实现一. 实现的功能二. 源代码 一. 实现的功能 用户输入明文 自动随机生成较大的数p和q,并对它们进行素性检测,检测成功之后,程序继续 计算Φ(n)的值,并求出它的所有因子 随机生成比Φ(n)...
  • RSA加密解密算法

    千次阅读 2019-02-27 20:08:09
    本次课程设计即完成RSA算法签名验证。 1.1.1 任务要求 (1)产生两个奇数,判断是否是素数。 (2)计算得到n=pq的值和φ(n)的值。 (3)设定加密用的参数e=17,用辗转相除法求得解密用的参数d。 (4)设默认要加密的...
  • 为什么80%的码农都做不了架构...bejson增加 在线RSA加密解密,RSA2加密解密(SHA256WithRSA) 地址: http://www.bejson.com/enc/rsa/ 转载于:https://my.oschina.net/ij2ee/blog/1811156
  • RSA 加密解密算法C语言 (含linux)

    热门讨论 2012-05-14 10:06:51
    RSA 加密解密算法C语言 (含linux)内含代码加实例
  • RSA算法 JS加密 JAVA解密

    万次阅读 2017-04-13 17:47:20
    有这样一个需求,前端登录的用户名密码,密码必需加密,但不可使用MD5,因为后台要检测密码的复杂度,那么在保证安全的前提下将密码传到后台呢,答案就是使用RSA非对称加密算法解决 。java代码需要依赖 commons-...
  • PHP开发接口使用RSA进行加密解密

    千次阅读 2018-05-22 22:39:24
    * RSA算法属于非对称加密算法,非对称加密算法需要两个秘钥:公开密钥(publickey)和私有秘钥(privatekey).公开密钥和私有秘钥是一对,如果公开密钥对数据进行加密,只有用对应的私有秘钥才能解密;如果私有秘钥对数据...
  • RSA算法原理——(3)RSA加解密过程及公式论证

    万次阅读 多人点赞 2018-07-04 00:16:32
    上期(RSA简介及基础数论知识)为...二、RSA算法介绍及数论知识介绍 三、RSA加解密过程及公式论证 二、RSA加解密过程及公式论证 今天的内容主要分为三个部分: rsa密钥生成过程: 讲解如何生成公钥和私钥 rs...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,282
精华内容 18,512
关键字:

rsa算法加密解密