算法基础——2.6加密与解密

例一：简单加密

classSimple
1. //buf中的byte每个都转为16进制的串的表述形式
2. staticStringbyteToAF(byte[]buf)
3. {
4. StringBuffersb=newStringBuffer();
5. sb.append(String.format("%02X",buf[i]));
6. returnsb.toString();
7. //用16进制串形式表达的byte，转换为byte数组
8. byte[]AFtoByte(Strings)
9. byte[]out=newbyte[s.length()/2];
10. 0;i<s.length();i+=2){
11. out[i/2]=(byte)(Character.getNumericValue(s.charAt(i))*16
12. +Character.getNumericValue(s.charAt(i+1)));
13. returnout;
14. //加密过程
15. staticStringencrypt(Stringsrc,Stringkey)
16. if(key.length()<1)returnnull;
17. try{
18. byte[]buf_txt=src.getBytes("utf-8");
19. byte[]buf_key=key.getBytes("utf-8");
20. 0;i<buf_txt.length;i++){
21. buf_txt[i]^=buf_key[i%buf_key.length];
22. returnbyteToAF(buf_txt);
23. catch(Exceptione){
24. e.printStackTrace();
25. null;
26. //解密过程
27. staticStringdecrypt(Stringsrc,Stringkey)
28. try{
29. byte[]buf_txt=AFtoByte(src);
30. byte[]buf_key=key.getBytes("utf-8");
31. 0;i<buf_txt.length;i++){
32. buf_txt[i]^=buf_key[i%buf_key.length];
33. newString(buf_txt,"utf-8");
34. catch(Exceptione){
35. e.printStackTrace();
36. voidmain(String[]args)
37. Strings=encrypt("我们ab","xyz");
38. System.out.println(s);
39. Strings2=decrypt(s,"xyz");
40. System.out.println(s2);
41. }

importjavax.crypto.*;
1. importjavax.crypto.spec.*;
2. importjava.security.*;
3. importsun.misc.BASE64Decoder;
4. importsun.misc.BASE64Encoder;
5. classAES
6. //处理密钥
7. byte[]bKey=pwd.getBytes("utf-8");
8. byte[]buf=byte[16];//创建一个空的16位字节数组（默认值为0）
9. 0;i<bKey.length&&i<buf.length;i++){
10. buf[i]=bKey[i];
11. SecretKeySpeckey=newSecretKeySpec(buf,"AES");
12. Ciphercipher=Cipher.getInstance("AES");//创建密码器
13. cipher.init(Cipher.ENCRYPT_MODE,key);
14. byte[]out=cipher.doFinal(src.getBytes("utf-8"));
15. //转为串
16. newBASE64Encoder().encode(out);
17. return"";
18. //处理密钥
19. byte[]bKey=pwd.getBytes("utf-8");
20. //创建一个空的16位字节数组（默认值为0）
21. 0;i<bKey.length&&i<buf.length;i++){
22. buf[i]=bKey[i];
23. SecretKeySpeckey="AES");
24. //密文还原为byte[]
25. buf=newBASE64Decoder().decodeBuffer(src);
26. cipher.init(Cipher.DECRYPT_MODE,153); background-color:inherit; font-weight:bold">byte[]out=cipher.doFinal(buf);
27. newString(out,"utf-8");
28. Strings="1中国人abc";
29. Strings2=encrypt(s,"xyz1");
30. Strings3=decrypt(s2,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px"> System.out.println(s3);
31. }

/*设计程序
1. 一种Playfair密码变种加密方法如下：首先选择一个密钥单词（称为pair）（字母不重复，且都为小写字母），然后与字母表中其他字母一起填入至一个5x5的方阵中，填入方法如下：
2. 1.首先按行填入密钥串。
3. 2.紧接其后，按字母序按行填入不在密钥串中的字母。
4. 3.由于方阵中只有25个位置，最后剩下的那个字母则不需变换。
5. 如果密钥为youandme，则该方阵如下：
6. youan
7. dmebc
8. fghij
9. klpqr
10. stvwx
11. 在加密一对字母时，如am，在方阵中找到以这两个字母为顶点的矩形（红色字体）：
12. 这对字母的加密字母为该矩形的另一对顶点，如本例中为ob。
13. 请设计程序，使用上述方法对输入串进行加密，并输出加密后的串。
14. 另外有如下规定：
15. 1、一对一对取字母，如果最后只剩下一个字母，则不变换，直接放入加密串中；
16. 2、如果一对字母中的两个字母相同，则不变换，直接放入加密串中；
17. 3、如果一对字母中有一个字母不在正方形中，则不变换，直接放入加密串中；
18. 4、如果字母对出现在方阵中的同一行或同一列，如df或hi，则只需简单对调这两个字母，即变换为fd或ih；
19. 5、如果在正方形中能够找到以字母对为顶点的矩形，假如字母对为am，则该矩形的另一对顶点字母中，与a同行的字母应在前面，在上例中应是ob；同样若待变换的字母对为ta，则变换后的字母对应为wo；
20. 6、本程序中输入串均为小写字母，并不含标点、空格或其它字符。
21. 解密方法与加密相同，即对加密后的字符串再加密，将得到原始串。
22. 要求输入形式如下：
23. 从控制台输入两行字符串，第一行为密钥单词（长度小于等于25），第二行为待加密字符串（长度小于等于50），两行字符串末尾都有一个回车换行符，并且两行字符串均为小写字母，不含其它字符。
24. 在标准输出上输出加密后的字符串。
25. 例如，若输入：
26. youandme
27. welcometohangzhou
28. 则表示输入的密钥单词为youandme，形成的正方形如上所示；待加密字符串为welcometohangzhou。在正方形中可以找到以第一对字母we为顶点的矩形，对应另一对顶点字母为vb，因此加密后为vb，同理可找到与字母对lc,et,oh,ho对应的顶点字母对。而字母对om位于上述正方形中的同一列，所以直接以颠倒这两个字母来加密，即为mo，字母对an同理。字母对gz中的z不在上述正方形中，因此原样放到加密串中。最后剩一个字母u也原样输出。
29. 因此输出的结果为：
30. vbrmmomvugnagzguu*/
31. classC6{
32. char[][]key=char[5][5];//5x5的方阵
33. int[]alp=int[26];//字母表，表示26个字母是否已经出现，-1表示没有出现过，i>-1表示已经出现，i/5为在方阵的横坐标，i%5为在方阵的纵坐标
34. //将密匙转化为5x5的方阵
35. voidchange(char[]ckey){
36. 0;i<26;++i)//字母表初始化
37. alp[i]=-1;
38. //按行填入密钥串
39. intix=0;ix<ckey.length;++ix){
40. key[ix/5][ix%5]=ckey[ix];
41. switch(ckey[ix]){//密钥中出现的字母，置为true
42. case'a':
43. alp['a'-'a']=ix;
44. break;
45. case'b':
46. alp['b'-'a']=ix;
47. break;
48. case'c':
49. alp['c'-'a']=ix;
50. case'd':
51. alp['d'-'a']=ix;
52. case'e':
53. alp['e'-'a']=ix;
54. case'f':
55. alp['f'-'a']=ix;
56. case'g':
57. alp['g'-'a']=ix;
58. case'h':
59. alp['h'-'a']=ix;
60. case'i':
61. alp['i'-'a']=ix;
62. case'j':
63. alp['j'-'a']=ix;
64. case'k':
65. alp['k'-'a']=ix;
66. case'l':
67. alp['l'-'a']=ix;
68. case'm':
69. alp['m'-'a']=ix;
70. case'n':
71. alp['n'-'a']=ix;
72. case'o':
73. alp['o'-'a']=ix;
74. case'p':
75. alp['p'-'a']=ix;
76. case'q':
77. alp['q'-'a']=ix;
78. case'r':
79. alp['r'-'a']=ix;
80. case's':
81. alp['s'-'a']=ix;
82. case't':
83. alp['t'-'a']=ix;
84. case'u':
85. alp['u'-'a']=ix;
86. case'v':
87. alp['v'-'a']=ix;
88. case'w':
89. alp['w'-'a']=ix;
90. case'x':
91. alp['x'-'a']=ix;
92. case'y':
93. alp['y'-'a']=ix;
94. case'z':
95. alp['z'-'a']=ix;
96. default:
97. //紧接其后，按字母序按行填入不在密钥串中的字母
98. intj=ckey.length,k=0;j<25&&k<26;++j,++k){
99. //不在密钥串中的字母
100. if(alp[k]==-1){
101. key[j/5][j%5]=(char)(k+'a');
102. alp[k]=j;
103. }else{
104. j--;
105. //输出转化过的5*5的矩阵
106. 5;++i){
107. intj=5;++j){
108. System.out.print(key[i][j]+"");
109. System.out.println();
110. //加密过程
111. staticStringencrypt(Stringpair,Strings){
112. char[]ckey=pair.toCharArray();//密匙
113. change(ckey);//将密匙转化为5x5的方阵
114. char[]c_s=s.toCharArray();
115. //从待加密字符串取每对字母加密
116. 1;i<c_s.length;i+=2){//1
117. //2如果一对字母中的两个字母相同，则不变换，直接放入加密串中；3或一对字母中有一个字母不在正方形中时则不变换，直接放入加密串中
118. if(c_s[i-1]==c_s[i]||(alp[c_s[i-1]-'a']==-1)||(alp[c_s[i]-'a']==-1))
119. continue;
120. //两个字母都在在正方形中且一对字母中的两个字母不同
121. introw1=alp[c_s[i-1]-'a']/5;//一对字母中的第一个字母横坐标
122. intclum1=alp[c_s[i-1]-'a']%//一对字母中的第一个字母纵坐标
123. introw2=alp[c_s[i]-'a']///一对字母中的第二个字母横坐标
124. intclum2=alp[c_s[i]-'a']%//一对字母中的第二个字母纵坐标
125. if(row1==row2||clum1==clum2){//4如果字母对出现在方阵中的同一行或同一列，如df或hi，则只需简单对调这两个字母
126. chartemp=c_s[i-1];
127. c_s[i-1]=c_s[i];
128. c_s[i]=temp;
129. //5、如果在正方形中能够找到以字母对为顶点的矩形，假如字母对为am，则该矩形的另一对顶点字母中，与a同行的字母应在前面，
130. //在上例中应是ob；同样若待变换的字母对为ta，则变换后的字母对应为wo；
131. else{
132. 1]=key[row1][clum2];
133. c_s[i]=key[row2][clum1];
134. /*if(c_s.length%2==1&&i==c_s.length){
135. break;
136. }*/
137. Strings2=newString(c_s);//存储加密过的字符串
138. returns2;
139. //解密过程
140. staticStringdecrypt(Stringpair,Strings){
141. //密匙
142. change(ckey);voidmain(String[]args){
143. Strings;//待加密字符串
144. Stringpair; Scannerscan=newScanner(System.in);
145. System.out.println("请输入两行字符串，第一行为密钥单词（长度小于等于25），第二行为待加密字符串（长度小于等于50）：");
146. pair=scan.nextLine();
147. s=scan.nextLine();
148. Strings2=encrypt(pair,s);
149. Strings3=decrypt(pair,s2);
150. System.out.println("加密过的字符串：");
151. System.out.println(s2);
152. System.out.println("解密过的字符串：");
153. System.out.println(s3);
154. }

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!