Crypto__库在VS-2005中的使用——RSA加解密

合集下载

C#与JavaRsa加密与解密互通

C#与JavaRsa加密与解密互通Rsa 加密标准的制定已经过去了⼗多年了. 这两天在看rsa 加密的⽂章,基本上都是在说 .net 与 java 之间的 rsa加密是不能互通的.因为项⽬有⽤到,所以花了点时间对rsa加密做了⼀点点了解,发现,不管是java 还是 C# 都对 rsa 的标准加密进⾏了实现, 是对于标准是实现,不能互通就讲不过去了. 今天特意写了⼀段java 代码试了⼀下,发现是完全可以的.密钥的描述: C#(.net) 中有三种⽅式导出密钥,⼀种是blob,⼀种是 xml 另⼀种是参数,其中xml 的⽅式是把参数进⾏了 xml序列化.blob 的形式我没看懂是什么意思,只知道⽂档上说是给微软的什么api⽤的,下⾯给出其参数的形式.RSAParameters 字段Contains对应的 PKCS #1 字段d，私钥指数privateExponentd mod (p - 1) exponent1d mod (q - 1) exponent2e，公钥指数publicExponent(InverseQ)(q) = 1 mod p coefficientn modulusp prime1q prime2RSA 算法若要⽣成密钥对，可以从创建名为 p 和 q 的两个⼤的质数开始; 这两个数相乘，结果称为 n; 因为 p 和 q 都是质数，所以 n 的全部因数为 1、p、q 和 n;如果仅考虑⼩于 n 的数，则与 n 为互质数（即与 n 没有公因数）的数的个数等于 (p - 1)(q - 1);现在，选择⼀个数 e，它与计算的值为互质数; 则公钥表⽰为 {e, n};若要创建私钥，则必须计算 d，它是满⾜ (d)(e) mod n = 1 的⼀个数; 根据 Euclidean 算法，私钥为 {d, n};纯⽂本 m 到密码⽂本 c 的加密定义为 c = (m ^ e) mod n; 解密则定义为 m = (c ^ d) mod n;总之,我们可以从 .net 的rsa 中拿到合适的密钥描述就是了,⾄于 java的,我想也是可以做到的,⽽且通常密钥是应该放在密钥容器的.接下来我们⽤.net ⽣成⼀个 rsa 的密钥,以⼗六进制的⽅式输出的(new ⼀个RSACryptoServiceProvider,把密钥导出就可以了)D: 2FE7479CF4CFEE63218C44D763C3E552DC5FBC94A31F944B88AE8E58F0ED16874B8BED35307B143F413761B2ECFFC95F48DF0D0A29FC155C0B968EFE9FFF36E7DP: 6777B761BC29637622FC63682243BB2E05CCFC6FF710ADE1DCE6B0C843B17C4FDQ: 68771CCDA40F0DA0B504C438BB03F7DF30F77364094D475E70270D148260D247Exponent: 010001InverseQ: 5665AB47697008CC2CECB544B582B9C50628281C400846C1E736629B03FE5C85Modulus: B3F276C8EDF515FD3248CCF4163480B9F77443A666522D66B89411EC6DFE11DEA917A97C977750EE777DACBD4D2C11BC363FDC110E5CCA0A1361D51AFA4A7ADDP: ECC60A01B1BDCBA1C5422D8A0A34FC0E46727DB4ED5089E54C356F052E0AB573Q: C28F233948483D0CD0E3FA7B5D2955F2B15E831B38876FB0E7180D873EDF7A6F为了⽅便写.net 代码,这⾥贴⼀下blob的密钥0702000000A40000525341320002000001000100DD7A4AFA1AD561130ACA5C0E11DC3F36BC112C4DBDAC7D77EE5077977CA917A9DE11FE6DEC1194B8662D5266A64374F7B9803416F4CC4832FD15F5EDC876F2B373B50A2E056F354CE58因为是私钥,所以同时可以加密和解密.下⾯上 C# 代码,⽐较简单using System;using System.Security.Cryptography;class Program{public static void Main(string[] args){byte[] plainText = new byte[]{0,1,2,3,4,5};byte[] cipherText;byte[] key = String2Bytes("0702000000A40000525341328001000001000100D3D10816051881319774576B67B1D24F3AA303471A4402AB625208EC1CB04D508AF2098227C5EE185890ECB83E6971C12BDCF4F8AB0FD729167C815D34 using(var rsa = new RSACryptoServiceProvider()){rsa.ImportCspBlob(key);Console.WriteLine("OAEP:");Console.WriteLine(Bytes2String(rsa.Encrypt(plainText, true)));Console.WriteLine("PCSK1-v1_5:");Console.WriteLine(Bytes2String(rsa.Encrypt(plainText, false)));}Console.Write("Press any key to continue . . . ");Console.ReadKey(true);}const string pattern = @"[^0-9a-fA-F]+";static byte[] String2Bytes(string str){str = System.Text.RegularExpressions.Regex.Replace(str, pattern, "");if (str == string.Empty)return null;byte[] data = new byte[str.Length / 2];for (int i = 0; i < data.Length; ++i)data[i] = byte.Parse(str.Substring(2 * i, 2), System.Globalization.NumberStyles.HexNumber);return data;}static string Bytes2String(byte[] data){System.Text.StringBuilder builder = new System.Text.StringBuilder();foreach (var element in data) {builder.AppendFormat("{0:X2}",element);}return builder.ToString();}}运⾏后输出(rsa加密,密⽂每次都不⼀定⼀样):OAEP:87F04B0F28B81D23E63DA71C8278E0B7E357F40583BDDCAB493D44A58080EB178EC8E0DB0DCD4BE5427FDB8190229B8DF2511BDA1082607C92BD03B0615D5AD3 PCSK1-v1_5:358AB4D336D0C35DAE3895E8A125F4F5AD0FB58117A4100FAF15DE95FF8615F01FFB1A59C9B579792B7C14E93E54A3E7E236D464DDB93D8DF9D96F63F46BACD7现在我们有密⽂了,⾄于.net 的解密 .net 加密后的密⽂,我没兴趣去看,反正铁定可以的就是了.下⾯我们写java 的解密部分package rsatest;import java.math.BigInteger;import java.security.KeyFactory;import java.security.PrivateKey;import java.security.PublicKey;import java.security.spec.RSAPrivateKeySpec;import java.security.spec.RSAPublicKeySpec;import javax.crypto.Cipher;public class RsaTest {public static void main(String[] args) throws Exception {//前⾯补了个0,符号位为0,表⽰⾮负BigInteger n = new BigInteger("B3F276C8EDF515FD3248CCF4163480B9F77443A666522D66B89411EC6DFE11DEA917A97C977750EE777DACBD4D2C11BC363FDC110E5CCA0A1361D51AFA4A7ADD", 16); BigInteger e = new BigInteger("010001", 16);BigInteger d = new BigInteger("2FE7479CF4CFEE63218C44D763C3E552DC5FBC94A31F944B88AE8E58F0ED16874B8BED35307B143F413761B2ECFFC95F48DF0D0A29FC155C0B968EFE9FFF36E7", 16);RSAPublicKeySpec keySpec = new RSAPublicKeySpec(n, e);PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(keySpec);RSAPrivateKeySpec prvKeySpec = new RSAPrivateKeySpec(n, d);PrivateKey privateKey = KeyFactory.getInstance("RSA").generatePrivate(prvKeySpec);//现在key 准备好了,把前⾯的密⽂放这⾥解密byte[] oaepCiphertext = Hex2Bytes("87F04B0F28B81D23E63DA71C8278E0B7E357F40583BDDCAB493D44A58080EB178EC8E0DB0DCD4BE5427FDB8190229B8DF2511BDA1082607C92BD03B0615D5AD3");//解密OAEP 加密的数据Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPPADDING");cipher.init(Cipher.DECRYPT_MODE, privateKey);byte[] plaintext = cipher.doFinal(oaepCiphertext);System.out.println(Bytes2Hex(plaintext));//解密PKCS1-v1_5 加密的数据byte[] ciphertext = Hex2Bytes("358AB4D336D0C35DAE3895E8A125F4F5AD0FB58117A4100FAF15DE95FF8615F01FFB1A59C9B579792B7C14E93E54A3E7E236D464DDB93D8DF9D96F63F46BACD7");cipher = Cipher.getInstance("RSA");cipher.init(Cipher.DECRYPT_MODE, privateKey);plaintext = cipher.doFinal(ciphertext);System.out.println(Bytes2Hex(plaintext));}public static byte[] Hex2Bytes(String hexStr) {if (hexStr.length() % 2 != 0) {hexStr = "0" + hexStr;}byte[] bytes = new byte[hexStr.length() / 2];for (int i = 0; i < bytes.length; ++i) {bytes[i] = (byte) Integer.parseUnsignedInt(hexStr.substring(i * 2, i * 2 + 2), 16);}return bytes;}public static String Bytes2Hex(byte[] bytes) {StringBuilder builder = new StringBuilder();for (byte b : bytes) {builder.append(String.format("%02X", b));}return builder.toString();}}程序运⾏后输出:000102030405000102030405跟我们预期的是⼀样的.我们再⽤java 对明⽂加密,代码⽚段// plaintext {0,1,2,3,4,5}cipher = Cipher.getInstance("RSA/ECB/OAEPPADDING");cipher.init(Cipher.ENCRYPT_MODE, publicKey);oaepCiphertext = cipher.doFinal(plaintext);System.out.println("OAEP:");System.out.println(Bytes2Hex(oaepCiphertext));cipher = Cipher.getInstance("RSA");cipher.init(Cipher.ENCRYPT_MODE, publicKey);ciphertext = cipher.doFinal(plaintext);System.out.println("PCSK1-v1_5:");System.out.println(Bytes2Hex(ciphertext));对应输出(rsa加密,密⽂每次都不⼀定⼀样):OAEP:3144C4CB06C7F49D31E65D09C840069F7CCF602487908CCEAB33D473B949199E1795530B69E1FA20EB59E392B2B934024D46E979DEA1682BDFA61D6FDD980F9C PCSK1-v1_5:699A694BEB75616879C6B8D311CC10D987EA109D494EE6C9380CD2C02A124613F130C440CB1CA6D3405E50B62CF96A79EB43C3370253E5D8C1A9132CFE01D686接下来⽤C# 对数据解密,代码⽚段//还是⽤之前那个rsa对象//OAEPcipherText = String2Bytes("3144C4CB06C7F49D31E65D09C840069F7CCF602487908CCEAB33D473B949199E1795530B69E1FA20EB59E392B2B934024D46E979DEA1682BDFA61D6FDD980F9C"); Console.WriteLine(Bytes2String(rsa.Decrypt(cipherText, true)));//PCSK1-v1_5cipherText = String2Bytes("699A694BEB75616879C6B8D311CC10D987EA109D494EE6C9380CD2C02A124613F130C440CB1CA6D3405E50B62CF96A79EB43C3370253E5D8C1A9132CFE01D686"); Console.WriteLine(Bytes2String(rsa.Decrypt(cipherText, false)));对应的输出:000102030405000102030405解密也成功了.或许该头疼的问题是,已知 {e,n} 或者 {d,n} 怎么⽣成.net 使⽤的密钥.。

RSA加密算法(C语言实现)

RSA加密算法（C语言实现）RSA（Rivest-Shamir-Adleman）算法是一种非对称加密算法，它是目前应用最广泛的加密算法之一、RSA算法基于两个大素数之间的乘积很难分解的特性，并使用公钥和私钥进行加密和解密。

在C语言中实现RSA算法需要进行以下步骤：1.生成大素数p和q：选择两个大素数p和q，它们需要满足p≠q。

这样选取p和q是为了使得计算n=p*q变得困难，保护私钥。

2.计算n：计算n=p*q，n即为公钥和私钥的参数之一3.计算欧拉函数φ(n)：计算欧拉函数φ(n)=(p-1)*(q-1)。

4.选择e：选择一个与φ(n)互质且小于φ(n)的整数e作为加密指数，e即为公钥的参数。

5. 计算d：计算d = e^(-1) mod φ(n)，d即为私钥的参数。

可以使用扩展欧几里得算法来计算d。

6. 加密：将明文M转换为整数m，加密后的密文C = m^e mod n。

7. 解密：解密密文C得到明文M = C^d mod n。

以下是C语言实现RSA加密算法的代码示例：```c#include <stdio.h>int gcd(int a, int b)if(b == 0)}return gcd(b, a % b);int extendedGcd(int a, int b, int *x, int *y) if(a == 0)*x=0;*y=1;return b;}int x1, y1;int gcd = extendedGcd(b % a, a, &x1, &y1);*x=y1-(b/a)*x1;*y=x1;return gcd;int modInverse(int a, int m)int x, y;int gcd = extendedGcd(a, m, &x, &y);if(gcd != 1)printf("Inverse doesn't exist\n");}return (x % m + m) % m;int powerMod(int x, unsigned int y, int m) if (y == 0)return 1;}int p = powerMod(x, y/2, m) % m;p=(p*p)%m;return (y%2 == 0) ? p : (x*p) % m;int maiint p, q, n, phiN, e, d;//选择两个大素数p和qp=31;q=17;//计算n和φ(n)n=p*q;phiN = (p - 1) * (q - 1);//选择加密指数ee=7;//计算解密指数dd = modInverse(e, phiN);int plaintext = 88;int ciphertext = powerMod(plaintext, e, n);int decryptedtext = powerMod(ciphertext, d, n);printf("Plaintext: %d\n", plaintext);printf("Ciphertext: %d\n", ciphertext);printf("Decryptedtext: %d\n", decryptedtext);return 0;```在上面的代码中，我们使用了几个辅助函数来实现扩展欧几里得算法、计算模反元素和快速幂算法。

rsa算法基本原理

rsa算法基本原理RSA算法基本原理RSA是一种非对称加密算法，它的基本原理是利用大素数的因数分解困难性来实现加密和解密的过程。

RSA算法由三个步骤组成：密钥生成、加密和解密。

1. 密钥生成RSA算法中，首先需要生成一对密钥：公钥和私钥。

公钥用于加密数据，私钥用于解密数据。

密钥的生成过程如下：1.1 选择两个大素数p和q，并计算它们的乘积n=p*q。

n的长度决定了RSA算法的安全性。

1.2 计算n的欧拉函数φ(n)=(p-1)*(q-1)。

1.3 选择一个与φ(n)互质的整数e，1 < e < φ(n)。

1.4 计算e关于φ(n)的模反元素d，即满足e*d ≡ 1 (mod φ(n))的整数d，1 < d < φ(n)。

1.5 公钥为(n, e)，私钥为(n, d)。

2. 加密加密过程是指使用公钥对原始数据进行加密的过程。

加密过程如下：2.1 将原始数据转换为整数m，满足0 ≤ m < n。

2.2 计算密文c ≡ m^e (mod n)，即对m进行模n的指数操作。

2.3 密文c即为加密后的数据。

3. 解密解密过程是指使用私钥对密文进行解密的过程。

解密过程如下：3.1 计算明文m ≡ c^d (mod n)，即对密文c进行模n的指数操作。

3.2 明文m即为解密后的数据。

RSA算法的安全性基于大整数的因子分解问题的困难性，因为在当前计算能力下，对于非常大的整数进行因子分解是非常耗时的。

这使得RSA算法在现实应用中具有较高的安全性。

除了加密和解密外，RSA算法还可以用于数字签名和密钥协商等领域。

数字签名是指用私钥对数据进行签名，然后用公钥进行验证，以确保数据的完整性和来源可靠性。

密钥协商是指两个通信方通过交换公钥来协商出一个共享的对称密钥，以便进行后续的加密通信。

总结一下，RSA算法是一种基于大整数的非对称加密算法，利用大素数的因子分解困难性来实现数据的加密和解密。

它的安全性建立在大整数因子分解问题的困难性上，适用于保护数据的机密性、完整性和来源可靠性。

Python中如何使用RSA算法进行加密和解密

Python中如何使用RSA算法进行加密和解密RSA算法是一种非对称加密算法，它是由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出。

它被广泛用于网络通信、数字签名、身份验证等领域。

Python语言可以很方便地使用RSA算法进行加密和解密，本文将详细介绍如何在Python中使用RSA算法。

一、RSA算法原理RSA算法的核心原理是利用欧拉定理和模运算，实现非对称加密。

具体过程如下：1.选择两个质数p和q，计算N=p*q，并求出其欧拉函数φ(N)=(p-1)*(q-1)。

2.选择一个整数e，使得1<e<φ(N)，且e和φ(N)互质。

3.计算e关于φ(N)的模反元素d，即d*e=1 mod φ(N)。

4.公钥为(p, q, e)，私钥为(p, q, d)。

5.加密时，将明文m用公钥加密成密文c：c=m^e mod N。

6.解密时，将密文c用私钥解密成明文m：m=c^d mod N。

二、Python中使用RSA算法Python中使用RSA算法，需要使用pycryptodome库。

安装方法如下：pip install pycryptodome使用方法如下：1.生成密钥对使用RSA模块中的generate函数生成RSA密钥对。

如下：from Crypto.PublicKey import RSAkey = RSA.generate(2048)其中，2048为密钥长度，可以根据需要设置。

2.获取公钥和私钥生成密钥对之后，可以使用exportKey函数获取公钥和私钥。

如下：public_key = key.publickey().exportKey()private_key = key.exportKey()此时，public_key为公钥，private_key为私钥。

3.加密和解密使用RSA密钥对进行加密和解密时，需要使用RSA模块中的encrypt和decrypt函数。

rsa加密解密原理

rsa加密解密原理
RSA加密解密原理是基于公钥密码学的一种加密算法。

它由三个关键要素组成：公钥、私钥和模数。

首先，生成密钥对。

密钥对包括公钥和私钥，其中公钥用于加密，私钥用于解密。

生成密钥对的过程是通过选择两个大质数，计算它们的乘积作为模数n，并选择一个与(n)互质的数e作为公钥，以及计算出一个满足(ed ≡ 1 mod φ(n))的数d作为私钥。

其中，φ(n)表示小于n且与n互质的正整数的个数。

加密过程如下：
1. 将明文转换为对应的数字表示。

2. 使用公钥中的指数e和模数n，通过计算(c ≡ m^e mod n)来进行加密，得到密文c。

其中，m表示明文，c表示密文。

解密过程如下：
1. 使用私钥中的指数d和模数n，通过计算(m ≡ c^d mod n)来进行解密，得到明文m。

其中，m表示明文，c表示密文。

RSA加密解密原理的安全性基于大数分解困难性问题，即将大数分解为其质因数的问题。

在目前的计算机技术下，对于足够大的密钥长度，破解RSA加密是非常困难的。

因此，RSA算法被广泛应用于信息安全领域，例如加密通信、数字
签名等。

简单的rsa加密解密计算

简单的rsa加密解密计算
RSA加密算法是一种非对称加密算法，它使用一对密钥（公钥
和私钥）来加密和解密数据。

下面我将简单介绍RSA加密和解密的
计算过程。

1. 生成密钥对，首先，选择两个不同的大质数p和q，并计算
它们的乘积n=pq。

然后选择一个整数e，使得e与(p-1)(q-1)互质，并计算出e的模反元素d。

公钥是(n, e)，私钥是(n, d)。

2. 加密，假设要加密的消息为M，首先将消息M转换为整数m，满足0≤m<n。

然后使用公钥(n, e)进行加密，加密后的密文C等于
m的e次方再对n取模，即C≡m^e (mod n)。

3. 解密，接收到密文C后，使用私钥(n, d)进行解密，解密后
的明文M等于C的d次方再对n取模，即M≡C^d (mod n)。

下面我举一个简单的例子来说明RSA加密和解密的计算过程：
假设我们选择两个质数p=11和q=3，计算n=pq=33，然后选择
e=3，并计算d=7。

这样我们得到公钥(n, e)=(33, 3)和私钥(n,
d)=(33, 7)。

现在假设要加密的消息为M=5，将其转换为整数m=5。

使用公钥进行加密，计算C≡5^3 (mod 33)，得到C=5。

接收到密文C=5后，使用私钥进行解密，计算M≡5^7 (mod 33)，得到M=5。

因此，我们成功地将消息M=5加密为密文C=5，然后再解密回到原始消息M=5。

这就是RSA加密和解密的简单计算过程。

RSA加密解密算法

RSA加密解密算法RSA（Rivest–Shamir–Adleman）加密算法是一种非对称加密算法，也是目前最常用的公钥加密算法之一、它是由Ron Rivest、Adi Shamir 和Leonard Adleman于1977年共同开发的，取名来自他们三个人的姓氏的首字母。

RSA算法的安全性建立在两个大素数难因分解的理论上，即若一个非常大的整数，其因数分解为两个素数的乘积，那么要分解这个大整数就很困难。

该算法的基本原理是选取两个大素数p和q，并计算得到N=p*q，将N作为公钥的一部分。

公开N和一个加密指数e，而私钥则包含了p、q 和一个解密指数d。

加密时，消息经过加密指数e进行加密得到密文，解密时利用解密指数d对密文进行解密。

只有知道私钥的人才能解密得到原始消息。

具体的加密过程如下：1.选择两个不同的大素数p和q。

2.计算N=p*q。

3.计算φ(N)=(p-1)*(q-1)，φ(N)即N的欧拉函数值。

4.选择一个与φ(N)互质的加密指数e，其中1<e<φ(N)。

5.计算解密指数d，使得(e*d)%φ(N)=16.公钥为(e,N)，私钥为(d,N)。

7.将明文m转化为整数m，确保m小于N。

8.加密密文c=m^e%N。

9.解密明文m=c^d%N。

RSA算法的安全性取决于分解大整数的难度，目前没有快速的算法能够在合理的时间内分解大整数。

因此，只要选择足够大的素数p和q，RSA算法就足够安全。

RSA算法在实际应用中起到了重要的作用。

它广泛应用于数字签名、密钥交换、加密通信等领域。

它通过使用不同的指数对数据进行加密和解密，实现了安全的通信。

同时，RSA算法也具有可逆性，在现实世界中起到了非常重要的作用。

总结来说，RSA加密算法是一种非对称加密算法，它的安全性基于大整数的因数分解难度。

它广泛应用于各个领域，通过使用公钥和私钥对数据进行加密和解密，实现了安全的通信。

尽管它的运算速度较慢，但是在很多场景下，RSA算法仍然是最安全和最实用的加密算法之一。

Crypto++使用_RSA加解密

Crypto++入门-安装Crypto++是一个C++编写的密码学类库。

读过《过河卒》的朋友还记得作者的那个不愿意去微软工作的儿子吗，就是Crypto++的作者Wei Dai。

Crypto++是一个非常强大的密码学库，在密码学界很受欢迎，最初还是Rivest(RSA的R)门下的一个博士姐姐把这个库介绍给我的。

虽然网络上可以找到很多密码学相关的代码和库，但是Crypto++有其明显的优点。

主要是功能全，统一性好。

例如椭圆曲线加密算法和AES 在OpenSSL的crypto库中就还没最终完成，而在Crypto++中就支持的比较好。

基本上密码学中需要的主要功能都可以在里面找得到。

Crypto++是由标准的C++写成的，学习C++、密码学、网络安全都可以通过阅读Crypto++的源代码得到启发和提高。

Crypto++的安装:首先到上下载最新版本的源代码，如果是windows 版的，会得到一个VC的项目，直接用VC打开就可以编译了。

这里建议大家使用最新版的C++编译器，因为诸如VC6的编译器是不支持C++的标准的，很多符合C++标准的代码不能编译通过。

编译的时间比较长，完成后会生成cryptlib.lib这个库文件。

可以将Crypto++源文件的目录命名为cryptopp，拷贝到编译器的include目录（例如：C:\\VC7\include），将cryptlib.lib文件拷贝到编译器的lib目录。

这样我们只需要说明链接cryptlib.lib即可。

例如在VC7中在项目->属性->链接器->命令行->附加选项中添加“cryptlib.lib”。

Hello World现在写一个hello world程序看看能不能编译通过。

#include<iostream>using namespace std;#include<cryptopp/aes.h>using namespace CryptoPP;int main(){cout<<"hello crypto++"<<endl;cout<<"Aes block size is"<<AES::BLOCKSIZE<<endl;return0;}编译运行，一切OK，哈哈：D，可以用了。

Crypt++中文使用手册

Crypto++入门- 安装Crypto++是一个C++编写的密码学类库。

读过《过河卒》的朋友还记得作者的那个不愿意去微软工作的儿子吗，就是Crypto++的作者Wei Dai。

Crypto++是一个非常强大的密码学库，在密码学界很受欢迎，最初还是Rivest(RSA的R)门下的一个博士姐姐把这个库介绍给我的。

虽然网络上可以找到很多密码学相关的代码和库，但是Crypto++有其明显的优点。

主要是功能全，统一性好。

例如椭圆曲线加密算法和AES 在OpenSSL的crypto库中就还没最终完成，而在Crypto++中就支持的比较好。

基本上密码学中需要的主要功能都可以在里面找得到。

Crypto++是由标准的C++写成的，学习C++、密码学、网络安全都可以通过阅读Crypto++的源代码得到启发和提高。

Crypto++的安装首先到上下载最新版本的源代码，如果是windows版的，会得到一个VC 的项目，直接用VC打开就可以编译了。

这里建议大家使用最新版的C++编译器，因为诸如VC6的编译器是不支持C++的标准的，很多符合C++标准的代码不能编译通过。

编译的时间比较长，完成后会生成cryptlib.lib这个库文件。

可以将Crypto++源文件的目录命名为cryptopp，拷贝到编译器的include目录（例如：C:\\VC7\include），将cryptlib.lib文件拷贝到编译器的lib目录。

这样我们只需要说明链接cryptlib.lib即可。

例如在VC7中在项目->属性->链接器->命令行->附加选项中添加“cryptlib.lib”。

Hello World现在写一个hello world程序看看能不能编译通过。

#include <iostream>using namespace std;#include <cryptopp/aes.h>using namespace CryptoPP;int main(){cout << "hello crypto++" << endl;cout << "Aes block size is " << AES::BLOCKSIZE << endl;return 0;}编译运行，一切OK，哈哈：D，可以用了。

RSA加密解密算法

RSA加密解密算法RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，由三位密码学家发明。

RSA加密算法能够实现数据的加密、解密和数字签名的功能，广泛应用于信息安全领域。

RSA算法的基本原理是利用大数分解的困难性来保证数据的安全性。

它采用了一对公钥和私钥来进行加密和解密操作。

公钥可以公开给他人，而私钥必须由加密方保密。

具体步骤如下：1. 密钥生成：选择两个大素数p和q，计算n = p * q，计算欧拉函数ϕ(n) = (p-1) * (q-1)，选择一个与ϕ(n)互质的整数e作为公钥，计算私钥d使得(e * d) mod ϕ(n) = 12. 加密：加密方使用公钥(e,n)对明文进行加密。

明文m需小于n，计算密文c = m^e mod n。

3. 解密：解密方使用私钥(d,n)对密文进行解密。

计算明文m = c^d mod n。

RSA算法的安全性基于大数分解问题的困难性。

大数分解是指将一个大素数分解成两个素数的乘积。

目前最快的分解算法是基于数域筛选的RSA整数分解算法，其时间复杂度为O(exp((64/9)^(1/3) * (ln N)^(1/3) * (ln ln N)^(2/3)))，其中N为待分解的大数。

根据目前的计算能力，RSA算法在合适的密钥长度下是足够安全的。

除了加密和解密，RSA算法还可以用于数字签名。

数字签名可以实现身份认证和数据完整性验证。

签名方使用私钥对消息进行签名，验证方使用公钥进行验证。

签名的过程如下：1. 签名：签名方使用私钥(d,n)对消息进行签名。

计算签名值s = m^d mod n。

2. 验证：验证方使用公钥(e,n)对签名值进行验证。

计算摘要v = s^e mod n，将v与原消息进行比较。

RSA算法的应用非常广泛。

在网络通信中，RSA算法可用于保护数据的机密性；在数字货币领域，RSA算法可用于数字签名和加密；在电子商务中，RSA算法可用于保护用户的隐私信息等。

Crypto++使用_RSA加解密

Crypto++入门- 安装Crypto++是一个C++编写的密码学类库。

读过《过河卒》的朋友还记得作者的那个不愿意去微软工作的儿子吗，就是Crypto++的作者Wei Dai。

Crypto++是一个非常强大的密码学库，在密码学界很受欢迎，最初还是Rivest(RSA的R)门下的一个博士姐姐把这个库介绍给我的。

虽然网络上可以找到很多密码学相关的代码和库，但是Crypto++有其明显的优点。

主要是功能全，统一性好。

例如椭圆曲线加密算法和AES 在OpenSSL的crypto库中就还没最终完成，而在Crypto++中就支持的比较好。

基本上密码学中需要的主要功能都可以在里面找得到。

Crypto++是由标准的C++写成的，学习C++、密码学、网络安全都可以通过阅读Crypto++的源代码得到启发和提高。

Crypto++的安装:首先到上下载最新版本的源代码，如果是windows 版的，会得到一个VC的项目，直接用VC打开就可以编译了。

这里建议大家使用最新版的C++编译器，因为诸如VC6的编译器是不支持C++的标准的，很多符合C++标准的代码不能编译通过。

编译的时间比较长，完成后会生成cryptlib.lib这个库文件。

可以将Crypto++源文件的目录命名为cryptopp，拷贝到编译器的include目录（例如：C:\\VC7\include），将cryptlib.lib文件拷贝到编译器的lib目录。

这样我们只需要说明链接cryptlib.lib即可。

例如在VC7中在项目->属性->链接器->命令行->附加选项中添加“cryptlib.lib”。

Hello World现在写一个hello world程序看看能不能编译通过。

#include <iostream>using namespace std;#include <cryptopp/aes.h>using namespace CryptoPP;int main(){cout << "hello crypto++" << endl;cout << "Aes block size is " << AES::BLOCKSIZE << endl;return 0;}编译运行，一切OK，哈哈：D，可以用了。

python中crypto-js 加密方法

python中crypto-js 加密方法在Python中使用CryptoJS进行加密有几种方法，包括使用AES加密，使用DES加密，以及使用RSA加密。

下面将逐一介绍这几种加密方法。

1. 使用AES加密AES（Advanced Encryption Standard）是一种对称加密算法，可以使用CryptoJS库在Python中进行AES加密。

以下是使用AES加密的步骤：安装CryptoJS库：在Python中，可以使用pip命令安装CryptoJS库：pip install cryptojs导入相关模块：pythonfrom Crypto.Cipher import AESimport base64创建AES对象并设置加密密钥：pythonkey = '1234567890123456' # 16位密钥iv = '1234567890123456' # 16位初始向量cipher = AES.new(key, AES.MODE_CBC, iv)进行加密：pythontext = 'Hello, World!' # 待加密的文本ciphertext = cipher.encrypt(text)进行解密：pythondecipher = AES.new(key, AES.MODE_CBC, iv)plain_text = decipher.decrypt(ciphertext)print(plain_text)以上就是使用AES加密的基本步骤，在实际应用中可以根据需要对密钥进行动态生成等处理。

2. 使用DES加密DES（Data Encryption Standard）是一种对称加密算法，同样可以使用CryptoJS库在Python中进行DES加密。

以下是使用DES加密的步骤：安装CryptoJS库：在Python中，可以使用pip命令安装CryptoJS库：pip install cryptojs导入相关模块：pythonfrom Crypto.Cipher import DESimport base64创建DES对象并设置加密密钥：pythonkey = '12345678' # 8位密钥cipher = DES.new(key, DES.MODE_ECB)进行加密：pythontext = 'Hello, World!' # 待加密的文本ciphertext = cipher.encrypt(text.ljust(8))进行解密：pythondecipher = DES.new(key, DES.MODE_ECB)plain_text = decipher.decrypt(ciphertext)print(plain_text)3. 使用RSA加密RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，可以使用CryptoJS 库在Python中进行RSA加密。

rsa_public_encrypt 用法

rsa_public_encrypt 用法rsa_public_encrypt是openssl库中的函数，用于进行RSA公钥加密操作。

RSA公钥加密是一种非对称加密算法，它使用公钥进行加密操作，而私钥用于解密。

在加密过程中，只有使用私钥才能解密出原始明文。

函数原型如下：cint rsa_public_encrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);参数说明：- flen: 要加密的数据长度（以字节为单位）- from: 待加密的数据- to: 加密后的数据- rsa: RSA公钥结构体指针- padding: 填充类型，常见的有RSA_PKCS1_PADDING和RSA_NO_PADDING返回值：- 成功返回加密后的数据长度，失败返回-1使用示例：c#include <openssl/rsa.h>#include <openssl/pem.h>int main() {RSA *rsa_pubkey = RSA_new(); 创建RSA结构体FILE *pubkey_file = fopen("public_key.pem", "rb"); 打开公钥文件PEM_read_RSA_PUBKEY(pubkey_file, &rsa_pubkey, 0, NULL); 读取公钥unsigned char input[] = "Hello, RSA!";unsigned char output[256]; 加密后的数据存放在output中，长度不超过RSA_size(rsa_pubkey)int encrypted_length = rsa_public_encrypt(strlen((const char *)input), input, output, rsa_pubkey, RSA_PKCS1_PADDING);if (encrypted_length == -1) {printf("Encryption failed!\n");ERR_print_errors_fp(stdout);return 1;}printf("Encrypted message: ");for (int i = 0; i < encrypted_length; ++i) {printf("%02x", output[i]);}printf("\n");RSA_free(rsa_pubkey); 释放RSA结构体fclose(pubkey_file); 关闭公钥文件return 0;}注意事项：- 为了使用rsa_public_encrypt函数，首先需要准备一对RSA密钥，其中公钥用于加密，私钥用于解密。

rsa公钥解密javascript方法

rsa公钥解密javascript方法
RSA（Rivest–Shamir–Adleman）是一种非对称加密算法，其中涉及公钥和私钥的使用。

公钥用于加密数据，而私钥用于解密数据。

然而，重要的是要理解，虽然公钥可以用于加密数据，但它不能用于解密数据。

解密RSA 加密的数据需要使用相应的私钥。

在JavaScript中，你通常会使用像node-rsa或jsencrypt这样的库来处理RSA加密和解密，因为直接处理大数的运算（这是RSA加密的基础）可能很复杂，而且容易出错。

这些库为我们处理了所有的底层数学运算，让我们能够简单地使用RSA。

如果你想在JavaScript中解密由RSA公钥加密的数据，这通常意味着你有一个误解。

你应该使用私钥来解密数据。

下面是一个使用node-rsa库进行RSA解密的示例：
首先，你需要安装node-rsa库：
然后，你可以使用以下代码进行解密：
请注意，上述代码中的key是一个私钥实例。

如果你尝试使用公钥实例来解密数据，它将失败，因为公钥不能用于解密。

总之，虽然RSA公钥加密的数据可以使用任何相应的公钥来解密，但私钥加密的数据只能使用相应的私钥来解密。

如果你尝试使用公钥来解密私钥加密的数据，你会得到一个错误，因为这不是RSA加密的工作原理。

linux中crypt的用法

Linux中crypt的用法1.简介在L in ux系统中，cr y pt是一个用于加密数据的命令行工具。

它可以通过使用不同的加密算法，对文件或文本进行加密和解密操作。

本文将介绍c ry pt的用法，包括使用步骤、常用的加密算法以及实际应用场景。

2.使用步骤使用cr yp t进行加密和解密操作的步骤如下：1.打开终端，进入Li n ux系统。

2.输入cr yp t命令，根据提示输入要加密的文件名或文本。

3.选择合适的加密算法并输入密码。

4.执行加密或解密操作。

3.常用的加密算法在L in ux中，cr ypt支持多种常用的加密算法，包括以下几种：3.1D E S算法D E S（Da ta En cr yp ti o nS ta nd ar d）是一种对称加密算法。

在使用D E S进行加密时，需要输入一个8字节的密钥。

该算法已不再被视为安全算法，因为它的密钥长度太短，容易受到暴力破解攻击。

3.2A E S算法A E S（Ad va nc ed En cr y pt io nS ta nd ar d）是一种高级加密标准。

它是一种对称加密算法，使用128位、192位或256位的密钥进行加密和解密。

AE S算法被广泛应用于各种领域，包括数据存储、网络传输等。

3.3R S A算法R S A是一种非对称加密算法，其中公钥用于加密数据，私钥用于解密数据。

R SA算法的安全性依赖于大质数分解的困难性。

它通常用于数据传输的身份验证和密钥交换。

4.实际应用场景L i nux中cr yp t命令的实际应用场景有很多，以下是其中的一些例子：4.1文件加密用户可以使用cr ypt命令对敏感文件进行加密，以保护其机密性。

例如，可以将包含个人身份信息的文件加密，只有拥有密码的人才能解密并查看文件内容。

4.2系统管理员使用系统管理员可以使用c ry pt命令对系统配置文件进行加密，以防止非授权人员篡改或查看文件内容。

这可以提高系统的安全性和稳定性。

RSA加解密私钥加密公钥解密私加公解C++调用openssl库的代码实例

RSA加解密私钥加密公钥解密私加公解C++调⽤openssl库的代码实例前提：秘钥长度=1024============================================== 对⼀⽚（117字节）明⽂加密私加==============================================// 私钥加密std::string rsa_pri_encrypt(const std::string &clearText, std::string &pubKey){std::string strRet;BIO *keybio = BIO_new_mem_buf((unsigned char *)pubKey.c_str(), -1);// 此处有三种⽅法// 1, 读取内存⾥⽣成的密钥对，再从内存⽣成rsa// 2, 读取磁盘⾥⽣成的密钥对⽂本⽂件，在从内存⽣成rsa// 3，直接从读取⽂件指针⽣成rsa//RSA* pRSAPublicKey = RSA_new();RSA* rsa = RSA_new();rsa = PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);if (!rsa){BIO_free_all(keybio);return std::string("");}int len = RSA_size(rsa);//int len = 1028;char *encryptedText = (char *)malloc(len + 1);memset(encryptedText, 0, len + 1);// 加密int ret = RSA_private_encrypt(clearText.length(), (const unsigned char*)clearText.c_str(), (unsigned char*)encryptedText, rsa, RSA_PKCS1_PADDING);if (ret >= 0)strRet = std::string(encryptedText, ret);// 释放内存free(encryptedText);BIO_free_all(keybio);RSA_free(rsa);return strRet;}============================================== 对⼀⽚（128字节）密⽂解密公解==============================================// 公钥解密std::string rsa_pub_decrypt(const std::string &clearText, std::string &pubKey){std::string strRet;BIO *keybio = BIO_new_mem_buf((unsigned char *)pubKey.c_str(), -1);//keybio = BIO_new_mem_buf((unsigned char *)strPublicKey.c_str(), -1);// 此处有三种⽅法// 1, 读取内存⾥⽣成的密钥对，再从内存⽣成rsa// 2, 读取磁盘⾥⽣成的密钥对⽂本⽂件，在从内存⽣成rsa// 3，直接从读取⽂件指针⽣成rsa//RSA* pRSAPublicKey = RSA_new();RSA* rsa = RSA_new();rsa = PEM_read_bio_RSAPublicKey(keybio, &rsa, NULL, NULL);if (!rsa){BIO_free_all(keybio);return std::string("");}int len = RSA_size(rsa);//int len = 1028;char *encryptedText = (char *)malloc(len + 1);memset(encryptedText, 0, len + 1);//解密int ret = RSA_public_decrypt(clearText.length(), (const unsigned char*)clearText.c_str(), (unsigned char*)encryptedText, rsa, RSA_PKCS1_PADDING);if (ret >= 0)strRet = std::string(encryptedText, ret);// 释放内存free(encryptedText);BIO_free_all(keybio);RSA_free(rsa);return strRet;}============================================== 对整体明⽂加密私加==============================================//私钥加密 + 分⽚std::string rsa_pri_split117_encrypt(const std::string &clearText, std::string &pubKey) {std::string result;std::string input;result.clear();for(int i = 0 ; i < clearText.length()/117; i++){input.clear();input.assign(clearText.begin() + i*117, clearText.begin() + i*117 + 117);result = result + rsa_pri_encrypt(input, pubKey);}if( clearText.length()%117 != 0){int tem1 = clearText.length()/117*117;int tem2 = clearText.length() - tem1;input.clear();input.assign(clearText.begin()+ tem1, clearText.end());result = result + rsa_pri_encrypt(input, pubKey);}return result;}============================================== 对整体密⽂解密公解==============================================//公钥解密 + 分⽚std::string rsa_pub_split128_decrypt(const std::string &clearText, std::string &pubKey) {//Base64 *base = new Base64();std::string result;std::string input;result.clear();for(int i = 0 ; i< clearText.length()/128; i++){input.clear();input.assign(clearText.begin() + i*128, clearText.begin() + i*128 + 128);result = result + rsa_pub_decrypt(input, pubKey);}if(clearText.length()%128 != 0){int tem1 = clearText.length()/128 * 128;int tem2 = clearText.length() - tem1;input.clear();input.assign(clearText.begin()+ tem1, clearText.end());result = result + rsa_pri_encrypt(input, pubKey);}return result;}附1：附2：。

C#使用RSA证书文件加密和解密示例

C#使⽤RSA证书⽂件加密和解密⽰例修改MSDN上的⽰例，使之可以通过RSA证书⽂件加密和解密，中间遇到⼀个⼩问题。

Q:执⾏ExportParameters()⽅法时，回报CryptographicException:该项不适于在指定状态下使⽤(Key not valid for use in specified state)。

A：导⼊带有私钥的证书时，需要使⽤"X509KeyStorageFlags"参数标记"私钥可导出"。

X509Certificate2 prvcrt = new X509Certificate2(@"X:\path\to\CA.pfx", "***password***", X509KeyStorageFlags.Exportable);以下为⽰例程序：View Codeusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace TeatApp_Crypto{using System;using System.Security.Cryptography;using System.Security.Cryptography.X509Certificates;using System.Text;class RSACSPSample{static void Main(){try{//Create a UnicodeEncoder to convert between byte array and string.UnicodeEncoding ByteConverter = new UnicodeEncoding();//Create byte arrays to hold original, encrypted, and decrypted data.byte[] dataToEncrypt = ByteConverter.GetBytes("Data to Encrypt");byte[] encryptedData;byte[] decryptedData;X509Certificate2 pubcrt = new X509Certificate2(@"X:\path\to\CA.crt");RSACryptoServiceProvider pubkey = (RSACryptoServiceProvider)pubcrt.PublicKey.Key;X509Certificate2 prvcrt = new X509Certificate2(@"X:\path\to\CA.pfx", "***password***", X509KeyStorageFlags.Exportable);RSACryptoServiceProvider prvkey = (RSACryptoServiceProvider)prvcrt.PrivateKey;//Create a new instance of RSACryptoServiceProvider to generate//public and private key data.//using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())//{//Console.WriteLine(RSA.ToXmlString(false));//Pass the data to ENCRYPT, the public key information//(using RSACryptoServiceProvider.ExportParameters(false),//and a boolean flag specifying no OAEP padding.encryptedData = RSAEncrypt(dataToEncrypt, pubkey.ExportParameters(false), false);Console.WriteLine("Encrypted plaintext: {0}", Convert.ToBase64String(encryptedData));//Pass the data to DECRYPT, the private key information//(using RSACryptoServiceProvider.ExportParameters(true),//and a boolean flag specifying no OAEP padding.decryptedData = RSADecrypt(encryptedData, prvkey.ExportParameters(true), false);//Display the decrypted plaintext to the console.Console.WriteLine("Decrypted plaintext: {0}", ByteConverter.GetString(decryptedData));//}prvkey.Clear();pubkey.Clear();Console.Read();}catch (ArgumentNullException){//Catch this exception in case the encryption did//not succeed.Console.WriteLine("Encryption failed.");}}static public byte[] RSAEncrypt(byte[] DataToEncrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding){try{byte[] encryptedData;//Create a new instance of RSACryptoServiceProvider.using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()){//Import the RSA Key information. This only needs//toinclude the public key information.RSA.ImportParameters(RSAKeyInfo);//Encrypt the passed byte array and specify OAEP padding.//OAEP padding is only available on Microsoft Windows XP or//later.encryptedData = RSA.Encrypt(DataToEncrypt, DoOAEPPadding);}return encryptedData;}//Catch and display a CryptographicException//to the console.catch (CryptographicException e){Console.WriteLine(e.Message);return null;}}static public byte[] RSADecrypt(byte[] DataToDecrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding) {try{byte[] decryptedData;//Create a new instance of RSACryptoServiceProvider.using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider()){//Import the RSA Key information. This needs//to include the private key information.RSA.ImportParameters(RSAKeyInfo);//Decrypt the passed byte array and specify OAEP padding.//OAEP padding is only available on Microsoft Windows XP or//later.decryptedData = RSA.Decrypt(DataToDecrypt, DoOAEPPadding);}return decryptedData;}//Catch and display a CryptographicException//to the console.catch (CryptographicException e){Console.WriteLine(e.ToString());return null;}}}}。

同时兼容JS和C#的RSA加密解密算法详解（对web提交的数据加密传输）

同时兼容JS和C#的RSA加密解密算法详解（对web提交的数据加密传输）前⾔我们在Web应⽤中往往涉及到敏感的数据，由于HTTP协议以明⽂的形式与服务器进⾏交互，因此可以通过截获请求的数据包进⾏分析来盗取有⽤的信息。

虽然https可以对传输的数据进⾏加密，但是必须要申请证书（⼀般都是收费的），成本较⾼。

那么问题来了，如果对web提交的敏感数据进⾏加密呢？web应⽤中，前端的数据处理和交互基本上都是靠javascript来完成，后台的逻辑处理可以C#(java)等进⾏处理。

微软的C#中虽然有RSA算法，但是格式和OpenSSL⽣成的公钥/私钥⽂件格式并不兼容。

这个也给贯通前后台的RSA加密解密带来了难度。

为了兼容OpenSSL⽣成的公钥/私钥⽂件格式，贯通javascript和C#的RSA加密解密算法，必须对C#内置的⽅法进⾏再度封装。

下⾯以登录为例，⽤户在密码框输⼊密码后，javascript发送ajax请求时，对密码先进⾏rsa加密后再发送，服务器接收到加密后的密码后，先对其进⾏解密，然后再验证登录是否成功。

1、为了进⾏RSA加密解密，⾸先需要⽤openssl⽣成⼀对公钥和私钥（没有的先下载openssl)：1）打开openssl.exe⽂件，输⼊ genrsa -out openssl_rsa_priv.pem 1024此命令在openssl.exe同⽬录下⽣成openssl_rsa_private_key.pem⽂件。

2）⽣成公钥 rsa -in openssl_rsa__private.pem -pubout -out openssl_rsa__public.pem以上命令会创建如下的⽂件：这个⽂件可以⽤⽂本编辑器进⾏打开，查看内容。

-----BEGIN PUBLIC KEY-----MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0w036ClSD0LvxPROMun0u022ROJlZE6P3m+gjq3gpi4n7lo8jhTqMqgccDbVJqnIfMzWS9O3lnlQXWTxJ3B4XJ52FAcriY5brOXUVgBLx5QMHLLd1gtJnmG4i7r4ytgX7XVKRnojR6zca1YnS0lbGGDF1CGllB1riNrdksSQP+wIDAQAB-----END PUBLIC KEY----------BEGIN RSA PRIVATE KEY-----MIICXQIBAAKBgQC0w036ClSD0LvxPROMun0u022ROJlZE6P3m+gjq3gpi4n7lo8jhTqMqgccDbVJqnIfMzWS9O3lnlQXWTxJ3B4XJ52FAcriY5brOXUVgBLx5QMHLLd1gtJnmG4i7r4ytgX7XVKRnojR6zca1YnS0lbGGDF1CGllB1riNrdksSQP+wIDAQABAoGAIOyl6lIxXKULZoBKbEqXfIz0GwxlGg1ywyn5mW2lAGQzKMken0ioBnD9xIVWrOlHyhkIvBCyuC0jgfE2Avn93MlB3j0WRuXMFlJpCBlEklMilO9Zgmwl+vTB3VZb8VzdrEEEUBio7LWP/KvSo+IFlNjDTKgAczbLTwAmj4w6g0ECQQDm4yxPdxcU2ywZ7PyjIMM9qnSah9KcrjU8gjEyHsUpgTjhw1cx7Peo+vRiHqxDy1yaSu1BlwRR52pCjKNnl0QhAkEAyGx3NxEIiLk2oXGGbIMZ4P6geC8gYu01BiRNWVf0Yi7+sCH68eUPoI+G5bJ8bvzXpvHjQi0s2OlRfct/qtPQmwJBALa+2DONbxdy4lUi3lO/esk0QVaOaoTY3gomggnJkQRo4zzOABXkGaIF/6gp3u9J5uG4rFFd1m19XP2Pk0ZK1AECQBYilJAKW4zuF7CA3z3AxOzqckKTwdnrJL4G6FwDsMPfONWvCw4IJE+xSk64BbIkTpTrhhPa9WcHba6c+P6e4h0CQQDWeGMMpkqPG/w4afNCGmvRnM8vNkGUAmDGvCsfkTIDijpKl5SD55hPHsWE5rsv1TLUpkWtrFBcg61bHwMUP3cv-----END RSA PRIVATE KEY-----2、⽤jsencrypt对密码进⾏加密：⾸先需要导⼊js包⽂件<script src="dist/js/jsencrypt.js"></script>var encrypt = new JSEncrypt();var pubkey = "-----BEGIN PUBLIC KEY----- \MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDAj0dPnBMf3Z4VT1B8Ee6bjKNs \hlYj7xvGijAa8RCdmGR7mrtrExnk8mdUlwdcS05gc4SSFOyWJcYtKUHpWn8/pkS0 \vgGOl9Bzn0Xt9hiqTb3pZAfykNrMDGZMgJgfD6KTnfzVUAOupvxjcGkcoj6/vV5I \eMcx8mT/z3elfsDSjQIDAQAB \-----END PUBLIC KEY-----";encrypt.setPublicKey(pubkey);var encrypted = encrypt.encrypt($('#txtpwd').val());//console.log(encrypted);$.ajax({type: "POST",url: "http://localhost:24830/services/rsa_pem.ashx",data: { "pwd": encrypted },dataType: "Json",error: function (xhr, status, error) {// alert(error);$("#txtInfo").text(' 请求服务器失败！');$(that).text('登录');$(that).attr('disabled', false);},success: function (json) {if (uid == "admin" && json.data=="000") {window.location.href = "index.html";}else {$("#txtInfo").text(' ⽤户名或者密码错误！');$(that).text('登录');$(that).attr('disabled', false);}}});3、后台⽤C#进⾏解密using System;using System.Collections.Generic;using System.IO;using System.Linq;using System.Security.Cryptography;using System.Text;using System.Threading.Tasks;namespace CMCloud.SaaS{public class RSACryptoService{private RSACryptoServiceProvider _privateKeyRsaProvider;private RSACryptoServiceProvider _publicKeyRsaProvider;/// <summary>/// RSA解密/// </summary>/// <param name="cipherText"></param>/// <returns></returns>public string Decrypt(string cipherText){if (_privateKeyRsaProvider == null){throw new Exception("_privateKeyRsaProvider is null");}return Decrypt2(cipherText);}/// <summary>/// RSA加密/// </summary>/// <param name="text"></param>/// <returns></returns>public string Encrypt(string text){if (_publicKeyRsaProvider == null){throw new Exception("_publicKeyRsaProvider is null");}return Encrypt2(text);//return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), false)); }private string Encrypt2(string text){Byte[] PlaintextData = Encoding.UTF8.GetBytes(text);int MaxBlockSize = _publicKeyRsaProvider.KeySize / 8 - 11;//加密块最⼤长度限制if (PlaintextData.Length <= MaxBlockSize){return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(PlaintextData, false));}else{using (MemoryStream PlaiStream = new MemoryStream(PlaintextData))using (MemoryStream CrypStream = new MemoryStream()){Byte[] Buffer = new Byte[MaxBlockSize];int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);while (BlockSize > 0){Byte[] ToEncrypt = new Byte[BlockSize];Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);Byte[] Cryptograph = _publicKeyRsaProvider.Encrypt(ToEncrypt, false);CrypStream.Write(Cryptograph, 0, Cryptograph.Length);BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);}return Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);}}}private string Decrypt2(string ciphertext){Byte[] CiphertextData = Convert.FromBase64String(ciphertext);int MaxBlockSize = _privateKeyRsaProvider.KeySize / 8; //解密块最⼤长度限制if (CiphertextData.Length <= MaxBlockSize)return System.Text.Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(CiphertextData, false)); using (MemoryStream CrypStream = new MemoryStream(CiphertextData))using (MemoryStream PlaiStream = new MemoryStream()){Byte[] Buffer = new Byte[MaxBlockSize];int BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);while (BlockSize > 0){Byte[] ToDecrypt = new Byte[BlockSize];Array.Copy(Buffer, 0, ToDecrypt, 0, BlockSize);Byte[] Plaintext = _privateKeyRsaProvider.Decrypt(ToDecrypt, false);PlaiStream.Write(Plaintext, 0, Plaintext.Length);BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);}return System.Text.Encoding.UTF8.GetString(PlaiStream.ToArray());}}public RSACryptoService(string privateKey, string publicKey = null){if (!string.IsNullOrEmpty(privateKey)){_privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);}if (!string.IsNullOrEmpty(publicKey)){_publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);}}private RSACryptoServiceProvider CreateRsaProviderFromPrivateKey(string privateKey) {var privateKeyBits = System.Convert.FromBase64String(privateKey);var RSA = new RSACryptoServiceProvider();var RSAparams = new RSAParameters();using (BinaryReader binr = new BinaryReader(new MemoryStream(privateKeyBits))){byte bt = 0;ushort twobytes = 0;twobytes = binr.ReadUInt16();if (twobytes == 0x8130)binr.ReadByte();else if (twobytes == 0x8230)binr.ReadInt16();elsethrow new Exception("Unexpected value read binr.ReadUInt16()");twobytes = binr.ReadUInt16();if (twobytes != 0x0102)throw new Exception("Unexpected version");bt = binr.ReadByte();if (bt != 0x00)throw new Exception("Unexpected value read binr.ReadByte()");RSAparams.Modulus = binr.ReadBytes(GetIntegerSize(binr));RSAparams.Exponent = binr.ReadBytes(GetIntegerSize(binr));RSAparams.D = binr.ReadBytes(GetIntegerSize(binr));RSAparams.P = binr.ReadBytes(GetIntegerSize(binr));RSAparams.Q = binr.ReadBytes(GetIntegerSize(binr));RSAparams.DP = binr.ReadBytes(GetIntegerSize(binr));RSAparams.DQ = binr.ReadBytes(GetIntegerSize(binr));RSAparams.InverseQ = binr.ReadBytes(GetIntegerSize(binr));}RSA.ImportParameters(RSAparams);return RSA;}private 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();elseif (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 RSACryptoServiceProvider CreateRsaProviderFromPublicKey(string publicKeyString){// encoded OID sequence for PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 }; byte[] x509key;byte[] seq = new byte[15];int x509size;x509key = Convert.FromBase64String(publicKeyString);x509size = x509key.Length;// --------- Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob ------using (MemoryStream mem = new MemoryStream(x509key)){using (BinaryReader binr = new BinaryReader(mem)) //wrap Memory Stream with BinaryReader for easy reading {byte bt = 0;ushort twobytes = 0;twobytes = binr.ReadUInt16();if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)binr.ReadByte(); //advance 1 byteelse if (twobytes == 0x8230)binr.ReadInt16(); //advance 2 byteselsereturn null;seq = binr.ReadBytes(15); //read the Sequence OIDif (!CompareBytearrays(seq, SeqOID)) //make sure Sequence for OID is correctreturn null;twobytes = binr.ReadUInt16();if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)binr.ReadByte(); //advance 1 byteelse if (twobytes == 0x8203)binr.ReadInt16(); //advance 2 byteselsereturn null;bt = binr.ReadByte();if (bt != 0x00) //expect null byte nextreturn null;twobytes = binr.ReadUInt16();if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)binr.ReadByte(); //advance 1 byteelse if (twobytes == 0x8230)binr.ReadInt16(); //advance 2 byteselsereturn null;twobytes = binr.ReadUInt16();byte lowbyte = 0x00;byte highbyte = 0x00;if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)lowbyte = binr.ReadByte(); // read next bytes which is bytes in moduluselse if (twobytes == 0x8202){highbyte = binr.ReadByte(); //advance 2 byteslowbyte = binr.ReadByte();}elsereturn null;byte[] modint = { lowbyte, highbyte, 0x00, 0x00 }; //reverse byte order since asn.1 key uses big endian orderint modsize = BitConverter.ToInt32(modint, 0);int firstbyte = binr.PeekChar();if (firstbyte == 0x00){ //if first byte (highest order) of modulus is zero, don't include itbinr.ReadByte(); //skip this null bytemodsize -= 1; //reduce modulus buffer size by 1}byte[] modulus = binr.ReadBytes(modsize); //read the modulus bytesif (binr.ReadByte() != 0x02) //expect an Integer for the exponent datareturn null;int expbytes = (int)binr.ReadByte(); // should only need one byte for actual exponent data (for all useful values)byte[] exponent = binr.ReadBytes(expbytes);// ------- create RSACryptoServiceProvider instance and initialize with public key -----RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();RSAParameters RSAKeyInfo = new RSAParameters();RSAKeyInfo.Modulus = modulus;RSAKeyInfo.Exponent = exponent;RSA.ImportParameters(RSAKeyInfo);return RSA;}}}private 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;}}}虽然将公钥暴露在js⽂件中，但是如果需要解密得到明⽂，必须需要私钥（这个存储在后台，不容易获取）。

实验四RSA加解密算法的实现

实验四RSA加解密算法的实现RSA加解密算法是一种非对称加解密算法，可以用于数据的安全传输与存储。

本实验旨在通过实现RSA加解密算法，进一步了解该算法的原理与实现过程。

1.RSA算法原理RSA算法基于数论中的欧拉定理和大素数分解难题。

其原理如下：(1)选择两个大素数p和q，并计算它们的乘积n。

(2)计算欧拉函数φ(n)=(p-1)(q-1)。

(3)选择一个小于φ(n)且与φ(n)互质的整数e，作为公钥的指数。

(4) 求解模方程e·d≡1(mod φ(n))，得到整数 d，作为私钥的指数。

(5)公钥为(n,e)，私钥为(n,d)。

(6) 加密时，将明文 m 使用公钥加密得到密文 c，即c≡m^e(mod n)。

(7) 解密时，将密文 c 使用私钥解密得到明文 m，即m≡c^d(mod n)。

2.RSA加解密算法实现为了实现RSA加解密算法，我们需要完成以下几个步骤：(1)选取两个大素数p和q，并计算n和φ(n)。

(2)选择一个与φ(n)互质的整数e。

(3) 计算 d，满足e·d≡1(mod φ(n))。

(4)加密明文m，计算密文c。

(5)解密密文c，计算明文m。

3.代码实现以下是RSA加解密算法的Python代码实现：```pythonimport randomdef is_prime(n):if n <= 1:return Falsefor i in range(2, int(n ** 0.5) + 1):if n % i == 0:return Falsereturn Truedef gcd(a, b):while b:a,b=b,a%breturn adef extended_gcd(a, b):if b == 0:return a, 1, 0g, x, y = extended_gcd(b, a % b) return g, y, x - (a // b) * y def generate_keys(:p = random.randint(100, 1000) while not is_prime(p):p+=1q = random.randint(100, 1000) while not is_prime(q):q+=1n=p*qphi_n = (p - 1) * (q - 1)e = random.randint(2, phi_n - 1) while gcd(e, phi_n) != 1:e+=1_, d, _ = extended_gcd(e, phi_n) d = d % phi_nreturn (n, e), (n, d)def encrypt(message, public_key):n, e = public_keycipher_text = []for char in message:cipher = pow(ord(char), e, n)cipher_text.append(cipher)return cipher_textdef decrypt(cipher_text, private_key):n, d = private_keyplain_text = ""for cipher in cipher_text:plain = pow(cipher, d, n)plain_text += chr(plain)return plain_text#测试public_key, private_key = generate_keys message = "Hello RSA!"cipher_text = encrypt(message, public_key) plain_text = decrypt(cipher_text, private_key)print("明文:", message)print("密文:", cipher_text)print("解密后的明文:", plain_text)```4.实验结果与分析运行以上代码，我们可以得到以下结果：```明文: Hello RSA!密文:[852,295,295,247,282,831,425,898,596,898,968,613,851,852,852]解密后的明文: Hello RSA!```可以看到，明文经过加密后得到了一串数字密文，再经过解密后可以得到原始的明文信息。