信息计算2019级1班22号李浩栋

李浩栋

李浩栋

李浩栋

1、RSA.h

1. #pragma once
   
2. #pragma once
   
3. #include <string>
   
4. #include <vector>
   
5. struct Key
   
6. {
   
7.         long pkey;
   
8.         //私钥(ekey, pkey): (e,n)
   
9.         long ekey;
   
10.         //公钥(dkey, pkey): (d, n)
    
11.         long dkey;
    
12. };
    
13. 
    
14. class RSA
    
15. {
    
16. public:
    
17.         RSA();
    
18. 
    
19.         Key getKey()
    
20.         {
    
21.                 return _key;
    
22.         }
    
23. 
    
24.         void ecrept(const char* plain_file_in, const char* ecrept_file_out,
    
25.                 long ekey, long pkey);//加密
    
26.         void decrept(const char* ecrept_file_in, const char* plain_file_out,
    
27.                 long dkey, long pkey);//解密
    
28. 
    
29.         std::vector<long> ecrept(std::string& str_in, long ekey, long pkey);//字符串加密
    
30.         std::string decrept(std::vector<long>& ecrept_str, long dkey, long pkey);//解密为字符串
    
31. 
    
32.         void printInfo(std::vector<long>& ecrept_str);//打印信息
    
33. private:
    
34.         long ecrept(long msg, long key, long pkey);//加密单个信息
    
35.         long produce_prime();//产生素数
    
36.         bool is_prime(long prime);//是否为素数
    
37.         void produce_keys();
    
38.         long produce_pkey(long prime1, long prime2);//计算pq乘积n
    
39.         long produce_orla(long prime1, long prime2);//计算欧拉函数φ(n)
    
40.         long produce_ekey(long orla);//产生e
    
41.         long produce_gcd(long ekey, long orla);//产生最大公约数
    
42.         long produce_dkey(long ekey, long orla);//产生d
    
43. 
    
44. private:
    
45.         Key _key;
    
46. };

复制代码

2、RSA.cpp

1. #include"RSA.h"
   
2. #include<time.h>
   
3. #include<math.h>
   
4. #include<iostream>
   
5. #include<fstream>
   
6. 
   
7. RSA::RSA()
   
8. {
   
9.         produce_keys();
   
10. }
    
11. 
    
12. void RSA::ecrept(const char* plain_file_in, const char* ecrept_file_out,
    
13.         long ekey, long pkey)//加密
    
14. {
    
15.         std::ifstream fin(plain_file_in);
    
16.         std::ofstream fout(ecrept_file_out, std::ofstream::app);
    
17.         if (!fin.is_open())
    
18.         {
    
19.                 std::cout << "open file failed" << std::endl;
    
20.                 return;
    
21.         }
    
22.         const int NUM = 256;
    
23.         char buffer[NUM];
    
24.         long buffer_out[NUM];
    
25.         int curNum;
    
26.         while (!fin.eof())
    
27.         {
    
28.                 fin.read(buffer, NUM);
    
29.                 curNum = fin.gcount();
    
30.                 for (int i = 0; i < curNum; ++i)
    
31.                 {
    
32.                         buffer_out[i] = ecrept(buffer[i], ekey, pkey);
    
33.                 }
    
34.                 fout.write((char*)buffer_out, curNum * sizeof(long));
    
35.         }
    
36.         fin.close();
    
37.         fout.close();
    
38. }
    
39. void RSA::decrept(const char* ecrept_file_in, const char* plain_file_out,
    
40.         long dkey, long pkey)//解密
    
41. {
    
42.         std::ifstream fin(ecrept_file_in);
    
43.         std::ofstream fout(plain_file_out, std::ofstream::app);
    
44.         if (!fin.is_open())
    
45.         {
    
46.                 std::cout << "open file failed" << std::endl;
    
47.                 return;
    
48.         }
    
49.         const int NUM = 256;
    
50.         long buffer[NUM];
    
51.         char buffer_out[NUM];
    
52.         int curNum;
    
53.         while (!fin.eof())
    
54.         {
    
55.                 fin.read((char*)buffer, NUM * sizeof(long));
    
56.                 curNum = fin.gcount() / sizeof(long);
    
57.                 for (int i = 0; i < curNum; ++i)
    
58.                 {
    
59.                         buffer_out[i] = ecrept(buffer[i], dkey, pkey);
    
60.                 }
    
61.                 fout.write(buffer_out, curNum);
    
62.         }
    
63.         fin.close();
    
64.         fout.close();
    
65. }
    
66. 
    
67. std::vector<long> RSA::ecrept(std::string& str_in, long ekey, long pkey)//字符串加密
    
68. {
    
69.         std::vector<long> vecout;
    
70.         size_t sz = str_in.size();
    
71.         for (const auto& e : str_in)
    
72.         {
    
73.                 vecout.push_back(ecrept(e, ekey, pkey));
    
74.         }
    
75.         return vecout;
    
76. }
    
77. std::string RSA::decrept(std::vector<long>& ecrept_str, long dkey, long pkey)//解密为字符串
    
78. {
    
79.         std::string strout;
    
80.         for (const auto& e : ecrept_str)
    
81.         {
    
82.                 strout.push_back(ecrept(e, dkey, pkey));
    
83.         }
    
84.         return strout;
    
85. }
    
86. 
    
87. void RSA::printInfo(std::vector<long>& ecrept_str)//打印信息
    
88. {
    
89.         for (const auto& e : ecrept_str)
    
90.         {
    
91.                 std::cout << e << ' ';
    
92.         }
    
93.         std::cout << std::endl;
    
94. }
    
95. 
    
96. //加密解密算法
    
97. //模幂运算(a^b)%c   
    
98. long RSA::ecrept(long msg, long key, long pkey)
    
99. {
    
100.         long msg_out = 1;
     
101.         //A0:a^(2^0) % c = a^1 = a%c
     
102.         long a = msg;
     
103.         long b = key;
     
104.         int c = pkey;
     
105.         while (b)
     
106.         {
     
107.                 if (b & 1)
     
108.                         //msg_out = (A0 * A1 ...Ai ... An) % c
     
109.                         msg_out = (msg_out * a) % c;
     
110.                 b >>= 1;
     
111.                 //Ai = (A(i - 1) * A(i - 1)) % c
     
112.                 a = (a * a) % c;
     
113.         }
     
114.         return msg_out;
     
115. }
     
116. 
     
117. long RSA::produce_prime()
     
118. {
     
119.         srand(time(nullptr));
     
120.         long prime = 0;
     
121.         while (1)
     
122.         {
     
123.                 prime = rand() % 50 + 2;
     
124.                 if (is_prime(prime))
     
125.                         break;
     
126.         }
     
127.         return prime;
     
128. }
     
129. 
     
130. bool RSA::is_prime(long prime)
     
131. {
     
132.         if (prime < 2)
     
133.                 return false;
     
134.         for (int i = 2; i < sqrt(prime); ++i)
     
135.         {
     
136.                 if (prime % i == 0)
     
137.                         return false;
     
138.         }
     
139.         return true;
     
140. }
     
141. 
     
142. void RSA::produce_keys()
     
143. {
     
144.         long prime1 = produce_prime();
     
145.         long prime2 = produce_prime();
     
146.         while (prime1 == prime2)
     
147.                 prime2 = produce_prime();
     
148.         _key.pkey = produce_pkey(prime1, prime2);
     
149.         long orla = produce_orla(prime1, prime2);
     
150.         _key.ekey = produce_ekey(orla);
     
151.         _key.dkey = produce_dkey(_key.ekey, orla);
     
152. }
     
153. 
     
154. long RSA::produce_pkey(long prime1, long prime2)
     
155. {
     
156.         return prime1 * prime2;
     
157. }
     
158. 
     
159. long RSA::produce_orla(long prime1, long prime2)
     
160. {
     
161.         return (prime1 - 1) * (prime2 - 1);
     
162. }
     
163. 
     
164. //随机选择一个整数e，条件是1 < e < φ(n)，且e与φ(n) 互质
     
165. long RSA::produce_ekey(long orla)
     
166. {
     
167.         long ekey;
     
168.         srand(time(nullptr));
     
169.         while (1)
     
170.         {
     
171.                 ekey = rand() % orla;
     
172.                 if (ekey > 1 && produce_gcd(ekey, orla) == 1)
     
173.                         break;
     
174.         }
     
175.         return ekey;
     
176. }
     
177. 
     
178. //求最大公约数
     
179. long RSA::produce_gcd(long ekey, long orla)
     
180. {
     
181.         //gcd(a, b)------gcd(b ,a%b)
     
182.         long ret;
     
183.         while (ret = ekey % orla)
     
184.         {
     
185.                 ekey = orla;
     
186.                 orla = ret;
     
187.         }
     
188.         return orla;
     
189. }
     
190. 
     
191. long RSA::produce_dkey(long ekey, long orla)
     
192. {
     
193.         //(dkey * ekey) % orla == 1
     
194. 
     
195.         long dkey = orla / ekey;//dkey最小为orla / ekey，才能保证dkey * ekey与orla相等
     
196.                                                         //只有dkey * ekey比orla大才能有余数为1
     
197.         while (1)
     
198.         {
     
199.                 if ((dkey * ekey) % orla == 1)
     
200.                         break;
     
201.                 ++dkey;
     
202.         }
     
203.         return dkey;
     
204. }

复制代码

3、Test.cpp

1. #include"RSA.h"
   
2. #include<iostream>
   
3. 
   
4. void test()
   
5. {
   
6.         RSA rsa;
   
7.         Key key = rsa.getKey();
   
8.         std::string strin;
   
9.         while (1)
   
10.         {
    
11.                 std::cout << "输入要加密的信息：" << std::endl;
    
12.                 std::cin >> strin;
    
13.                 std::vector<long>strecrept = rsa.ecrept(strin, key.ekey, key.pkey);
    
14.                 std::string strout = rsa.decrept(strecrept, key.dkey, key.pkey);
    
15.                 std::cout << "加密后的信息：" << std::endl;
    
16.                 rsa.printInfo(strecrept);
    
17.                 std::cout << "解密后的信息：" << std::endl;
    
18.                 std::cout << strout << std::endl;
    
19.                 std::cout << std::endl;
    
20. 
    
21.         }
    
22. }
    
23. 
    
24. int main()
    
25. {
    
26.         test();
    
27.         system("pause");
    
28.         return 0;
    
29. }

复制代码

李浩栋