RSA加密算法(c语言的表达)
C语言中的数据压缩和加密算法
C语言中的数据压缩和加密算法数据压缩和加密在计算机领域中起着至关重要的作用。
数据压缩可以帮助我们减少存储空间的占用以及提高数据传输的效率，而数据加密则能够确保数据的安全性和隐私保护。
在C语言中，我们可以利用不同的算法实现数据压缩和加密的功能。
一、数据压缩算法数据压缩算法可以降低数据的体积，减少对存储空间和传输带宽的需求。
下面介绍几种常见的数据压缩算法。
1. 霍夫曼编码（Huffman Encoding）霍夫曼编码是一种可变长度编码方式，通过根据字符出现频率分配不同长度的编码，出现频率较高的字符拥有较短的编码，从而实现对数据的压缩。
在C语言中，我们可以使用树结构来实现霍夫曼编码算法。
2. Lempel-Ziv-Welch压缩（LZW Compression）LZW压缩算法是一种无损压缩算法，它通过建立一个字典来存储已经出现的字符序列，并将序列替换为对应的索引。
随着序列的不断出现，字典也会不断扩充，从而实现对数据的压缩。
在C语言中，我们可以使用哈希表来实现LZW压缩算法。
二、数据加密算法数据加密算法可以将原始数据转换为一种看似无规律的形式，从而保护数据的安全性，防止未经授权的访问和篡改。
下面介绍几种常见的数据加密算法。
1. AES加密算法高级加密标准（AES）是一种对称加密算法，广泛应用于网络通信和数据存储领域。
AES算法基于分组密码结构，采用128、192或256位密钥对数据进行加密和解密。
在C语言中，我们可以使用openssl库中的函数来实现AES算法。
2. RSA加密算法RSA算法是一种非对称加密算法，它基于大数的因数分解难题。
RSA算法使用一对公钥和私钥进行加密和解密，公钥可以公开，而私钥必须保密。
在C语言中，我们可以使用openssl库中的函数来实现RSA算法。
三、应用实例数据压缩和加密在实际应用中有着广泛的应用场景。
例如，在网络传输中，通过对数据进行压缩可以减少带宽的占用，提高数据传输的效率。
C#实现RSA加密解密
C#实现RSA加密解密RSA介绍RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在(美国⿇省理⼯学院)开发的。
RSA取名来⾃开发他们三者的名字。
RSA的缺点:产⽣密钥很⿇烦，受到素数产⽣技术的限制，因⽽难以做到⼀次⼀密。
分组长度太⼤，为保证安全性，n ⾄少也要 600bits以上，使运算代价很⾼，尤其是速度较慢，较对称密码算法慢⼏个数量级；且随着⼤数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。
⽬前，SET(Secure Electronic Transaction)协议中要求CA采⽤2048bits长的密钥，其他实体使⽤1024⽐特的密钥。
C)RSA密钥长度随着保密级别提⾼，增加很快。
下表列出了对同⼀安全级别所对应的密钥长度。
保密级别对称密钥长度（bit)RSA密钥长度（bit)ECC密钥长度（bit)保密年限808010241602010112112204822420301281283072256204019219276803842080256256153605122120RSA的参数RSA密码由三个整数组成，我们分别称之为n, e, d(n、d): 私钥，这个我们要私密保存(n、e): 公钥，可以对外公布n: 模数(Modulus)，私钥和公钥都包含有这个数e: 公钥指数(publicExponent)，⼀般是固定值65537d：私钥指数(privateExponent)dotnet中的表⽰RSA参数的结构体是RSAParametersopenssl⽣成RSA密钥对1. ⽣成⼀个RSA密钥openssl genrsa -out private_pkcs1.pem 2048上⾯的命令导出是pkcs#1格式rsa私钥2. 从⽣成的RSA密钥中提取RSA公钥ps: 私钥中包含了公钥相关信息，所以可以从私钥中导出公钥信息openssl rsa -in private_pkcs1.pem -out public_pkcs1.pem -pubout -RSAPublicKey_out公钥格式转换(PKCS#8 => PKCS#1)openssl rsa -in public_pkcs8.pem -out public_pkcs1.pem -pubin -RSAPublicKey_out私钥格式转换 (PKCS#1 => PKCS#8)openssl pkcs8 -in private_pkcs1.pem -out private_pkcs8.pem -topk8 -nocryptRSA私钥格式转换(PKCS#8 => PKCS#1)openssl rsa -in private_pkcs8.pem -out private_pkcs1.pemC#中RSA的相关操作⽣成公钥和私钥struct RSASecretKey{public RSASecretKey(string privateKey, string publicKey){PrivateKey = privateKey;PublicKey = publicKey;}public string PublicKey { get; set; }public string PrivateKey { get; set; }public override string ToString(){return string.Format("PrivateKey: {0}\r\nPublicKey: {1}", PrivateKey, PublicKey);}}/// <summary>/// generate RSA secret key/// </summary>/// <param name="keySize">the size of the key,must from 384 bits to 16384 bits in increments of 8 </param> /// <returns></returns>RSASecretKey GenerateRSASecretKey(int keySize){RSASecretKey rsaKey = new RSASecretKey();using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize)){rsaKey.PrivateKey = rsa.ToXmlString(true);rsaKey.PublicKey = rsa.ToXmlString(false);}return rsaKey;}实现公钥加密私钥解密string RSAEncrypt(string xmlPublicKey,string content){string encryptedContent = string.Empty;using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){rsa.FromXmlString(xmlPublicKey);byte[] encryptedData = rsa.Encrypt(Encoding.Default.GetBytes(content), false);encryptedContent = Convert.ToBase64String(encryptedData);}return encryptedContent;}string RSADecrypt(string xmlPrivateKey, string content){string decryptedContent = string.Empty;using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){rsa.FromXmlString(xmlPrivateKey);byte[] decryptedData = rsa.Decrypt(Convert.FromBase64String(content), false);decryptedContent = Encoding.GetEncoding("gb2312").GetString(decryptedData);}return decryptedContent;}密钥格式的转换C#中RSA公钥和私钥的格式都是XML的,⽽在其他语⾔如java中,⽣成的RSA密钥就是普通的Base64字符串,所以需要将C#xml格式的密钥转换成普通的Base64字符串,同时也要实现Base64密钥字符串⽣成C#中xml格式的密钥.安装 BouncyCastle 这个Nuget包PM > Install-Package BouncyCastle构造⼀个RSAKeyConventer类namespace RSA{using System;using System.Security.Cryptography;using Org.BouncyCastle.Asn1.Pkcs;using Org.BouncyCastle.Math;using Org.BouncyCastle.Pkcs;using Org.BouncyCastle.Asn1.X509;using Org.BouncyCastle.X509;using Org.BouncyCastle.Security;using Org.BouncyCastle.Crypto.Parameters;public class RSAKeyConverter{/// <summary>/// xml private key -> base64 private key string/// </summary>/// <param name="xmlPrivateKey"></param>/// <returns></returns>public static string FromXmlPrivateKey(string xmlPrivateKey){string result = string.Empty;using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){rsa.FromXmlString(xmlPrivateKey);RSAParameters param = rsa.ExportParameters(true);RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(new BigInteger(1, param.Modulus), new BigInteger(1, param.Exponent),new BigInteger(1, param.D), new BigInteger(1, param.P),new BigInteger(1, param.Q), new BigInteger(1, param.DP),new BigInteger(1, param.DQ), new BigInteger(1, param.InverseQ));PrivateKeyInfo privateKey = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);result = Convert.ToBase64String(privateKey.ToAsn1Object().GetEncoded());}return result;}/// <summary>/// xml public key -> base64 public key string/// </summary>/// <param name="xmlPublicKey"></param>/// <returns></returns>public static string FromXmlPublicKey(string xmlPublicKey){string result = string.Empty;using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){rsa.FromXmlString(xmlPublicKey);RSAParameters p = rsa.ExportParameters(false);RsaKeyParameters keyParams = new RsaKeyParameters(false, new BigInteger(1,p.Modulus), new BigInteger(1, p.Exponent));SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyParams);result = Convert.ToBase64String(publicKeyInfo.ToAsn1Object().GetEncoded());}return result;}/// <summary>/// base64 private key string -> xml private key/// </summary>/// <param name="privateKey"></param>/// <returns></returns>public static string ToXmlPrivateKey(string privateKey){RsaPrivateCrtKeyParameters privateKeyParams =PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey)) as RsaPrivateCrtKeyParameters; using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){RSAParameters rsaParams = new RSAParameters(){Modulus = privateKeyParams.Modulus.ToByteArrayUnsigned(),Exponent = privateKeyParams.PublicExponent.ToByteArrayUnsigned(),D = privateKeyParams.Exponent.ToByteArrayUnsigned(),DP = privateKeyParams.DP.ToByteArrayUnsigned(),DQ = privateKeyParams.DQ.ToByteArrayUnsigned(),P = privateKeyParams.P.ToByteArrayUnsigned(),Q = privateKeyParams.Q.ToByteArrayUnsigned(),InverseQ = privateKeyParams.QInv.ToByteArrayUnsigned()};rsa.ImportParameters(rsaParams);return rsa.ToXmlString(true);}}/// <summary>/// base64 public key string -> xml public key/// </summary>/// <param name="pubilcKey"></param>/// <returns></returns>public static string ToXmlPublicKey(string pubilcKey){RsaKeyParameters p =PublicKeyFactory.CreateKey(Convert.FromBase64String(pubilcKey)) as RsaKeyParameters;using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){RSAParameters rsaParams = new RSAParameters{Modulus = p.Modulus.ToByteArrayUnsigned(),Exponent = p.Exponent.ToByteArrayUnsigned()};rsa.ImportParameters(rsaParams);return rsa.ToXmlString(false);}}}}js的rsa操作移步:。
C语言加密与解密算法
C语言加密与解密算法在计算机科学与信息安全领域，加密与解密算法起着至关重要的作用。
加密算法用于将原始数据转换为不可读的密文，而解密算法则用于将密文还原为可读的原始数据。
C语言是一种常用的编程语言，具备高效性和灵活性，适用于加密与解密算法的开发。
本文将介绍几种常用的C语言加密与解密算法。
一、凯撒密码算法凯撒密码算法是一种最简单的替换加密算法，通过将字母按照固定的偏移量进行替换来实现加密与解密。
以下是一个简单的C语言凯撒密码实现例子：```c#include <stdio.h>void caesarEncrypt(char* message, int key) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' + key) % 26 + 'a';} else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' + key) % 26 + 'A';}i++;}}void caesarDecrypt(char* message, int key) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' - key + 26) % 26 + 'a'; } else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' - key + 26) % 26 + 'A'; }i++;}}int main() {char message[] = "Hello, World!";int key = 3;printf("Original message: %s\n", message);caesarEncrypt(message, key);printf("Encrypted message: %s\n", message);caesarDecrypt(message, key);printf("Decrypted message: %s\n", message);return 0;}```以上程序演示了凯撒密码的加密与解密过程，通过指定偏移量实现对消息的加密与解密。
rsa 原理
rsa 原理
RSA加密算法是一种非对称加密算法，也就是说它使用了两
个密钥：公钥和私钥。
其基本原理是利用大数分解的困难性来保证信息的安全性。
具体而言，RSA算法的生成过程如下：
1. 随机选择两个质数p和q，并计算它们的乘积n = p * q，n
被称为模数。
2. 计算欧拉函数φ(n) = (p - 1) * (q - 1)，欧拉函数表示小于n
且与n互质的正整数的个数。
3. 选择一个与φ(n)互质的正整数e作为公钥，通常选择65537（即2^16 + 1）作为公钥，因为它是一个较小的质数，且满足了一些加密要求。
4. 计算与e关于模φ(n)的乘法逆元d，即d满足(e * d) mod φ(n) = 1，d作为私钥。
5. 公钥是(n, e)，私钥是(n, d)。
对于明文M的加密过程如下：
1. 将明文M转化为一个整数m，要求m小于模数n。
2. 加密过程为密文C = (m^e) mod n，即C = (M^e) mod n。
对于密文C的解密过程如下：
1. 解密过程为明文M = (C^d) mod n，即M = (C^d) mod n。
RSA算法的安全性依赖于大数分解的困难性，也就是说，如
果有人能够在合理的时间内将n分解为p和q，那么就能够计
算出私钥d，进而解密密文。
然而对于较大的n，目前的计算
机技术并不足以快速分解它，因此RSA算法被认为是安全的。
需要注意的是，RSA算法是一种非对称加密算法，加密过程
中使用公钥进行加密，解密过程中使用私钥进行解密。
同时，RSA算法还可以用于数字签名和密钥交换等安全领域中。
中国剩余定理内容 加密 c语言
中国剩余定理内容加密c语言全文共四篇示例，供读者参考第一篇示例：中国剩余定理的基本概念是：如果给定了一组正整数m1, m2, ..., mn，它们两两互素（即最大公约数为1），那么对于任意一组整数a1, a2, ..., an，存在一个唯一的整数x，满足以下条件：x ≡ a1 (mod m1)x ≡ a2 (mod m2)...x ≡ an (mod mn)这个定理的应用可以追溯到中国数学家孙子在《孙子算经》中提出的问题。
在现代密码学中，CRT广泛应用于RSA算法和其他公钥密码算法的加密和解密过程中。
在将中国剩余定理应用于加密算法时，一般采用了多模数（multi-prime）RSA加密或解密方式。
多模数RSA算法能够提高加密速度和效率，减少计算开销。
下面我们来介绍一下如何在C语言中实现多模数RSA算法。
我们需要定义一个结构体来表示模数和余数对。
我们可以定义如下结构体：result %= product;return result;}```除了加密操作之外，我们还可以编写一个解密函数来实现多模数RSA的解密过程。
解密的过程稍微复杂一些，需要更多的数学知识和计算。
中国剩余定理在密码学中有着重要的应用，特别是在多模数RSA算法中。
通过使用CRT，我们可以提高加密和解密的效率和速度，同时保证数据的安全性。
在实际的应用中，我们可以根据具体的需求和场景来选择合适的加密算法和技术。
希望本文能够帮助读者更深入地了解中国剩余定理在加密算法中的应用。
第二篇示例：中国剩余定理，又称孙子定理，是中国古代数学的重要成就之一。
它是中国数学家孙子提出的一种用于求解同余方程组的方法，也可以用于解决模运算的问题。
在现代密码学领域，中国剩余定理也被广泛应用于加密算法中。
中国剩余定理的基本概念是：如果模数m1、m2、...、mn两两互质(即，它们的最大公约数为1)，则对于任意整数a1、a2、...、an和整数m1、m2、...、mn，方程组：x ≡ a1 (mod m1)x ≡ a2 (mod m2)...x ≡ an (mod mn)有解，且解是唯一的模m1*m2*...*mn。
rsa算法代码c++语言
rsa算法代码c++语言RSA 算法是一种非对称加密算法，其中加密和解密使用的是不同的密钥，因此在 C++ 中实现 RSA 算法需要使用到一些复杂的数学运算和密码学知识。
以下是一个简单的 RSA 算法的示例代码，演示了如何生成密钥对以及进行加密和解密操作：```cpp#include <iostream>#include <vector>#include <cmath>#include <cstdlib>#include <ctime>using namespace std;// 生成大质数的函数bool isPrime(int n) {if (n <= 1)return false;if (n <= 3)return true;if (n % 2 == 0 || n % 3 == 0)return false;for (int i = 5; i * i <= n; i = i + 6)if (n % i == 0 || n % (i + 2) == 0)return false;return true;}// 生成随机大整数的函数int generateRandomPrime(int bits) {// 确保 bits 是一个有效的位数if (bits < 1)return -1;// 使用一个随机数生成器来生成一个随机的大整数random_device rd;mt19937 gen(rd());uniform_int_distribution<int> dis(0, (1 << bits) - 1);// 生成一个随机的大整数int num = dis(gen);// 检查生成的整数是否是质数while (!isPrime(num)) {num = dis(gen);}return num;}// RSA 加密函数vector<int> rsaEncrypt(vector<int> message, int publicKey) {vector<int> encryptedMessage;// 加密每个消息元素for (int i = 0; i < message.size(); i++) {int encrypted = message[i] ^ (publicKey * message[i]) % pow(2, message.size());encryptedMessage.push_back(encrypted);}return encryptedMessage;}// RSA 解密函数vector<int> rsaDecrypt(vector<int> encryptedMessage, int privateKey) {vector<int> message;// 解密每个密文元素for (int i = 0; i < encryptedMessage.size(); i++) {int decrypted = (privateKey * encryptedMessage[i]) % pow(2,encryptedMessage.size());message.push_back(decrypted);}return message;}int main() {// 生成密钥对int privateKey = generateRandomPrime(1024);int publicKey = privateKey * pow(2, privateKey - 1, privateKey);// 生成要加密的消息vector<int> message = {1, 2, 3, 4, 5};// 加密消息vector<int> encryptedMessage = rsaEncrypt(message, publicKey);// 输出密文cout << "密文: ";for (int i = 0; i < encryptedMessage.size(); i++)cout << encryptedMessage[i] << " ";cout << endl;// 解密密文vector<int> decryptedMessage = rsaDecrypt(encryptedMessage, privateKey);// 输出明文cout << "明文: ";for (int i = 0; i < decryptedMessage.size(); i++)cout << decryptedMessage[i] << " ";cout << endl;return 0;}```这段代码是一个简单的 RSA 算法的实现示例，主要包含了生成大质数、生成密钥对、加密和解密等功能。
rsa加密算法密文长度
rsa加密算法密文长度
RSA加密算法是一种非对称加密算法，它的密文长度取决于所使用的密钥长度。
在RSA加密算法中，密钥包括公钥和私钥，公钥用于加密，私钥用于解密。
RSA算法的密文长度是公钥长度的一个固定倍数，具体倍数取决于所使用的填充方案。
在RSA加密算法中，密文长度是一个重要的参数，它直接影响着算法的安全性和效率。
一般来说，密文长度越长，加密的安全性越高，但同时也会导致加密和解密的效率降低。
因此，在选择密文长度时，需要权衡安全性和效率之间的关系。
在实际应用中，RSA算法的密文长度常常是固定的，常见的密文长度为1024位、2048位或4096位。
这些长度是经过充分考虑安全性和效率之后得出的。
一般来说，密文长度越长，破解密文的难度就越大，但同时也会导致加密和解密的速度变慢。
在使用RSA加密算法时，需要注意密文长度的选择。
如果密文长度过短，可能会导致加密的安全性不足；如果密文长度过长，可能会导致加密和解密的速度变慢。
因此，选择适当的密文长度是非常重要的。
除了密文长度外，RSA加密算法还有其他一些参数需要注意。
例如，选择合适的填充方案和哈希算法可以进一步提高加密的安全性。
同时，密钥的生成和管理也是非常重要的，需要保证私钥的安全性，
防止私钥泄露导致加密失效。
总的来说，RSA加密算法的密文长度是一个重要的参数，它直接关系到加密的安全性和效率。
在选择密文长度时，需要考虑安全性和效率之间的平衡，并结合实际应用的需求进行选择。
同时，还需要注意其他参数的选择，以保证加密的安全性和可靠性。
RAS加密算法2
RAS加密算法2
RAS加密算法2
RSA加密算法是一种非对称加密算法，也称作公钥加密算法，是由
Ron Rivest、Adi Shamir和Len Adleman在1977年开发的。
RSA的全称
是Rivest-Sharmir-Adleman，他们三个人的名字的首字母组成，是一种
非对称加密算法，也就是说该加密算法需要两个密钥：公钥和私钥。
其中，公钥用来加密明文，私钥用来解密密文。
RSA是目前最有影响力的公钥加
密算法，并被广泛应用于电子商务，软件，数字视频及音频等领域中去加
密和解密信息。
RSA加密算法的原理是选取质数p，q，计算出N=p*q，再根据N和
Z(N)的关系和私钥e计算出公钥d，最后根据加密和解密函数进行加密和
解密。
具体的运算流程是：
1.首先，选择两个大质数p和q，令n=p*q，这里n可以看作是有两
个大素数组成的密钥。
2.接下来，计算出一个数字，要求这个数字小于n并且与n互质，记
作e，这里e就是RSA算法中的公钥。
3.再算出另一个数字，要求这个数字与e满足模反元素的关系，记作d，这里d就是RSA算法中的私钥。
4.由此，RSA的公钥为(N,e)，私钥为d。
5. 公钥加密：将明文m用公钥(N,e)加密，得到密文C，其中C=me mod N。
6. 私钥解密：将密文C用私钥d解密，得到明文，其中m=Cd mod N。
最后。
典型密码算法c语言实现
典型密码算法c语言实现由于密码算法涉及到大量的数学和编程知识，因此实现密码算法需要具备一定的数学和编程基础。
下面是一些常见的密码算法的C语言实现示例：1. 哈希函数：```cinclude <>include <>include <openssl/>void print_sha256(char input) {unsigned char hash[SHA256_DIGEST_LENGTH];SHA256_CTX sha256;SHA256_Init(&sha256);SHA256_Update(&sha256, input, strlen(input));SHA256_Final(hash, &sha256);for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {printf("%02x", hash[i]);}printf("\n");}```2. 对称加密算法：```cinclude <>include <>include <openssl/>void aes_encrypt(char plaintext, char key, char ciphertext) { AES_KEY aesKey;AES_set_encrypt_key(key, 128, &aesKey);int len = strlen(plaintext);int outLength = len + AES_BLOCK_SIZE;ciphertext = (char )malloc(outLength);AES_encrypt(plaintext, ciphertext, &aesKey);}```3. 非对称加密算法：```cinclude <>include <>include <openssl/>include <openssl/>include <openssl/>RSA createRSA(int keylen) {RSA rsa = NULL;BIO keybio = BIO_new_mem_buf(key, -1);if (keybio == NULL) {return NULL;}if ((rsa = PEM_read_bio_RSA_PrivateKey(keybio, &rsa, NULL, NULL)) == NULL) {return NULL;}BIO_free(keybio);return rsa; }```。
RSA加密算法验证（C#实现）
RSA加密算法验证（C#实现）RSA算法简单原理介绍（节选于⽹络）假设想要通过⼀个不可靠的媒体接收的⼀条私⼈讯息。
她可以⽤以下的⽅式来产⽣⼀个公钥和⼀个私钥：1. 随意选择两个⼤的p和q，p不等于q，计算N=pq。
2. 根据，求得r = (p-1)(q-1)3. 选择⼀个⼩于 r 的整数 e，求得 e 关于模 r 的，命名为d。
（模反元素存在，当且仅当e与r互质）4. 将 p 和 q 的记录销毁。
(N,e)是公钥，(N,d)是私钥。
Alice将她的公钥(N,e)传给Bob，⽽将她的私钥(N,d)藏起来。
加密消息 假设Bob想给Alice送⼀个消息m，他知道Alice产⽣的N和e。
他使⽤起先与Alice约好的格式将m转换为⼀个⼩于N的整数n，⽐如他可以将每⼀个字转换为这个字的码，然后将这些数字连在⼀起组成⼀个数字。
假如他的信息⾮常长的话，他可以将这个信息分为⼏段，然后将每⼀段转换为n。
⽤下⾯这个公式他可以将n加密为c： ne ≡ c (mod N)计算c并不复杂。
Bob算出c后就可以将它传递给Alice。
解密消息Alice得到Bob的消息c后就可以利⽤她的密钥d来解码。
她可以⽤以下这个公式来将c转换为n： cd ≡ n (mod N)得到n后，她可以将原来的信息m重新复原。
解码的原理是： cd ≡ n e·d(mod N)以及ed≡ 1 (mod p-1)和ed≡ 1 (mod q-1)。
由可证明（因为p和q是质数） n e·d ≡ n (mod p) 和 n e·d ≡ n (mod q)这说明（因为p和q是不同的质数，所以p和q互质） n e·d ≡ n (mod pq)1using System;2using System.Collections.Generic;3using ponentModel;4using System.Data;5using System.Drawing;6using System.Linq;7using System.Text;8using System.Threading.Tasks;9using System.Windows.Forms;1011namespace RSA12 {13public partial class Form1 : Form14 {15public Form1()16 {17 InitializeComponent();18 }1920//****************************************21//验证输⼊的p,q是否为素数，并计算n与m22//****************************************23private void button1_Click(object sender, EventArgs e)24 {25long p, q;26//获取p,q的值27 p = long.Parse(textBox1.Text);28 q = long.Parse(textBox2.Text);2930//判断p，q是否为素数，若为真进⾏计算，则否弹出提⽰31if (isPrim(p) && isPrim(q))32 {33long n = p * q;34long m = (p - 1) * (q - 1);35 textBox3.Text = n.ToString();36 textBox4.Text = m.ToString();37 }38else39 {40 MessageBox.Show("请按要求,重新输⼊p,q");41 textBox1.Clear();42 textBox2.Clear();43 textBox3.Clear();44 textBox1.Focus();45 }464748 }4950//****************************************51//⽤随机数⽣成素数pq，并计算n与m52//****************************************5354private void button5_Click(object sender, EventArgs e)55 {56//⽣成随机数⼯具57 Random random = new Random();58long p, q;5960//设置判断标志61 Boolean flag = false;62while (!flag)63 {64 p = random.Next(595530);65 q = random.Next(585530);6667//若⽣成的两个随机数都为素数，设定更新标志，并进⾏显⽰68if (isPrim(p) && isPrim(q))69 {70 flag = true;71 textBox1.Text = p.ToString();72 textBox2.Text = q.ToString();73 textBox3.Clear();74 textBox4.Clear();75 }7677 }78 }7980//****************************************81//验证输⼊的d是否为素数，并计算公钥d82//****************************************83private void button2_Click(object sender, EventArgs e)84 {85//获取d,m的值86long d = long.Parse(textBox5.Text);87long m = long.Parse(textBox4.Text);8889//判断输⼊的d是否符合条件90if (d > 1 && d < m && gcd(d, m) == 1 && isPrim(d))91 {92//使⽤逆元函数，计算d,m的逆元93long result = niyuan(d, m);94 textBox6.Text = result.ToString();95 }96else97 {98 MessageBox.Show("输⼊的 e 不符合要求，请按要求,重新输⼊公钥 e ！");99 textBox5.Clear();100 textBox5.Focus();101102 }103 }104105//****************************************106//随机⽣成私钥d，并计算出公钥e107//****************************************108private void button6_Click(object sender, EventArgs e)109 {110long d = 0;111112//获取m的值，⽤以计算e113long m = long.Parse(textBox4.Text);114115//⽣成随机数⼯具，并设置随机是否完成标志116 Random radom = new Random();117 Boolean flag = false;118while(!flag)119 {120 d = radom.Next(655300);121if (d > 1 && d < m && gcd(d, m) == 1 && isPrim(d)) 122 {123 flag = true;124 }125 }126127//利⽤逆元函数计算公钥128long result = niyuan(d, m);129130 textBox5.Text = d.ToString();131 textBox6.Text = result.ToString();132133 }134135//****************************************136//利⽤公钥n和私钥e，加密明⽂137//****************************************138private void button4_Click(object sender, EventArgs e) 139 {140//设置标志，判断是否已经输⼊明⽂141 Boolean flag = false;142if (!string.IsNullOrWhiteSpace(textBox7.Text))143 flag = true;144145if(flag == false)146 {147 MessageBox.Show("加密前,请先输⼊明⽂！");148 textBox7.Focus();149 }150else151 {152long n = long.Parse(textBox3.Text);153long m = long.Parse(textBox7.Text);154long E = long.Parse(textBox5.Text);155156//利⽤快速指数模运算函数⽣成密⽂157long C = getMod(E, m, n);158 textBox8.Text = C.ToString();159 }160161 }162163//****************************************164//利⽤公钥n和公钥d，解密密⽂165//****************************************166private void button3_Click(object sender, EventArgs e) 167 {168//设置标志，判断是否已经输⼊密⽂169 Boolean flag = false;170if (!string.IsNullOrWhiteSpace(textBox9.Text))171 flag = true;172if(flag == false)173 {174 MessageBox.Show("解密前，请先输⼊密⽂！"); 175 textBox9.Focus();176 }177else178 {179long C = long.Parse(textBox9.Text);180long n = long.Parse(textBox3.Text);181long d = long.Parse(textBox6.Text);182183//利⽤快速指数模运算函数解密密⽂184long M = getMod(d, C, n);185 textBox10.Text = M.ToString();186 }187188 }189190//****************************************191//输⼊⼀个数，以6为步进单元判断其是否为素数192//****************************************193private bool isPrim(long num)194 {195//两个较⼩数另外处理196if (num == 2 || num == 3)197return true;198//不在6的倍数两侧的⼀定不是质数199if (num % 6 != 1 && num % 6 != 5)200return false;201long tmp = (long)Math.Sqrt(num);202//在6的倍数两侧的也可能不是质数203for (long i = 5; i <= tmp; i += 6)204if (num % i == 0 || num % (i + 2) == 0)205return false;206//排除所有，剩余的是质数207return true;208 }209210//****************************************211//采⽤递归的形式，判断两个数是否互质212//****************************************213private long gcd(long x, long y)214 {215return y != 0 ? gcd(y, x % y) : x;216 }217218//****************************************219//利⽤欧⼏⾥得算法计算m，d的逆元220//****************************************221private long niyuan(long number1, long number3)222 {223long x1 = 1, x2 = 0, x3 = number3, y1 = 0, y2 = 1, y3 = number1; 224long q;225long number4 = 0;226long t1, t2, t3;227while (y3 != 0)228 {229if (y3 == 1)230 {231 number4 = y2;232break;233 }234else235 {236 q = (x3 / y3);237 t1 = x1 - q * y1;238 t2 = x2 - q * y2;239 t3 = x3 - q * y3;240 x1 = y1; x2 = y2; x3 = y3;241 y1 = t1; y2 = t2; y3 = t3;242 }243 }244if (number4 < 0)245 number4 = number4 + number3;246return number4;247 }248249//****************************************250//利⽤快速指数模运算，计算m^e mod n251//****************************************252private long getMod(long a, long b, long c)253 {254//指数 e --> a 底数 m --> b 模数 n --> c255long number3 = 1;256while (a != 0)257 {258if (a % 2 == 1)259 {260 a = a - 1;261 number3 = (number3 * b) % c;262 }263else264 {265 a = (a / 2);266 b = (b * b) % c;267 }268 }269return number3;270271 }272 }273 }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include
#include
#include
#include
int r; //公开模数
int sk; //私人密钥
int pk; //公开密钥
int Euler;//欧拉函数
int check(int x)
{
for(int i=2;i<=x-1;i++)
{
if(x%i==0) break;
}
if(i==x) return 1;
else return 0;
}
void produceSS()
{
int p,q;
int flag=0;
int n=0;
cout<<"输入值不要太大,防止溢出!"<
{
if(n>0) cout<<"p应为素数，请重新输入!"<
cin>>p;
flag=check(p);
n++;
}
flag=0;
n=0;
while(flag==0)
{
if(n>0) cout<<"q应为素数，请重新输入!"<
cin>>q;
flag=check(q);
n++;
}
r=p*q;
cout<<"公开模数:r="<
cout<<"欧拉函数:Euler="<
int gcd(int x,int y)
{
int a=x;
int b=y;
int z;
b++;
do
{
b--;
x=a;
y=b;
while(x%y!=0)
{
z=x%y;
x=y;
y=z;
}
}while(z>1);
return b;
}
int trAsc(int s,int a[]) //转为二进制数
{
int x=s;
int n=0;
while(x!=0)
{
a[n]=x%2;
x=x/2;
n++;
}
return n;
}
int pfc(int x,int key) //平方乘
{
int a[13];
int m=trAsc(key,a); //二进制位数
int c=1;
for(int i=m-1;i>=0;i--)
{
c=c*c%r;
if(a[i]==1) c=c*x%r;
}
return c;
}
/*int producePk()
{
int a1=sk;
int r1=r;
int q1, p1;
int b1=0;
int b2=1;
int b3;
do{
cout<
q1=r1%a1;
b3=b1-b2*p1;
b1=b2;
b2=b3;
r1=a1;
a1=q1;
}while(a1!=1);
return abs(b2);
}*/
void produceKey() } void main()
{
int k;
int n=0;
int flag=0;
int b1=0;
int b2=1;
int a,c,q,p;
cout<<"e应小于欧拉函数:"<
cin>>sk;
sk++;
do
{
sk--;
sk=abs(sk);//绝对值
sk=gcd(Euler,sk);
b1=0;
b2=1;
a=sk;
c=Euler;
do
{
q=c/a; //辗转相除
p=c%a;
pk=b1-b2*q;
c=a;
a=p;
b1=b2;
b2=pk;
}while (p!=1);
pk=abs(pk);
a=pfc(8,sk);
c=pfc(a,pk);
} while(c!=8); //加密、解密正确判断
cout<<"d="<
void Encryption() //加密
{
int Express;
int flag=1;
while(flag)
{
cout<<"明文编码应小于公开模数r:"<
cin>>Express;
if(Express>r)
cout<<"明文编码应小于公开模数,请重新输入!"<
}
cout<<"sk="<
cout<<"密文为:"<
void Decrypt()//减密
{
int Express;
int flag=1;
while(flag)
{
cout<<"密文编码应小于公开模数r:"<
cin>>Express;
if(Express>r)
cout<<"密文编码应小于公开模数,请重新输入!"<
}
cout<<"pk="<
cout<<"明文为:"<
{
int flag=1;
int step;
int n;
while(flag)
{
cout<<"1.产生素数"<
cin>>step;
switch(step)
{
case 1:produceSS();
break;
case 2:produceKey();
break;
case 3:Encryption();
break;
case 4:Decrypt();
break;
case 5:exit(0);
break;
}
}
}