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语言实现)
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;```在上面的代码中，我们使用了几个辅助函数来实现扩展欧几里得算法、计算模反元素和快速幂算法。
R S A 加 密 算 法
RSA加密算法实现以及C#一.RSA算法简介大体是先生成两个大素数p和q，再生成e，e和（p-1）*（q-1）互素。
取p和q的乘积：n=p*q 为公共模数。
再生成正整数d，满足d*e-1可以被（p-1）*（q-1）整除。
这样d就为私钥，(e,n)为公钥，形成rsa的公私钥对。
其中n的二进制位称为该密钥长度，密钥越长越难破解，也就越安全。
RSA算法 :?首先, 找出三个数, p, q, r,?其中 p, q 是两个相异的质数, r 是与 (p-1)(q-1) 互质的数.?p, q, r 这三个数便是 private key?接著, 找出 m, 使得 rm == 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就是Exponent，n是Modulus，p是P，q是Q，r是D，而InverseQ * p == 1 mod q======================================================== ====================RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024); --1024 bit keyRSAParameters par = rsa.ExportParameters(false); -- export the public keystring str = rsa.ToXmlString(true);str 值如下：========================RSAKeyValuetuNKKEhLHftRx81wHKQgunAHSUmLwBWBMNqBEZvZSAmntlzJPN3Yy7N5 3lLpeacl9M1J0LjeFyyOzpWwiYsapyDo4vlGzYcUy0AojMNW5DXuG7-UK0+ LWdW2gs6mhN3CWwmynqCKnvrwv993m-iPiFXUyqQu+OhSsca7p4XZnn8= -ModulusExponentAQAB-ExponentP7X5WxuLAIYcoXt5LKelRzUZT8hjkU4qIikHBplK8TUNU5y1rDlQ9Awd b9mTIf2sILUDT7ryZZ6KlIFDfCVu3IQ==-PQxSOlCaMGBOo15EG1zwQJl1zhKicAXtzc-1nlnWiRz0cr5PiBdYJE2Rn miDNgOvz-WiU1RTvoWFTgQy5erXPBnw==-QDPjeIJk75JzH4Dt1GUlBBpJ3rZkewfFG3SDs8kEuqgxoPwSEBREflvjc yquzQQuFbIRsjRFHKmL0zy27CU3vFlIQ==-DPDQOQYXfhMe8ZsB3bW4Llp-n73pD7VaYRZIAsDxLzgJPUjcBI5xfBkjax 0X1vvtcQKvplau8wjiK3LZr-Ugw9GBBw==-DQInverseQMjXjlXM7NuJWahnVSSD2JLeDDjwEyat7xyG+9mgWCMUSM-2v ja4v9U+exOYu8T4fnwKq5+hKlA3E2Aw9IjeIxg==-InverseQ Dh7zgME+fuOvrwbB-UjKau+Uj80frui-7x8eU3f3e4XGREW+CSHObUWy uucytzoW5TR0EeS6MX4TJpRhCg4NDzp6vbye3RIN8KAsRSbd8Znh38ABer5 43rjzB-kn305bKnmbqQtO89pQEidjZX441AYu1dkqTkhLYwHQSxbFNpcE= -RSAKeyValue========================二.填充算法由于密钥长度有限，一次性加密的数据长度也有限，因此必须对明文进行分块加密，再合并加密结果。
RSA加密算法及实现
RSA加密算法及实现RSA加密算法是一种非对称加密算法，广泛应用于网络通信中的数据加密和数字签名等方面。
RSA算法的核心思想是基于大数分解的难解性问题，通过数论中的数学原理实现加密过程。
下面将详细介绍RSA加密算法的原理和实现。
RSA算法的原理如下：1.密钥的生成：-随机选择两个不同的大质数p和q。
-计算n=p*q。
-计算欧拉函数φ(n)=(p-1)*(q-1)。
-选择一个整数e，使得1<e<φ(n)，且e与φ(n)互质。
- 计算e关于φ(n)的模反元素d，使得d * e ≡ 1 (modφ(n))。
-公钥为(n,e)，私钥为(n,d)。
2.加密算法：-将明文m转化为整数。
- 计算密文c = m^e mod n。
3.解密算法：- 计算明文m = c^d mod n。
1.密钥的生成：首先，使用一个大数库来生成大质数p和q，确保p和q均为质数。
然后，计算n=p*q，并计算φ(n)=(p-1)*(q-1)。
选择一个合适的e，可以是小于φ(n)的质数或者与φ(n)互质的数。
使用扩展欧几里德算法，计算e关于φ(n)的模反元素d。
最终得到公钥为(n,e)，私钥为(n,d)。
2.加密算法：将明文m转化为整数。
然后，使用快速模幂算法计算密文c = m^e mod n。
3.解密算法：使用快速模幂算法，计算明文m = c^d mod n。
需要注意的是，RSA算法对加密和解密的数据长度有限制，一般建议将要加密的数据分块进行加密。
同时，为了增强安全性，一般会使用大的素数来生成密钥。
总结：RSA加密算法是一种非对称加密算法，通过数论中的数学原理实现加密过程。
它的核心思想是基于大数分解的难解性问题。
RSA算法的实现需要生成密钥对、加密和解密三个步骤。
密钥的生成需要随机选择两个大质数，并进行相应的计算。
加密算法通过快速模幂算法进行加密，解密算法也通过快速模幂算法进行解密。
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加解密算法C语言的实现
RSA加解密算法C语言的实现RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，常用于保护网络通信的安全性。
它的主要思想是通过生成一对公钥和私钥，使用公钥进行加密，使用私钥进行解密，从而保证安全性。
RSA算法的实现一般包括生成密钥对、加密和解密三个部分。
1.生成密钥对RSA算法的第一步是生成一对公钥和私钥。
生成密钥对的过程如下：1）选择两个较大的质数p和q；2）计算N=p*q，确定模数N；3）计算欧拉函数φ(N)=(p-1)*(q-1)；4）选择一个整数e，满足1<e<φ(N)且e与φ(N)互质；5）计算e关于模φ(N)的乘法逆元d，满足d * e ≡ 1 (modφ(N))。
生成密钥对的代码实现如下：```c#include <stdio.h>typedef unsigned long long int ulli;ulli gcd(ulli a, ulli b)if (b == 0)return a;}return gcd(b, a % b);ulli inverse(ulli e, ulli phi)ulli d = 0;ulli x1 = 0, x2 = 1, y1 = 1, y2 = 0; ulli temp_phi = phi;while (e > 0)ulli quotient = phi / e;ulli remainder = phi - quotient * e; phi = e;e = remainder;ulli x = x2 - quotient * x1;ulli y = y2 - quotient * y1;x2=x1;x1=x;y2=y1;y1=y;}if (phi != 1)return -1; // 没有乘法逆元}if (y2 < 0)d = temp_phi + y2;} elsed=y2;}return d;int mainulli p, q, N, phi, e, d;printf("Enter two prime numbers: ");scanf("%llu %llu", &p, &q);N=p*q;phi = (p - 1) * (q - 1);printf("Enter a number e such that 1 < e < phi(N) and gcd(e, phi(N)) = 1: ");scanf("%llu", &e);d = inverse(e, phi);printf("Public Key (N, e) = (%llu, %llu)\n", N, e);printf("Private Key (N, d) = (%llu, %llu)\n", N, d);return 0;```2.加密RSA算法的第二步是使用公钥进行加密。
RSA加密算法及实现
RSA加密算法及实现RSA 是一种非对称加密算法，由Rivest、Shamir 和Adleman 三位数学家于1977年提出，现在广泛应用于电子邮件加密、数字签名和安全传输等领域。
RSA 算法基于两个大素数的乘积难以分解的特性，实现了安全的加密和解密过程。
RSA算法的核心原理是利用数论中的欧拉函数、模逆和模幂运算。
下面将详细介绍RSA算法的加密和解密流程。
1.生成密钥对首先选择两个不同的大素数p和q，计算它们的乘积n=p*q。
然后计算欧拉函数φ(n)=(p-1)*(q-1)。
选择一个与φ(n)互质的整数e，作为公钥的指数。
再利用模逆运算求解整数d，使得(d*e)%φ(n)=1，d即为私钥的指数。
2.加密过程假设要加密的消息（明文）为m，公钥为(n,e)。
将明文转换成整数M，并满足0≤M<n。
加密过程即为计算密文C=M^e%n，然后将密文发送给接收者。
3.解密过程接收者使用私钥(n,d)进行解密。
将密文C转换成整数，并计算明文M=C^d%n。
最后将整数M转换成消息，并得到解密后的明文。
RSA算法的安全性基于分解大整数n的困难性，如果有人能够有效地分解n，并得到p和q，那么整个算法的安全性将被破坏。
目前，分解大整数依然是一个非常耗费计算资源的问题，因此RSA算法在理论上是安全的。
实现 RSA 加密算法需要涉及大数运算和模幂运算等复杂的数学运算。
下面是一个简化版的 RSA 加密算法的 Python 代码实现：```pythonimport random#扩展欧几里得算法求解模逆def extended_gcd(a, b):if b == 0:return a, 1, 0gcd, x, y = extended_gcd(b, a % b)return gcd, y, x - (a // b) * y#计算模幂运算def mod_exp(a, b, n):result = 1while b > 0:if b % 2 == 1:result = (result * a) % na=(a*a)%nb//=2return result#生成密钥对def generate_keys(:p = random.randint(100, 1000)q = random.randint(100, 1000)while p == q or not is_prime(p) or not is_prime(q): p = random.randint(100, 1000)q = random.randint(100, 1000)n=p*qphi = (p - 1) * (q - 1)e = random.randint(2, phi - 1)gcd, d, _ = extended_gcd(e, phi)#确保d为正数if d < 0:d += phireturn (n, e), (n, d)#加密过程def encrypt(message, public_key):n, e = public_keym = int.from_bytes(message.encode(, 'big')c = mod_exp(m, e, n)return c#解密过程def decrypt(ciphertext, private_key):n, d = private_keym = mod_exp(ciphertext, d, n)message = m.to_bytes((m.bit_length( + 7) // 8, 'big').decode return message#判断一个数是否为素数def is_prime(n):if n <= 1:return Falsefor i in range(2, int(n ** 0.5) + 1):if n % i == 0:return Falsereturn True#示例运行代码if __name__ == '__main__':public_key, private_key = generate_keysmessage = "Hello, RSA!"ciphertext = encrypt(message, public_key)plaintext = decrypt(ciphertext, private_key)print("Public key:", public_key)print("Private key:", private_key)print("Ciphertext:", ciphertext)print("Decrypted plaintext:", plaintext)```以上代码是一个简单的实现，仅用于理解RSA加密算法的基本原理。
rsa算法基本流程及签名流程
1、RSA算法及其实现RSA加密算法是目前应用最广泛的公钥加密算法，特别适用于通过Internet 传送的数据，常用于数字签名和密钥交换，被国际上的一些标准化组织ISO、ITU、SWIFT作为标准来采用.1。
1 RSA算法的基本原理独立地选取两个大素数(保密).计算（公开)，其中为欧拉函数值（保密）。
随机选取一整数e，满足,，e是公开的密钥即公钥。
用Euclid算法计算d，，d是保密的密钥即私钥。
加密变换：对明文，密文为.解密变换：对密文，明文为。
其中，加密变换、解密变换两步也可以改为用d加密,e解密，就变成签名和验证过程.1。
2 RSA算法的实现步骤1素数的产生对随机数作素性检测，若通过则为素数，否则增加一个步长后再做素性检测，直到找出素数。
素性检测采用Fermat测试。
这个算法的理论依据是费尔马小定理：如果m是一个素数，且a不是m的倍数，那么根据费尔马小定理。
实际应用,此对于整数m，需计算，再将结果与a比较.如果两者相同，则m为素数。
选取a=2，则a一定不会是任何素数的倍数。
步骤2随机数的产生随机数不仅用于密钥生成，也用作公钥加密时的填充字符。
它必须具有足够的随机性,以防止破译者掌握随机数的规律后重现密钥的配制过程或者探测到加密块中的明文。
因为在计算机上不可能产生真正的随机数，实际采用周期大于2256位的伪随机序列发生器。
步骤3密钥的生成（1)选择e的值为2623883或者94475891;(2)随机生成大素数p，直到gcd（e, p—1)=1；（3)随机生成不同于p的大素数q,直到gcd(e,q—1)=1；（4）计算n=pq，φ（n)=(p-1)(q—1）；（5)计算d,；（6)计算dmod(p—1）,dmod（q—1）；（7)计算（q—1)modp；（8)将(e,n）放入RSA公钥；将n,e，dmod(p—1),dmod（q-1）,(q-1)modp 放入RSA私钥。
步骤4加密利用RSA加密，第一步需要将明文数字化.假定A、B统一明文编码方式为空格=00，A=01,B=02,C=03,…，Z=26, 则明文数字化HI为08、09；然后把明文M分成等长数据块，块长为s,其中，s尽可能大。
RSA加密算法实验报告_2
现代密码学实验报告题目: RSA算法的实现过程
一、实验目的
二、简单实现RSA过程, 通过OpenSSL命令编辑器实现发送方对明文进行加
密, 签名, 接受方验证, 解密的简单过程。
三、实验原理
RSA加密算法的基本流程:
四、实验步骤
发送方对明文进行加密:
首先利用MD5对明文进行摘要操作:
然后生成秘钥文件:
再利用这个密钥对摘要进行加密:
然后对摘要进行签名操作:
发送方加密后要发送的东西是: 明文和摘要的签名传送到接收方后,接收方进行解密操作:
接收方进行验证:
通过比较可以发现所得摘要的结果是相同的, 则可以得到结论: 该明文没有被篡改。
五、实验心得
通过对RSA过程的简单模仿, 我们可以明白理论和现实是有一定差别的, 我们需要将明文利用MD5进行摘要处理, 然后在通过MD5对摘要进行验证, 从而判断密文是否经过修改, 达到数据的安全性, 完整性和保密性。
在使用OpenSSL进行RSA过程模仿时要注意文件名的对应, 这需要我们在命名文件时能做到见名之意, 方便我们后续的操作。
命令行的书写方式需要我们对字母有一定的敏感性, 经常会出现字母出现问题而导致错误的发生。
RSA算法及实现介绍
四、加解密框架(伪代码)：
• 加解密框架(伪代码)： RSA_Code( M，e，n，Len，C_out ) {
M明文分组m1…mx； For I = 1 to x
C = m^e mod n --积模分解公式、Fame2 Next I }
RSA_Decode(C, dp, dq, p, q, u, Len, M_out) {
C密文分组c1…cx; For I =1 to x
m1 = C^dp mod p m2 = C^dq mod q h’ = (m1 – m2) mod p h = h’u mod p M = m2 + qh Next I }
• RSA算法主要用到的基本运算法则：
• Fame2寄存器简介 FM_STAT: 提示运行状态 FM_CMD: 控制运算模块的复位、运行等操作 FM_MODE：选择运算模式 FM_XPTR\YPTR\TOPP:参数寄存器 FM_UPTR \FM_UPTRT:实现需要的运算步骤 …等等
三、寻找大素数：p 、q
• 寻找到大素数p、q即可通过计算得到公钥 （e，n），及CRT私钥（p、q、dp、dq、u）
• 费马小定理： N为任意正整数，P为素数，且N不能被P整 除，则有：
拉宾米勒测试方法寻找素数P：
1.判断P是否为奇数，不是则判断失败。 2.选T个随机整数A，且0<A<P成立。进行费马
小定理测试，计算并判断A^(p-1) mod p结 果是否为1，不是则失败。 3.找到R、M，使p = 2^R * M +1成立。 4.如果A^M mod N = 1成立，则进行下一个A 元素的测试，否则将A^M乘方后作为底数S， 在计算S^M mod N = 1是否成立。若到 S = A^2^MR 时，仍有S^M mod N = 1不成立， 则P不是素数
RSA算法及实现介绍
RSA算法及实现介绍RSA算法是一种非对称加密算法，其安全性基于大数分解的困难性。
RSA算法是由三位数学家（R．Rivest、A．Shamir 和 L. Adleman）于1977年共同提出的，是目前应用最为广泛的公钥加密算法之一RSA算法的原理是基于两个相当大的素数相乘很容易实现，但是将一个相当大的整数进行因数分解却是一件非常困难的事情。
因此，利用这个特性，RSA算法能够实现加密和解密过程。
RSA算法主要包括三个步骤，密钥生成、加密和解密。
密钥生成是RSA算法的第一步，其目的是生成公钥和私钥。
公钥由两个部分组成，n和e，其中n是两个大素数p和q的乘积，e为与(p-1)(q-1)互质的整数。
私钥由两个部分组成，n和d，其中d是e的模(p-1)(q-1)的逆元。
密钥的生成可以通过以下步骤实现：1.随机选择两个不同的素数p和q。
2.计算n=p*q。
3.计算(p-1)(q-1)。
4.选择一个与(p-1)(q-1)互质的整数e。
5.计算e的模(p-1)(q-1)的逆元d。
6.公钥为(n,e)，私钥为(n,d)。
加密是RSA算法的第二步，其过程是将明文转化为密文。
密文通过以下步骤生成：1.将明文转化为数字，例如使用ASCII码将字符转为整数。
2. 使用公钥中的n和e，计算密文c = m^e mod n，其中m为明文。
解密是RSA算法的第三步，其过程是将密文转化为明文。
明文通过以下步骤生成：1. 使用私钥中的n和d，计算明文m = c^d mod n，其中c为密文。
1.安全性高：RSA算法的安全性基于大数分解的困难性问题，即将一个相当大的整数进行因数分解是一件非常困难的事情。
2.公钥可分享：公钥可分享给其他人使用，保密性不会因公钥的传输而被破坏。
3.算法简单：RSA算法的加密和解密过程简单，只需要进行指数运算和取模运算。
4.可用于数字签名：RSA算法既可以用于加密和解密，也可以用于数字签名。
数字签名可以验证数据的完整性和真实性。
数据加密--详解RSA加密算法原理与实现
数据加密--详解RSA加密算法原理与实现RSA算法简介RSA是最流⾏的⾮对称加密算法之⼀。
也被称为公钥加密。
它是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年⼀起提出的。
当时他们三⼈都在⿇省理⼯学院⼯作。
RSA就是他们三⼈姓⽒开头字母拼在⼀起组成的。
RSA是⾮对称的，也就是⽤来加密的密钥和⽤来解密的密钥不是同⼀个。
和DES⼀样的是，RSA也是分组加密算法，不同的是分组⼤⼩可以根据密钥的⼤⼩⽽改变。
如果加密的数据不是分组⼤⼩的整数倍，则会根据具体的应⽤⽅式增加额外的填充位。
RSA作为⼀种⾮对称的加密算法，其中很重要的⼀特点是当数据在⽹络中传输时，⽤来加密数据的密钥并不需要也和数据⼀起传送。
因此，这就减少了密钥泄露的可能性。
RSA在不允许加密⽅解密数据时也很有⽤，加密的⼀⽅使⽤⼀个密钥，称为公钥，解密的⼀⽅使⽤另⼀个密钥，称为私钥，私钥需要保持其私有性。
RSA被认为是⾮常安全的，不过计算速度要⽐DES慢很多。
同DES⼀样，其安全性也从未被证明过，但想攻破RSA算法涉及的⼤数（⾄少200位的⼤数）的因⼦分解是⼀个极其困难的问题。
所以，由于缺乏解决⼤数的因⼦分解的有效⽅法，因此，可以推测出⽬前没有有效的办法可以破解RSA。
RSA算法基于的原理，基本上来说，加密和解密数据围绕着模幂运算，这是取模计算中的⼀种。
取模计算是整数计算中的⼀种常见形式。
x mod n的结果就是x / n的余数。
⽐如，40 mod 13 = 1，因为40 / 13 = 3，余数为1。
模幂运算就是计算a b mod n的过程。
计算公钥和私钥RSA中的公钥和私钥需要结合在⼀起⼯作。
公钥⽤来对数据块加密，之后，只有对应的私钥才能⽤来解密。
⽣成密钥时，需要遵循⼏个步骤以确保公钥和私钥的这种关系能够正常⼯作。
这些步骤也确保没有实际⽅法能够从⼀个密钥推出另⼀个。
RSA公钥加密算法的设计与实现本科毕业论文
RSA公钥加密算法的设计与实现本科毕业论⽂RSA公钥加密算法的设计与实现RSA公钥加密算法的设计与实现【论⽂摘要】RSA公钥加密算法是⽬前最有影响⼒的⾮对称加密算法，为ISO的推荐的加密标准。
⽽⾮对称加密因其安全性、开放性以及在数字签名技术中的重要性，在我们的⽣活中被使⽤得越加频繁。
RSA的安全性建⽴在⼤整数的分解困难上，其基本原理是初等数论中的欧拉定理。
在⼯业实现上，为了保证加密的安全性，通常要求密钥对⼤于1Kbits，然⽽计算机的整型变量为32bits，这构成⼀个⽭盾。
此外，RSA密钥的⽣成需要产⽣随机的⼤素数，这也是本⽂需要解决的问题。
【关键词】RSA；⾮对称加密；素数The d esign and implementation of RSA public keyencryption algorithm【ABSTRACT】RSA public key encryption algorithms are the most influential dissymmetrical encryption algorithms, the recommended encryption standard to ISO. And dissymmetrical encryption is used more and more frequently in our lives because of its security, openness and the importance in digital signature technology.RSA's security is built on the difficulties of big integer factorization, whose basic principle is the Euler's theorem in elementary number theory. In order to ensure the security of encryption, when it comes to industry, we often require the key pair is greater than 1Kbits. However, the integer class of computers occupies 32bits, which constitutes a contradiction. In addition, RSA's key-generation needs a random large prime number, which is also a problem to be solved.【Keywords】RSA; dissymmetrical encryption; prime number⽬录RSA公钥加密算法的设计与实现 ...................... II The design and implementation of RSA public key encryption algorithm .............................................. II ⽬录............................................... III ⼀．前⾔ (1)（⼀）引论 (1)（⼆）背景知识 (2)1. 密码技术的发展 (2)2. 密码学的主要任务 (4)3. 密码系统的安全性 (5)4. 对称与⾮对称密码的区别 (5)5. 公钥：RSA密码体制 (6)⼆、实验部分 (8)（⼀）实验⽬的 (8)（⼆）实验环境 (8)（三）实验步骤 (8)1. ⼤整数类 (8)2. 快速模幂运算 (9)3. 快速产⽣随机素数 (9)4. 扩展的欧⼏⾥德算法 (10)（四）代码设计 (11)1. ⼤整数类 (11)2. Rsa类 (14)3. 关键代码 (16)三、结果与讨论 (17)（⼀）程序展⽰ (17)1. 程序主界⾯ (17)2. RSA密钥产⽣ (18)3. 加密解密展⽰ (20)（⼆）RSA分析 (21)1. RSA的安全性 (21)2. RSA效率 (22)（三）⼩结 (24)注释 (25)参考⽂献 (26)致谢 (27)⼀．前⾔（⼀）引论从公元前5世纪，古希腊斯巴达⼈⽤⽊棍和带⼦进⾏换位密码，到现在的⽹上购物、⽹上银⾏，密码学在我们⽣活中占着越来越重要的地位。
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算法可用于保护用户的隐私信息等。
rsa算法原理
rsa算法原理
RSA（Rivest-Shamir-Adleman）算法是一种非对称加密算法，它具有较高的安全性、较高的效率、采用较简单的计算机运行体系结构，所以在网络信息加密中得到了广泛应用。
RSA算法是由Ron Rivest、Adi Shamir和Len Adleman于1977年提出，它基于一个十分简单的数论事实：大素数的乘积仍然是两个大素数的乘积，算法的入口参数是两个大素数：p和q，它们的乘积可以简单的计算为N=p*q，因此，N被称为模数。
RSA算法的实现要求一个公钥和一个私钥，具体的加密和解密过程如下：
（1）加密：
首先，求e和d，其中，e是公钥，d是私钥。
e和d满足e*d＝1 mod(p-1)*(q-1)），其中，mod是模运算符号。
接着，加密计算过程：M＝P^e（modN），其中，P是明文，M是密文，N是模数。
（2）解密：用私钥d解密：P＝M^d（modN）
RSA算法的安全特性主要在于求解出私钥d是一个无法实现的极其困难的任务。
确切地说，求解e和d时，需要求解的数学问题是求解模反元素的问题，因此求解d是一个极其复杂的数论问题，只有当p、q非常大时，才可以构成比较大的N，从而使加密过程更加安全。
因此，RSA常被用作电子商务、数字签名、数据加密等安全保护工作，有句名言“穷则思变”，人类无时无刻都在思考新的想法以改
善它们的生活。
RSA算法的发明是这一想法的具体应用，这一发明大大提高了网络安全的可靠性，使得电子商务的发展走向了更安全的道路。
身份证信息rsa加密算法以实现
摘要系统实现了对身份信息的加密、解密、签名认证以及公私密钥对产生器等相关功能，对身份信息的的加解密采用的是RSA加密算法，可直接呈现加密后的RSA结果，为了确保会话密钥的安全，也是通过使用非对称加密算法RSA算法为会话密钥加密.目录摘要 (I)绪论 (2)（一）课题来源 (2)（二）研究意义 (2)一、数据安全的研究方向 (2)(二)身份信息的加密、解密 (2)二身份信息加解密及验证系统方案及实现 (4)（一）文件的加密 (4)（二）文件的解密及传输验证的正确性 (4)（三）公私密钥对 (5)绪论（一）课题来源计算机技术的不断发展，Internet的普及，网络化的信息逐渐被人们所接受，传统的传递信息的方式法神关了巨大的变化，也逐渐改变了人们的生活。
目前互联网发展日益迅速，人们越来越多地使用互联网传递各种消息资料，而利用互联网进行文件的传输是人们进行信息交流的必要手段，然而文件在传输过程中容易受到截获、嗅探和篡改等攻击，也日益成为困扰人们使用互联网传递文件的阻碍。
同时信息的保密性也越来越受到威胁，如何提高身份信息的保密性及身份信息传输过程变得更安全可靠就是一个急需解决的问题，尤其是在政务系统的应用中，安全性则成为的重中之重的问题，安全问题的解决是良好办公系统环境的先决条件。
（二）研究意义通过国家计算机网络应急技术处理协调中心统计显示，我国政府网络被黑客入侵逐年递增，维护好电子政务系统的安全、办公过程中信息传递的安全，防止被一些怀有不良居心的人抄袭或破坏，因此就需要安全措施来保护相应的信息及数据不被窃取或篡改，而采取对数据直接解密的方式即方便又安全，是保护信息安全的有效手段。
本研究课题，完成相应的系统，用户间可进行安全的文件、图片的收发。
所有的交互身份信息都经过加密和签名处理，通过验证签名机制可验证是否被恶意篡改，传输者将明文进行加密后的密文进行存储和传输，授权的接收者用本系统进行解密恢复明文，而未经授权的截获者将无法对明文可见，从而保证了身份信息的安全性。
rsa加密算法c语言编程实验的步骤和内容
rsa加密算法c语言编程实验的步骤和内容## 1. RSA加密算法简介RSA加密算法是一种非对称加密算法，由三位数学家Rivest、Shamir和Adleman于1977年提出，是目前最广泛使用的公钥加密算法之一。
RSA算法的安全性基于大数分解的困难性，即将一个大的合数分解成其质数因子的乘积。
## 2. RSA加密算法的基本原理RSA加密算法基于公钥和私钥的概念，其中公钥用于加密数据，私钥用于解密数据。
具体的加密和解密过程如下：### 2.1 密钥生成过程- 选择两个大素数p和q，计算其乘积n = p * q。
- 计算欧拉函数值φ(n) = (p-1) * (q-1)。
- 选择一个整数e，使得1 < e < φ(n)且e与φ(n)互质。
- 计算e对于φ(n)的模反元素d，即满足(e * d) mod φ(n) = 1。
- 公钥为(n, e)，私钥为(n, d)。
### 2.2 加密过程- 将明文M转化为整数m，满足0 <= m < n。
- 加密后的密文C = m^e mod n。
### 2.3 解密过程- 将密文C转化为整数c，满足0 <= c < n。
- 解密后的明文M = c^d mod n。
## 3. RSA加密算法的C语言实现步骤为了实现RSA加密算法的C语言程序，我们需要按照以下步骤进行：### 3.1 定义必要的数据结构和函数我们需要定义一个结构体来存储公钥和私钥的信息，包括n、e和d。
同时，我们还需要定义一些函数来实现加密和解密的过程，包括计算模幂、计算最大公约数等。
### 3.2 生成密钥对根据密钥生成过程，我们需要实现一个函数来生成公钥和私钥。
在这个函数中，我们需要选择两个大素数p和q，并计算n、φ(n)、e 和d的值，并将其存储在定义的结构体中。
### 3.3 实现加密函数实现加密函数，输入明文M和公钥(n, e)，输出密文C。
在这个函数中，我们需要将明文转化为整数m，并通过计算模幂的方法得到加密后的密文。
RSA加密算法及其C语言实现
RSA加密算法及其C语言实现A. 加密解密1. 密钥的产生1) 找出两个相异的大素数P和Q，令N＝P×Q，M＝（P－1）（Q－1）。
2) 找出与M互素的大数E，用欧氏算法计算出大数D，使D×E≡1 MOD M。
3) 丢弃P和Q，公开E，D和N。
E和N即加密密钥，D和N即解密密钥。
2. 加密的步骤1) 计算N的有效位数tn（以字节数计），将最高位的零忽略掉，令tn1＝tn－1。
比如N＝0x012A05，其有效位数tn＝5，tn1＝4。
2) 将明文数据A分割成tn1位（以字节数计）的块，每块看成一个大数，块数记为bn。
从而，保证了每块都小于N。
3) 对A的每一块Ai进行Bi＝Ai^E MOD N运算。
Bi就是密文数据的一块，将所有密文块合并起来，就得到了密文数据B。
3. 解密的步骤1) 同加密的第一步。
2) 将密文数据B分割成tn位（以字节数计）的块，每块看成一个大数，块数记为bn。
3) 对B的每一块Bi进行Ci＝Bi^D MOD N运算。
Ci就是密文数据的一块，将所有密文块合并起来，就得到了密文数据C。
4. 定理及证明<定理>费马小定理：P是任意一个素数，Q是任意一个整数，则P^Q≡P MOD Q。
换句话说，如果P和Q互质，则P^（Q－1）≡1 MOD Q。
<证明>运用一些基本的群论知识，可以很容易地证出来，请参考群论的相关书籍。
<定理>若P，Q是相异素数，N＝P×Q，M＝（P－1）（Q－1）。
D×E≡1 MOD M。
A是任意一个正整数，B ≡A^E MOD N，C ≡B^D MOD N。
则C≡A MOD N。
<证明>因为D×E≡1 MOD M，所以D×E=kM＋1，其中k是整数。
所以，C≡B^D≡（A^E）^D≡A^（E×D）≡A^（kM＋1）MOD N。
1) 如果A不是P的倍数，也不是Q的倍数。
RSA算法和实现及实例
RSA算法和实现及实例一、RSA算法原理1.密钥生成首先，选择两个不相等的素数p和q，并计算它们的乘积n。
然后计算n的欧拉函数φ(n)=(p-1)(q-1)。
选择一个与φ(n)互质的数e，这个数即为公钥e。
然后选择一个数d，使得(d * e)mod φ(n) = 1，即d是e的模φ(n)的乘法逆元，d即为私钥。
2.加密解密加密时，将明文M进行加密，得到密文C = M^e mod n。
解密时，用私钥d对密文C进行解密，得到明文M = C^d mod n。
二、RSA算法实现实现RSA算法需要以下几个步骤：1.选择两个大素数p和q，计算乘积n=p*q。
2.计算n的欧拉函数φ(n)=(p-1)(q-1)。
3.选择一个与φ(n)互质的正整数e，计算其模φ(n)的乘法逆元d。
4.所得到的公钥为(e,n)，私钥为(d,n)。
5. 加密时，将明文M通过公钥加密得到密文C = M^e mod n。
6. 解密时，用私钥对密文C进行解密得到明文M = C^d mod n。
三、RSA算法实例假设选择的两个素数p=13，q=17，计算乘积n=p*q=221计算n的欧拉函数φ(n)=(p-1)(q-1)=12*16=192选择一个与φ(n)互质的正整数e=5计算e的模φ(n)的乘法逆元d=77所以所得到的公钥为(e,n)=(5,221)，私钥为(d,n)=(77,221)。
加密时，假设明文M = 8，利用公钥进行加密：C = M^e mod n =8^5 mod 221 = 40。
解密时，利用私钥进行解密：M = C^d mod n = 40^77 mod 221 = 8所以加密后的密文为40，解密后恢复得到原始明文为8总结：本文详细介绍了RSA算法的原理、实现方法以及一个实例。
RSA算法是一种非对称加密算法，通过选择两个大素数和计算乘积、欧拉函数、乘法逆元等步骤，实现了安全可靠的加密和解密过程。
通过加密后的密文可以通过相应的私钥解密得到原始明文，确保数据的安全性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数学文化课程报告题目：RSA公钥加密算法及实现RSA公钥加密算法及实现摘要公钥密码是密码学界的一项重要发明，现代计算机与互联网中所使用的密码技术都得益于公钥密码。
公钥密码是基于数学的上的困难问题来保证其性。
其中RSA加密算法是一项重要的密码算法，RSA利用大整数的质数分解的困难性，从而保证了其相对安全性。
但如果发现了一种快速进行质数分解的算法，则RSA算法便会失效。
本文利用C 语言编程技术进行了RSA算法的演示[1]。
关键词：C语言编程、RSA算法、应用数学。
RSA public key encryption algorithmAbstractPublic key cryptography is an important invention in cryptography, thanks to public key cryptography, and it is used in modern computer and Internet password technology. Public key cryptography is based on the mathematics difficult problem to ensure its confidentiality. The RSA public key encryption algorithm is an important cryptographic algorithm, RSA using the difficulty that large integer is hard to be factorized into prime Numbers to ensure it safety. But if you can find a kind of fast algorithm to do the factorization, RSA algorithm will be failure. In this paper we used C language programming technology to demonstrate the RSA algorithm.Keywords：C language programming、RSA algorithm、Applied mathematics目录第1章引言 (1)第2章RSA公钥密码算法的基本理论知识 (2)2.1模运算操作、费马小定理与欧拉定理 (2)2.1.1 模运算操作 (2)2.1.2 费马小定理 (2)2.1.3 欧拉定理 (2)2.2 RSA算法的过程 (3)2.3 RSA算法的可行性 (3)第3章RSA算法的演示 (4)3.1 RSA程序的设计 (4)3.2 RSA算法的实现 (5)3.3 RSA算法的演示 (6)第4章结果分析与讨论 (7)第5章结论 (8)致 (9)参考文献 (10)附录 (111)附录A 各函数C语言代码 (111)第1章引言计算机与网络技术的高速发展，使密码技术成为信息安全技术的核心。
它主要由密码编码技术和密码分析技术两大分支组成。
密码编码技术的主要任务是寻求产生安全性高的有效密码算法和协议，以满足对消息进行加密或认证的要求。
密码分析技术的主要任务是破译密码或伪造认证信息，实现窃取信息或进行诈骗破坏话动。
这两个分支既相互对立又相互依存，正是由于这种对立统一关系，才推动了密码学自身的发展[2]。
公钥加密中，密钥分为加密和解密密钥两种，发送者用加密密钥对消息进行加密，解密者用解密密钥对明文解密，公钥和密钥是一一对应的，一对公钥和密钥称为密钥对，由公钥加密的密文必须由与该公钥配对的密钥解密。
密钥对中的两个密钥具有非常密切的关系，不能单独生成。
RSA公钥加密算法是1977年由罗纳德·维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。
1987年首次公布，当时他们三人都在麻省理工学院工作。
RSA就是他们三人姓氏开头字母拼在一起组成的。
RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。
今天只有短的RSA钥匙才可能被强力方式解破。
到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。
只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。
但在分布式计算和量子计算机理论日趋成熟的今天，RSA加密安全性受到了挑战。
RSA算法基于一个十分简单的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。
RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。
RSA是被研究得最广泛的公钥算法，从提出到现今的三十多年里，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一[3]。
第2章RSA公钥密码算法的基本理论知识2.1模运算操作、费马小定理与欧拉定理2.1.1模运算操作对任意整数a和任意正整数n，存在唯一的整数q和r，满足。
0<r<=n，并且a=n*q+r，值q=［a/n］称为除法的商，其中［b］表示小于等于x的最大整数。
值r=a rood n称为除法的余数，因此，对于任意整数，可表示为：a=［a/n］+(a mod n) (2.1)且有（a*b）mod c =（（a mod c）*（b mod c））mod c (2.2)费马定理和欧拉定理在公钥密码学中有重要的作用。
2.1.2费马小定理如果P是素数，a是不能被P整除的正整数，则：a p-1≡1 mod p (2.3)2.1.3欧拉定理对于任何互质的整数a和n，有在数论中，欧拉定理,（也称费马-欧拉定理）是一个关于同余的性质。
欧拉定理表明，若n,a为正整数，且n,a互质，φ(n)在1到n中为与n互质的数的个数，则:aφ(n) =1 mod n (2.4) 欧拉定理证明:将1~n中与n互质的数按顺序排布：x1,x2……xφ(n) （显然，共有φ(n)个数）我们考虑这么一些数：m1=a*x1;m2=a*x2;m3=a*x3……mφ(n)=a*xφ(n)1）这些数中的任意两个都不模n同余，因为如果有mS≡mR (mod n) （这里假定mS更大一些），就有：mS-mR=a(xS-xR)=qn，即n能整除a(xS-xR)。
但是a与n互质，a与n的最大公因子是1，而xS-xR<n，因而左式不可能被n整除。
也就是说这些数中的任意两个都不模n同余，φ(n)个数有φ(n)种余数。
2）这些数除n的余数都与n互质，因为如果余数与n有公因子r，那么a*xi=pn+qr=r(……)，a*xi与n不互质，而这是不可能的。
那么这些数除n的余数，都在x1,x2,x3……xφ(n)中，因为这是1~n中与n互质的所有数，而余数又小于n.由1）和2）可知，数m1,m2,m3……mφ(n)（如果将其次序重新排列）必须相应地同余于x1,x2,x3……xφ(n).故得出：m1*m2*m3……mφ(n)≡x1*x2*x3……xφ(n) (mod n)或者说a^[φ(n)]*(x1*x2*x3……xφ(n))≡x1*x2*x3……xφ(n)或者为了方便：K{a^[φ(n)]-1}≡0 ( mod n ) 这里K=x1*x2*x3……xφ(n)。
以上定理是我们证明RSA算法可行性的基础[4]。
2.2RSA算法的过程N=p*q，其中p和q是素数，L为（p-1）和（q-1）的公倍数，L=lcm（（p-1），（q-1））（由欧拉函数得出）。
E为与L互质的随机数，D是使得（D*E）mod L =1的数。
M为明文，E为加密后的密文，{E，N}为公钥，可以公开，{D，N}为私钥由自己保管。
甲向乙发送自己的公钥，乙用公钥加密后，将密文发送给甲，甲用私钥解密，得到密文。
加密算法为：E=M E mod N。
解密算法为：M=E D mod N。
其中有M与E小于N,均大于0。
2.3 RSA算法的可行性RSA算法的可逆性表明其理论上的可行性，要证明可逆性即证明：M=C D=(M E)D=M e*d mod n因为E*D=1mod L，这说明存在E*D=t*L+1，其中t为正整数且有t>=1。
所以：M E*D=M t*L+1 mod N=（（M t*L mod N）（M mod N））mod N 因此可以通过证明M t*L=1 mod N成立来证明。
欧拉定理证明有a L =1 mod n，所以：M t*L=1 mod N从理论上证明算法可逆，第3章RSA算法的演示在编写程序之前先理清思路，设计关键的函数的入口、出口、功能、编写出伪代码。
之后，便是进行函数编写、调试阶段。
最后，便将函数组合在一起，使之成为一个完整的程序。
3.1 RSA程序的设计程序中有判断是否为质数、求两个数的公倍数、判断是否互质、求最大互质数、由E和L求出密钥D、加密算法和解密算法。
各函数算法见附录A。
3.2 RSA算法的实现RSA加密产生公钥和密钥过程可分为以下四步：（1）得出公钥中的N：随机取两个不同的素数，p和q，N=p*q。
（2）求出L：L的值为（p-1）和（q-1）的最小公倍数，L=lcm((p-1),(q-1))。
（3）求出一个随机的公钥E：求出一个与L互质的数E，有gcd(E，L)=1。
（4）求出一个随钥D：密钥D应满足（D*E）mod L=1；主函数的代码如下：int main(){long int p,q,E,D,N,L,ming,mi;display();srand(time(NULL));do{p=rand()%500;}while(p<100||!(iszs(p)));do{q=rand()%500;}while(!(iszs(q))||p==q);N=p*q;L=lcm(p-1,q-1);E=gcd(L);D=qiuD(E,L);if(D<=0||E<=0) return 0;printf("p=%ld q=%ld N=%ld L=%ld E=%ld D=%ld\n",p,q,N,L,E,D);printf("{E=%ld,N=%ld},{D=%ld,N=%ld}\n",E,N,D,N);printf("Let's do it!\n");do{do{printf("请输入一个小于N=%ld的正整数:",N);scanf("%ld",&ming);getchar();}while(ming>N||ming<=0);mi=Encryption(E,N,ming);ming=Decryption(D,N,mi);printf("公钥：E=%ld N=%ld 密文：%ld\n密钥：D=%ld N=%ld 明文：%ld\n",E,N,mi,D,N,ming);printf("还想再来一次吗？[y/n]：");}while('y'==getchar());printf("See you!\n");return 0;}3.3 RSA算法的演示完成编程后，便做了一次测试，测试结果如图3-1所示。