Principle and program demonstration of Diffie-Hellman Key Exchange Algorithm

In. Its mathematical basis is the mathematical difficulty of discrete logarithm. The key exchange process is described as follows:
Select two large numbers p and g and make them public. p is a prime number, and g is a module p of p. The original unit root (primitive root module p ), the original unit root refers to the power 1 and power 2 of g under the modulo p multiplication operation ...... (P-1) the numbers of the first power are different from each other and are retrieved from 1 to the first power;
For Alice (one of them), a random integer a is generated, a is kept confidential, Ka = g ^ a mod p is calculated, and Ka is sent to Bob;
For Bob (another contact), a random integer B is generated, B is kept confidential, Kb = g ^ B mod p is calculated, and Kb is sent to Alice;
For Alice, after receiving the Kb sent by Bob, the calculated key is: key = Kb ^ a mod p = (g ^ B) ^ a = g ^ (B *) mod p;
For Bob, after receiving the Ka sent by Alice, the calculated key is: key = Ka ^ B mod p = (g ^ a) ^ B = g ^ (a * B) mod p.
The attacker knows p and g and intercepts Ka and Kb. However, when they are all very large numbers, it is very difficult to calculate a and B Based on these four numbers, this is the mathematical problem of discrete logarithm.
To implement the Diffie-Hellman Key Exchange Protocol, you must be able to quickly calculate the power of a big digital model. In the modulo algorithm, you still need to calculate the multiplication and modulo operations of large numbers. Therefore, the entire process requires three algorithms: high-Precision multiplication and high-precision Division (used to calculate the quotient and remainder of A large number divided by another large number at the same time), a fast Modulo-power algorithm.
High-Precision multiplication and division can be simulated by a program. The quick modulo algorithm also summarizes the rule from the manual calculation, for example:
5 ^ 8 = (5 ^ 2) ^ 4 = (25) ^ 4 = (25 ^ 2) ^ 2 = (625) ^ 2. In this way, originally, 8 multiplications were required for calculation of 5 ^ 8, but now only three multiplications are required: 5 ^ 2, 25 ^ 2,625 ^ 2. This is the basis of the rapid Modulo-power algorithm. Describe the algorithm, that is:
Algorithm M: Input integer A, B, P, calculate a ^ B mod P:
M1. initialize c = 1
M2. if B is 0, C is the result to be calculated. Returns the value of C. The algorithm ends.
M3. If B is odd, C = C * a mod P, B = B-1, to M2.
M4. if B is an even number, convert a = A * a mod P, and B = B/2 to M2.
The high-precision Trial Division principle is simple, but the code implementation requires careful consideration of some details.
My DEMO code is as follows:
High-Precision computing:

1. Class supernumber {
2. Public:
3. Supernumber (){
4. Memset (data, 0, max_size );
5. High = 0;
6. }
7. // General integer to supernumber conversion. This version does not support negative numbers
8. Supernumber (unsigned long l ){
9. Memset (data, 0, max_size );
10. High = 0;
11. While (l ){
12. Data [++ high] = l % 10;
13. L/= 10;
14. }
15. }
16. // STR represents the decimal number in the string format
17. Supernumber (const char * Str ){
18. Assert (STR! = NULL );
19. High = strlen (STR );
20. For (int I = high, j = 0; I> = 1; I --, j ++ ){
21. Data [I] = str [j]-'0 ';
22. }
23. }
24. SuperNumber (const SuperNumber & s ){
25. Memcpy (data, s. data, MAX_SIZE );
26. High = s. high;
27. }
28. Operator const char * () const {
29. Return toString (10 );
30. }
31. Supernumber & operator = (const supernumber & S ){
32. If (this! = & S ){
33. Memcpy (data, S. Data, max_size );
34. High = S. High;
35. }
36. Return * this;
37. }
39. // Set the data to 0
40. Void reset (){
41. Memset (data, 0, max_size );
42. High = 0;
43. }
45. // Str represents the decimal number in the string format
46. Void setToStr (const char * str ){
47. Assert (str! = NULL );
48. High = strlen (str );
49. For (int I = high, j = 0; I> = 1; I --, j ++ ){
50. Data [I] = str [j]-'0 ';
51. }
52. }
53. // Convert the data to a base-specified string. The default value is decimal.
54. Const char * toString (int base = 10) const {
55. Static char buf [MAX_SIZE];
56. Const char table [] = "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
58. If (high = 0) return "0 ";
60. Assert (base> = 2); // The specified hexadecimal value should not be less than 2
62. // Hexadecimal conversion
63. Buf [MAX_SIZE-1] = '/0 ';
64. Int begin = MAX_SIZE-1;
65. Char temp [MAX_SIZE];
66. Memcpy (temp, data, MAX_SIZE );
67. While (1 ){
68. // Locate the start position of the highest bit
69. Int h = high;
70. While (temp [h] = 0 & h> = 1) h --;
71. If (h = 0) break;
73. // Except the base
74. Int t = 0;
75. While (h> = 1 ){
76. T = t * 10 + temp [h];
77. Temp [h] = t/base;
78. T = t % base;
79. H --;
80. }
81. Buf [-- begin] = table [t];
82. }
84. Return buf + begin;
85. }
87. // Multiplication
88. SuperNumber operator * (const SuperNumber & s) const {
89. SuperNumber result; // default set to 0
90. Int I, j;
92. // Multiply
93. For (I = 1; I <= high; I ++ ){
94. For (j = 1; j <= s. high; j ++ ){
95. Int k = data [I] * s. data [j] + result. data [I + J-1];
96. Result. data [I + J-1] = k % 10;
97. Result. data [I + j] + = k/10;
98. }
99. }
100. // Carry
101. For (I = 1; I <MAX_SIZE-1; I ++ ){
102. If (result. Data [I]> = 10 ){
103. Result. Data [I + 1] + = result. Data [I]/10;
104. Result. Data [I] % = 10;
105. }
106. }
107. // Determine the highest bit
108. For (I = MAX_SIZE-1; I> = 1 & result. Data [I] = 0; I --);
109. Result. High = I;
111. Return result;
112. }
114. // Division, which is implemented by calling doDivide internally
115. SuperNumber operator/(const SuperNumber & s) const {
116. SuperNumber q, r;
117. DoDivide (s, q, r );
118. Return q;
119. }
120. // Modulo operation, which is implemented by calling doDivide internally
121. SuperNumber operator % (const SuperNumber & s) const {
122. SuperNumber q, r;
123. DoDivide (s, q, r );
124. Return r;
125. }
127. // Division operation. In a division operation, the operator and remainder, operators, and % are reloaded simultaneously.
128. // This function is called internally. dest is the divisor, Q is the quotient, and R is the remainder. The algorithm uses the Trial Division.
129. Void doDivide (const SuperNumber & dest, SuperNumber & Q, SuperNumber & R) const {
130. Int I, j, t;
132. Q. reset ();
133. Q. high = high-dest. high + 1; // initial bid of the operator
134. R = * This; // the remainder is actually the dividend.
135. T = DeST. High;
136. // Judge whether the Division ends
137. While (r> = DEST ){
138. // Perform cyclic subtraction for Trial Division
139. While (DEST> = R. sub (1, t )){
140. Q. Data [q. High --] = 0;
141. ++ T;
142. }
143. While (R. sub (1, t)> = DEST ){
144. // When I is subtraction, the lowest subscript OF THE devisor and J is the lowest subscript OF THE devisor.
145. For (I = R. High-t + 1, j = 1; j <= DeST. High; I ++, J ++ ){
146. R. Data [I]-= DeST. Data [J];
147. If (R. data [I] <0 ){
148. R. data [I] + = 10;
149. R. data [I + 1]-= 1;
150. }
151. }
152. While (R. data [I] <0 & I <= R. high ){
153. R. data [I] + = 10;
154. R. data [I + 1]-= 1;
155. ++ I;
156. }
157. Q. data [Q. high] + = 1;
158. }
159. // The maximum subscript of the Updater after a Trial Division is completed
160. Q. high-= 1;
161. // Update the highest subscript of the divisor.
162. While (R. data [R. high] = 0 ){
163. R. high --;
164. T --;
165. }
166. T + = 1; // The next Divisor
167. }
169. Q. high = high-dest. high + 1;
170. While (Q. data [Q. high] = 0) Q. high-= 1;
171. R. high = high;
172. While (R. data [R. high] = 0) R. high-= 1;
173. }
175. // Big digital-to-analog power algorithm. It is a simple natural algorithm, that is, to break down an index into binary values.
176. // More simply, it is to constantly find the square modulo power, instead of multiplying all squares before
177. // Perform a final modulo operation
178. // A. power_mod (p, n) calculates a ^ p mod n
179. SuperNumber power_mod (int power, SuperNumber n) const {
180. Supernumber C ("1"), T (* This );
182. While (Power ){
183. If (Power % 2 ){
184. C = C * T % N;
185. Power-= 1;
186. } Else {
187. T = T * T % N;
188. Power/= 2;
189. }
190. }
192. Return C % N;
193. }
195. Bool operator> = (const supernumber & S) const {
196. If (high = S. High ){
197. Int K = high;
198. While (data [k] = S. Data [k] & K> = 1) k --;
199. If (k <1) return true; // equal
200. Return data [k]> s. data [k];
201. } Else if (high> s. high) return true;
202. Return false;
203. }
205. Bool operator <(const SuperNumber & s) const {
206. Return! (* This> = s );
207. }
209. // Start from the highest digit in decimal format, count to the first digit, and intercept consecutive digits from the second digit.
210. // The c-digit to form a new number. For example, if the data is 12345678925698
211. // Sub (3, 5) returns the number 34567. If the number is not enough, run
212. // Sub (3, 5), because 34567 is 5 from the high digits, and the remaining number is 3rd,
213. // There are three at most, and five are not enough. At this time, 567 is returned and no error is returned.
214. SuperNumber sub (int I, int c) const {
215. SuperNumber ret;
216. Assert (high> = I); // ensure intercept
218. I = high-I + 1; // subscript of the I-th digit starting from the high digit
219. If (I> = c ){
220. Ret. high = c;
221. While (C> = 1) ret. Data [c --] = data [I --];
222. } Else {
223. Ret. High = I;
224. While (I> = 1 ){
225. Ret. Data [I] = data [I];
226. I --;
227. }
228. }
229. // Filter the leading 0
230. While (ret. data [ret. high] = 0) ret. high --;
231. Return ret;
232. }
234. // I/O
235. Friend istream & operator> (istream & in, SuperNumber & s ){
236. Char t [256];
237. In> t;
238. S. setToStr (t );
239. Return in;
240. }
241. Friend ostream & operator <(ostream & out, const SuperNumber & s ){
242. Return out <s. toString (10 );
243. }
244. Private:
245. Enum {MAX_SIZE = 256}; // maximum decimal digits
246. // Note that using data [0] to store the subscript of the highest bit is a bit clever. Later
247. // This is a huge error during debugging, but it can be handled for this question.
248. Char data [MAX_SIZE]; // internal representation of the data, in decimal format
249. // Where data [0] stores the subscript of the highest bit, data [1]
250. // The bitwise of the stored data, that is, the bitwise
251. Int high;
252. };

Main function:

1. Int main (INT argc, char ** argv ){
2. Freopen ("in.txt", "r", stdin );
4. Supernumbertest st;
6. // St. Run ();
8. // Both g and n are prime numbers greater than 2 ^ 127. They are made public in DH algorithms.
9. Supernumber g, N;
10. Int A, B;
11. Supernumber ka, kb, key;
13. Srand (time (0 ));
15. Cin> g> n;
17. Cout <"g =" <g <endl
18. <"N =" <n <endl;
20. Cout <"/nThis is Alice:/n ";
21. A = rand ();
22. Cout <"Alice get a random integer a =" <a <endl;
23. Cout <"Alice computer g ^ a mod n:/n ";
24. Ka = g. power_mod (a, n );
25. Cout <"Alice compute out ka =" <ka <endl;
27. Cout <"/nThis is Bob:/n ";
28. B = rand ();
29. Cout <"Bob get a random integer B =" <B <endl;
30. Cout <"Bob compute g ^ B mod n:/n ";
31. Kb = g. power_mod (B, n );
32. Cout <"Bob compute out kb =" <kb <endl;
34. Cout <"/nalice get Kb from Bob, she compute out key is:/N ";
35. Cout <kb. power_mod (A, n) <Endl;
37. Cout <"/nbob get Ka from Alice, he compute out key is:/N ";
38. Cout <ka. power_mod (B, n) <Endl;
41. Return 0;
42. }

Running result:
G = 170141183460469231731687303715884105757
N = 170141183460469231731687303715884106309

This is Alice:
Alice get a random integer a = 20276
Alice computer G ^ A mod N:
Alice compute out Ka = 102075421398841759242347870420481896337

This is Bob:
Bob get a random integer B = 28664
Bob compute G ^ B mod N:
Bob compute out kb = 62348451302684698452476840835428450852

Alice get Kb from Bob, she compute out key is:
80402514625208456390620786920929643017

Bob get Ka from Alice, he compute out key is:
80402514625208456390620786920929643017
The Demo code of the algorithm implemented using the gnu gmp library is given in the http://oldpiewiki.yoonkn.com/cgi-bin/moin.cgi/DiffieHellmanKeyExchange.