网站优化 seo和sem,室内装修设计师怎么样,如何自己做电商,如何利用tp-link按错900做网站第1关#xff1a;实验一#xff1a;古典密码算法---代换技术
任务描述 本关任务#xff1a;了解古典密码体制技术中的代换技术#xff0c;并编程实现代换密码的加解密功能。
注意所有明文字符为26个小写字母#xff0c;也就是说字母表为26个小写字母。
相关知识 为了完…第1关实验一古典密码算法---代换技术
任务描述 本关任务了解古典密码体制技术中的代换技术并编程实现代换密码的加解密功能。
注意所有明文字符为26个小写字母也就是说字母表为26个小写字母。
相关知识 为了完成本关任务你需要掌握1.古典密码算法2.代换密码。
古典密码算法 古典密码算法历史上曾被广泛应用大都使用手工和机械操作来实现加密和解密比较简单。古典密码主要是利用密码算法实现文字信息的加密和解密本实验运用两种常见的具有代表性的古典密码技术——代换密码技术以帮助学员对密码算法建立一个初步的认识和印象。
代换密码 代换密码算法的原理是使用替代法进行加密就是将明文中的字符用其它字符替代后形成密文。例如明文字母a,b,c,d用D,E,F,G做对应替换后形成密文。
代换密码包括多种类型如单表替代密码多明码替代密码多字母替代密码多表替代密码等。本实验利用一种典型的单表替代密码——恺撒caesar密码又叫循环移位密码加密方法是将明文中的每个字符用此字符在字母表中后面第k个字母替代加密过程可以表示为下面的函数
E(m)(mk)(modn)
其中m为明文字母在字母表中的位置数n为字母表中的字母个数k为密钥E(m)为密文字母在字母表中对应的位置数。
例如对于明文字母H其在字母表中的位置数为8设k4则按照上式计算出来的密文为L
E(8)(mk)(modn)(84)(mod26)12L
编程要求 本关的编程任务是补全右侧代码片段Encrypt和Dencrypt中Begin至End中间的代码具体要求如下
在Encrypt中根据实验原理部分对凯撒密码算法的介绍将明文字符串参数clearText通过密钥参数K加密转换成密文并存入密文字符串参数变量cipherText。
在Dencrypt中与Encrypt函数相对将密文字符串参数cipherText通过密钥参数K解密转换成明文并存入明文字符串参数变量clearText。
测试说明 平台将自动编译补全后的代码并生成若干组测试数据接着根据程序的输出判断程序是否正确。
以下是平台的测试样例 测试输入 4 internet 预期输出 密钥4 明文internet 密文mrxivrix 解密internet 输入格式 第1行整数k表示密钥 第2行待加密明文 输出格式 第1行输出密钥k 第2行输出原始明文 第3行输出加密后的密文 第4行输出解密后的明文 开始你的任务吧祝你成功
//
// main.cpp
// step1
//
// Created by ljpc on 2018/10/16.
// Copyright © 2018年 ljpc. All rights reserved.
//#include iostream
#include stdio.h
#include string.h
#define N 26void Encrypt(int K, char* clearText, char* cipherText)
{// 请在这里补充代码完成本关任务/********* Begin *********/int len strlen(clearText);for (int i 0; i len; i) {if (clearText[i] a clearText[i] z) {cipherText[i] ((clearText[i] - a K) % N) a;}else {cipherText[i] clearText[i];}}cipherText[len] \0;/********* End *********/
}void Dencrypt(int K, char* clearText, char* cipherText)
{// 请在这里补充代码完成本关任务/********* Begin *********/int len strlen(cipherText);for (int i 0; i len; i) {if (cipherText[i] a cipherText[i] z) {int temp cipherText[i] - a - K;if (temp 0) temp N;clearText[i] temp a;} else {clearText[i] cipherText[i];}}clearText[len] \0;/********* End *********/
}int main(int argc, const char * argv[]) {int K;char ClearText[100];char ClearText2[100];char CipherText[100];scanf(%d, K);scanf(%s, ClearText);printf(密钥%d\n, K);printf(明文%s\n, ClearText);Encrypt(K, ClearText, CipherText);printf(密文%s\n, CipherText);Dencrypt(K, ClearText2, CipherText);printf(解密%s\n, ClearText2);return 0;
}
第2关实验二古典密码算法---置换技术
任务描述 本关任务了解古典密码体制技术中的置换技术并编程实现置换密码的加解密功能。
相关知识 为了完成本关任务你需要掌握1.古典密码算法2.置换密码。
古典密码算法 古典密码算法历史上曾被广泛应用大都使用手工和机械操作来实现加密和解密比较简单。古典密码主要是利用密码算法实现文字信息的加密和解密本实验运用常见的具有代表性的古典密码技术——置换密码技术以帮助学员对密码算法建立一个初步的认识和印象。
置换密码 置换密码又称为换位密码算法的原理是不改变、替换明文字符只将字符在明文中的排列顺序改变从而实现明文信息的加密。
矩阵换位法是实现置换密码的一种常用方法类似于教材中的双换位密码。它将明文中的字母按照给定的顺序安排在一个矩阵中然后用根据密钥提供的顺序重新组合矩阵中字母从而形成密文。
例如,明文为attackbeginsatfive密钥为1 4 5 3 2 6将明文按照每行6列的形式排在矩阵中形成如下形式 根据密钥1 4 5 3 2 6给定一个置换 根据上面的置换将原有矩阵中的字母按照第1列第4列第5列第3列第2列第6列的顺序排列则有下面形式 从而得到密文:abatgftetcnvaiikse。
其解密的过程是根据密钥的字母数作为列数将密文按照列行的顺序写出再根据由密钥给出的矩阵置换产生新的矩阵从而恢复明文。
注意本实验为了迎合程序中下标使用惯例所有索引从0开始另外本实验重在实现置换的过程所以本样例中的明文长度和密钥长度一直无需重组为矩阵详情参看样例。
编程要求 本关的编程任务是补全右侧代码片段Encrypt和Dencrypt中Begin至End中间的代码具体要求如下
在Encrypt中根据实验原理部分对置换密码算法的介绍将明文字符串参数clearText通过密钥表参数cipherTab加密转换成密文并存入密文字符串参数变量cipherText。
在Dencrypt中与Encrypt函数功能相反将密文字符串参数cipherText通过密钥表参数cipherTab解密转换成明文并存入明文字符串参数变量clearText。
测试说明 平台将自动编译补全后的代码并生成若干组测试数据接着根据程序的输出判断程序是否正确。
以下是平台的测试样例 测试输入 internet 4 7 3 1 2 6 0 5 预期输出 密钥 0 1 2 3 4 5 6 7 4 7 3 1 2 6 0 5 明文internet 密文rtentein 解密internet 输入格式 第1行待加密的明文 第2行置换密钥索引从0开始密钥表大小等于与明文长度一直 输出格式 第1~3行密钥表信息 第4行明文 第5行密文 第6行解密 开始你的任务吧祝你成功
第3关实验三DES加解密算法的实现
任务描述 本关任务掌握DES加密算法的加解密过程并且实现DES加解密算法中的各个功能模块。
相关知识 为了完成本关任务你需要掌握1.DES算法2.DES加密3.DES解密4.子密钥的生成算法。
DES算法 DES(Data Encryption Standard)算法于1977年得到美国政府的正式许可是一种用56位密钥来加密64位数据的方法。DES算法以被应用于许多需要安全加密的场合。
DES加密 DES算法把64位的明文输入块变为64位的密文输出块它所使用的密钥也是64位其功能是把输入的64位数据块按位重新组合并把输出分为L0 、R0 两部分每部分各长32位其置换规则见下表 58,50,12,34,26,18,10,2,60,52,44,36,28,20,12,4, 62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8, 57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3, 61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7,
即将输入的第58位换到第1位第50位换到第2位……依此类推最后一位是原来的第7位。L0 R0则是换位输出后的两部分L0是输出的左32位R0是右32位经过16次迭代运算后得到L(16)和R(16)将此作为输入进行逆置换即得到密文输出。 其中每一轮迭代的结构如下图所示 迭代中的F函数如下图所示 F函数中用到的8个BOX置换如下图所示 DES解密 DES算法的解密过程是一样的区别仅仅在于第一次迭代时用子密钥K16第二次K15、……最后一次用K1算法本身并没有任何变化。
子密钥的生成算法 子密钥Ki(48bit)的生成算法初始Key值为64位但DES算法规定其中第8、16、......64位是奇偶校验位不参与DES运算故Key实际可用位数便只有56位。 将56位分为C0、D0两部分各28位然后分别进行第1次循环左移得到C1、D1将C128位、D128位合并得到56位再经过缩小选择换位2从而便得到了密钥K 148位依此类推便可得到K 1、K2、......、K16。
需要注意的是16次循环左移对应的左移位数要依据下述规则进行循环左移位数1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1。 其中置换选择1表如下 置换选择2表如下 编程要求 本关的编程任务是补全右侧代码片段ByteToBit、BitToByte、CYCLELEFT、SETKEY、Set_SubKey、S_BOXF、XOR、F_FUNCTION和DES中Begin至End中间的代码具体要求如下
在ByteToBit中将字节组In转化成位组Outs其中参数bits是每个字符占的位数通常设置为8。在BitToByte中将位组In转换成字节组Outs其中参数bits是每个字符占的位数通常设置为8。在CYCLELEFT中循环左移位组In所有位向左移动loop步其中len是位组长度。在SETKEY中根据8个字节的字符串参数变量Key_C产生64位bool类型的密钥每个字符占8位左边高位右边低位并存入位组参数变量Key_B。在Set_SubKey中根据64位位组密钥生成16个48位的子密钥位组。在S_BOXF中根据S_BOX置换表将48位位组In置换为32位位组Out。在XOR中将位组InA和InB按位异或并将结果存入InA位组中其中len是位组的长度。在F_FUNCTION中实现F函数里的扩展置换EXPAND_32to48、S盒置换S_BOX以及P盒置换TRANS_32to32。在DES中实现加解密算法并通过Type参数来判断执行加密true还是解密false功能。
因为有些函数的实现存在多种方式故生成的密钥会因程序具体实现而不同主程序通过调用这些函数判断整个DES算法实现是否正确。
测试说明 平台将自动编译补全后的代码并生成若干组测试数据接着根据程序的输出判断程序是否正确。
以下是平台的测试样例 测试输入 romantic 2018helo 预期输出 明文romantic 明文0x72 0x6f 0x6d 0x61 0x6e 0x74 0x69 0x63 明文0111001001101111011011010110000101101110011101000110100101100011 密钥2018helo 密钥0x32 0x30 0x31 0x38 0x68 0x65 0x6c 0x6f 密钥0011001000110000001100010011100001101000011001010110110001101111 解密romantic 解密0x72 0x6f 0x6d 0x61 0x6e 0x74 0x69 0x63 解密0111001001101111011011010110000101101110011101000110100101100011 输入格式 第1行8字节长度的明文8个字符 第2行8字节长度的密钥8个字符 输出格式 如上样例输出
开始你的任务吧祝你成功
//
// des.cpp
// step3
//
// Created by ljpc on 2018/10/17.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include des.h
bool flag true;
void print_bool(char* s, const bool *out, int len){printf(%s: , s);for (int i0; ilen; i) {printf(%d, out[i]);}printf(\n);
}
void SETKEY(const char Key_C[8], bool Key_B[64])
// Key_C: 2018helo
// ascii: 0x32 0x30 0x31 0x38 0x68 0x65 0x6c 0x6f
// 8bits: 00110010 00110000 00110001 00111000 01101000 01100101 01101100 01101111
// Key_B: 0011001000110000001100010011100001101000011001010110110001101111
{// 请在这里补充代码完成本关任务/********* Begin *********/for(int i0; i8; i)for(int j0; j8; j)//Key_B[63-i*8-j] ((Key_C[i]j) 1);Key_B[i*87-j] ((Key_C[i]j) 1);/********* End *********/
}
void ByteToBit(bool *Outs, const char *In, int bits)
// In: password
// ascii: 0x70 0x61 0x73 0x73 0x77 0x6f 0x72 0x64
// 8bits: 01110000 01100001 01110011 01110011 01110111 01101111 01110010 01100100
// Outs: 0111000001100001011100110111001101110111011011110111001001100100
{// 请在这里补充代码完成本关任务/********* Begin *********/for(int i0; ibits; i)for(int j0; jbits; j)//Outs[63-i*bits-j] ((In[i]j) 1);Outs[i*bitsbits-1-j] ((In[i]j) 1);/********* End *********/
}
void BitToByte(char *Outs, const bool *In, int bits)
// In: 0111000001100001011100110111001101110111011011110111001001100100
// 8bits: 01110000 01100001 01110011 01110011 01110111 01101111 01110010 01100100
// ascii: 0x70 0x61 0x73 0x73 0x77 0x6f 0x72 0x64
// Outs: password
{// 请在这里补充代码完成本关任务/********* Begin *********/for(int i0; ibits; i){int val 0;for (int j0; jbits; j) {//val (val1) | In[63-i*bits-(bits-1-j)];val (val1) | In[i*bitsj];}Outs[i] val;}Outs[bits] \0;/********* End *********/
}
void CYCLELEFT(bool *In, int len, int loop) // 循环左移函数
// before: 0000000011110000111111110000
// loop: 1
// after: 0000000111100001111111100000
{// 请在这里补充代码完成本关任务/********* Begin *********/bool tmp[28];memcpy(tmp, In, sizeof(tmp));for (int i0; ilen; i) {In[i] tmp[(iloop)%len];}/********* End *********/
}
void Set_SubKey(bool subKey[16][48], bool Key[64]) // 设置子密钥
// Key: 0011001000110000001100010011100001101000011001010110110001101111
// SubKey: 011000000011110001100100010111000101100101000100
// SubKey: 010000001011010001110100010111001000100011100100
// SubKey: 110001001100010001110110110000001110110011011001
// SubKey: 111001101100001100100010001010111011011000011001
// SubKey: 101010101001001100100011101110110101010100100010
// SubKey: 101010010001001001011011000011000100101100100110
// SubKey: 001001010101001011011000110101000110100011010100
// SubKey: 000101100101100111010000111000011000001011011001
// SubKey: 000101100100100101010001111000111010011010011000
// SubKey: 000011110110100100010101001110010001011100001111
// SubKey: 000011110010010110001101000111100101000010100110
// SubKey: 010110110000010010101001010001000110100111100101
// SubKey: 110110011000100010101000101000101010100011011001
// SubKey: 100100001010101010001110111000111001011100010011
// SubKey: 001100000011111000000110000111110000011100101010
// SubKey: 011100000011111000000100000101000101011101100110
{// 请在这里补充代码完成本关任务/********* Begin *********/bool realKey[56];bool left[28];bool right[28];bool compressKey[48]; // 去掉奇偶标记位将64位密钥变成56位for (int i0; i56; i){realKey[i] Key[TRANS_64to56[i]-1];}// 生成子密钥保存在 subKeys[16] 中for(int round0; round16; round){// 前28位与后28位for(int i0; i28; i)left[i] realKey[i];for(int i28; i56; i)right[i-28] realKey[i];// 左移CYCLELEFT(left, 28, SHIFT_TAB[round]);CYCLELEFT(right, 28, SHIFT_TAB[round]);for(int i0; i28; i)realKey[i] left[i];for(int i28; i56; i)realKey[i] right[i-28];// 压缩置换由56位得到48位子密钥for(int i0; i48; i)compressKey[i] realKey[TRANS_56to48[i]-1];for (int i0; i48; i) {subKey[round][i] compressKey[i];}}/********* End *********/
}
void XOR(bool *InA, const bool *InB, int len) // 异或函数
// Before InA: 000000000001011111111110100100000000001111111000
// Before InB: 011000000011110001100100010111000101100101000100
// Before InA: 011000000010101110011010110011000101101010111100
// Before InB: 011000000011110001100100010111000101100101000100
{// 请在这里补充代码完成本关任务/********* Begin *********/for (int i0; ilen; i) {InA[i] InA[i] ^ InB[i];}/********* End *********/
}
void S_BOXF(bool Out[32], const bool In[48])// S-盒代替函数
{// 请在这里补充代码完成本关任务/********* Begin *********/int x 0;for(int i0; i48; ii6){int row In[i0]*2 In[i5];int col In[i1]*8 In[i2]*4 In[i3]*2 In[i4];int num S_BOX[i/6][row][col];for (int k3; k0; k--) {Out[xk] num%2;num / 2;}x 4;}/********* End *********/
}
void F_FUNCTION(bool In[32], const bool Ki[48]) // f 函数完成扩展置换、S-盒代替和P盒置换
{// 请在这里补充代码完成本关任务/********* Begin *********/// 第一步扩展置换32 - 48bool expandR[48];for(int i0; i48; i)//expandR[47-i] In[32-EXPAND_32to48[i]]; // 0x8c 0x22 0xe2 0x86 0x48 0x5a 0x4b 0xaeexpandR[i] In[EXPAND_32to48[i]-1]; // 0x8c 0x22 0xe2 0x86 0x48 0x5a 0x4b 0xae// 第二步异或XOR(expandR, Ki, 48);// 第三步查找S_BOX置换表bool output[32];S_BOXF(output, expandR);// 第四步P-置换32 - 32for(int i0; i32; i){In[i] output[TRANS_32to32[i]-1];}/********* End *********/
}
void DES(char Out[8], char In[8], const bool subKey[16][48], bool Type) // 标准DES Type: True加密/False解密
{// 请在这里补充代码完成本关任务/********* Begin *********/bool plain[64];bool left[32];bool right[32];bool newLeft[32];bool cipher[64];bool currentBits[64];ByteToBit(plain, In, 8);// 第一步初始置换IPfor(int i0; i64; i)currentBits[i] plain[TRANS_INIT[i]-1];// 第二步获取 Li 和 Rifor(int i0; i32; i)left[i] currentBits[i];for(int i32; i64; i)right[i-32] currentBits[i];// 第三步共16轮迭代if (Type true) { // 加密for(int round0; round16; round){memcpy(newLeft, right, sizeof(newLeft));F_FUNCTION(right,subKey[round]);XOR(right, left, 32);memcpy(left, newLeft, sizeof(left));}}if (Type false) { // 解密for(int round15; round0; round--){memcpy(newLeft, right, sizeof(newLeft));F_FUNCTION(right,subKey[round]);XOR(right, left, 32);memcpy(left, newLeft, sizeof(left));}}// 第四步合并L16和R16注意合并为 R16L16for(int i0; i32; i)//cipher[63-i] left[31-i];cipher[i] right[i];for(int i32; i64; i)//cipher[63-i] right[31-(i-32)];cipher[i] left[(i-32)];// 第五步结尾置换IP-1for(int i0; i64; i)currentBits[i] cipher[i];for(int i0; i64; i)cipher[i] currentBits[TRANS_END[i]-1];BitToByte(Out, cipher, 8);/********* End *********/
}
第4关实验四RSA加解密算法的实现
任务描述 本关任务掌握RSA加密算法的加解密过程并且实现RSA加解密算法中的各个功能模块。
相关知识 为了完成本关任务你需要掌握1.RSA加密算法2.公钥和私钥的产生3.加解密消息。
RSA加密算法 RSA加密算法是一种非对称加密算法。在公钥加密标准和电子商业中RSA被广泛使用。RSA是1977年由罗纳德•李维斯特Ron Rivest、阿迪•萨莫尔Adi Shamir和伦纳德•阿德曼Leonard Adleman一起提出的。当时他们三人都在麻省理工学院工作RSA就是他们三人姓氏开头字母拼在一起组成的。
RSA算法的可靠性基于分解极大的整数是很困难的。假如有人找到一种很快的分解因子的算法的话那么用RSA加密的信息的可靠性就肯定会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长用RSA加密的信息实际上是不能被解破的。
公钥和私钥的产生 假设Alice想要通过一个不可靠的媒体接收Bob的一条私人讯息。她可以用以下的方式来产生一个公钥和一个密钥
step1随意选择两个大的质数p和qp不等于q计算Npq。
step2根据欧拉函数不大于N且与N互质的整数个数为(p−1)(q−1)。
step3选择一个整数e与(p−1)(q−1)互质并且e小于(p−1)(q−1)。
step4用以下这个公式计算dd×e≡1(mod(p−1)(q−1))。
step5将p和q的记录销毁。
其中e是公钥d是私钥。d是秘密的而N是公众都知道的Alice将她的公钥传给Bob而将她的私钥藏起来。
加解密消息 假设Bob想给Alice送一个消息m他知道Alice产生的N和e用下面这个公式他可以将m加密为c
cm e (modn)
计算c并不复杂Bob算出c后就可以将它传递给Alice。
Alice得到Bob的消息c后就可以利用她的密钥d来解码她可以用以下这个公式来将c转换为m
mc d ((modn))
最终她可以将原来的信息m重新复原。
编程要求 本关的编程任务是补全右侧代码片段PRIME、mod、exgcd、Inv、GCD和ModPow中Begin至End中间的代码具体要求如下
在PRIME中借助全局数组变量p用素数筛法求10000以内的所有素数并存入全局数组变量prime中。
在mod中计算64位整型参数变量a在参数变量n下的模。
在exgcd中根据参数a、b、c实现扩展欧几里得axbyc并将结果存入x、y。
在Inv中借助exgcd函数计算参数a在模n下的逆元。
在GCD中求两个整数a和b的最大公约数。
在ModPow中计算a的b次幂在模n下的结果x≡a b (modn)。
测试说明 平台将自动编译补全后的代码并生成若干组测试数据接着根据程序的输出判断程序是否正确。
以下是平台的测试样例 测试输入 14 16 465 预期输出 素数47 59 公开N2773 欧拉T2668 公钥E3 私钥D1779 明文465 密文1191 解密465 输入格式 第1行整数p1和p2表示素数表中的第一个素数 第2行整型数据明文 输出格式 如上样例8行输出 开始你的任务吧祝你成功
//
// main.cpp
// step4
//
// Created by ljpc on 2018/10/16.
// Copyright © 2018年 ljpc. All rights reserved.
//
#include iostream
#include algorithm
#include stdio.h
using namespace std;
#define int64 long long
int prime[2001]; //存放素数
int p[10001]; //用筛选法求素数
void PRIME()
{// 请在这里补充代码完成本关任务/********* Begin *********/int i,i2,k;for(i0;i10000;i2)p[i]0;for(i1;i10000;i2)p[i]1;p[2]1;p[1]0;for(i3;i100;i2){if(p[i]1){i2ii;ki2i;while(k10000){p[k]0;ki2;}}}int t 0;prime[t]2;for(i3;i10000;i2)if(p[i])prime[t]i;/********* End *********/}
int64 mod(int64 a,int64 n)
{// 请在这里补充代码完成本关任务/********* Begin *********/return (a%nn)%n;/********* End *********/
}
void exgcd(int64 a,int64 b,int64 d,int64 x,int64 y)
{// 请在这里补充代码完成本关任务/********* Begin *********/if(b0){da;x1;y0;return;}exgcd(b,a%b,d,y,x);y-x*(a/b);/********* End *********/
}
//a-1 mod n
int64 Inv(int64 a,int64 n) // 计算逆元素
{// 请在这里补充代码完成本关任务/********* Begin *********/int64 d,x,y;exgcd(a,n,d,x,y);if(d1)return mod(x,n);elsereturn -1;/********* End *********/
}
//求两个数的最大公约数
int64 GCD(int64 n,int64 m)
{// 请在这里补充代码完成本关任务/********* Begin *********/int64 t,r;if(nm){tn;nm;mt;}while((rn%m)!0){nm;mr;}return m;/********* End *********/
}
//xa^b(mod n)
int64 ModPow(int64 a,int64 b,int64 n)
{// 请在这里补充代码完成本关任务/********* Begin *********/int64 d1,i0;while(b(1i)) i;for(--i;i0;--i){dd*d%n;if(b(1i))dd*a%n;}return d;/********* End *********/
}
int main(int argc, const char * argv[]) {PRIME();int64 P1, P2;int64 T;int64 N;int64 E;int64 D;int64 M;int64 C;int64 m;scanf(%lld %lld, P1, P2);scanf(%lld, M);P1 prime[P1];P2 prime[P2];T (P1-1)*(P2-1);N P1 * P2;for(int64 i2; iT; i)if(GCD(T, i)1){E i;break;}D Inv(E, T);C ModPow(M,E,N);m ModPow(C,D,N);printf(素数%lld %lld\n, P1, P2);printf(公开N%lld\n,N);printf(欧拉T%lld\n,T);printf(公钥E%lld\n,E);printf(私钥D%lld\n,D);printf(明文%lld\n,M);printf(密文%lld\n,C);printf(解密%lld\n,m);return 0;
}
