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

正则表达式 2020-06-21

例一：简单加密

[java] view plain copy
  1. publicclassA
  2. {
  3. staticvoidmain(String[]args)throwsException
  4. Strings="我们abc";
  5. Stringkey="xyz";
  7. byte[]key_buf=key.getBytes("utf-8");
  8. //加密
  9. byte[]buf=s.getBytes("utf-8");
  10. for(inti=0;i<buf.length;i++){
  11. buf[i]^=key_buf[i%key_buf.length];
  12. }
  13. //解密
  14. 0;i<buf.length;i++){
  15. buf[i]^=key_buf[i%key_buf.length];
  16. }
  18. System.out.println(newString(buf,"utf-8"));
  19. }

例二：完整简单加密

    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. }

例三:AES加密

    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. }

相关文章

正则替换html代码中img标签的src值
正则替换html代码中img标签的src值在开发富文本信息在移动端...
【C++】正则表达式
正则表达式
shell之三剑客awk基础用法
AWK是一种处理文本文件的语言，是一个强大的文件分析工具。它...
正则表达式
正则表达式是特殊的字符序列，利用事先定义好的特定字符以及...
Python基础知识进阶之正则表达式
Python界一名小学生，热心分享编程学习。
开发者神器，代码文档终于有救了
收集整理每周优质开发者内容，包括、、等方面。每周五定期发...