rsa算法中p，q，n，e，d一般大小都为多少啊？

Posted 2023-04-10

老师让编个rsa，为了降低难度，p q n e d都可以设为已知，但是我不知道他们一般大概有多大？
求达人指点。
谢谢。
谢谢，我还是没看太明白这几个参数大概有多大，我要在程序中直接给它赋值，就不用随即生成了。您觉得我把它们赋值为多少比较靠谱？
谢谢！

这个不好说，什么情况都可能不是吗。
RSA是目前最有影响力的公钥加密算法，该算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可发布的供任何人使用，私钥则为自己所有，供解密之用。

解密者拥有私钥，并且将由私钥计算生成的公钥发布给加密者。加密都使用公钥进行加密，并将密文发送到解密者，解密者用私钥解密将密文解码为明文。

以甲要把信息发给乙为例，首先确定角色：甲为加密者，乙为解密者。首先由乙随机确定一个KEY，称之为密匙，将这个KEY始终保存在机器B中而不发出来；然后，由这个 KEY计算出另一个KEY，称之为公匙。这个公钥的特性是几乎不可能通过它自身计算出生成它的私钥。接下来通过网络把这个公钥传给甲，甲收到公钥后，利用公钥对信息加密，并把密文通过网络发送到乙，最后乙利用已知的私钥，就对密文进行解码了。以上就是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)是私钥。

下面讲解RSA算法的应用。

RSA的公钥和私钥是由KeyPairGenerator生成的，获取KeyPairGenerator的实例后还需要设置其密钥位数。设置密钥位数越高，加密过程越安全，一般使用1024位。如下代码：

[代码]java代码：
1KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(RSA);
2// 密钥位数
3keyPairGen.initialize(1024);

公钥和私钥可以通过KeyPairGenerator执行generateKeyPair()后生成密钥对KeyPair，通过KeyPair.getPublic()和KeyPair.getPrivate()来获取。如下代码：

[代码]java代码：
1// 动态生成密钥对，这是当前最耗时的操作，一般要2s以上。
2KeyPair keyPair = keyPairGen.generateKeyPair();
3// 公钥
4PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
5// 私钥
6PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
7byte[] publicKeyData = publicKey.getEncoded();
8byte[] privateKeyData = publicKey.getEncoded();
公钥和私钥都有它们自己独特的比特编码，可以通过getEncoded()方法获取，返回类型为byte[]。通过byte[]可以再度将公钥或私钥还原出来。具体代码如下：

[代码]java代码：
01// 通过公钥byte[]将公钥还原，适用于RSA算法
02public static PublicKey getPublicKey(byte[] keyBytes) throws
03NoSuchAlgorithmException,InvalidKeySpecException
04 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
05 KeyFactory keyFactory = KeyFactory.getInstance("RSA");
06 PublicKey publicKey = keyFactory.generatePublic(keySpec);
07 return publicKey;
08
09// 通过私钥byte[]将公钥还原，适用于RSA算法
10public static PrivateKey getPrivateKey(byte[] keyBytes) throws
11NoSuchAlgorithmException,InvalidKeySpecException
12 PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
13 KeyFactory keyFactory = KeyFactory.getInstance("RSA");
14 PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
15 return privateKey;
16
在上文讲到的RSA算法实现过程中提到(N,e)是公钥，(N,d)是私钥。既然已经获取到了PublicKey和PrivateKey了，那如何取到N、e、d这三个值呢。要取到这三个值，首先要将PublicKey和PrivateKey强制转换成RSAPublicKey和RSAPrivateKey。共同的N值可以通过getModulus()获取。执行RSAPublicKey.getPublicExponent()可以获取到公钥中的e值，执行RSAPrivateKey.getPrivateExponent()可以获取私钥中的d值。这三者返回类型都是BigInteger。代码如下：

[代码]java代码：
01// 打印公钥信息
02public static void printPublicKeyInfo(PublicKey key)
03RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
04Log.d(MainActivity.TAG, "RSAPublicKey:");
05Log.d(MainActivity.TAG, "Modulus.length=" +
06rsaPublicKey.getModulus().bitLength());
07Log.d(MainActivity.TAG, "Modulus=" +
08rsaPublicKey.getModulus().toString());
09Log.d(MainActivity.TAG, "PublicExponent.length=" +
10rsaPublicKey.getPublicExponent().bitLength());
11Log.d(MainActivity.TAG, "PublicExponent=" +
12rsaPublicKey.getPublicExponent().toString());
13
14
15// 打印私钥信息
16public static void printPublicKeyInfo(PrivateKey key)
17RSAPrivateKey rsaPublicKey = (RSAPrivateKey) privateKey;
18Log.d(MainActivity.TAG, "RSAPrivateKey:");
19Log.d(MainActivity.TAG, "Modulus.length=" +
20rsaPrivateKey.getModulus().bitLength());
21Log.d(MainActivity.TAG, "Modulus=" +
22rsaPrivateKey.getModulus().toString());
23Log.d(MainActivity.TAG, "PublicExponent.length=" +
24rsaPrivateKey.getPrivateExponent().bitLength());
25Log.d(MainActivity.TAG, "PublicExponent=" +
26rsaPrivateKey.getPrivateExponent().toString());
27

由于程序中动态生成KeyPair对明文加密后生成的密文是不可测的，所以在实际开发中通常在生成一个KeyPair后将公钥和私钥的N、e、d这三个特征值记录下来，在真实的开发中使用这三个特征值再去将PublicKey和PrivateKey还原出来。还原方法如下：

[代码]java代码：
01// 使用N、e值还原公钥
02public static PublicKey getPublicKey(String modulus, String
03publicExponent)
04 throws NoSuchAlgorithmException, InvalidKeySpecException
05 BigInteger bigIntModulus = new BigInteger(modulus);
06 BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
07 RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus,
08bigIntPrivateExponent);
09 KeyFactory keyFactory = KeyFactory.getInstance("RSA");
10 PublicKey publicKey = keyFactory.generatePublic(keySpec);
11 return publicKey;
12
13
14// 使用N、d值还原公钥
15public static PrivateKey getPrivateKey(String modulus, String
16privateExponent)
17 throws NoSuchAlgorithmException, InvalidKeySpecException
18 BigInteger bigIntModulus = new BigInteger(modulus);
19 BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);
20 RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(bigIntModulus,
21 bigIntPrivateExponent);
22 KeyFactory keyFactory = KeyFactory.getInstance("RSA");
23 PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
24 return privateKey;
25

公钥和私钥都具备后，就可以使用加解密的工具类javax.crypto.Cipher对明文和密文进行处理了。与所有的引擎类一样，可以通过调用Cipher类中的getInstance(String transformation)静态工厂方法得到Cipher对象。该方法中的参数描述了由指定输入产生输出所进行的操作或操作集合，可以是下列两种形式之一：“algorithm/mode/padding”或“algorithm”。例如下面的例子就是有效的transformation形式："DES/CBC/PKCS5Padding"或"DES"。如果没有指定模式或填充方式，就使用特定提供者指定的默认模式或默认填充方式。

Cipher的加密和解密方式所调用的方法和过程都一样，只是传参不同的区别。 参考技术A RSA遭受攻击的很多情况是因为算法实现的一些细节上的漏洞所导致的，所以在使用RSA算法构造密码系统时，为保证安全，在生成大素数的基础上，还必须认真仔细选择参数，防止漏洞的形成。根据RSA加解密过程，其主要参数有三个：模数N，加密密钥e，解密密钥d。
3.4.1 模数N的确定
虽然迄今人们无法证明，破解RSA系统等于对N因子分解，但一般相信RSA系统的安全性等同于因子分解，即：若能分解因子N，即能攻破RSA系统，若能攻破RSA系统，即能分解因子Ⅳ。因此，在使用RSA系统时，对于模数N的选择非常重要。在RSA算法中，通过产生的两个大素数p和q相乘得到模数N，而后分别通过对它们的数学运算得到密钥对。由此，分解模数N得到p和q是最显然的攻击方法，当然也是最困难的方法，如果模数N被分解，攻击者利用得到的P和q便可计算出，进而通过公开密钥e由解密密钥d，则RSA体制立刻被攻破。相当一部分的对RSA的攻击就是试图分解模数N，选择合适的N是实现RSA算法并防止漏洞的重要环节。一般地，模数N的确定可以遵循以下几个原则：
①p和q之差要大。
当p和q相差很小时，在已知n的情况下，可假定二者的平均值为，然后利用，若等式右边可开方，则得到及，即N被分解。
②p-1和q-1的最大公因子应很小。
③p和q必须为强素数。
一素数p如果满足：
条件一：存在两个大素数，，使得|p-1且|p+1；
条件二：存在四个大素数，，，使得。则此素数为强素数。其中，，，称为3级的素数，，称为2级的素数，p则称为1级的素数，很明显地，任何素数均为3级的素数。只有两个强素数的积所构成的N，其因子分解才是较难的数学问题。
④p和q应大到使得因子分解N为计算上不可能。
RSA的安全性依赖于大数的因子分解，若能因子分解模数N，则RSA即被攻破，因此模数N必须足够大直至因子分解N在计算上不可行。因子分解问题为密码学最基本的难题之一，如今，因子分解的算法已有长足的进步，但仍不足以说明RSA可破解。为保证安全性，实际应用中所选择的素数P和拿至少应该为300位以上的二进制数，相应的模数N将是600位以上的二进制数。
目前，SET(Secure Electronic Transaction)协议中要求CA采用2048比特长的密钥，其他实体使用1024比特的密钥。随着计算能力的提高和分布式运算的发展，安全密钥的长度将是动态增长的。
Jadith Moore给出了使用RSA时有关模数的一些限制：
①若给定模数的一个加/解密密钥指数对已知，攻击者就能分解这个模数。
②若给定模数的一个加/解密密钥指数对已知，攻击者无需分解模数Ⅳ就可以计算出别的加/解密密钥指数对。
③在通信网络中，利用RSA的协议不应该使用公共模数。
④消息应该用随机数填充以避免对加密指数的攻击。
3.4.2 e的选取原则
在RSA算法中，e和互质的条件容易满足，如果选择较小的e，则加、解密的速度加快，也便于存储，但会导致安全问题。
一般地，e的选取有如下原则：
①e不能够太小。在RSA系统中，每人的公开密钥P只要满足即可，也即e可以任意选择，为了减少加密运算时间，很多人采用尽可能小的e值，如3。但是已经证明低指数将会导致安全问题，故此，一般选择e为16位的素数，可以有效防止攻击，又有较快速度。
②e应选择使其在的阶为最大。即存在i，使得，
可以有效抗击攻击。
3.4.3 d的选取原则
一般地，私密密钥d要大于。在许多应用场合，常希望使用位数较短的密钥以降低解密或签名的时间。例如IC卡应用中，IC卡CPU的计算能力远低于计算机主机。长度较短的d可以减少IC卡的解密或签名时间，而让较复杂的加密或验证预算(e长度较长)由快速的计算机主机运行。一个直接的问题就是：解密密钥d的长度减少是否会造成安全性的降低?很明显地，若d的长度太
小，则可以利用已知明文M加密后得，再直接猜测d，求出是否等于M。若是，则猜测J下确，否则继续猜测。若d的长度过小，则猜测的空间变小，猜中的可能性加大，已有证明当时，可以由连分式算法在多项式时间内求出d值。因此其长度不能过小。 参考技术B #include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>

int str2num(char *str) //字符转数字

int i=0,num=0;

for(i=0;i<(int)strlen(str);i++)
num=num*10+str[i]-'0';
return num;



float CarmSqrt(float x) //求平方根 系统的太慢，用了别人的

union

int intPart;
float floatPart;
convertor;

union

int intPart;
float floatPart;
convertor2;

convertor.floatPart = x;
convertor2.floatPart = x;
convertor.intPart = 0x1FBCF800 + (convertor.intPart >> 1);
convertor2.intPart = 0x5f3759df - (convertor2.intPart >> 1);
return 0.5f*(convertor.floatPart + (x * convertor2.floatPart));
//可以不用，用sqrt()也可以

int isPrime(int n) //判断是否为素数

int i=0,k=2;

k=(int)CarmSqrt(n);
for(i=2;i<=k;i++)

if(n%i==0)
break;


if(i>k)
return 1;
else
return 0;



int rnd(int max) //生成随机数 2~max 用来生成e，
//取系统时间做随机数种子
int range,n;
int min=2,flag=0;
time_t t;
double j;

range=max-min;
t=time(NULL);
srand((unsigned)t);

n=rand();

j=((double)n/(double)RAND_MAX);

n=(int)(j*(double)range);
n+=min;

return n;



int co_prime(int a ,int b) // 求互质

int c;
do

if(b==1)
return 1;
c=a%b;
a=b;
b=c;

while(c!=0);
return 0;


void get_d_e(int p,int q)

int r,t,e,d,i=2,k=0;

if(isPrime(p)!=1||isPrime(q)!=1)

printf("Invaild Parameters\nshould be PRIME!\n");
printf("Usage:RSA Prime1 Prime2\n");
exit(0);


r=p*q;

t=(p-1)*(q-1);
e=rnd(t)/10;
while(co_prime(t,e)!=1)

e=e+1;



for(d=2;d<t;d++)

if((e*d)%t==1)
break;


printf("d=%d e=%d r=%d\n",d,e,r);


void en(int n,int e,int r)

//加密


void de(int c,int d,int r)

//解密


void main(int argc,char* argv[])

int n1,n2;

if(argc!=3&&argc!=5)

printf("Invaild Parameters!\n");
printf("Usage: \nRSA -e Express e r\n");
printf("RSA -d Ciphertext d r\n");
printf("RSA Prime1 Prime2\n");//错误输出
exit(0);

else

if(argv[1][0]!='-')

n1=str2num(argv[1]);
n2=str2num(argv[2]);
get_d_e(n1,n2);
exit(0);


else
if(argv[1][1]=='e') //加密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);



if(argv[1][1]=='d') //解密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);



else
printf("Invaild Parameters!\n");
printf("Usage: \nRSA -e Express e r\n");
printf("RSA -d Ciphertext d r\n");
printf("RSA Prime1 Prime2\n");
exit(0);

本回答被提问者和网友采纳 参考技术C #include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>

int str2num(char *str) //字符转数字

int i=0,num=0;

for(i=0;i<(int)strlen(str);i++)
num=num*10+str[i]-'0';
return num;



float CarmSqrt(float x) //求平方根 系统的太慢，用了别人的

union

int intPart;
float floatPart;
convertor;

union

int intPart;
float floatPart;
convertor2;

convertor.floatPart = x;
convertor2.floatPart = x;
convertor.intPart = 0x1FBCF800 + (convertor.intPart >> 1);
convertor2.intPart = 0x5f3759df - (convertor2.intPart >> 1);
return 0.5f*(convertor.floatPart + (x * convertor2.floatPart));
//可以不用，用sqrt()也可以

int isPrime(int n) //判断是否为素数

int i=0,k=2;

k=(int)CarmSqrt(n);
for(i=2;i<=k;i++)

if(n%i==0)
break;


if(i>k)
return 1;
else
return 0;



int rnd(int max) //生成随机数 2~max 用来生成e，
//取系统时间做随机数种子
int range,n;
int min=2,flag=0;
time_t t;
double j;

range=max-min;
t=time(NULL);
srand((unsigned)t);

n=rand();

j=((double)n/(double)RAND_MAX);

n=(int)(j*(double)range);
n+=min;

return n;



int co_prime(int a ,int b) // 求互质

int c;
do

if(b==1)
return 1;
c=a%b;
a=b;
b=c;

while(c!=0);
return 0;


void get_d_e(int p,int q)

int r,t,e,d,i=2,k=0;

if(isPrime(p)!=1||isPrime(q)!=1)

printf("Invaild Parameters\nshould be PRIME!\n");
printf("Usage:RSA Prime1 Prime2\n");
exit(0);


r=p*q;

t=(p-1)*(q-1);
e=rnd(t)/10;
while(co_prime(t,e)!=1)

e=e+1;



for(d=2;d<t;d++)

if((e*d)%t==1)
break;


printf("d=%d e=%d r=%d\n",d,e,r);


void en(int n,int e,int r)

//加密


void de(int c,int d,int r)

//解密


void main(int argc,char* argv[])

int n1,n2;

if(argc!=3&&argc!=5)

printf("Invaild Parameters!\n");
printf("Usage: \nRSA -e Express e r\n");
printf("RSA -d Ciphertext d r\n");
printf("RSA Prime1 Prime2\n");//错误输出
exit(0);

else

if(argv[1][0]!='-')

n1=str2num(argv[1]);
n2=str2num(argv[2]);
get_d_e(n1,n2);
exit(0);


else
if(argv[1][1]=='e') //加密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);



if(argv[1][1]=='d') //解密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);



else
printf("Invaild Parameters!\n");
printf("Usage: \nRSA -e Express e r\n");
printf("RSA -d Ciphertext d r\n");
printf("RSA Prime1 Prime2\n");
exit(0);
参考技术D #include
<stdio.h>
#include
<string.h>
#include
<time.h>
#include
<stdlib.h>
#include
<math.h>
int
str2num(char
*str)
//字符转数字

int
i=0,num=0;
for(i=0;i<(int)strlen(str);i++)
num=num*10+str[i]-'0';
return
num;

float
CarmSqrt(float
x)
//求平方根
系统的太慢，用了别人的

union

int
intPart;
float
floatPart;
convertor;
union

int
intPart;
float
floatPart;
convertor2;
convertor.floatPart
=
x;
convertor2.floatPart
=
x;
convertor.intPart
=
0x1FBCF800
+
(convertor.intPart
>>
1);
convertor2.intPart
=
0x5f3759df
-
(convertor2.intPart
>>
1);
return
0.5f*(convertor.floatPart
+
(x
*
convertor2.floatPart));
//可以不用，用sqrt()也可以
int
isPrime(int
n)
//判断是否为素数

int
i=0,k=2;
k=(int)CarmSqrt(n);
for(i=2;i<=k;i++)

if(n%i==0)
break;

if(i>k)
return
1;
else
return
0;

int
rnd(int
max)
//生成随机数
2~max
用来生成e，

//取系统时间做随机数种子
int
range,n;
int
min=2,flag=0;
time_t
t;
double
j;
range=max-min;
t=time(NULL);
srand((unsigned)t);
n=rand();
j=((double)n/(double)RAND_MAX);
n=(int)(j*(double)range);
n+=min;
return
n;

int
co_prime(int
a
,int
b)
//
求互质

int
c;
do

if(b==1)
return
1;
c=a%b;
a=b;
b=c;
while(c!=0);
return
0;

void
get_d_e(int
p,int
q)

int
r,t,e,d,i=2,k=0;
if(isPrime(p)!=1||isPrime(q)!=1)

printf("Invaild
Parameters\nshould
be
PRIME!\n");
printf("Usage:RSA
Prime1
Prime2\n");
exit(0);

r=p*q;
t=(p-1)*(q-1);
e=rnd(t)/10;
while(co_prime(t,e)!=1)

e=e+1;

for(d=2;d<t;d++)

if((e*d)%t==1)
break;

printf("d=%d
e=%d
r=%d\n",d,e,r);

void
en(int
n,int
e,int
r)

//加密

void
de(int
c,int
d,int
r)

//解密

void
main(int
argc,char*
argv[])

int
n1,n2;
if(argc!=3&&argc!=5)

printf("Invaild
Parameters!\n");
printf("Usage:
\nRSA
-e
Express
e
r\n");
printf("RSA
-d
Ciphertext
d
r\n");
printf("RSA
Prime1
Prime2\n");//错误输出
exit(0);

else
if(argv[1][0]!='-')

n1=str2num(argv[1]);
n2=str2num(argv[2]);
get_d_e(n1,n2);
exit(0);

else
if(argv[1][1]=='e')
//加密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);

if(argv[1][1]=='d')
//解密

n1=str2num(argv[3]);
n2=str2num(argv[4]);
en(str2num(argv[2]),n1,n2);
exit(0);

else
printf("Invaild
Parameters!\n");
printf("Usage:
\nRSA
-e
Express
e
r\n");
printf("RSA
-d
Ciphertext
d
r\n");
printf("RSA
Prime1
Prime2\n");
exit(0);

RSA加密解密（python版）

RSA的算法涉及三个参数，n、e、d。

其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。

e1和d是一对相关的值，e可以任意取，但要求e与(p-1)*(q-1)互质；再选择d，要求(d*e1)mod((p-1)*(q-1))=1。

（n，e),(n，d)就是密钥对。其中(n，e)为公钥，(n，d)为私钥。^[1] 

RSA加解密的算法完全相同，设A为明文，B为密文，则：A=B^d mod n；B=A^e mod n；（公钥加密体制中，一般用公钥加密，私钥解密）

e和d可以互换使用，即：

A=B^d mod n；B=A^e mod n;

 

#!/usr/bin/env python
#coding -*- utf:8 -*-
import math
import random

#生成素数数组
def prime_array():
    arraya = []
    for i in range(2,100): #生成前100中的素数，从2开始因为2是最小的素数
        x = prime(i,2)    #i为素数是返回True，则将x加入arraya数组中;2为测试值
        if x:
            arraya.append(i)
    return arraya

#判断是否为素数
def prime(n, test_divisor):
    if math.sqrt(n) < test_divisor:
        return True   #为素数时返回True
    if n % test_divisor == 0:
        return False  #不为素数时返回Fasle
    else:
        return prime(n, test_divisor+1)

#找出与（p-1）*(q-1)互质的数e
def co_prime(s):
    while True:
        e = random.choice(range(100))
        x = gcd(e,s)
        if x==1: #如果最大公约数为1，则退出循环返回e
            break
    return e

#求两个数的最大公约数
def gcd(a,b):
    if b==0:
        return a
    else:
        return gcd(b, a%b)

#根据e*d mod s = 1,找出d
def find_d(e,s):
    for d in range(100000000): #随机太难找，就按顺序找到d,range里的数字随意
        x = (e*d) % s
        if x==1:
            return d

#生成公钥和私钥
def main():
    a= prime_array()
    print("前100个素数:",a)
    p = random.choice(a)
    q = random.choice(a)
    print("随机生成两个素数p和q. p=",p," q=",q)
    n = p * q
    s = (p-1)*(q-1)
    #print("The p is ", p)
    #print("The q is ", q)
    #print("The n(p*q) is ",n)
    e = co_prime(s)
    print("根据e和(p-1)*(q-1))互质得到: e=", e)
    d = find_d(e,s)
    print("根据(e*d) 模 ((p-1)*(q-1)) 等于 1 得到 d=", d)
    print("公钥:   n=",n,"  e=",e)
    print("私钥:   n=",n,"  d=",d)
    pbvk=(n,e,d)
    return pbvk

#生成public key公钥或private key私钥
#zx==0 公钥 zx==1 私钥
#a为元组(n,e,d)
def generate_pbk_pvk(a,zx):
    pbk = (a[0],a[1]) #public key公钥 元组类型，不能被修改
    pvk = (a[0],a[2]) #private key私钥
    #print("公钥:   n=",pbk[0],"  e=",pbk[1])
    #print("私钥:   n=",pvk[0],"  d=",pvk[1])
    if zx==0:
        return pbk
    if zx==1:
        return pvk

#加密
def encryption(mw, ned):
    # 密文B = 明文A的e次方 模 n， ned为公钥
    #mw就是明文A，ned【1】是e， ned【0】是n
    B = pow(mw,ned[1]) % ned[0]
    return B

#解密
def decode(mw, ned):
    # 明文C = 密文B的d次方 模 n， ned为私钥匙
    #mw就是密文B， ned【1】是e，ned【1】是d
    C = pow(mw,ned[1]) % ned[0]
    return C

if __name__==‘__main__‘:
    pbvk = main()
    pbk = generate_pbk_pvk(pbvk, 0) #公钥  if 0 return pbk if 1 return pvk
    A = int(input("请输入明文: "))
    print("加密中....")
    B = encryption(A,pbk) #加密
    print("生成的密文是: ", B)
    pvk = generate_pbk_pvk(pbvk, 1)  #私钥
    print("解密中....")
    C = decode(B,pvk)     #解密
    print("解密后的明文是: ", C)
    if A==C:
        print("加密前的明文和解密后的明文一样，成功!!!")