维吉尼亚密码java代码实现完整版

使用Java实现安全性加密与解密在当今信息时代，数据的安全性越来越受到重视。

无论是个人的隐私信息还是企业的商业机密，都需要得到有效的保护。

而加密与解密技术就是一种常用的保护数据安全的手段。

本文将介绍如何使用Java语言实现安全性加密与解密。

1. 加密与解密的基本概念加密是将明文转换为密文的过程，而解密则是将密文转换回明文的过程。

加密算法通常使用一个密钥，密钥用于控制加密过程的转换规则，只有拥有正确的密钥才能进行解密。

常见的加密算法有对称加密算法和非对称加密算法。

对称加密算法使用相同的密钥进行加密和解密，速度较快，但密钥的传输和管理相对困难。

非对称加密算法使用一对密钥，公钥用于加密，私钥用于解密，安全性较高，但速度较慢。

2. 使用Java实现对称加密Java提供了多种对称加密算法的实现，如DES、AES等。

下面以AES算法为例，介绍如何使用Java实现对称加密。

首先，需要导入Java加密扩展（JCE）的包。

在Java 8及以上版本中，JCE已经被默认包含在JDK中，无需额外导入。

接下来，可以使用以下代码进行AES加密：```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class AESUtil {private static final String ALGORITHM = "AES";public static String encrypt(String plainText, String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());return Base64.getEncoder().encodeToString(encryptedBytes);}public static String decrypt(String encryptedText, String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);byte[] encryptedBytes = Base64.getDecoder().decode(encryptedText);byte[] decryptedBytes = cipher.doFinal(encryptedBytes);return new String(decryptedBytes);}}```以上代码中，`encrypt`方法用于对明文进行加密，`decrypt`方法用于对密文进行解密。

des加密算法java代码1、DES加密算法Java实现（1）导入所需要的包：import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;（2）定义加密算法：public class DesEncrypter {Cipher ecipher;Cipher dcipher;public DesEncrypter(String passPhrase) {try {// Create the keyDESKeySpec keySpec = newDESKeySpec(passPhrase.getBytes('UTF8'));SecretKeyFactory keyFactory =SecretKeyFactory.getInstance('DES');SecretKey key = keyFactory.generateSecret(keySpec); // Create the cipherecipher = Cipher.getInstance('DES');dcipher = Cipher.getInstance('DES');// Initialize the cipher for encryptionecipher.init(Cipher.ENCRYPT_MODE, key);// Initialize the same cipher for decryption dcipher.init(Cipher.DECRYPT_MODE, key);} catch (Exception e) {}}（3）定义加密函数：public String encrypt(String str) {try {// Encode the string into bytes using utf-8 byte[] utf8 = str.getBytes('UTF8');// Encryptbyte[] enc = ecipher.doFinal(utf8);// Encode bytes to base64 to get a stringreturn new sun.misc.BASE64Encoder().encode(enc);} catch (Exception e) {}return null;}（4）定义解密函数：// Decryptpublic String decrypt(String str) {try {// Decode base64 to get bytesbyte[] dec = newsun.misc.BASE64Decoder().decodeBuffer(str);// Decryptbyte[] utf8 = dcipher.doFinal(dec);// Decode using utf-8return new String(utf8, 'UTF8');} catch (Exception e) {}return null;}}（5）定义测试类，测试加密解之密是否正确：public class TestDes {public static void main(String[] args) {try {// Create encrypter/decrypter classDesEncrypter encrypter = new DesEncrypter('your key');// EncryptString encrypted = encrypter.encrypt('Don't tell anybody!');// DecryptString decrypted = encrypter.decrypt(encrypted);// Print out valuesSystem.out.println('Encrypted: ' + encrypted);System.out.println('Decrypted: ' + decrypted);} catch (Exception e) {}}}。

java证书的加密与解密代码java证书的加密与解密代码java很多时候要对秘要进行持久化加密，此时的加密采用md5。

采用对称加密的时候就采用DES方法了，那么java证书的加密与解密代码是什么呢?下面跟yjbys店铺一起来学习一下吧!以下两个类可以很方便的完成字符串的加密和解密：加密：CryptHelper.encrypt(password)解密：CrypHelper.decrypt(password)代码如下：CryptUtils.java[java]package b.crypt;import java.io.IOException;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import.apache.xerces.internal.impl.dv.util.Base64;public class CryptUtils {private static String Algorithm = "DES";private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};private static String VALUE_ENCODING="UTF-8";/*** 生成密钥** @return byte[] 返回生成的密钥* @throws exception* 扔出异常.*/public static byte[] getSecretKey() throws Exception {KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);SecretKey deskey = keygen.generateKey();// if (debug ) System.out.println ("生成密钥:"+byte2hex (deskey.getEncoded// ()));return deskey.getEncoded();}/*** 将指定的数据根据提供的密钥进行加密** @param input* 需要加密的数据* @param key* 密钥* @return byte[] 加密后的数据* @throws Exception*/public static byte[] encryptData(byte[] input, byte[] key) throws Exception {SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);// if (debug )// {// System.out.println ("加密前的二进串:"+byte2hex (input ));// System.out.println ("加密前的字符串:"+new String (input ));//// }Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.ENCRYPT_MODE, deskey);byte[] cipherByte = c1.doFinal(input);// if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));return cipherByte;}public static byte[] encryptData(byte[] input) throws Exception {return encryptData(input, DEFAULT_KEY);}/*** 将给定的已加密的数据通过指定的密钥进行解密** @param input* 待解密的数据* @param key* 密钥* @return byte[] 解密后的数据* @throws Exception*/public static byte[] decryptData(byte[] input, byte[] key) throws Exception {SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);// if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.DECRYPT_MODE, deskey);byte[] clearByte = c1.doFinal(input);// if (debug )// {// System.out.println ("解密后的二进串:"+byte2hex (clearByte ));// System.out.println ("解密后的字符串:"+(new String (clearByte )));//// }return clearByte;}public static byte[] decryptData(byte[] input) throws Exception {return decryptData(input, DEFAULT_KEY);}/*** 字节码转换成16进制字符串** @param byte[] b 输入要转换的字节码* @return String 返回转换后的16进制字符串*/public static String byte2hex(byte[] bytes) {StringBuilder hs = new StringBuilder();for(byte b : bytes)hs.append(String.format("%1$02X", b));return hs.toString();}public static byte[] hex2byte(String content) {int l=content.length()>>1;byte[] result=new byte[l];for(int i=0;iint j=i<<1;String s=content.substring(j, j+2);result[i]=Integer.valueOf(s, 16).byteValue();}return result;}/*** 将字节数组转换为base64编码字符串* @param buffer* @return*/public static String bytesToBase64(byte[] buffer) { 下载文档。

Java加密解密和数字签名完整代码⽰例常见的加密算法基本的单向加密算法：BASE64严格地说，属于编码格式，⽽⾮加密算法MD5(MessageDigestalgorithm5，信息摘要算法)SHA(SecureHashAlgorithm，安全散列算法)HMAC(HashMessageAuthenticationCode，散列消息鉴别码)复杂的对称加密（DES、PBE）、⾮对称加密算法：DES(DataEncryptionStandard，数据加密算法)PBE(Password-basedencryption，基于密码验证)RSA(算法的名字以发明者的名字命名：RonRivest,AdiShamir和LeonardAdleman)DH(Diffie-Hellman算法，密钥⼀致协议)DSA(DigitalSignatureAlgorithm，数字签名)ECC(EllipticCurvesCryptography，椭圆曲线密码编码学)数字签名算法简述数字签名算法可以看做是⼀种带有密钥的消息摘要算法，并且这种密钥包含了公钥和私钥。

也就是说，数字签名算法是⾮对称加密算法和消息摘要算法的结合体。

特点数字签名算法要求能够验证数据完整性、认证数据来源，并起到抗否认的作⽤。

原理数字签名算法包含签名和验证两项操作，遵循私钥签名，公钥验证的⽅式。

签名时要使⽤私钥和待签名数据，验证时则需要公钥、签名值和待签名数据，其核⼼算法主要是消息摘要算法。

1. 消息摘要String beforeDegist = "asdf";System.out.println("摘要前:"+beforeDegist);//初始信息要转换成字节流的形式byte[] plainText = beforeDegist.getBytes("UTF8");//使⽤getInstance("算法")来获得消息摘要,这⾥使⽤SHA-1的160位算法或者MD5算法geDigest messageDigest = MessageDigest.getInstance("SHA-1");MessageDigest messageDigest = MessageDigest.getInstance("MD5");System.out.println("/n" + messageDigest.getProvider().getInfo());//开始使⽤算法messageDigest.update(plainText);//输出算法运算结果String afterDegist = new String(messageDigest.digest(),"UTF8");System.out.println("摘要后:"+afterDegist);2. 私钥加密/*** 此例⼦是对⼀个字符串信息，⽤⼀个私钥(key)加密，然后在⽤该私钥解密，验证是否⼀致* 私钥加密，是对称加密* 使⽤对称算法。

vigenere密码例题Vigenère密码是一种多表密码，使用一系列不同的凯撒密码。

它是由法国密码专家Blaise de Vigenère在16世纪提出的。

Vigenère密码的加密过程是通过将明文中的每个字母依次与一个密钥中的字母进行移位加密来实现的。

举个例子，我们使用明文 "HELLO" 和密钥 "KEY" 来加密。

首先，我们将明文和密钥转换为数字，比如A=0，B=1，C=2，以此类推。

然后，我们将明文的每个字母依次与密钥的对应字母相加（或相减），并将结果转换回字母形式。

如果密钥比明文短，我们会循环使用密钥直到与明文长度相匹配。

使用密钥 "KEY" 对明文 "HELLO" 进行加密的过程如下：H (7) + K (10) = R (17)。

E (4) + E (4) = I (8)。

L (11) + Y (24) = B (1)。

L (11) + K (10) = U (20)。

O (14) + E (4) = S (18)。

因此，加密后的密文为 "RIBUS"。

解密过程与加密过程相反。

我们使用密钥 "KEY" 对密文"RIBUS" 进行解密的过程如下：R (17) K (10) = H (7)。

I (8) E (4) = E (4)。

B (1) Y (24) = L (11)。

U (20) K (10) = L (11)。

S (18) E (4) = O (14)。

因此，解密后的明文为 "HELLO"。

Vigenère密码因为其相对复杂的加密方式，曾被认为是不可破解的。

然而，随着密码学的发展，人们发现了一些攻击方法，比如Kasiski检测和Friedman测试，可以用来破解Vigenère密码。

《网络信息安全》课程结课论文《维吉尼亚密码加密并破解思路》学生姓名阿依古丽.木沙学号5011213334所属学院信息工程学院专业计算机科学与技术班级17-1指导教师李鹏塔里木大学教务处制摘要使用维吉尼亚密码加密只是众多密码加密方法中的一个，本设计是基于维吉尼亚密码的一种扩展，能起到更强的加密，完成所有属于ACSII的加密，本人主要负责设计的规划，程序设计，界面设计，报告的完成等工作，整个程序是Java平台下实现的。

本次设计方法的原理以及方法仍然以维吉尼亚通用的方法来介绍。

关键词：维吉尼亚加密，密钥，加密，解密。

目录一、密码分析及密码系统设计原则 (1)二、维吉尼亚密码 (2)（一）维吉尼亚密码的介绍 (2)（二）维吉尼亚密码的原理 (3)（三）维吉尼亚密码-特点 (5)（四）维吉尼亚密码的演变 (6)（五）维吉尼亚密码下的扩展 (6)三、加密的意义 (7)总结 (8)参考文献 (9)前言随着计算机联网的逐步实现，计算机信息的保密问题显得越来越重要。

数据保密变换，或密码技术，是对计算机信息进行保护的最实用和最可靠的方法。

密码是实现秘密通讯的主要手段，是隐蔽语言、文字、图象的特种符号。

凡是用特种符号按照通讯双方约定的方法把电文的原形隐蔽起来，不为第三者所识别的通讯方式称为密码通讯。

在计算机通讯中，采用密码技术将信息隐蔽起来，再将隐蔽后的信息传输出去，使信息在传输过程中即使被窃取或载获，窃取者也不能了解信息的内容，从而保证信息传输的安全。

所以，加密显得越来越重要，学会做加密软件，是很大的成果，可以用于各个领域.本文首先介绍“维吉尼亚”密码的分析及设计规则，然后介绍维吉尼亚密码的概念，原理，特点，密码的使用，还有加密的意义等。

一、密码分析及密码系统设计原则对通信双方而言，通信的一方将信息加密后发送给另一方，是为了使攻击者即使得到密文也无法读懂。

对于攻击者来说，在不知道密钥的情况下，要想读懂密文，就要根据他的知识以及掌握的情报来进行密码分析。

java 加密解密简单实现加密算法有很多种：这里只大约列举几例：1:消息摘要：（数字指纹）：既对一个任意长度的一个数据块进行计算，产生一个唯一指纹。

MD5/SHA1发送给其他人你的信息和摘要,其他人用相同的加密方法得到摘要，最后进行比较摘要是否相同。

2:单匙密码体制:DES:比较简便高效,密钥简短，加解密速度快，破译极其困难,但其安全性依赖于密匙的安全性。

DES（Data Encryption Standard）是发明最早的最广泛使用的分组对称加密算法。

DES算法的入口参数有三个：Key、Data、Mode。

其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密3:数字签名:就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行RSA算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。

当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。

代表：DSA4:非对称密匙密码体制（公匙体系）：加密密匙不同于解密密匙，加密密匙公之于众，谁都可以使用，解密密匙只有解密人自己知道。

代表：RSA下面是对上面几个例子进行的简单实现：Java代码1.package test;2.import java.io.FileInputStream;3.import java.io.FileOutputStream;4.import java.io.IOException;5.import java.io.ObjectInputStream;6.import java.io.ObjectOutputStream;7.import java.security.*;8.import javax.crypto.Cipher;9.import javax.crypto.KeyGenerator;10.import javax.crypto.SecretKey;11./**12. * 加密解密13. *14. * @author shy.qiu15. * @since /qiushyfm16. */17.public class CryptTest {18. /**19. * 进行MD5加密20. *21. * @param info22. * 要加密的信息23. * @return String 加密后的字符串24. */25. public String encryptToMD5(String info) {26. byte[] digesta = null;27. try {28. // 得到一个md5的消息摘要29. MessageDigest alga = MessageDigest.getInstance("MD5");30. // 添加要进行计算摘要的信息31. alga.update(info.getBytes());32. // 得到该摘要33. digesta = alga.digest();34. } catch (NoSuchAlgorithmException e) {35. e.printStackTrace();36. }37. // 将摘要转为字符串38. String rs = byte2hex(digesta);39. return rs;40. }41. /**42. * 进行SHA加密43. *44. * @param info45. * 要加密的信息46. * @return String 加密后的字符串47. */48. public String encryptToSHA(String info) {49. byte[] digesta = null;50. try {51. // 得到一个SHA-1的消息摘要52. MessageDigest alga = MessageDigest.getInstance("SHA-1");53. // 添加要进行计算摘要的信息54. alga.update(info.getBytes());55. // 得到该摘要56. digesta = alga.digest();57. } catch (NoSuchAlgorithmException e) {58. e.printStackTrace();59. }60. // 将摘要转为字符串61. String rs = byte2hex(digesta);62. return rs;63. }64. // //////////////////////////////////////////////////////////////////////////65. /**66. * 创建密匙67. *68. * @param algorithm69. * 加密算法,可用 DES,DESede,Blowfish70. * @return SecretKey 秘密（对称）密钥71. */72. public SecretKey createSecretKey(String algorithm) {73. // 声明KeyGenerator对象74. KeyGenerator keygen;75. // 声明密钥对象76. SecretKey deskey = null;77. try {78. // 返回生成指定算法的秘密密钥的 KeyGenerator 对象79. keygen = KeyGenerator.getInstance(algorithm);80. // 生成一个密钥81. deskey = keygen.generateKey();82. } catch (NoSuchAlgorithmException e) {83. e.printStackTrace();84. }85. // 返回密匙86. return deskey;87. }88. /**89. * 根据密匙进行DES加密90. *91. * @param key92. * 密匙93. * @param info94. * 要加密的信息95. * @return String 加密后的信息96. */97. public String encryptToDES(SecretKey key, String info) {98. // 定义加密算法,可用 DES,DESede,Blowfish99. String Algorithm = "DES";100. // 加密随机数生成器 (RNG),(可以不写)101. SecureRandom sr = new SecureRandom();102. // 定义要生成的密文103. byte[] cipherByte = null;104. try {105. // 得到加密/解密器106. Cipher c1 = Cipher.getInstance(Algorithm); 107. // 用指定的密钥和模式初始化Cipher对象108. // 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE) 109. c1.init(Cipher.ENCRYPT_MODE, key, sr); 110. // 对要加密的内容进行编码处理,111. cipherByte = c1.doFinal(info.getBytes()); 112. } catch (Exception e) {113. e.printStackTrace();114. }115. // 返回密文的十六进制形式116. return byte2hex(cipherByte);117. }118. /**119. * 根据密匙进行DES解密120. *121. * @param key122. * 密匙123. * @param sInfo124. * 要解密的密文125. * @return String 返回解密后信息126. */127. public String decryptByDES(SecretKey key, String sInfo ) {128. // 定义加密算法,129. String Algorithm = "DES";130. // 加密随机数生成器 (RNG)131. SecureRandom sr = new SecureRandom();132. byte[] cipherByte = null;133. try {134. // 得到加密/解密器135. Cipher c1 = Cipher.getInstance(Algorithm); 136. // 用指定的密钥和模式初始化Cipher对象137. c1.init(Cipher.DECRYPT_MODE, key, sr); 138. // 对要解密的内容进行编码处理139. cipherByte = c1.doFinal(hex2byte(sInfo)); 140. } catch (Exception e) {141. e.printStackTrace();142. }143. // return byte2hex(cipherByte);144. return new String(cipherByte);145. }146. // /////////////////////////////////////////////////// //////////////////////////147. /**148. * 创建密匙组，并将公匙，私匙放入到指定文件中149. *150. * 默认放入mykeys.bat文件中151. */152. public void createPairKey() {153. try {154. // 根据特定的算法一个密钥对生成器155. KeyPairGenerator keygen = KeyPairGenerator.get Instance("DSA");156. // 加密随机数生成器 (RNG)157. SecureRandom random = new SecureRandom(); 158. // 重新设置此随机对象的种子159. random.setSeed(1000);160. // 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器161. keygen.initialize(512, random);// keygen.initi alize(512);162. // 生成密钥组163. KeyPair keys = keygen.generateKeyPair(); 164. // 得到公匙165. PublicKey pubkey = keys.getPublic();166. // 得到私匙167. PrivateKey prikey = keys.getPrivate(); 168. // 将公匙私匙写入到文件当中169. doObjToFile("mykeys.bat", new Object[] { prike y, pubkey });170. } catch (NoSuchAlgorithmException e) {171. e.printStackTrace();172. }173. }174. /**175. * 利用私匙对信息进行签名把签名后的信息放入到指定的文件中176. *177. * @param info178. * 要签名的信息179. * @param signfile180. * 存入的文件181. */182. public void signToInfo(String info, String signfile) {183. // 从文件当中读取私匙184. PrivateKey myprikey = (PrivateKey) getObjFromFile( "mykeys.bat", 1);185. // 从文件中读取公匙186. PublicKey mypubkey = (PublicKey) getObjFromFile("m ykeys.bat", 2);187. try {188. // Signature 对象可用来生成和验证数字签名189. Signature signet = Signature.getInstance("DSA");190. // 初始化签署签名的私钥191. signet.initSign(myprikey);192. // 更新要由字节签名或验证的数据193. signet.update(info.getBytes());194. // 签署或验证所有更新字节的签名，返回签名195. byte[] signed = signet.sign();196. // 将数字签名,公匙,信息放入文件中197. doObjToFile(signfile, new Object[] { signed, m ypubkey, info });198. } catch (Exception e) {199. e.printStackTrace();200. }201. }202. /**203. * 读取数字签名文件根据公匙，签名，信息验证信息的合法性204. *205. * @return true 验证成功 false 验证失败206. */207. public boolean validateSign(String signfile) { 208. // 读取公匙209. PublicKey mypubkey = (PublicKey) getObjFromFile(si gnfile, 2);210. // 读取签名211. byte[] signed = (byte[]) getObjFromFile(signfile,1);212. // 读取信息213. String info = (String) getObjFromFile(signfile, 3) ;214. try {215. // 初始一个Signature对象,并用公钥和签名进行验证216. Signature signetcheck = Signature.getInstance( "DSA");217. // 初始化验证签名的公钥218. signetcheck.initVerify(mypubkey);219. // 使用指定的 byte 数组更新要签名或验证的数据220. signetcheck.update(info.getBytes());221. System.out.println(info);222. // 验证传入的签名223. return signetcheck.verify(signed);224. } catch (Exception e) {225. e.printStackTrace();226. return false;227. }228. }229. /**230. * 将二进制转化为16进制字符串231. *232. * @param b233. * 二进制字节数组234. * @return String235. */236. public String byte2hex(byte[] b) {237. String hs = "";238. String stmp = "";239. for (int n = 0; n < b.length; n++) {240. stmp = (ng.Integer.toHexString(b[n] & 0 XFF));241. if (stmp.length() == 1) {242. hs = hs + "0" + stmp;243. } else {244. hs = hs + stmp;245. }246. }247. return hs.toUpperCase();248. }249. /**250. * 十六进制字符串转化为2进制251. *252. * @param hex253. * @return254. */255. public byte[] hex2byte(String hex) {256. byte[] ret = new byte[8];257. byte[] tmp = hex.getBytes();258. for (int i = 0; i < 8; i++) {259. ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1] );260. }261. return ret;262. }263. /**264. * 将两个ASCII字符合成一个字节；如："EF"--> 0xEF 265. *266. * @param src0267. * byte268. * @param src1269. * byte270. * @return byte271. */272. public static byte uniteBytes(byte src0, byte src1) {273. byte _b0 = Byte.decode("0x" + new String(new byte[ ] { src0 }))274. .byteValue();275. _b0 = (byte) (_b0 << 4);276. byte _b1 = Byte.decode("0x" + new String(new byte[ ] { src1 }))277. .byteValue();278. byte ret = (byte) (_b0 ^ _b1);279. return ret;280. }281. /**282. * 将指定的对象写入指定的文件283. *284. * @param file285. * 指定写入的文件286. * @param objs287. * 要写入的对象288. */289. public void doObjToFile(String file, Object[] objs) {290. ObjectOutputStream oos = null;291. try {292. FileOutputStream fos = new FileOutputStream(fi le);293. oos = new ObjectOutputStream(fos);294. for (int i = 0; i < objs.length; i++) { 295. oos.writeObject(objs[i]);296. }297. } catch (Exception e) {298. e.printStackTrace();299. } finally {300. try {301. oos.close();302. } catch (IOException e) {303. e.printStackTrace();304. }305. }306. }307. /**308. * 返回在文件中指定位置的对象309. *310. * @param file311. * 指定的文件312. * @param i313. * 从1开始314. * @return315. */316. public Object getObjFromFile(String file, int i) { 317. ObjectInputStream ois = null;318. Object obj = null;319. try {320. FileInputStream fis = new FileInputStream(file );321. ois = new ObjectInputStream(fis);322. for (int j = 0; j < i; j++) {323. obj = ois.readObject();324. }325. } catch (Exception e) {326. e.printStackTrace();327. } finally {328. try {329. ois.close();330. } catch (IOException e) {331. e.printStackTrace();332. }333. }334. return obj;335. }336. /**337. * 测试338. *339. * @param args340. */341. public static void main(String[] args) {342. CryptTest jiami = new CryptTest();343. // 执行MD5加密"Hello world!"344. System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));345. // 生成一个DES算法的密匙346. SecretKey key = jiami.createSecretKey("DES"); 347. // 用密匙加密信息"Hello world!"348. String str1 = jiami.encryptToDES(key, "Hello"); 349. System.out.println("使用des加密信息Hello 为:" + str1);350. // 使用这个密匙解密351. String str2 = jiami.decryptByDES(key, str1); 352. System.out.println("解密后为：" + str2);353. // 创建公匙和私匙354. jiami.createPairKey();355. // 对Hello world!使用私匙进行签名356. jiami.signToInfo("Hello", "mysign.bat");357. // 利用公匙对签名进行验证。

vigenere密码原理维吉尼亚密码（Vigenère cipher）是一种经典的多表密码算法，它采用了简单的替换方法和关键字循环。

维吉尼亚密码最早由法国人布莱克默（Blaise de Vigenère）在16世纪中期创造，并且在欧洲多个国家使用了数百年。

它是最早并且最著名的使用重复密钥的多表密码之一。

维吉尼亚密码是一种多表密码，这意味着它使用了一系列的字母表来进行替换。

维吉尼亚密码的加密过程通过将明文字符替换成密文字符来实现。

不同于凯撒密码只使用一个固定的替换规则，维吉尼亚密码使用一系列的凯撒密码来实现，这些凯撒密码都是通过关键字生成的。

维吉尼亚密码使用一个关键字作为循环的密钥，该关键字会重复直到与明文长度相等。

例如，如果明文是"HELLO"且关键字是"KEY"，则关键字会重复直到与明文长度相等，即"KEYKE"。

然后，关键字中的每个字母会与明文中的相应字母进行替换。

替换的方法是将明文字母与关键字字母在字母表中的位置相加，并且对字母表的长度取模。

最后，将得到的结果字母替换掉对应的明文字母，从而得到密文。

下面以一个例子来说明维吉尼亚密码的加密过程。

设定明文为"HELLO"，关键字为"KEY"。

首先，将关键字"KEY"重复直到与明文长度相等，得到"KEYKE"。

然后，将明文字符"H"与关键字字符"K"相加，其在字母表中的位置为8+11=19。

对字母表的长度26取模，得到替换结果19，即字母"T"。

同样地，将"E"与"K"相加，其在字母表中的位置为5+11=16，对26取模，得到替换结果16，即字母"Q"。

继续进行下去，得到密文"TIPTL"。

Java实现加密和解密的源代码本⽂转载于⽹络，抄录下来只是为了⽅便以后查找。

原⽂地址：加密解密，曾经是我⼀个毕业设计的重要组件。

在⼯作了多年以后回想当时那个加密、解密算法，实在是太单纯了。

⾔归正传，这⾥我们主要描述Java已经实现的⼀些加密解密算法，最后介绍数字证书。

如基本的单向加密算法：BASE64 严格地说，属于编码格式，⽽⾮加密算法MD5(Message Digest algorithm 5，信息摘要算法)SHA(Secure Hash Algorithm，安全散列算法)HMAC(Hash Message Authentication Code，散列消息鉴别码)复杂的对称加密（DES、PBE）、⾮对称加密算法：DES(Data Encryption Standard，数据加密算法)PBE(Password-based encryption，基于密码验证)RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)DH(Diffie-Hellman算法，密钥⼀致协议)DSA(Digital Signature Algorithm，数字签名)ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)本篇内容简要介绍BASE64、MD5、SHA、HMAC⼏种⽅法。

MD5、SHA、HMAC这三种加密算法，可谓是⾮可逆加密，就是不可解密的加密⽅法。

我们通常只把他们作为加密的基础。

单纯的以上三种的加密并不可靠。

BASE64按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计⽤来把任意序列的8位字节描述为⼀种不易被⼈直接识别的形式。

（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）常见于邮件、http加密，截取http信息，你就会发现登录操作的⽤户名、密码字段通过BASE64加密的。

JAVAAES加密算法实现代码1、代码package com.zhaochao.utill;import java.io.UnsupportedEncodingException;import java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import javax.crypto.BadPaddingException;import javax.crypto.Cipher;import javax.crypto.IllegalBlockSizeException;import javax.crypto.KeyGenerator;import javax.crypto.NoSuchPaddingException;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class AESUitl {public static byte[] encrypt(String content, String password) {try {KeyGenerator kgen = KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加密} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (UnsupportedEncodingException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();}return null;}public static byte[] decrypt(byte[] content, String password) {try {KeyGenerator kgen = KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器cipher.init(Cipher.DECRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(content);return result; // 加密} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();}return null;}public static void main(String[] rags) {String content = "test2222";String password = "12345678";// 加密System.out.println("加密前：" + content);byte[] encryptResult = encrypt(content, password);System.out.println("加密后："+new String(encryptResult));// 解密byte[] decryptResult = decrypt(encryptResult, password); System.out.println("解密后：" + new String(decryptResult)); }}2、输出结果加密前：test2222加密后：��»�4�s-�?�D�H�解密后：test2222。