网络安全RSA算法的实现实验报告
现代密码算法实验报告(3篇)
第1篇一、实验目的1. 了解现代密码学的基本原理和数论基础知识；2. 掌握非对称密码体制的著名代表RSA加密算法的工作原理和流程；3. 设计实现一个简单的密钥系统；4. 掌握常用加密算法AES和DES的原理及实现。
二、实验内容1. RSA加密算法实验2. AES加密算法实验3. DES加密算法实验三、实验原理1. RSA加密算法RSA算法是一种非对称加密算法，由罗纳德·李维斯特、阿迪·沙米尔和伦纳德·阿德曼三位密码学家于1977年提出。
其基本原理是选择两个大质数p和q，计算它们的乘积n=pq，并计算欧拉函数φ(n)=(p-1)(q-1)。
选择一个整数e，满足1<e<φ(n)且e与φ(n)互质。
计算e关于φ(n)的模逆元d。
公开密钥为(e,n)，私有密钥为(d,n)。
加密过程为C=Me mod n，解密过程为M=Cd mod n。
2. AES加密算法AES（Advanced Encryption Standard）是一种分组加密算法，采用128位分组大小和128、192或256位密钥长度。
AES算法主要分为四个阶段：初始轮、密钥扩展、中间轮和最终轮。
每个轮包括字节替换、行移位、列混淆和轮密钥加。
3. DES加密算法DES（Data Encryption Standard）是一种分组加密算法，采用64位分组大小和56位密钥长度。
DES算法主要分为16轮，每轮包括置换、置换-置换、S盒替换和密钥加。
四、实验步骤及内容1. RSA加密算法实验（1）选择两个大质数p和q，计算n=pq和φ(n)=(p-1)(q-1)；（2）选择一个整数e，满足1<e<φ(n)且e与φ(n)互质，计算e关于φ(n)的模逆元d；（3）生成公开密钥(e,n)和私有密钥(d,n)；（4）用公钥对明文进行加密，用私钥对密文进行解密。
2. AES加密算法实验（1）选择一个128、192或256位密钥；（2）初始化初始轮密钥；（3）进行16轮加密操作，包括字节替换、行移位、列混淆和轮密钥加；（4）输出加密后的密文。
(完整版)RSA算法实验报告
RSA算法的实现实验原理算法原理RSA公开密钥密码体制。
所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。
RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。
RSA的算法涉及三个参数，n、e1、e2。
其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。
e1和e2是一对相关的值，e1可以任意取，但要求e1与(p-1）*(q-1）互质；再选择e2，要求（e2*e1）mod((p-1）*(q-1））=1。
（n，e1）,(n，e2）就是密钥对。
其中(n，e1）为公钥，(n，e2）为私钥。
RSA加解密的算法完全相同，设A为明文，B为密文，则：A=B^e2 mod n；B=A^e1 mod n；（公钥加密体制中，一般用公钥加密，私钥解密）e1和e2可以互换使用，即：A=B^e1 mod n；B=A^e2 mod n;密钥生成首先要使用概率算法来验证随机产生的大的整数是否质数，这样的算法比较快而且可以消除掉大多数非质数。
假如有一个数通过了这个测试的话，那么要使用一个精确的测试来保证它的确是一个质数。
密钥分配和其它加密过程一样，对RSA来说分配公钥的过程是非常重要的。
分配公钥的过程必须能够抵挡一个从中取代的攻击。
假设Eve交给Bob一个公钥，并使Bob相信这是Alice的公钥，并且她可以截下Alice和Bob之间的信息传递，那么她可以将她自己的公钥传给Bob，Bob以为这是Alice的公钥。
步骤如下（这里设B为是实现着）（1）B寻找出两个大素数p和q。
（2）B计算出n=p*q和ϕ（n）=）（p-1）*（q-1）。
（3）B选择一个随机数e（0<e<ϕ(n)）,满足（e,ϕ(n))=1 (即e与欧拉函数互素ϕ（n）)。
（4）B使用欧几里得算法计算e的模余ϕ（n）的乘法逆元素d。
rsa算法实验报告
rsa算法实验报告RSA算法实验报告摘要：RSA算法是一种非对称加密算法，被广泛应用于网络安全领域。
本实验通过对RSA算法的原理和实现进行了深入研究，并通过编写代码实现了RSA算法的加密和解密过程。
实验结果表明，RSA算法具有较高的安全性和可靠性，能够有效保护数据的机密性和完整性。
一、引言RSA算法是一种基于大数因子分解的非对称加密算法，由Rivest、Shamir和Adleman三位数学家于1977年提出。
它的安全性基于两个大素数的乘积难以分解，因此被广泛应用于数字签名、数据加密等领域。
本实验旨在通过对RSA 算法的原理和实现进行研究，深入了解其加密和解密过程，并通过编写代码实现RSA算法的加密和解密过程。
二、RSA算法原理RSA算法的原理主要包括密钥生成、加密和解密三个过程。
首先，选择两个大素数p和q，并计算它们的乘积n=p*q，然后计算欧拉函数φ(n)=(p-1)*(q-1)。
接下来选择一个整数e，使得1<e<φ(n)，且e与φ(n)互质，即e和φ(n)的最大公约数为1。
然后计算e的乘法逆元d，使得(e*d) mod φ(n) = 1。
最后，公钥为(n, e)，私钥为(n, d)。
加密过程中，将明文m通过公钥加密为密文c，即c=m^e mod n；解密过程中，将密文c通过私钥解密为明文m，即m=c^d mod n。
三、实验设计本实验使用Python语言编写了RSA算法的加密和解密代码，通过输入明文和密钥，实现了对明文的加密和解密过程。
具体实验步骤如下：1. 选择两个大素数p和q，并计算n=p*q，以及φ(n)=(p-1)*(q-1)；2. 选择一个整数e，使得1<e<φ(n)，且e与φ(n)互质；3. 计算e的乘法逆元d，使得(e*d) mod φ(n) = 1；4. 将明文m通过公钥加密为密文c，即c=m^e mod n；5. 将密文c通过私钥解密为明文m，即m=c^d mod n。
RSA算法的实现实验报告
RSA算法的实现实验报告一、实验目的本实验的主要目的是了解和掌握RSA（Rivest-Shamir-Adleman）算法的原理以及其在加密和解密过程中的具体实现。
通过实践和对比分析，了解RSA算法的安全性和效率，并加深对大数计算的理解。
二、算法原理1.密钥生成（1）选择两个大素数p和q，并计算其乘积n=p*q。
（2）计算n的欧拉函数φ(n)=(p-1)*(q-1)。
（3）选择一个整数e，满足1<e<φ(n)，并且e与φ(n)互质，即gcd(e, φ(n)) = 1（4）计算e的乘法逆元d，满足e*d ≡ 1 (mod φ(n))。
（5）公钥为(n,e)，私钥为(n,d)。
2.加密加密过程使用公钥对明文进行加密：（1）明文转化为整数m，满足0≤m＜n。
（2）计算密文c = m^e mod n。
3.解密解密过程使用私钥对密文进行解密：（1）计算明文m = c^d mod n。
（2）还原明文。
三、实验步骤1.实现大数的运算由于RSA算法的关键在于处理大数运算，我们首先实现了大数的加法、减法和乘法运算，并使用这些运算函数作为之后RSA算法中的基础运算。
2.实现RSA算法的密钥生成（1）随机选择两个大素数p和q。
（2）计算n=p*q。
（3）计算φ(n)=(p-1)*(q-1)。
（4）选择一个满足要求的公钥e。
（5）计算e的乘法逆元d。
（6）生成公钥(n,e)和私钥(n,d)。
3.实现RSA算法的加密和解密（1）输入明文。
（2）使用公钥对明文进行加密。
（3）得到密文。
（4）使用私钥对密文进行解密。
（5）还原明文。
四、实验结果与分析我们使用python语言实现了RSA算法，并进行了一些测试和分析，得到以下结果和结论。
1.RSA算法的安全性2.RSA算法的效率3.实验结果分析我们对一些常见文本进行了加密和解密实验，得到了正确的结果。
实验结果表明，RSA算法能够对数据进行有效的加密和解密，并确保数据的安全性。
rsa加密 实验报告
rsa加密实验报告RSA加密实验报告概述RSA加密算法是一种非对称加密算法，广泛应用于信息安全领域。
本实验旨在通过实际操作，深入理解RSA加密算法的原理、过程和应用。
实验目的1. 理解RSA加密算法的原理和基本概念；2. 掌握RSA加密算法的加密和解密过程；3. 了解RSA加密算法的应用场景和安全性。
实验材料1. 一台计算机；2. 编程语言或工具，如Python。
实验步骤1. 生成密钥对首先，我们需要生成一对RSA密钥，包括公钥和私钥。
公钥用于加密数据，私钥用于解密数据。
在Python中，可以使用`cryptography`库来生成密钥对。
2. 加密数据选择一段需要加密的数据，可以是文本、图片或其他文件。
将数据使用公钥进行加密，得到密文。
在Python中，可以使用`cryptography`库中的RSA加密函数来实现。
3. 解密数据使用私钥对密文进行解密，还原成原始数据。
在Python中，可以使用`cryptography`库中的RSA解密函数来实现。
4. 实验结果分析分析实验结果，包括加密后的密文和解密后的明文。
观察密文的长度和结构，以及解密过程是否成功。
同时，可以比较不同数据加密的结果，探讨RSA加密算法的安全性和可靠性。
实验注意事项1. 密钥的安全性：私钥是解密数据的关键，必须妥善保管，避免泄露给他人。
公钥可以公开使用，但也需要注意保护，以防止被篡改。
2. 数据大小限制：RSA加密算法对数据的大小有一定限制，一般建议将较大的数据先进行分块处理，然后分别加密和解密。
3. 算法优化：RSA加密算法的性能较低，特别是对大素数的计算。
在实际应用中，可以采用一些优化技术，如使用快速模幂算法，提高加密和解密的效率。
实验结论通过本次实验，我们深入了解了RSA加密算法的原理和过程。
RSA加密算法具有较高的安全性，适用于保护敏感数据的加密和解密。
然而，由于其计算复杂度较高，对于大数据的加密和解密可能存在性能问题。
网络信息安全试验报告(2)
网络信息安全试验报告－RSA加密算法的实现姓名：拓慧玲学号：20907210专业：09信管2班指导老师：吕林涛一、实验目的通过本次实验，掌握RSA算法的基本思想。
使用C语言实现RSA算法，并且可以对简单数字串进行加密、解密。
二、实验原理通过查阅资料，了解RSA算法基本思想。
首先, 找出三个数, p, q, r, 其中p, q 是两个相异的质数, r 是与(p-1)(q-1) 互质的数。
p, q, r 这三个数便是private key（私钥）接著, 计算m, r*m == 1 mod (p-1)(q-1)..... 这个m 一定存在, 因为r 与(p-1)(q-1) 互质, 用辗转相除法就可以得到了.....再来, 计算n = pq....... m, n 这两个数便是public key(公钥)。
编码过程是：若明文为a, 将其看成是一个大整数, 假设 a < n....如果 a >= n 的话, 就将a 表成s 进位(s <= n, 通常取s = 2^t),则每一位数均小於n, 然后分段编码......接下来, 计算b == a^m mod n, (0 <= b < n),b 就是编码后的密文......解码的过程是, 计算 c == b^r mod pq (0 <= c < pq),如果第三者进行窃听时, 他会得到几个数: m, n(=pq), b。
他如果要破解的话, 必须想办法得到r。
. 所以, 他必须先对n 作质因数分解。
但是n往往是非常大的数，同时还有两个非常的大质数p, q, 使第三者作因数分解时发生困难。
对方往往很难破解出明文。
三、实验源码#include<stdio.h>#include<math.h>#include<string.h>int getd(int p, int q,int e){int qn,d=1;qn=(p-1)*(q-1);while(d){if(d*e%qn==1) return(d);else d++;}}/*getd*/int power(int a,int b){int mut=1;while(b!=0){mut*=a;b--;}return mut;}/*power*/int jiemi(int e,int n,int p){int q;q=power(p,e)%n;return q;}/*jiemi*/int jiami(int e,int n,int p){int q;q=power(p,e)%n;return q;}/*jiami*/int main(){int prime1,prime2,p;int d,e,n,miwen,minwen;int getd(int p,int q,int e);printf("请输入两个大的素数和公钥，e和n \n");scanf("%d%d%d",&prime1,&prime2,&e);n=prime1*prime2;printf("n为%d \n",n);d=getd(prime1,prime2,e);printf("私有密钥是%d\n",d);/*其中e和n为共钥,d为私钥*/ printf("请输入要加密的数字串\n");scanf("%d",&p);while(p!=0){miwen=jiami(e,n,p);printf("加密的数值是%d",miwen);minwen = jiemi (d,n,miwen);printf("\n\n解密后的数值为; %d \n",minwen);scanf("%d",&p);break;}}四、实验结果五、实验总结通过此次实验，我了解了公钥密码体制的基本思想，基本掌握了公钥密码体制RSA。
RSA算法实验报告
RSA算法实验报告第一点：RSA算法原理及其数学基础RSA算法是一种非对称加密算法，于1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）提出。
它的名称就是这三位发明者姓氏的首字母缩写。
RSA算法的出现，为信息安全领域带来了重大的变革，它不仅解决了密钥的分发问题，还提供了加密和解密功能。
RSA算法的核心是基于整数分解的难解性。
假设我们有一个大整数N，它是由两个大质数p和q相乘得到的，即N=pq。
我们知道，分解N为p和q是非常困难的，尤其是在N非常大的情况下。
这就是RSA算法的安全性所在。
RSA算法的步骤如下：1.选择两个大的质数p和q，计算N=pq，再计算欧拉函数φ(N)=(p-1)(q-1)。
2.选择一个与φ(N)互质的整数e，计算d，使得ed≡1(mod φ(N))。
3.将(N,e)作为公钥，(N,d)作为私钥。
4.加密：明文M转换为0到N-1之间的整数m，密文c≡m^e(mod N)。
5.解密：密文c转换为0到N-1之间的整数c，明文m≡c^d(mod N)。
第二点：RSA算法的实现与分析在实际应用中，RSA算法的实现主要包括以下几个步骤：1.随机选择两个大的质数p和q。
为了确保N的安全性，通常需要选择几千位的质数。
2.计算N=pq和φ(N)=(p-1)(q-1)。
3.选择一个与φ(N)互质的整数e，通常选择65537，因为它是一个质数，并且在模运算中具有较好的性能。
4.计算d，使得ed≡1(mod φ(N))。
5.输出公钥(N,e)和私钥(N,d)。
RSA算法的分析主要关注以下几个方面：1.安全性：RSA算法的安全性主要取决于N的质数因子p和q的大小。
当N的位数足够多时，分解N为p和q是非常困难的。
2.性能：RSA算法的加密和解密速度较慢，尤其是当N的位数较多时。
因此，RSA算法更适合用于加密较小的数据，如密钥交换和数字签名。
RSA算法实验报告
实验二非对称密码算法RSA一、实验目的通过实际编程了解非对称密码算法RSA勺加密和解密过程，加深对非对称密码算法的认识。
二、实验环境运行Windows或Linux操作系统的PC机，具有版本的Java语言编译环境。
三、实验内容和步骤1、对RSA算法的理解RSA算法(公开密钥算法)的原理：(1) •选择两个大的素数p和q (典型情况下为1024位)(2) ．计算n = p * q 和z = ( p-1 ) * ( q-1 ) .(3) ．选择一个与z 互素的数，将它称为d⑷. 找到e,使其满足e*d = 1 mod z提前计算出这些参数以后，我们就可以开始执行加密了。
首先将明文分成块，使得每个明文消息P落在间隔0*P<n中。
为了做到这一点，只要将明文划分成k 位的块即可，这里k是满足2A k<n的最大整数。
为了加密一个消息P,只要计算C=P A e(mod n)即可。
为了解密C,只要计算P=C A d(modn)即可。
可以证明，对于指定范围内的所有P,加密盒解密互为反函数。
为了执行加密，你需要e和n；为了执行解密，你需要d和n。
因此，公钥是有(e，n)对组成，而私钥是有(d，n)对组成。
实例：根据已知参数：p=3，q=11，M=2计算公私钥，并对明文进行加密，然后对密文进行解密。
由题意知：n = p * q = 33, z = (p-1 ) * (q-1 )= 20,选 d = 7，计算得e=3,所以C=MAe(mod n) = 8M=CAd(mod n) = 22、RSA 算法与DES 算法的比较：运行附件的RSATool,输入一大段文字，记录运行时间。
再使用DES算法加密相同的文字，记录运行时间，对比这两个时间发现，RSA算法比DES算法慢很多，因为RSA算法进行的是大数运算，所以程序运行的速度比DES慢很多。
因此RSA算法只适合于少量数据加密，不适合于大量数据加密。
3、算法设计主要的方法：(1)、public static void GetPrime()方法名称：产生大数的方法。
RSA加密算法实验报告_2
现代密码学实验报告题目: RSA算法的实现过程
一、实验目的
二、简单实现RSA过程, 通过OpenSSL命令编辑器实现发送方对明文进行加
密, 签名, 接受方验证, 解密的简单过程。
三、实验原理
RSA加密算法的基本流程:
四、实验步骤
发送方对明文进行加密:
首先利用MD5对明文进行摘要操作:
然后生成秘钥文件:
再利用这个密钥对摘要进行加密:
然后对摘要进行签名操作:
发送方加密后要发送的东西是: 明文和摘要的签名传送到接收方后,接收方进行解密操作:
接收方进行验证:
通过比较可以发现所得摘要的结果是相同的, 则可以得到结论: 该明文没有被篡改。
五、实验心得
通过对RSA过程的简单模仿, 我们可以明白理论和现实是有一定差别的, 我们需要将明文利用MD5进行摘要处理, 然后在通过MD5对摘要进行验证, 从而判断密文是否经过修改, 达到数据的安全性, 完整性和保密性。
在使用OpenSSL进行RSA过程模仿时要注意文件名的对应, 这需要我们在命名文件时能做到见名之意, 方便我们后续的操作。
命令行的书写方式需要我们对字母有一定的敏感性, 经常会出现字母出现问题而导致错误的发生。
RSA密码算法实现
密码学实验报告学院名称：通信与信息工程学院实验名称：RSA密码算法实现【实验名称】RSA密码算法实现【实验目的】1、了解公钥密码体制的基本思想。
2、掌握公钥密码算法RSA，并体会其设计思想。
3、学会分析RSA算法的安全性。
【实验原理及步骤】实验原理：RSA 的安全性依赖于大数分解。
公钥和私钥都是两个大素数（大于 100 个十进制位）的函数。
据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积。
密钥对的产生。
选择两个大素数，p 和 q 。
计算：n = p × q然后随机选择加密密钥 e，要求 e 和 ( p - 1 ) × ( q - 1 ) 互质。
最后，利用 Euclid 算法计算解密密钥 d, 满足e × d = 1 ( mod ( p - 1 ) × ( q - 1 ) )其中 n 和 d 也要互质。
数 e 和 n 是公钥，d 是私钥。
两个素数 p 和 q 不再需要，应该丢弃，不要让任何人知道。
加密信息 m（二进制表示）时，首先把 m 分成等长数据块 m1 ,m2,..., mi ，块长 s，其中 2^s ≤ n, s 尽可能的大。
对应的密文是：ci = mi^e ( mod n )解密时作如下计算：mi = ci^d ( mod n )RSA算法以两个大素数的乘积作为算法的公钥来加密消息，而密文的解密必须知道相应的两个大素数。
实验步骤：1、分析它的算法原理。
2、在vc++6.0上编写源程序。
源程序如下：3、运行，调试，得出结果。
【实验结果】【实验分析与心得体会】经过此次实验，我了解了公钥密码体制的基本思想，基本了掌握公钥密码算法RSA。
学会了分析密码算法安全性的基本思想。
但在此次实验中出现了不少以前学过而又已经忘了的普通算法，所以，在以后的学习试验中，首先是得把必备的一些基础知识弄扎实。
信息安全-RSA加密算法实验报告
信息安全-RSA加密算法实验报告RSA加密算法是一种非对称加密算法，它能够保障信息的安全性，被广泛应用于各种领域。
本次实验的目的是深入理解RSA加密算法的原理和应用，掌握RSA算法的加密和解密过程，并进行相应的实验操作。
一、具体实验操作1.1 生成RSA密钥对在Python中引入RSA模块，使用generate方法生成RSA密钥对。
密钥长度为1024位，生成的公钥和私钥分别保存在public.pem和private.pem两个文件中。
```from Crypto.PublicKey import RSA# 生成RSA密钥对key = RSA.generate(1024)# 分别保存到public.pem和private.pem文件中with open('public.pem', 'wb') as f:f.write(key.publickey().exportKey())1.2 加密和解密加密和解密的过程中，首先读入公钥和私钥，分别使用公钥对信息进行加密，私钥对密文进行解密。
# 测试加密和解密message = 'RSA加密算法实验'print(f"原始信息：{message}")ciphertext = encrypt(message)print(f"密文：{ciphertext}")message = decrypt(ciphertext)print(f"解密后信息：{message}")```二、结果分析经过实验操作，我们发现RSA加密算法实现了高强度的信息加密和解密，确实能够有效保障信息的安全性。
下面对RSA算法的加密和解密过程进行详细的分析。
2.1 密钥产生RSA算法的优势在于它的非对称密码系统，即公钥加密，私钥解密；私钥加密，公钥解密。
RSA的安全基于大质数分解理论，具体来说，是利用了存在一个大因子分解困难的数，对于多种攻击手段都有较好的抵御力度。
RSA算法实验报告
RSA算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握 RSA 算法的原理及实现过程，通过实际操作和编程实现，验证 RSA 算法在加密和解密过程中的有效性和安全性，并分析其性能和特点。
二、实验原理RSA 算法是一种非对称加密算法，它基于数论中的大整数分解难题。
其密钥生成过程如下：1、选择两个大的质数 p 和 q。
2、计算 n ＝ p q。
3、计算欧拉函数φ(n) ＝（p 1) （q 1)。
4、选择一个整数 e，满足 1 ＜ e ＜φ(n)，且 e 与φ(n) 互质。
5、计算 d，满足e d ≡ 1 （mod φ(n)）。
公钥为（n, e)，私钥为（n, d)。
加密过程：对于明文 m，计算密文 c ＝ m^e （mod n)。
解密过程：对于密文 c，计算明文 m ＝ c^d （mod n)。
三、实验环境本次实验使用的编程语言为 Python，使用的开发工具为 PyCharm。
四、实验步骤1、生成密钥｀｀｀pythonimport randomdef generate_prime(bits)：while True:num ＝ randomgetrandbits(bits)if is_prime(num)：return numdef is_prime(num)：if num ＜ 2:return Falsefor i in range(2, int(num05) ＋ 1)：if num ％ i ＝＝ 0:return Falsereturn Truedef generate_keys(bits)：p ＝ generate_prime(bits ／／ 2)q ＝ generate_prime(bits ／／ 2)n ＝ p qphi_n ＝（p 1) （q 1)e ＝ 65537 常见的选择d ＝ pow(e, －1, phi_n)return （n, e)，（n, d)｀｀｀2、加密函数｀｀｀pythondef encrypt(message, public_key)：n, e ＝ public_keymessage ＝ intfrom_bytes(messageencode(），＇big'）ciphertext ＝ pow(message, e, n)return ciphertext｀｀｀3、解密函数｀｀｀pythondef decrypt(ciphertext, private_key)：n, d ＝ private_keyplaintext ＝ pow(ciphertext, d, n)plaintext ＝ plaintextto_bytes(（plaintextbit_length(）＋ 7) ／／ 8, ＇big'）decode(）return plaintext｀｀｀4、测试｀｀｀pythonpublic_key, private_key ＝ generate_keys(1024)message ＝＂这是要加密的消息"ciphertext ＝ encrypt(message, public_key)decrypted_message ＝ decrypt(ciphertext, private_key)print(＂原始消息：＂， message)print(＂加密后的密文：＂， ciphertext)print(＂解密后的消息：＂， decrypted_message)｀｀｀五、实验结果与分析通过实验，成功生成了 RSA 算法的密钥对，并对给定的明文进行了加密和解密操作。
实验五、RSA算法的实现
8、将明文P (假设P是一个小于n的整数)加密为密文C，计算方法为：C = Pemod n
9、将密文C解密为明文P，计算方法为：P = Cdmod n
然而只根据n和e（不是p和q）要计算出d是不可能的。因此，任何人都可对明文进行加密，但只有授权用户（知道d）才可对密文解密。
a>>=1;
b>>=1;
} if(!(a & 1))
{ t=a; //如果a为偶数，交换a，b
a=b;
b=t; }
do
{ while(!(b & 1))
{ b>>=1; //b为偶数，a为奇数时，gcd(b,a)=gcd(b/2,a) }
if(b < a)
{ t=a; //如果b小于a，交换a，b
a=b;
{ unsigned __int64 a=p > q ? p : q;
unsigned __int64 b=p < q ? p : q;
unsigned __int64 t;
if(p == q)
{ return p; //两数相等，最大公约数就是本身}
else
{ while(b) //辗转相除法，gcd(a,b)=gcd(b,a-qb)
1、确定密钥的长度；
2、随机选择两个不同的素数p处q，它们的宽度是密钥宽度的二分之一；
3、计算出p和q的乘积n；
4、在2和Φ(n)之间随机选择一个数e，e必须和Φ(n)互素整数e用做加密（其中Φ(n)=(p-1)*(q-1)）；
5、从公式ed≡1 modΦ(n)中求出解密密钥d；
6、得公钥（e，n），私钥(d，n)；
base+=g_Rnd.Random(base); //再加上一个随机数
rsa算法实验报告
rsa算法实验报告RSA算法实验报告引言RSA算法是一种非对称加密算法，广泛应用于信息安全领域。
本实验旨在通过实际操作，深入了解RSA算法的原理和应用。
一、RSA算法原理RSA算法是基于大数因子分解的数论问题，其基本原理如下：1. 选择两个大素数p和q，并计算n=p*q。
2. 计算欧拉函数φ(n)=(p-1)*(q-1)。
3. 选择一个小于φ(n)且与φ(n)互质的整数e，作为公钥。
4. 计算e关于φ(n)的模反元素d，作为私钥。
5. 公钥为(n, e)，私钥为(n, d)。
6. 加密过程：将明文m通过公钥进行加密，得到密文c=(m^e) mod n。
7. 解密过程：将密文c通过私钥进行解密，得到明文m=(c^d) mod n。
二、实验步骤1. 选择两个大素数p和q，并计算n=p*q。
2. 计算欧拉函数φ(n)=(p-1)*(q-1)。
3. 选择一个小于φ(n)且与φ(n)互质的整数e，作为公钥。
4. 计算e关于φ(n)的模反元素d，作为私钥。
5. 生成公钥(n, e)和私钥(n, d)。
6. 输入明文m。
7. 加密过程：计算密文c=(m^e) mod n。
8. 解密过程：计算明文m=(c^d) mod n。
9. 输出解密后的明文m。
三、实验结果本次实验选择了p=61，q=53作为素数，计算得到n=3233，φ(n)=3120。
选择e=17作为公钥，计算得到d=2753作为私钥。
输入明文m=1234，经过加密过程得到密文c=855。
再经过解密过程，得到解密后的明文m=1234。
四、实验分析通过本次实验，我们可以看到RSA算法具有较高的安全性和可靠性。
由于大素数因子分解问题的难解性，即使知道公钥(n, e)和密文c，也很难推导出私钥d 和明文m。
这使得RSA算法成为一种重要的加密算法。
然而，RSA算法的加解密过程涉及大数的运算，速度较慢，特别是对于较长的密钥长度。
因此，在实际应用中，需要权衡安全性和效率，选择合适的密钥长度。
(完整word版)RSA算法的实现实验报告
RSA算法的实现一、实验目的1. 熟悉公钥密码体制；2.掌握产生密钥对的程序设计方法；3.掌握产生加密/解密的程序设计方法。
二、实验内容和要求1.进行RSA加密/解密算法的设计；2.对RSA程序进行编译和调试；3.使用编写的程序进行加密和解密。
三、实验环境运行Windows操作系统的PC机，可以利用具有VC++语言环境；如果所运用的语言是JAVA，那么也可以利用JAVA语言环境来实现RSA算法的加密和解密。
四、实验步骤1.采用C++语言进行本次实验的编写，实验的代码如下：#include <stdio.h>#include<conio.h>int candp(int a,int b,int c){ int r=1;b=b+1;while(b!=1){r=r*a;r=r%c;b--;}printf("%d\n",r);return r;}void main(){int p,q,e,d,m,n,t,c,r;char s;printf("please input the p,q: ");scanf("%d%d",&p,&q);n=p*q;printf("the n is %3d\n",n);t=(p-1)*(q-1);printf("the t is %3d\n",t);printf("please input the e: ");scanf("%d",&e);if(e<1||e>t){printf("e is error,please input again: ");scanf("%d",&e);}d=1;while(((e*d)%t)!=1) d++;printf("then caculate out that the d is %d\n",d);printf("the cipher please input 1\n");printf("the plain please input 2\n");scanf("%d",&r);switch(r){case 1: printf("input the m: "); /*输入要加密的明文数字*/ scanf("%d",&m);c=candp(m,e,n);printf("the cipher is %d\n",c);break;case 2: printf("input the c: "); /*输入要解密的密文数字*/ scanf("%d",&c);m=candp(c,d,n);printf("the cipher is %d\n",m);break;}getch();}2、代码的思想：首先随意输入两个素数p和q，然后利用算法计算出p*q 即n,再算出(p-1)*(q-1)即t,并且同时输出计算的结果n和t，接下来输入e,经过算法可以计算出d，由此可以知道RSA算法的公钥和私钥；接下来可以有两个选择：一选择输入明文，有明文经过算法可以计算出密文；二输入密文，有密文经过算法可以计算出明文。
RSA实验报告2024
RSA实验报告（二）引言：RSA算法是一种公钥加密算法，被广泛应用于信息安全领域。
本次实验旨在通过实现RSA算法，深入理解其原理和实际应用。
本文将通过对RSA算法进行实验，并详细分析实验结果，探讨RSA算法的性能和安全性。
概述：RSA算法是由三位密学家Rivest、Shamir和Adleman于1977年共同提出的。
它基于数论中的大数分解问题，通过巧妙地利用素数和模幂运算的特性，实现了一种快速且安全的加密算法。
本次实验将从密钥对、加密和解密三个方面对RSA算法进行实验。
正文内容：一、密钥对1.选择素数：通过随机的方法选择两个大的素数p和q，保证其大小和位数的安全性。
2.计算n和φ(n)：根据选择的p和q，计算出n和φ(n)，其中n=pq，φ(n)为欧拉函数的值。
3.选择公钥：选择一个与φ(n)互质的整数e，作为公钥。
4.计算私钥：根据选择的公钥e和φ(n)，通过扩展欧几里得算法计算出私钥d。
5.密钥完毕：将公钥(n,e)和私钥(n,d)存储起来，用于后续的加密和解密操作。
二、加密1.明文转化：将要加密的明文转化为对应的整数，使用ASCII 码或其他字符编码方式进行转化。
2.加密运算：使用公钥(n,e)，对明文进行模幂运算，得到密文。
3.密文输出：将得到的密文输出。
三、解密1.密文转化：将接收到的密文转化为对应的整数。
2.解密运算：使用私钥(n,d)，对密文进行模幂运算，得到解密后的明文。
3.明文输出：将得到的明文输出。
四、性能分析1.密钥长度：根据实验结果统计不同密钥长度下加密和解密的速度，比较性能差异。
2.加解密时间：通过实验测量不同明文长度下的加密和解密时间，分析RSA算法的执行效率。
3.密文大小：研究密文与明文的关联性，分析密文对明文的扩展效果。
4.安全性分析：基于已知攻击手段，分析RSA算法的安全性，包括素数选择、模幂运算等环节。
五、实验结果1.密钥：统计不同长度密钥所需时间，并分析其对RSA算法的影响。
RSA加密算法实验报告
RSA加密算法实验报告摘要：本次实验主要使用Python语言实现RSA加密算法，并通过实验对该算法进行了测试和分析。
实验结果表明，RSA算法在保证数据的安全性的同时也存在一定的效率问题。
一、引言RSA加密算法是一种非对称加密算法，广泛应用于网络通信、电子商务中的数据传输和数据存储等领域。
RSA算法的核心原理基于大数分解的数学问题，通过对两个大素数的乘积进行因式分解，从而实现加密和解密的功能。
二、实验方法1.选择并生成两个大素数p和q；2.计算n=p*q，ϕ(n)=(p-1)*(q-1)；3.选择一个小于ϕ(n)且与ϕ(n)互质的正整数e作为加密指数；4.计算d，使得e * d ≡ 1 (mod ϕ(n))；5.公钥为(e,n)，私钥为(d,n)；6.对明文进行加密和解密。
三、实验结果1.选择大素数p=61，q=53，计算n=3233，ϕ(n)=3120；2.选择e=17，并计算d=2753；3.得到公钥(e,n)=(17,3233)，私钥(d,n)=(2753,3233)；4.选择明文m=88进行加密，加密后得到密文c=1323；5.用私钥对密文进行解密，解密后得到明文m'=88四、实验分析1.算法安全性分析：2.算法效率分析：RSA算法的效率受到两个大素数p和q的影响，生成和选择两个大素数的难度较大，因而算法的运算速度较慢。
五、实验总结通过本次实验，我们实现了RSA加密算法，成功进行了加密和解密过程，并对算法进行了安全性和效率的分析。
实验结果表明，RSA算法可以确保数据的安全性，但在效率方面存在一定的问题。
未来的研究可以探索优化RSA算法的方法，提高算法的运算效率，以适应大规模数据处理的需求。
RSA算法实验报告
RSA算法的实现一、实验目的1、理解公钥密码体制基本原理。
2、理解并能够编写RSA算法。
3、熟练应用C++编程实现算法。
二、实验内容利用C++编程实现RSA算法密码体制，算法描述参考课本P191-204。
三、实验原理1、算法原理步骤如下（这里设B为是实现着）（1）B寻找出两个大素数p和q。
（2）B计算出n=p*q和ϕ（n）=）（p-1）*（q-1）。
（3）B选择一个随机数e（0<e<ϕ(n)）,满足（e,ϕ(n))=1 (即e与欧拉函数互素ϕ（n）)。
（4）B使用欧几里得算法计算e的模余ϕ（n）的乘法逆元素d。
（5）B在目录中公开n和e作为他的公开密钥，保密p、q和d。
加密时，对每一明文m计算密文cΞm e（modn）解密时，对每一密文c计算明文mΞc d（modn）2、主要函数说明（1）判断一个数是否为素数函数bool prime(int n){int m=sqrt(n);for(int i=2;i<m;i++){if(n%i==0)break;}if(i>=m)return 1;else return 0;}（2）模幂算法(这里以明文m为一个为例)①令f=1；②用for循环遍历从i=1到i=b，令f=(f*a)%n③输出f，f的值即为模幂的结果。
int multiplication(int a,int b,int n){int f=1;for(int i=1;i<=b;i++){f=(f*a)%n;}return f;}（3）扩展欧几里得算法由扩展欧几里得算法可以计算整数s和t ，使得s*e+t*N=（e,N）=1,则e的乘法逆元等价于s mod N。
①定义变量x1,x2,x3,y1,y2,y3,t1,t2,t3,q;②令x1 = y2 = 1; x2 = y1 = 0;③计算q = x3/y3; t1 = x1 - q*y1;t2 = x2 - q*y2; t3 = x3 - q*y3;④x1 = y1; x2 = y2; x3 = y3; y1 = t1; y2 = t2; y3 = t3;⑤当y3 =1时，*result = y2; result 的结果即为所求乘法逆元；如果y3 ！=1，则返回顺序执行③、④步直到满足y3 =1int ExtendedEuclid( int f,int d ,int *result){int x1,x2,x3,y1,y2,y3,t1,t2,t3,q;x1 = y2 = 1;x2 = y1 = 0;if(f>=d){x3=f;y3=d;}else{x3=d;y3=f;}while( 1 ){if ( y3 == 1 ){*result = y2; /* 两个数互素则resutl为其乘法逆元，此时返回值为1 */return 1;}q = x3/y3;t1 = x1 - q*y1;t2 = x2 - q*y2;t3 = x3 - q*y3;x1 = y1;x2 = y2;x3 = y3;y1 = t1;y2 = t2;y3 = t3;}}（4）主函数①输入两个数字判断是否为素数，当不为素数时重新输入。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
网络安全基础教程报告题目：RSA加密算法学号：1108040205专业及班级：计网1102班姓名：雪飞日期：2013.11.26一、RSA算法介绍与应用现状RSA公开密钥加密算法自20世纪70年代提出以来，已经得到了广泛认可和应用。
发展至今，电子安全领域的各方面已经形成了较为完备的国际规。
RSA作为最重要的公开密钥算法，在各领域的应用数不胜数。
RSA在硬件方面，以技术成熟的IC应用于各种消费类电子产品。
RSA在软件方面的应用，主要集中在Internet上。
加密连接、数字签名和数字证书的核心算法广泛使用RSA。
日常应用中，有比较著名的工具包Open SSL(SSL，Security Socket Layer,是一个安全传输协议，在Internet上进行数据保护和身份确认。
Open SSL是一个开放源代码的实现了SSL及相关加密技术的软件包，由加拿大的Eric Yang等发起编写的。
Open SSL应用RSA实现签名和密钥交换，已经在各种操作系统得到非常广泛的应用。
另外，家喻户晓的IE浏览器，自然也实现了SSL协议，集成了使用RSA技术的加密功能，结合MD5和SHA1，主要用于数字证书和数字签名，对于习惯于使用网上购物和网上银行的用户来说，几乎天天都在使用RSA技术。
RSA更出现在要求高度安全稳定的企业级商务应用中。
在当今的企业级商务应用中，不得不提及使用最广泛的平台j2ee。
事实上，在j2se的标准库中，就为安全和加密服务提供了两组API：JCA和JCE。
JCA (Java Cryptography Architecture)提供基本的加密框架，如证书、数字签名、报文摘要和密钥对产生器；JCA由几个实现了基本的加密技术功能的类和接口组成，其中最主要的是java.security包，此软件包包含的是一组核心的类和接口，Java中数字签名的方法就集中在此软件包中。
JCE(Java Cryptography Extension) 在JCA的基础上作了扩展，JCE也是由几个软件包组成，其中最主要的是javax.crypto包，此软件包提供了JCE加密技术操作API。
javax.crypto中的Cipher类用于具体的加密和解密。
在上述软件包的实现中，集成了应用RSA算法的各种数据加密规(RSA算法应用规介绍参见：.rsasecurity./rsalabs/node.asp?id=2146 ，这些API部支持的算法不仅仅只有RSA，但是RSA是数字签名和证书中最常用的)，用户程序可以直接使用java标准库中提供的API 进行数字签名和证书的各种操作。
二、算法原理1．选择两个不同的大素数p、q(目前两个数的长度都接近512bit是安全的）；2. 计算n = p*q。
3. 计算n的欧拉函数t=(p-1)(q-1)。
4. 选择整数e作为公钥，使e与t互素，且1<e< t。
5. 用欧几里得算法计算d作为私钥,使d*e=1 mod t。
6. 加密：C=M^e mod n7. 解密：M＝C^d mod n=(M^e)^d mod n= M^e^d mod n。
三、RSA算法的各环节RSA算法是1978年由R.L.Rivest，A.Shamir和L.Adleman提出的一种用数论构造的、也是迄今为止理论上最为成熟完善的公钥密码体制。
RSA的理论基础是数论中的欧拉定理,它的的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。
3.1 RSA公钥加密解密概述RSA算法采用下述加密/解密变换。
1．密钥的产生①选择两个的大素数P和q。
②计算N=p q，≯(N) =(p-1)(g-1)，其中≯(N)是N的欧拉函数值。
③选择一个整数e，满足l<e<≯(N)，且g c d(≯(N)，e)≡1。
④计算私钥d(解密密钥)，满足e d≡l(mod≯(N))，d是e在模≯(N)下的乘法逆元。
⑤以(e, n)为公钥，(d ,N)为密钥，销毁p，q，≯(N)。
2．加密加密时首先将明文比特串进行分组，使得每个分组对应得串在数值上小于N，即分组的二进制长度小于l092N。
然后，对每个明文分组M，作加密运算：C=E k(M)=M e mod N3．解密对密文分组的解密运算为：M=D k (C) =C d mod N由定理1和定理2可以证明解密运算能恢复明文M3.2 RSA签名算法并非所有的公开密钥系统，均可同时达到秘密性与数字签名功能。
一般而言，一公开密钥系统若作为密码系统，则无法作为数字签名，反之亦然。
只有很少数的系统可同时作为密码系统和数字签名，如本文讨论的RSA系统。
RSA签名算法如下：设N=p q，且p和q是两个大素数，e和d满足e d≡l(mod ≯(N))。
公开密钥：N，e私有密钥：d签名过程：发送方使用自己的私钥d对明文m进行数字签名变换：y=x d mod N：并将加密后的消息和签名y发送给接收方；验证过程：接收方使用发送方的公钥e对收到的消息y进行数字签名验证变换x’=y e mod N，并使用发送方的密钥解密恢复消息x，比较x’与x，如果x’=x则证实发送方的身份合法。
这样，用户A若想用RSA签名方案对消息x签名，他只需公开他的公钥N和e，由于签名算法是的，因此A是唯一能产生签名的人，任何要验证用户A 签名的用户只需查到A 的公钥即可验证签名。
对于实现签名和公钥加密的组合，常用方法是：假定通信双方为A和B。
对于明文x，A计算他的签名y=x d mod N，然后利用B的公开加密函数E B对信息对(x, y)加密得到Z，将密文Z传送给B，当B收到密文Z后，他首先用他的解密函数D B来解密得到(x，y)=D B (Z)= D B (E B(x，y))，然后利用A的验证算法来检查x’=x=y e mod N是否成立。
3.3 大数运算处理．RSA依赖大数运算，目前主流RSA算法都建立在1024位的大数运算之上。
而大多数的编译器只能支持到64位的整数运算，即我们在运算中所使用的整数必须小于等于64位，即：0xffffffffffffffff也就是615，这远远达不到RSA的需要，于是需要专门建立大数运算库来解决这一问题。
最简单的办法是将大数当作数组进行处理，数组的各元素也就是大数每一位上的数字，通常采用最容易理解的十进制数字0~9。
然后对“数字数组”编写加减乘除函数。
但是这样做效率很低，因为二进制为1024位的大数在十进制下也有三百多位，对于任何一种运算，都需要在两个有数百个元素的数组空间上多次重循环，还需要许多额外的空间存放计算的进退位标志及中间结果。
另外，对于某些特殊的运算而言，采用二进制会使计算过程大大简化，而这种大数表示方法转化成二进制显然非常麻烦，所以在某些实例中则干脆采用了二进制数组的方法来记录大数，当然这样效率就更低了。
一个有效的改进方法是将大数表示为一个n进制数组，对于目前的32位系统而言n可以取值为2的32次方，即0x100000000，假如将一个二进制为1024位的大数转化成0x10000000进制，就变成了32位，而每一位的取值围不再是二进制的0~ 1或十进制的0~9，而是0~0xffffffff我们正好可以用一个32位的DWORD(如：无符号长整数，unsigned long)类型来表示该值。
所以1024位的大数就变成一个含有32个元素的DWORD数组，而针对DWORD 数组进行各种运算所需的循环规模至多32次而已。
例如大数1 09551 61 5，等于0Xffffffff ffffffff其表示方式就相当于十进制的99：有两位，只是每位上的元素不是9而都是0xffffffff。
而616等于0x00000001 00000000 00000000，就相当于十进制的100：有三位，第一位是l，其它两位都是0，如此等等。
在实际应用中，“数字数组"的排列顺序采用低位在前高位在后的方式，这样，大数A就可以方便地用数学表达式来表示其值：X=ΣX i r i (r=0x100000000，0<X i <r)任何整数运算最终都能分解成数字与数字之间的运算，在Oxl00000000进制下其“数字"最大达到Ox腼筒，其数字与数字之间的运算，结果也必然超出了目前32位系统的字长。
在VC++中，存在一个int64类型可以处理64位的整数，所以不用担心这一问题，而在其它编译系统中如果不存在64位整形，就需要采用更小的进制方式来存储大数，例如16位的WORD类型可以用来表示0x10000进制。
但效率更高的办法还是采用32位的DWORD 类型。
3.4 大素数的产生根据RSA算法的加解密变换，需要产生两个的大素数作为基础运算。
在2000年前欧几里德证明了素数有无穷多个，这自然的就引出一个问题：既然素数有无穷个，那么是否有一个计算素数的通项公式?两千年来，数论学的一个重要任务，就是寻找一个可以表示全体素数的素数普遍公式。
为此，人类耗费了巨大的心血。
希尔伯特认为，如果有了素数统一的素数普遍公式，那么这些哥德巴赫猜想和孪生素数猜想都可以得到解决。
“研究各种各样的素数分布状况，一直是数论中最重要和最有吸引力的中心问题之一。
关于素数分布性质的许多著名猜想是通过数值观察计算和初步研究提出的，大多数至今仍未解决”。
因此，欲得到素数，必须另寻出路。
大素数的产生应是现代密码学应用中最重要的步骤。
几乎所有的公开密钥系统均需要用到大的素数，若此素数选用不当，则此公开密钥系统的安全性就岌岌可危。
一般而言，素数的产生通常有两种方法，一为确定性素数产生方法，一为概率性素数产生方法，目前后者是当今生成素数的主要方法。
所谓概率性素数产生法，是指一种算法，其输入为一奇数，输出为两种状态YES或NO之一。
若输入一奇数n，输出为NO，则表示11为合数，若输出为YES，则表示n为素数的概率为1-r，其中r为此素数产生法中可控制的任意小数，但不能为0。
此类方法中较著名的有Solovay-Strassen算法、Lehmann算法、Miller-Rabin算法等。
在实际应用中，一般做法是先生成大的随机整数，然后通过素性检测来测试其是否为素数。
数论学家利用费尔马定理研究出了多种素数测试方法，目前最快的算法是Miller-Rabin(拉宾米勒)测试算法(也称为伪素数检测)，其过程如下：首先选择一个待测的随机数N计算r，2r是能够整除N-1的2的最大幂数。
1．计算M，使得N=2r×M+1。
2．选择随机数A<N。
3．若A M mod N =l，则N通过随机数A的测试。
4．让A取不同的值对N进行5次测试，若全部通过则判定N为素数。
若N通过一次测试，则N为合数(非素数)的概率为25％，若N通过t次测试，则为合数(非素数)的概率为1／4t。