好久没写博客了，正好趁着实现网络工程与安全的DES算法的功夫，把代码发上来。
DES的介绍可见：DES加密
原理不赘述了。。实在太多，其实就是一个形式化算法，按部就班的实现就可以，只不过有些繁琐，我写了3个晚上 = =。
主要实现了利用DES算法对一个文本文档加密，然后再将其内容解密。
程序截图
明文和密钥
加密然后解密
密文和解密后文本
代码
1 //该程序实现了文本文档的DES加密和解密。
2
3 #include <iostream>
4 #include <string.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7 using namespace std;
8
9 //IP置换表
10 char IP[64] = {
11 57,49,41,33,25,17,9,1,
12 59,51,43,35,27,19,11,3,
13 61,53,45,37,29,21,13,5,
14 63,55,47,39,31,23,15,7,
15 56,48,40,32,24,16,8,0,
16 58,50,42,34,26,18,10,2,
17 60,52,44,36,28,20,12,4,
18 62,54,46,38,30,22,14,6};
19
20 //IP^-1 置换表
21 char IP_1[64] = {
22 39,7,47,15,55,23,63,31,
23 38,6,46,14,54,22,62,30,
24 37,5,45,13,53,21,61,29,
25 36,4,44,12,52,20,60,28,
26 35,3,43,11,51,19,59,27,
27 34,2,42,10,50,18,58,26,
28 33,1,41,9,49,17,57,25,
29 32,0,40,8,48,16,56,24};
30
31 //扩展置换表E
32 int E[48] = {31, 0, 1, 2, 3, 4,
33 3, 4, 5, 6, 7, 8,
34 7, 8,9,10,11,12,
35 11,12,13,14,15,16,
36 15,16,17,18,19,20,
37 19,20,21,22,23,24,
38 23,24,25,26,27,28,
39 27,28,29,30,31, 0};
40
41 //置换函数P
42 int P[32] = {15,6,19,20,28,11,27,16,
43 0,14,22,25,4,17,30,9,
44 1,7,23,13,31,26,2,8,
45 18,12,29,5,21,10,3,24};
46
47 //S盒
48 int S[8][4][16] ={
49 {{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
50 {0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
51 {4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
52 {15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
53
54 {{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
55 {3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
56 {0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
57 {13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
58
59 {{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
60 {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
61 {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
62 {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
63
64 {{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
65 {13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
66 {10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
67 {3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
68
69 {{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
70 {14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
71 {4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
72 {11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
73
74 {{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
75 {10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
76 {9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
77 {4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
78
79 {{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
80 {13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
81 {1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
82 {6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
83
84 {{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
85 {1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
86 {7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
87 {2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}};
88 //置换选择1
89 int PC_1[56] = {56,48,40,32,24,16,8,
90 0,57,49,41,33,25,17,
91 9,1,58,50,42,34,26,
92 18,10,2,59,51,43,35,
93 62,54,46,38,30,22,14,
94 6,61,53,45,37,29,21,
95 13,5,60,52,44,36,28,
96 20,12,4,27,19,11,3};
97
98 //置换选择2
99 int PC_2[48] = {13,16,10,23,0,4,2,27,
100 14,5,20,9,22,18,11,3,
101 25,7,15,6,26,19,12,1,
102 40,51,30,36,46,54,29,39,
103 50,44,32,47,43,48,38,55,
104 33,52,45,41,49,35,28,31};
105
106 //对左移次数的规定
107 int LS[17] = {0,1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
108
109 //存放子密钥
110 unsigned __int64 K[17];
111
112 //将含64个二进制字符的字符串转换为二进制形式存储在long long int中
113 unsigned __int64 str2bit(unsigned char s[])
114 {
115 unsigned __int64 bin = 0;
116 int i;
117 for(i=0;i<64;i++){
118 bin = bin<<1 | (s[i]-'0'); //s[i]>>j & 1 表示取s[i]的第j位
119 }
120 return bin;
121 }
122
123 //将含8位字符串转换为二进制形式存储在long long int中，例ABCDEFGH转换为64位二进制数
124 unsigned __int64 bstr2bit(unsigned char s[])
125 {
126 unsigned __int64 bin = 0;
127 int i,j;
128 for(i=0;i<8;i++){
129 for(j=0;j<8;j++){
130 bin = bin | ( (unsigned __int64)((s[i]>>j)%2) << (j+8*(7-i)) ); //将s[i]的第j位(低位开始）取出放到bin的对应位置
131 }
132 }
133 return bin;
134 }
135
136 //将 unsigned __int64 形式的按十六进制串输出（64位有效的二进制数串）
137 void DisplayHex64(unsigned __int64 bin)
138 {
139 int i,t=0;
140 for(i=63;i>=0;i--){
141 t = t<<1 | ((bin>>i) & 1);
142 if(i%4==0){
143 if(0<=t && t<=9)
144 printf("%d",t);
145 else if(10<=t && t<=15)
146 printf("%c",65+t-10);
147 t=0;
148 }
149 if(i%8==0)
150 printf(" ");
151 }
152 printf("
");
153 }
154 //将 unsigned __int64 形式的按十六进制串输出（48位有效的二进制数串）
155 void DisplayHex48(unsigned __int64 bin)
156 {
157 int i,t=0;
158 for(i=47;i>=0;i--){
159 t = t<<1 | ((bin>>i) & 1);
160 if(i%4==0){
161 if(0<=t && t<=9)
162 printf("%d",t);
163 else if(10<=t && t<=15)
164 printf("%c",65+t-10);
165 t=0;
166 }
167 if(i%8==0)
168 printf(" ");
169 }
170 printf("
");
171 }
172 //将 unsigned __int64 形式的按十六进制串输出（32位有效的二进制数串）
173 void DisplayHex32(unsigned __int64 bin)
174 {
175 int i,t=0;
176 for(i=31;i>=0;i--){
177 t = t<<1 | ((bin>>i) & 1);
178 if(i%4==0){
179 if(0<=t && t<=9)
180 printf("%d",t);
181 else if(10<=t && t<=15)
182 printf("%c",65+t-10);
183 t=0;
184 }
185 if(i%8==0)
186 printf(" ");
187 }
188 printf("
");
189 }
190 //将 unsigned __int64 形式的按十六进制串输出（28位有效的二进制数串）
191 void DisplayHex28(unsigned __int64 bin)
192 {
193 int i,t=0;
194 for(i=27;i>=0;i--){
195 t = t<<1 | ((bin>>i) & 1);
196 if(i%4==0){
197 if(0<=t && t<=9)
198 printf("%d",t);
199 else if(10<=t && t<=15)
200 printf("%c",65+t-10);
201 t=0;
202 }
203 if(i%8==0)
204 printf(" ");
205 }
206 printf("
");
207 }
208
209 //将 unsigned __int64 形式的二进制串和十六进制输出（64位有效的二进制数串）
210 void DisplayBin64(unsigned __int64 bin)
211 {
212 int i;
213 for(i=63;i>=0;i--){
214 printf("%d",(bin>>i) %2);
215 }
216 printf("
");
217 DisplayHex64(bin);
218 }
219
220 //将 unsigned __int64 形式的二进制串和十六进制输出（48位有效的二进制数串）
221 void DisplayBin48(unsigned __int64 bin)
222 {
223 int i;
224 for(i=47;i>=0;i--){
225 printf("%d",(bin>>i) %2);
226 }
227 printf("
");
228 DisplayHex48(bin);
229 }
230
231 //将 unsigned __int64 形式的二进制串和十六进制输出（32位有效的二进制数串）
232 void DisplayBin32(unsigned __int64 bin)
233 {
234 int i;
235 for(i=31;i>=0;i--){
236 printf("%d",(bin>>i) %2);
237 }
238 printf("
");
239 DisplayHex32(bin);
240 }
241
242 //将 unsigned __int64 形式的二进制串和十六进制输出（28位有效的二进制数串）
243 void DisplayBin28(unsigned __int64 bin)
244 {
245 int i;
246 for(i=27;i>=0;i--){
247 printf("%d",(bin>>i) %2);
248 }
249 printf("
");
250 DisplayHex28(bin);
251 }
252
253
254 /* ------------------------------ 【1】初始置换IP ------------------------------
255 * 把明文顺序打乱重新排列，置换输出为64位，
256 * 数据置换后的第一位，第二位分别是原来的58、50位
257 */
258
259 unsigned __int64 InitReplace(unsigned __int64 bin) //初始置换IP
260 {
261 unsigned __int64 t = 0;
262 int i;
263 for(i=0;i<64;i++){
264 t = t | ( (bin>>(63-IP[i])) %2) << (63-i);
265 }
266 return t;
267 }
268
269 /* ------------------------------ 【2】将置换输出的64位数据分成左右两半 ------------------------------
270 * 左一半称为L0，右一半称为R0，各32位。
271 */
272
273 void DivideLR(unsigned __int64 binip,unsigned __int64 &L0,unsigned __int64 &R0) //将置换输出的64位数据分为L0（32位），R0（32位）两部分
274 {
275 unsigned __int64 one = 1;
276 L0 = binip >> 32;
277 R0 = binip % (one<<32);
278 }
279
280 /* ------------------------------ 【3】计算函数的16轮迭代 ------------------------------
281 * 1~16轮加密迭代
282 */
283
284 //置换选择1,64->56
285 unsigned __int64 FunPC_1(unsigned __int64 bink)
286 {
287 unsigned __int64 binpc_1 = 0;
288 int i;
289 for(i=0;i<56;i++)
290 binpc_1 |= ( (bink>>(63-PC_1[i])) %2) << (55-i);
291 return binpc_1;
292 }
293
294 //获得第i轮C，D，即Ci-1,Di-1 ==> Ci,Di
295 void getNextCD(int i,unsigned __int64 &C,unsigned __int64 &D)
296 {
297 unsigned __int64 t=0,one=1;
298 t = C >> (28-LS[i]);
299 C = (C<<LS[i])%(one<<28);
300 C |= t;
301 t = D >> (28-LS[i]);
302 D = (D<<LS[i])%(one<<28);
303 D |= t;
304 }
305
306 //置换选择2，56->48
307 unsigned __int64 FunPC_2(unsigned __int64 t)
308 {
309 //获得子密钥k
310 unsigned __int64 k=0;
311 int i;
312 for(i=0;i<48;i++)
313 k |= ( (t>>(55-PC_2[i])) %2) << (47-i);
314 return k;
315 }
316
317 //子密钥生成
318 void ProduceK(unsigned __int64 bink)
319 {
320 unsigned __int64 binpc_1,one=1,C=0,D=0;
321 binpc_1 = FunPC_1(bink); //置换选择1
322
323 //分成2个28位
324 C = binpc_1 >> 28;
325 D = binpc_1 % (one << 28);
326
327 int i;
328 for(i=1;i<=16;i++){
329 //确定子密钥K[i]
330 getNextCD(i,C,D);
331 printf("第%d轮：
",i);
332 printf("C[%d] = ",i);
333 DisplayBin28(C);
334 printf("D[%d] = ",i);
335 DisplayBin28(D);
336 printf("
");
337
338 unsigned __int64 t=0;
339 t = ((C<<28) | D)%(one<<56);
340 K[i] = FunPC_2(t); //进行置换选择2，将56位->48位子密钥
341 }
342 }
343
344 //扩展置换E，32->48
345 unsigned __int64 FunE(unsigned __int64 R)
346 {
347 unsigned __int64 t = 0;
348 int i;
349 for(i=0;i<48;i++)
350 t |= ( (R>>(31-E[i])) %2) << (47-i);
351 return t;
352 }
353
354 //S盒代换
355 unsigned __int64 FunS(unsigned __int64 RX)
356 {
357 int x,y,i;
358 unsigned __int64 one = 1,t,RS = 0;
359 for(i=0;i<8;i++){
360 t = ( RX >> (6*(7-i)) ) % (one<<6);
361 x = t>>5;
362 x = (x<<1) | (t%2);
363 y = (t<<1)%(one<<6)>>2;
364 RS = RS<<4 | S[i][x][y];
365 }
366 return RS;
367 }
368
369 //置换P运算
370 unsigned __int64 FunP(unsigned __int64 RS)
371 {
372 unsigned __int64 RP = 0;
373 int i;
374 for(i=0;i<32;i++)
375 RP |= ( (RS>>(31-P[i])) %2) << (31-i);
376 return RP;
377 }
378
379 //轮函数f(R,K)
380 unsigned __int64 f(int i,unsigned __int64 R,unsigned __int64 k)
381 {
382 unsigned __int64 RE,RX,RS,RP;
383 RE = FunE(R); //将32位Ri-1扩展置换为48位
384 RX = RE ^ k; //将48位RE与子密钥k异或运算
385 RS = FunS(RX); //S盒代换
386 RP = FunP(RS); //置换P运算
387 return RP;
388 }
389
390 unsigned __int64 Iteration16(unsigned __int64 L0,unsigned __int64 R0) //进行16次迭代计算
391 {
392 int i;
393 unsigned __int64 Ri = R0;
394 unsigned __int64 Li = L0;
395 printf("L0=");
396 DisplayBin32(L0);
397 printf("R0=");
398 DisplayBin32(R0);
399 printf("
");
400 for(i=1;i<=16;i++){
401 printf("第%d轮加密：
",i);
402 unsigned __int64 t = Ri;
403
404 //轮函数
405 Ri = f(i,Ri,K[i]);
406 printf("f(R%d,K%d)=",i-1,i);
407 DisplayBin32(Ri);
408
409 //Li-1和轮函数结果异或运算得到Ri
410 Ri = Li ^ Ri;
411 //轮函数运算结果即是Li
412 Li = t;
413
414 //输出Li和Ri
415 printf("L%d=",i);
416 DisplayBin32(Li);
417 printf("R%d=",i);
418 DisplayBin32(Ri);
419 printf("
");
420 }
421
422 return Ri<<32 | Li;
423 }
424
425 unsigned __int64 InverseIteration16(unsigned __int64 L0,unsigned __int64 R0) //进行逆16次迭代计算，为解密过程
426 {
427 int i;
428 unsigned __int64 Ri = R0;
429 unsigned __int64 Li = L0;
430 printf("L0=");
431 DisplayBin32(L0);
432 printf("R0=");
433 DisplayBin32(R0);
434 printf("
");
435 for(i=16;i>=1;i--){
436 printf("第%d轮加密：
",17-i);
437 unsigned __int64 t = Ri;
438
439 //轮函数
440 Ri = f(i,Ri,K[i]);
441 printf("f(R%d,K%d)=",i-1,i);
442 DisplayBin32(Ri);
443
444 //Li-1和轮函数结果异或运算得到Ri
445 Ri = Li ^ Ri;
446 //轮函数运算结果即是Li
447 Li = t;
448
449 //输出Li和Ri
450 printf("L%d=",i);
451 DisplayBin32(Li);
452 printf("R%d=",i);
453 DisplayBin32(Ri);
454 printf("
");
455 }
456
457 return Ri<<32 | Li;
458 }
459
460
461
462 /* ------------------------------ 【4】逆初始置换IP^-1 ------------------------------
463 * 把数据打乱重排，产生64位密文。
464 */
465
466 unsigned __int64 InverseInitReplace(unsigned __int64 bin) //进行逆初始置换IP^-1
467 {
468 unsigned __int64 t = 0;
469 int i;
470 for(i=0;i<64;i++){
471 t = t | ( (bin>>(63-IP_1[i])) %2) << (63-i);
472 }
473 return t;
474 }
475
476 void printOut(FILE* fo,unsigned __int64 bin)
477 {
478 char ans[8]={0},t=0;
479 int i,cnt=0;
480 for(i=63;i>=0;i--){
481 t = t<<1 | ((bin>>i)%2);
482 if(i%8==0){
483 ans[cnt++] = t;
484 t = 0;
485 }
486 }
487 fwrite(ans,1,8,fo);
488 }
489
490 //加密函数
491 void Encryption()
492 {
493 //文件读入
494 FILE* fm = fopen(".\Plaintext.txt","rb"); //明文文件
495 FILE* fk = fopen(".\key.txt","r"); //密钥文件
496 FILE* fo = fopen(".\Ciphertext.txt","wb"); //密文文件
497
498 if(fm==NULL){
499 printf("明文文件input.txt打开失败
");
500 }
501 if(fk==NULL){
502 printf("密钥文件key.txt打开失败
");
503 }
504 if(fo==NULL){
505 printf("加密后文件output.txt打开失败
");
506 }
507
508 unsigned char s[165]={0},key[65]={0};
509 int i;
510
511 fscanf(fk,"%s",key); //读取密钥
512
513 while(fread(s,1,8,fm)){
514 printf("----------------------------------------------------------------------------
");
515 printf("
");
516 printf("当前读取的明文串为：
");
517 printf("%s
",s);
518 unsigned __int64 bin = bstr2bit(s); //将加密串转换为2进制形式
519 printf("
");
520 unsigned __int64 bink = str2bit(key); //将密钥串转换为2进制形式
521 printf("
");
522
523 //输出
524 printf("
");
525 printf("【输入】
");
526 printf("输入的二进制明文串：
");
527 DisplayBin64(bin);
528 printf("输入的二进制密钥串：
");
529 DisplayBin64(bink);
530 printf("
");
531
532 //IP置换
533 printf("明文初始化置换后：
");
534 unsigned __int64 binip = InitReplace(bin);
535 DisplayBin64(binip);
536 printf("
");
537
538 //获得L0,R0
539 printf("将明文分割为L0，R0两部分：
");
540 unsigned __int64 L0,R0;
541 DivideLR(binip,L0,R0); //将binip分割为L0和R0
542 //输出L0，R0
543 printf("L0为：");
544 DisplayBin32(L0);
545 printf("R0为：");
546 DisplayBin32(R0);
547 printf("
");
548
549 //生成16个子密钥，并输出
550 printf("--------------- 子密钥生成过程 ---------------
");
551 memset(K,0,sizeof(K));
552 ProduceK(bink);
553 printf("生成的16个子密钥：
");
554 for(i=1;i<=16;i++){
555 printf("K[%d]为 ",i);
556 DisplayBin48(K[i]);
557 //printf("
");
558 }
559 printf("
");
560
561 //16次加密迭代
562 printf("--------------- 16轮加密迭代 ---------------
");
563 unsigned __int64 binIter = Iteration16(L0,R0);
564 printf("迭代加密后的结果：
");
565 DisplayBin64(binIter);
566 printf("
");
567
568 //逆初始置换IP_1
569 unsigned __int64 binip_1 = InverseInitReplace(binIter);
570 printf("最后，逆初始置换：
");
571 DisplayBin64(binip_1);
572 printf("
");
573
574 //输出最终加密结果
575 printf("【加密结果】
明文 "%s" 的DES加密的结果为:
",s);
576 DisplayBin64(binip_1);
577
578 printf("
");
579 printf("----------------------------------------------------------------------------
");
580 printf("
");
581
582 //将加密结果写到加密文件中
583 printOut(fo,binip_1);
584
585 memset(s,0,sizeof(s));
586 }
587 //文件关闭
588 fclose(fm);
589 fclose(fk);
590 fclose(fo);
591 }
592
593 //解密函数
594 void Decryption()
595 {
596 //文件读入
597 FILE* fm = fopen(".\Ciphertext.txt","rb"); //密文文件
598 FILE* fk = fopen(".\key.txt","r"); //密钥文件
599 FILE* fo = fopen(".\DecrypPlaintext.txt","wb"); //解密后文件
600
601 if(fm==NULL){
602 printf("密文文件 Ciphertext.txt 打开失败
");
603 }
604 if(fk==NULL){
605 printf("密钥文件 key.txt 打开失败
");
606 }
607 if(fo==NULL){
608 printf("解密后文件 DecrypPlaintext.txt 打开失败
");
609 }
610
611 unsigned char s[165]={0},key[65]={0};
612 int i;
613
614 fscanf(fk,"%s",key); //读取密钥
615
616 while(fread(s,1,8,fm)){
617 printf("----------------------------------------------------------------------------
");
618 printf("
");
619 printf("当前读取的密文串为：
");
620 printf("%s
",s);
621 unsigned __int64 bin = bstr2bit(s); //将密文串转换为2进制形式
622 printf("
");
623 unsigned __int64 bink = str2bit(key); //将密钥串转换为2进制形式
624 printf("
");
625
626 //输出
627 printf("----------------------------------------------------------------------------
");
628 printf("
");
629 printf("【输入】
");
630 printf("输入的二进制密文串：
");
631 DisplayBin64(bin);
632 printf("输入的二进制密钥串：
");
633 DisplayBin64(bink);
634 printf("
");
635
636 //IP置换
637 printf("密文初始化置换后：
");
638 unsigned __int64 binip = InitReplace(bin);
639 DisplayBin64(binip);
640 printf("
");
641
642 //获得L0,R0
643 printf("将密文分割为L0，R0两部分：
");
644 unsigned __int64 L0,R0;
645 DivideLR(binip,L0,R0); //将binip分割为L0和R0
646 //输出L0，R0
647 printf("L0为：");
648 DisplayBin32(L0);
649 printf("R0为：");
650 DisplayBin32(R0);
651 printf("
");
652
653 //生成16个子密钥，并输出
654 printf("--------------- 子密钥生成过程 ---------------
");
655 memset(K,0,sizeof(K));
656 ProduceK(bink);
657 printf("生成的16个子密钥：
");
658 for(i=1;i<=16;i++){
659 printf("K[%d]为 ",i);
660 DisplayBin48(K[i]);
661 //printf("
");
662 }
663 printf("
");
664
665 //16次加密迭代
666 printf("--------------- 16轮加密迭代 ---------------
");
667 unsigned __int64 binIter = InverseIteration16(L0,R0);
668 printf("迭代解密后的结果：
");
669 DisplayBin64(binIter);
670 printf("
");
671
672 //逆初始置换IP_1
673 unsigned __int64 binip_1 = InverseInitReplace(binIter);
674 printf("最后，逆初始置换：
");
675 DisplayBin64(binip_1);
676 printf("
");
677
678 //输出最终加密结果
679 printf("【解密结果】
密文 "%s" 的DES解密的结果为:
",s);
680 DisplayBin64(binip_1);
681
682 printf("
");
683 printf("----------------------------------------------------------------------------
");
684
685 //将加密结果写到加密文件中
686 printOut(fo,binip_1);
687
688 memset(s,0,sizeof(s));
689 }
690 //文件关闭
691 fclose(fm);
692 fclose(fk);
693 fclose(fo);
694 }
695
696 int Menu(int &Case)
697 {
698 int in;
699
700 FILE* fk = fopen(".\key.txt","r"); //密钥文件
701 if(fk==NULL){
702 printf("密钥文件key.txt打开失败
");
703 }
704
705 unsigned char key[100];
706 fscanf(fk,"%s",key); //读取密钥
707 unsigned __int64 bink = str2bit(key); //将密钥串转换为2进制形式
708 printf("【%d】当前密钥（key）为：（二进制形式）
",Case++);
709 DisplayBin64(bink);
710 printf("（密钥存储在 key.txt 中）
");
711 printf("
");
712
713 printf("请选择，是使用DES算法加密还是解密？
");
714 printf("（加密过程：Plaintext.txt => Ciphertext.txt
");
715 printf(" 解密过程：Ciphertext.txt => DecrypPlaintext.txt ）
");
716 printf("[1] 加密
");
717 printf("[2] 解密
");
718 printf("[0] 退出程序
");
719
720 scanf("%d",&in);
721 getchar();
722 fflush(stdin); // 清空缓冲区
723
724 if(in==0 || in==1 || in==2){
725 return in;
726 }
727 else{
728 printf("输入错误，请重新输入！
");
729 printf("
");
730 printf("----------------------------------------------------------------------------
");
731 printf("
");
732 return -1;
733 }
734 }
735
736 /*
737 * 主函数
738 */
739 int main()
740 {
741 int Case=1,in;
742 while(1){
743 in = Menu(Case);
744 switch(in){
745 case -1: //输入错误，进入下次循环
746 break;
747 case 0: //退出程序
748 printf("谢谢使用 :)
");
749 return 0;
750 case 1: //加密
751 Encryption();
752 break;
753 case 2: //解密
754 Decryption();
755 break;
756 }
757 }
758 return 0;
759 }
Freecode : www.cnblogs.com/yym2013