RSA算法分析与编程实现
RSA加密算法_源代码__C语言实现
RSA算法
1978年就出现了这种算法，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir和Leonard Adleman。但RSA的安全性一直未能得到理论上的证明。
RSA的安全性依赖于大数难于分解这一特点。公钥和私钥都是两个大素数（大于100个十进制位）的函数。据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积。
} b--; //c=a * c % n; //这里也会溢出，若把64位整数拆为两个32位整数不知是否可以解决这个问题。
c=MulMod(a, c, n);
} return c;
}/*
Rabin-Miller素数测试，通过测试返回1，否则返回0。
n是待测素数。
注意：通过测试并不一定就是素数，非素数通过测试的概率是1/4
5,
7,
11,
13,
17,
19,
23,
29,
RSA的C语言算法实现
三、程序运行结果及相关说明 主函数实现求 N 的欧拉数、由公钥求解私钥、加密解密选择以及相应的密文明文输出。 子函数 candp 实现加密解密时的求幂取余运算， fun 实现 e 与 t 的互素判断，已验证 e 是否 符合要求。程序主体参考了网上的相关 RSA 算法程序，我对其中 e 的合法性判断、主函数 实现的顺序以及相关提示信息做了补充与修改并加上了注释， 这样程序可读性更强， 运行时 更容易操作，思路也更加严密。 当 P=43, q=59 时，对 13不互素，提示需重新输入，输入 13 后，便可以进行正确操作。 由于 int 型变量为十六位，因此 n 最大只能小于 65536，此程序只是对 RSA 算法的入门，无 法实现达到安全要求的数据位数。
//公钥 e 与 t 的互素判断
x=y; y=t%y; } if(x == 1) return 0; else return 1; }
//x 与 y 互素时返回 0 //x 与 y 不互素时返回 1
void main() { int p,q,e,d,m,n,t,c,r; printf("请输入两个素数 p,q: "); scanf("%d%d",&p,&q); n=p*q; printf("计算得 n 为 %3d\n",n); t=(p-1)*(q-1); //求 n 的欧拉数 printf("计算得 t 为 %3d\n",t); printf("请输入公钥 e: "); scanf("%d",&e); if(e<1||e>t||fun(e,t)) { printf("e 不合要求，请重新输入: "); //e<1 或 e>t 或 e 与 t 不互素时，重新输入 scanf("%d",&e); } d=1; while(((e*d)%t)!=1) d++; //由公钥 e 求出私钥 d printf("经计算 d 为 %d\n",d); printf("加密请输入 1\n"); //加密或解密选择 printf("解密请输入 2\n"); scanf("%d",&r); switch(r) { case 1: printf("请输入明文 m: "); //输入要加密的明文数字 scanf("%d",&m); c=candp(m,e,n); printf("密文为 %d\n",c);break; case 2: printf("请输入密文 c: "); //输入要解密的密文数字 scanf("%d",&c); m=candp(c,d,n); printf("明文为 %d\n",m);break; } }
RSA算法python实现
RSA算法python实现RSA算法是⼀种⾮对称加密算法，是现在⼴泛使⽤的公钥加密算法，主要应⽤是加密信息和数字签名。
详情请看维基：算法基本思路：1.公钥与私钥的⽣成：(1)随机挑选两个⼤质数 p 和 q，构造N = p*q；(2)计算欧拉函数φ(N) = (p-1) * (q-1)；(3)随机挑选e，使得gcd(e, φ(N)) = 1，即 e 与φ(N) 互素；(4)计算d，使得 e*d ≡ 1 (mod φ(N))，即d 是e 的乘法逆元。
此时，公钥为（e, N），私钥为（d, N），公钥公开，私钥⾃⼰保管。
2.加密信息：(1)待加密信息（明⽂）为 M，M < N；（因为要做模运算，若M⼤于N，则后⾯的运算不会成⽴，因此当信息⽐N要⼤时，应该分块加密）(2)密⽂C = M e mod N(3)解密C d mod N = (M e)d mod N = M d*e mod N ；要理解为什么能解密？要⽤到欧拉定理（其实是费马⼩定理的推⼴）aφ(n)≡ 1 (mod n)，再推⼴：aφ(n)*k≡ 1 (mod n)，得：aφ(n)*k+1≡ a (mod n)注意到 e*d ≡ 1 mod φ(N)，即：e*d = 1 + k*φ(N)。
因此，M d*e mod N = M1 + k*φ(N) mod N = M简单来说，别⼈⽤我的公钥加密信息发给我，然后我⽤私钥解密。
3.数字签名：(1)密⽂C = M d mod N(2)解密M = C e mod N = (M d)e mod N = M d*e mod N = M ；（原理同上）简单来说，我⽤⾃⼰的密钥加密签名，别⼈⽤我的公钥解密可以看到这是我的签名。
注意，这个不具有隐私性，即任何⼈都可以解密此签名。
算法的安全性：基于⼤整数N难以分解出p和q，构造φ(N)；或由N直接构造φ(N)同样难。
算法的实现：1.快速幂取模；2.素性测试；3.扩展欧⼏⾥得求乘法逆元和最⼤公约数；实现代码：import randomdef fastExpMod(b, e, m):"""e = e0*(2^0) + e1*(2^1) + e2*(2^2) + ... + en * (2^n)b^e = b^(e0*(2^0) + e1*(2^1) + e2*(2^2) + ... + en * (2^n))= b^(e0*(2^0)) * b^(e1*(2^1)) * b^(e2*(2^2)) * ... * b^(en*(2^n))b^e mod m = ((b^(e0*(2^0)) mod m) * (b^(e1*(2^1)) mod m) * (b^(e2*(2^2)) mod m) * ... * (b^(en*(2^n)) mod m) mod m"""result = 1while e != 0:if (e&1) == 1:# ei = 1, then mulresult = (result * b) % me >>= 1# b, b^2, b^4, b^8, ... , b^(2^n)b = (b*b) % mreturn resultdef primeTest(n):q = n - 1k = 0#Find k, q, satisfied 2^k * q = n - 1while q % 2 == 0:k += 1;q /= 2a = random.randint(2, n-2);#If a^q mod n= 1, n maybe is a prime numberif fastExpMod(a, q, n) == 1:return"inconclusive"#If there exists j satisfy a ^ ((2 ^ j) * q) mod n == n-1, n maybe is a prime number for j in range(0, k):if fastExpMod(a, (2**j)*q, n) == n - 1:return"inconclusive"#a is not a prime numberreturn"composite"def findPrime(halfkeyLength):while True:#Select a random number nn = random.randint(0, 1<<halfkeyLength)if n % 2 != 0:found = True#If n satisfy primeTest 10 times, then n should be a prime numberfor i in range(0, 10):if primeTest(n) == "composite":found = Falsebreakif found:return ndef extendedGCD(a, b):#a*xi + b*yi = riif b == 0:return (1, 0, a)#a*x1 + b*y1 = ax1 = 1y1 = 0#a*x2 + b*y2 = bx2 = 0y2 = 1while b != 0:q = a / b#ri = r(i-2) % r(i-1)r = a % ba = bb = r#xi = x(i-2) - q*x(i-1)x = x1 - q*x2x1 = x2x2 = x#yi = y(i-2) - q*y(i-1)y = y1 - q*y2y1 = y2y2 = yreturn(x1, y1, a)def selectE(fn, halfkeyLength):while True:#e and fn are relatively primee = random.randint(0, 1<<halfkeyLength)(x, y, r) = extendedGCD(e, fn)if r == 1:return edef computeD(fn, e):(x, y, r) = extendedGCD(fn, e)#y maybe < 0, so convert itif y < 0:return fn + yreturn ydef keyGeneration(keyLength):#generate public key and private keyp = findPrime(keyLength/2)q = findPrime(keyLength/2)n = p * qfn = (p-1) * (q-1)e = selectE(fn, keyLength/2)d = computeD(fn, e)return (n, e, d)def encryption(M, e, n):#RSA C = M^e mod nreturn fastExpMod(M, e, n)def decryption(C, d, n):#RSA M = C^d mod nreturn fastExpMod(C, d, n)#Unit Testing(n, e, d) = keyGeneration(1024)#AES keyLength = 256X = random.randint(0, 1<<256)C = encryption(X, e, n)M = decryption(C, d, n) print"PlainText:", X print"Encryption of plainText:", C print"Decryption of cipherText:", M print"The algorithm is correct:", X == M Python。
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;```在上面的代码中，我们使用了几个辅助函数来实现扩展欧几里得算法、计算模反元素和快速幂算法。
C语言实现RSA算法
C语言实现RSA算法RSA算法是一种非对称加密算法，用于在网络通信中进行数据加密和解密。
下面我将给出C语言中RSA算法的实现。
首先，我们需要生成RSA密钥对，包括公钥和私钥。
以下是生成RSA 密钥对的C代码实现：```c#include <stdio.h>#include <stdlib.h>#include <math.h>//定义最大素数范围//定义RSA密钥结构体typedef structunsigned long long e; // 公钥指数unsigned long long d; // 私钥指数unsigned long long n; // 模数} RSAKey;//判断一个数是否为素数int isPrime(unsigned long long num)//小于等于1的数不是素数if (num <= 1) return 0;//判断是否存在因子for (unsigned long long i = 2; i <= sqrt(num); i++)if (num % i == 0)return 0;}}return 1;//生成一个指定范围内的随机素数unsigned long long generateRandomPrime(unsigned long long min, unsigned long long max)unsigned long long num;donum = rand( % (max - min + 1) + min;} while (!isPrime(num));return num;//求最大公约数unsigned long long gcd(unsigned long long a, unsigned long long b)unsigned long long temp;while (b != 0)temp = a % b;a=b;b = temp;}return a;//求模反元素unsigned long long modReverse(unsigned long long a, unsigned long long b)unsigned long long m0 = b, t, q;unsigned long long x0 = 0, x1 = 1;if (b == 1) return 0;while (a > 1)q=a/b;t=b;b=a%b;a=t;t=x0;x0=x1-q*x0;x1=t;}if (x1 < 0) x1 += m0;return x1;//生成RSA密钥对RSAKey generateRSAKeys(unsigned long long p, unsigned long long q)RSAKey keys;//计算模数keys.n = p * q;//计算欧拉函数值unsigned long long phi = (p - 1) * (q - 1);//选择公钥指数ekeys.e = generateRandomPrime(2, phi - 1);//计算私钥指数dkeys.d = modReverse(keys.e, phi);return keys;int mai//设置随机种子//生成两个不同的随机素数unsigned long long p = generateRandomPrime(2,MAX_PRIME_NUMBER);unsigned long long q = generateRandomPrime(2,MAX_PRIME_NUMBER);RSAKey keys = generateRSAKeys(p, q);printf("公钥指数e: %llu\n", keys.e);printf("私钥指数d: %llu\n", keys.d);printf("模数n: %llu\n", keys.n);return 0;```运行上述代码，即可生成RSA密钥对。
RSA的C语言算法实现
RSA的C语言算法实现RSA算法是一种非对称密码算法，用于加密和解密数据。
它是由三位数学家Rivest、Shamir和Adleman在1977年提出的，是目前最广泛使用的公钥加密算法之一RSA算法的实现需要以下步骤：1.选择两个大素数p和q，计算它们的乘积n=p*q。
n称为模数。
2.计算欧拉函数φ(n)=(p-1)*(q-1)。
3. 选择一个小于φ(n)的整数e，使得e与φ(n)互质，即gcd(e,φ(n)) = 1、e称为公钥指数。
4. 计算私钥指数d，满足(d * e) mod φ(n) = 1、d称为私钥指数。
5.公钥是(n,e)，私钥是(n,d)。
6. 要加密消息m，计算c = m^e mod n，其中c是密文。
7. 要解密密文c，计算m = c^d mod n，其中m是原始消息。
下面是一个使用C语言实现RSA算法的示例：```c#include <stdio.h>#include <stdlib.h>typedef unsigned long long int ullong;ullong gcd(ullong a, ullong b)ullong temp;while (b != 0)temp = b;b=a%b;a = temp;}return a;ullong mod_inverse(ullong a, ullong m) ullong m0 = m;ullong y = 0, x = 1;if (m == 1)return 0;while (a > 1)ullong q = a / m;ullong t = m;m=a%m,a=t;t=y;y=x-q*y;x=t;}if (x < 0)x+=m0;return x;ullong mod_exp(ullong base, ullong exponent, ullong modulus) ullong result = 1;base = base % modulus;while (exponent > 0)if (exponent % 2 == 1)result = (result * base) % modulus;exponent = exponent >> 1;base = (base * base) % modulus;}return result;int mai//选择素数p和qullong p = 17;ullong q = 19;//计算模数n和欧拉函数φ(n)ullong n = p * q;ullong phi_n = (p - 1) * (q - 1);//选择公钥指数eullong e = 5;//计算私钥指数dullong d = mod_inverse(e, phi_n);//打印公钥和私钥printf("公钥: (%llu, %llu)\n", n, e); printf("私钥: (%llu, %llu)\n", n, d);//要加密的消息ullong m = 88;//加密消息ullong c = mod_exp(m, e, n);//打印加密结果printf("加密结果: %llu\n", c);//解密消息ullong decrypted_m = mod_exp(c, d, n); //打印解密结果printf("解密结果: %llu\n", decrypted_m);return 0;```这是一个简单的RSA实现示例，用于加密和解密一个整数。
RSA算法分析和实现
1.知识的准备1.1整除，因子•对整数 b!=0 及 a , 如果存在整数 m 使得 a=mb,称 b 整除 a, 也称b是a的因子•记作 b|a•例 1,2,3,4,6,8,12,24 整除 24•1|24， 2|24， 3|24， 4|24 …1.2 素数称整数p(p>1)是素数，如果p的因子只有±1，±p。
任一整数a(a>1)都能惟一地分解为以下形式：其中p1>p2>…pt是素数，ai>0(i=1,…,t)。
例如：91=7×13，11011=7×112×131.3 互素数•若满足下面2个条件，则称c是两个整数a、b的最大公因子，表示为c=gcd(a, b)。
① c是a的因子也是b的因子，即c是a、b的公因子。
② a和b的任一公因子，也是c的因子。
•如果gcd(a,b)=1，则称a和b互素。
•整数 a, b 互素是指，它们没有除1之外的其它因子•8 与15 互素•8的因子1,2,4,8•15的因子 1,3,5,15• 1 是唯一的公因子1.4模运算•设n是一正整数，a是整数，如果用n除a，得商为q，余数为r，则a=qn+r,0≤r<n,其中为小于或等于x的最大整数。
若用a mod n表示余数r，则：•如果(a mod n)=(b mod n)，则称两整数a和b模n同余，记为a≡b mod n。
称与a模n同余的数的全体为a的同余类，记为[a]，称a为这个同余类的表示元素。
注意：如果a≡0(mod n)，则n|a同余有以下性质：①若n|(a-b)，则a≡b mod n。
② (a mod n)≡(b mod n)，则a≡b mod n。
③ a≡b mod n,则b≡a mod n。
④ a≡b mod n,b≡c mod n,则a≡c mod n。
从以上性质易知，同余类中的每一元素都可作为这个同余类的表示元素。
2. RSA算法的程序实现算法描述•独立地选取两大素数p和q(各100～200位十进制数字)•计算n=p×q，其欧拉函数值ϕ(n)=(p－1)(q－1)•随机选一整数e，1≤e<ϕ(n)，gcd(ϕ(n), e)=1•在模ϕ(n)下，计算e的有逆元d=e -1 mod ϕ(n)•以n，e为公钥。
rsa算法c语言实现,（完整版）RSA算法C语言代码
rsa算法c语⾔实现,（完整版）RSA算法C语⾔代码《(完整版)RSA算法C语⾔代码》由会员分享，可在线阅读，更多相关《(完整版)RSA算法C语⾔代码(5页珍藏版)》请在⼈⼈⽂库⽹上搜索。
1、include #include #include #include #include char s100,*c; int n,e,d,i,C,j,k=0,len; int str100,b30; unsigned gcd(unsigned a, unsigned b ) if(a%b=0) return b; else return gcd(b,a%b); void Egcd(int a, int b,int y=0; return ; if(ab) Egcd(a,b%a,x,y); x=(int) (b*y+1)/a; else Egcd(a%b,b,x,y); y=(int)(a*x-1)。
2、/b; void RSA() int p,q,N,Y; printf(请输⼊素数p和q:); scanf(%d %d, n=p*q; N=(p-1)*(q-1); 初始化随机数 产⽣随机整数e, e与N互质 /printf(n=%d N=%dn,n,N); srand( (unsigned)time( NULL ) );/ while(1) / e=rand()%N; / printf(e=%dn,e); if(e=0) continue;if(gcd(N,e)=1) break; /printf(e=%dn,e); Egcd(e,N,d,Y); / printf(d=%d Y=%dn,d,。
3、Y); printf( 公钥 PU=e=%d,n=%dn,e,n); printf( 私钥 PR=d=%d,n=%dn,d,n); void encrypt() /加密函数 len=strlen(s);/hgprintf(len=%dn,len); for(i=0;ilen;i+) /去掉 s100 中的空格 if(si122) bk=i; k+; for(j=i;jlen-1;j+) sj=sj+1; len-; slen=0; /结束符printf( 密⽂是： ); for(i=0;ilen;i+) C=1; /printf(shiji=%dn,si-97); for(int j=0;。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二 RSA算法
实验目的：
1．深入了解RSA加密算法的加密原理
2．通过编程模拟RSA算法的加密过程
实验内容：
一. RSA概述
①RSA加密算法是一种最常用的非对称加密算法，CFCA在证书服务中离不了它。
在公钥加密标准和电子商业中，RSA被广泛使用。
②公钥和私钥
1.随意选择两个大的质数p和q，p不等于q，计算N=pq。
2.根据欧拉函数，不大于N且与N互质的整数个数为(p-1)(q-1)
3.选择一个整数e与(p-1)(q-1)互质，并且e小于(p-1)(q-1)
4.用以下这个公式计算d：d× e≡ 1 (mod (p-1)(q-1))
5.将p和q的记录销毁。
(N,e)是公钥，(N,d)是私钥。
(N,d)是秘密的。
Alice将她的公钥(N,e)传给Bob，而将她的私钥(N,d)藏起来。
二.RSA算法的编程实现
#include<iostream>
#include<cmath>
using namespace std;
void main()
{
int p,q;//定义存放两个质数的变量
cout<<"请输入两个较大的素数："<<endl;
cin>>p>>q;
cout<<"p="<<p<<",q="<<q<<endl;
int n,o;
n=p*q;
o=(p-1)*(q-1);
cout<<"n="<<n<<",o="<<o<<endl;
cout<<"请从【0，"<<o-1<<"】中选择一个与"<<o<<"互素的数e："<<endl;
int e,i;
float d;
cin>>e;//输入e值
for(i=1;;i++)//计算d值
{
d=(float)(o*i+1)/e;
if(d-(int)d==0)
break;
}
cout<<"e="<<e<<",d="<<d<<endl;
cout<<"公开密钥Pk={e,n}={"<<e<<","<<n<<"}"<<endl;//输出公开密钥
cout<<"秘密密钥Sk={d,n}={"<<d<<","<<n<<"}"<<endl; //输出私密密钥
cout<<endl;
cout<<"请输入要加密的正整数（以-1结束）："<<endl;
int m1[500],m3[500],m4[500];
double m2[500];
int j;
for(j=0;j<500;j++)//对明文进行加密
{
cin>>m1[j];
if(m1[j]==-1)
break;
m2[j]=pow(m1[j],e);
m4[j]=m2[j]/n;
m3[j]=m2[j]-m4[j]*n;
}
cout<<"密文为："<<endl;
int k;
for(k=0;k<j;k++)//输出密文
cout<<m3[k]<<" ";
cout<<endl;
}
三.实例描述
在以下实例中只选取小数值的素数p,q,以及e，假设用户A需要将明文“key”通过RSA 加密后传递给用户B，过程如下：
（1）设计公私密钥(e,n)和(d,n)。
令p=3，q=11，得出n=p×q=3×11=33；f(n)=(p-1)(q-1)=2×10=20；取e=3，（3与20互质）则e×d≡1 mod f(n)，即3×d≡1 mod 20。
d怎样取值呢？可以用试算的办法来寻找。
试算结果见下表：
通过试算我们找到，当d=7时，e×d≡1 mod f(n)同余等式成立。
因此，可令d=7。
从而我们可以设计出一对公私密钥，加密密钥（公钥）为：KU =(e,n)=(3,33)，解密密钥（私钥）为：KR =(d,n)=(7,33)。
（2）英文数字化。
将明文信息数字化，并将每块两个数字分组。
假定明文英文字母编码表为按字母顺序排列数值，即：
则得到分组后的key的明文信息为：11，05，25。
（3）明文加密
用户加密密钥(3,33) 将数字化明文分组信息加密成密文。
由C≡Me(mod n)得：
因此，得到相应的密文信息为：11，26，16。
（4）密文解密。
用户B收到密文，若将其解密，只需要计算M= Cd(mod n),即：
用户B得到明文信息为：11，05，25。
根据上面的编码表将其转换为英文，我们又得到了恢复后的原文“key”。
当然，实际运用要比这复杂得多，由于RSA算法的公钥私钥的长度（模长度）要到1024
位甚至2048位才能保证安全，因此，p、q、e的选取、公钥私钥的生成，加密解密模指数运算都有一定的计算程序，需要仰仗计算机高速完成。
四.运行结果
五.RSA的安全性
在RSA密码应用中，公钥KU是被公开的，即e和n的数值可以被第三方窃听者得到。
破解RSA密码的问题就是从已知的e和n的数值（n等于pq），想法求出d的数值，这样就可以得到私钥来破解密文。
从上文中的公式：d ≡e-1 (mod((p-1)(q-1)))或de≡1 (mod((p-1)(q-1))) 我们可以看出。
密码破解的实质问题是：从pq的数值，去求出(p-1)和(q-1)。
换句话说，只要求出p和q的值，我们就能求出d的值而得到私钥。
当p和q是一个大素数的时候，从它们的积pq去分解因子p和q，这是一个公认的数学难题。
比如当pq大到1024位时，迄今为止还没有人能够利用任何计算工具去完成分解因子的任务。
然而，虽然RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。
即RSA的重大缺陷是无法从理论上把握它的保密性能如何。
此外，RSA的缺点还有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。
B)分组长度太大，为保证安全性，n 至少也要 600 bits 以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。
因此，使用RSA只能加密少量数据，大量的数据加密还要靠对称加密算法。
六.心得体会
通过本次实验，我对非对称加密算法RSA的理解加深了，会运用一些现成的算法进行编程，对一些比较复杂的算法有了进一步的认识。