java文件加密解密课程设计
java 密码加密解密方法
java 密码加密解密方法在Java中，密码的加密和解密可以通过多种方式实现。
其中，常用的方法包括使用MessageDigest类进行加密，以及使用对称加密和非对称加密算法进行加密和解密。
一种常见的密码加密方法是使用MessageDigest类进行加密。
这可以通过以下步骤实现：首先，将密码转换为字节数组。
然后，使用MessageDigest类的getInstance方法获取特定的加密算法实例，例如SHA-256或MD5。
接下来，使用update方法将密码的字节数组传递给MessageDigest实例。
最后，使用digest方法获得加密后的字节数组，并将其转换为十六进制字符串或其他格式存储在数据库或其他地方。
另一种常见的方法是使用对称加密算法，例如AES或DES。
这些算法使用相同的密钥进行加密和解密。
在Java中，可以使用javax.crypto包中的类来实现对称加密。
通常，需要生成一个密钥并将其存储在安全的地方，然后使用该密钥对密码进行加密和解密。
此外，还可以使用非对称加密算法，例如RSA。
这种方法使用公钥对数据进行加密，然后使用私钥进行解密。
在Java中，可以使用java.security包中的类来实现非对称加密。
无论使用哪种方法，都需要注意密码安全的问题。
例如，密钥的安全存储和管理，以及密码传输过程中的安全性。
另外，还需要考虑密码的哈希加盐等技术来增加密码的安全性。
总之，在Java中实现密码的加密和解密有多种方法，开发人员可以根据实际需求和安全要求选择合适的加密算法和实现方式。
希望这些信息能够帮助你更好地理解Java中密码加密解密的方法。
使用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`方法用于对密文进行解密。
JAVA实现AES的加密和解密算法
JAVA实现AES的加密和解密算法AES（高级加密标准）是一种对称加密算法，可以通过Java的javax.crypto库来实现。
下面我们将介绍一种基于Java的AES加密和解密算法的实现方法。
1.导入所需的包在Java中使用AES加密和解密算法需要导入以下两个包：```import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;```2.创建加密和解密函数首先，我们需要创建加密函数和解密函数。
加密函数将输入的明文数据加密为密文，解密函数将输入的密文数据解密为明文。
```javaprivate static byte[] encrypt(byte[] key, byte[] data) throws ExceptionSecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);return cipher.doFinal(data);private static byte[] decrypt(byte[] key, byte[] encryptedData) throws ExceptionSecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);return cipher.doFinal(encryptedData);```3.测试加密和解密函数为了验证加密和解密函数的正确性，我们可以创建一个测试函数来测试它们。
java实现文件内容的加密和解密
java实现⽂件内容的加密和解密package com.umapp.test;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.OutputStream;import java.security.Key;import java.security.SecureRandom;import javax.crypto.Cipher;import javax.crypto.CipherInputStream;import javax.crypto.CipherOutputStream;import javax.crypto.KeyGenerator;public class TestDES {Key key;public TestDES(String str) {getKey(str);//⽣成密匙}/*** 根据参数⽣成KEY*/public void getKey(String strKey) {try {KeyGenerator _generator = KeyGenerator.getInstance("DES");_generator.init(new SecureRandom(strKey.getBytes()));this.key = _generator.generateKey();_generator = null;} catch (Exception e) {throw new RuntimeException("Error initializing SqlMap class. Cause: " + e);}}/*** ⽂件file进⾏加密并保存⽬标⽂件destFile中** @param file 要加密的⽂件如c:/test/srcFile.txt* @param destFile 加密后存放的⽂件名如c:/加密后⽂件.txt*/public void encrypt(String file, String destFile) throws Exception {Cipher cipher = Cipher.getInstance("DES");// cipher.init(Cipher.ENCRYPT_MODE, getKey());cipher.init(Cipher.ENCRYPT_MODE, this.key);InputStream is = new FileInputStream(file);OutputStream out = new FileOutputStream(destFile);CipherInputStream cis = new CipherInputStream(is, cipher);byte[] buffer = new byte[1024];int r;while ((r = cis.read(buffer)) > 0) {out.write(buffer, 0, r);}cis.close();is.close();out.close();}/*** ⽂件采⽤DES算法解密⽂件** @param file 已加密的⽂件如c:/加密后⽂件.txt* * @param destFile* 解密后存放的⽂件名如c:/ test/解密后⽂件.txt*/public void decrypt(String file, String dest) throws Exception {Cipher cipher = Cipher.getInstance("DES");cipher.init(Cipher.DECRYPT_MODE, this.key);InputStream is = new FileInputStream(file);OutputStream out = new FileOutputStream(dest);CipherOutputStream cos = new CipherOutputStream(out, cipher);byte[] buffer = new byte[1024];int r;while ((r = is.read(buffer)) >= 0) {System.out.println();cos.write(buffer, 0, r);}cos.close();out.close();is.close();}public static void main(String[] args) throws Exception {TestDES td = new TestDES("aaa");td.encrypt("e:/r.txt", "e:/r解密.txt"); //加密 td.decrypt("e:/r解密.txt", "e:/r1.txt"); //解密 }}。
Java加解密
Java加解密⼀、概述 Jasypt 这个Java类包为开发⼈员提供⼀种简单的⽅式来为项⽬增加加密功能，包括：密码Digest认证，⽂本和对象加密，集成hibernate，Spring Security(Acegi)来增强密码管理。
Jasypt是⼀个Java库，可以使开发者不需太多操作来给Java项⽬添加基本加密功能，⽽且不需要知道加密原理。
根据Jasypt⽂档，该技术可⽤于加密任务与应⽤程序，例如加密密码、敏感信息和数据通信、创建完整检查数据的sums. 其他性能包括⾼安全性、基于标准的加密技术、可同时单向和双向加密的加密密码、⽂本、数字和⼆进制⽂件。
Jasypt也可以与Acegi Security整合也即Spring Security。
Jasypt亦拥有加密应⽤配置的集成功能，⽽且提供⼀个开放的API从⽽任何⼀个Java Cryptography Extension都可以使⽤Jasypt。
Jasypt还符合RSA标准的基于密码的加密，并提供了⽆配置加密⼯具以及新的、⾼可配置标准的加密⼯具。
1、该开源项⽬可⽤于加密任务与应⽤程序，例如加密密码、敏感信息和数据通信 2、还包括⾼安全性、基于标准的加密技术、可同时单向和双向加密的加密密码、⽂本、数字和⼆进制⽂件。
3、Jasypt还符合RSA标准的基于密码的加密，并提供了⽆配置加密⼯具以及新的、⾼可配置标准的加密⼯具。
4、加密属性⽂件（encryptable properties files）、Spring work集成、加密Hibernate数据源配置、新的命令⾏⼯具、URL加密的Apache wicket集成以及升级⽂档。
5、Jasypt也可以与Acegi Security整合也即Spring Security。
Jasypt亦拥有加密应⽤配置的集成功能，⽽且提供⼀个开放的API从⽽任何⼀个Java Cryptography Extension都可以使⽤Jasypt。
java课程设计凯撒加密解密
java课程设计凯撒加密解密一、教学目标本章节的教学目标旨在让学生掌握Java语言实现凯撒加密和解密的方法。
通过本章节的学习，学生应达到以下目标：1.知识目标：了解凯撒加密和解密的基本原理；掌握Java语言的基本语法和编程技巧；理解循环、条件语句在程序中的应用。
2.技能目标：能够使用Java语言编写简单的凯撒加密和解密程序；能够分析并解决程序中的错误和问题；能够协作完成编程任务，提高团队协作能力。
3.情感态度价值观目标：培养对计算机科学的兴趣和好奇心；培养学生的创新精神和实践能力；培养学生的团队合作意识和沟通能力。
二、教学内容本章节的教学内容主要包括以下几个部分：1.凯撒加密和解密的基本原理；2.Java语言的基本语法和编程技巧；3.循环、条件语句在程序中的应用；4.凯撒加密和解密程序的编写与调试。
第1课时：凯撒加密和解密的基本原理；第2课时：Java语言的基本语法和编程技巧；第3课时：循环、条件语句在程序中的应用；第4课时：凯撒加密和解密程序的编写与调试。
为了提高教学效果，本章节将采用以下教学方法：1.讲授法：讲解凯撒加密和解密的基本原理，以及Java语言的基本语法和编程技巧；2.案例分析法：分析典型的凯撒加密和解密案例，引导学生理解并掌握相关知识；3.实验法：让学生动手编写凯撒加密和解密程序，培养学生的实践能力；4.讨论法：学生进行小组讨论，分享编程心得，提高学生的团队协作能力。
四、教学资源为了支持教学内容和教学方法的实施，本章节将准备以下教学资源：1.教材：Java编程入门教程；2.参考书：Java语言程序设计；3.多媒体资料：凯撒加密和解密的案例视频；4.实验设备：计算机、网络环境。
五、教学评估本章节的教学评估将采用多元化的评价方式，以全面、客观地评价学生的学习成果。
评估内容包括：1.平时表现：通过课堂参与、提问、回答问题等环节，评估学生的学习态度和积极性；2.作业：布置相关的编程作业，评估学生的理解和应用能力；3.实验报告：评估学生在实验过程中的操作能力和解决问题的能力；4.考试：设置期末考试，检验学生对凯撒加密和解密知识的掌握程度。
java 加密解密简单实现
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. // 利用公匙对签名进行验证。
Java 加密、解密Word文档
Java加密、解密Word文档对一些重要文档，我们为保证其文档内容不被泄露，常需要对文件进行加密，查看文件时，需要正确输入密码才能打开文件。
下面介绍了一种比较简单的方法给Word文件添加密码保护以及如何给已加密的Word文件取消密码保护。
使用工具：Free Spire.Doc for Java 2.0.0（免费版）Jar文件导入：方法1：通过官网下载控件包。
在程序下新建一个directory目录，并命名（本示例中命名为lib）；将控件包lib文件夹下的jar（如下图1）复制到程序中新建的目录下。
复制jar文件后，鼠标右键点击jar文件，选择”Add as Library”。
完成导入（如下图2）。
图1：图2：方法2：通过maven导入。
参考导入方法。
Java代码示例【示例1】设置Word密码保护import com.spire.doc.*;public class Encrypt {public static void main(String[] args){//加载测试文档String input = "test.docx";String output= "result.docx";Document doc = new Document(input);//调用方法加密文档doc.encrypt("123");//保存加密后的文档doc.saveToFile(output);}}文件加密结果：【示例2】取消Word密码保护import com.spire.doc.*;public class Decrypt {public static void main(String[] args){//加载带密码的文件，输入原密码并解除Document doc = new Document();doc.loadFromFile("result.docx",FileFormat.Docx_2013,"123");//将解密后的文档另存doc.saveToFile("Decrypt.docx",FileFormat.Docx_2013);}}运行程序后，生成的文件将不再有密码保护。
java国密加密与解密流程
java国密加密与解密流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 引入国密相关的依赖库在 Java 项目中，需要引入国密相关的依赖库，例如 Bouncy Castle 库。
JAVA使用DES加密算法加密解密
JAVA使⽤DES加密算法加密解密程序中使⽤了.properties⽂件作为参数配置⽂档，好处是灵活配置各项参数⼀旦对数据库的⼀些参数进⾏了配置，势必涉及数据库的IP，端⼝，⽤户名和密码properties⽂件全是unicode编码明⽂存储，程序打包交付后，其他⼈能够很容易使⽤解压软件打开jar查看你的.properties⽂件所以⼀些敏感变量需要加密处理⾸先需要了解⼀些基本的加密算法，⽐如MD5，⽐如DES和RSAMD5是⼀种不可逆的加密算法，使⽤散列后特征码的⽅式表现需要加密的字符或者⽂件，常⽤在系统登陆的密码⽐对中将MD5码存储在数据库中，⽤户登陆时将⽤户输⼊的字符散列成MD5后于数据库中的密⽂进⾏⽐对不可逆的加密算法有⼀种好处就是，即使后台数据库被攻破了，对⽅拿这些MD5散列密⽂也毫⽆办法求得明⽂DES和RSA都是可逆的加密算法，也就是可以通过密钥和密⽂解开得到明⽂，其中最常见的64位轮转DES算法在JAVA的JDK中提供了先天性的良好的加密⽀持，其中就包括⼤名⿍⿍的DES下⾯⼀个DESHelper类展⽰了如何将密⽂解开得到明⽂的⽅法package com.newflypig.des;import java.security.SecureRandom;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import sun.misc.BASE64Decoder;/*** 处理数据库密码的密⽂转明⽂类* @author newflypig* time：2015年10⽉30⽇* TODO**/public class DESHelper {/*** Description 根据键值进⾏解密* @param data* @param key 加密键byte数组* @return* @throws Exception*/private static byte[] decrypt(byte[] data, byte[] key) throws Exception {// ⽣成⼀个可信任的随机数源SecureRandom sr = new SecureRandom();// 从原始密钥数据创建DESKeySpec对象DESKeySpec dks = new DESKeySpec(key);// 创建⼀个密钥⼯⼚，然后⽤它把DESKeySpec转换成SecretKey对象SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");SecretKey securekey = keyFactory.generateSecret(dks);// Cipher对象实际完成解密操作Cipher cipher = Cipher.getInstance("DES");// ⽤密钥初始化Cipher对象cipher.init(Cipher.DECRYPT_MODE, securekey, sr);return cipher.doFinal(data);}public static String decrypt(String data, String key) throws Exception {if (data == null)return null;BASE64Decoder decoder = new BASE64Decoder();byte[] buf = decoder.decodeBuffer(data);byte[] bt = decrypt(buf, key.getBytes());return new String(bt);}}如需对加密算法有更深刻的了解，可以⾃⾏研究实现原理，对于敏捷开发这⾥只需要不求甚解的运⽤就⾏了，记得保护好你的key也就是密钥⼀开始提到的需要将properties⽂件中的参数解开得到明⽂，想必你应该已经知道该使⽤哪种加密算法了吧对了，就是上⾯的DES加密算法，这⾥只提供了解密，因为不需要在程序中提供加密函数各位可以⾃⼰编写⾃⼰的加密函数，或者可以在⾃⼰的JUnit测试⾥⾯写加密的语句⽤来对数据库密码进⾏加密。
文件加密传输系统的设计与JAVA实现
中图分类 号 ： Ｐ ３ Ｔ ３ ９ 文 献标 识码 ： Ａ 文章 编号 ： ６ ４ ０ （ ０ ００ （ ） ０ ３ －０ １ ７ － ９ Ｘ ２ １ ） ９ ｂ－ ０ １ １ ８
１引言
信 息 技 术 与 网络 技 术 的 发 展 ， 在 改 正 变 着人 类 信 息 传 递 的 方 式 、 际 间 的 沟 通 人 方式 ， 时 也 深 刻 地 影 响 着 社 会 生 活 的 各 同 个 方 面 。 日常 的 网 络应 用 中 ， 件 传 输 已 在 文 经 成 为 继 即 时通 讯 之 后 第 二 大 的 网 络 基础 应 用 ， 点对 点 的 文 件 发 送 是 最 方 便 的 文 而 件 传 输 手 段 。 来 越 多 的 网 民 或 是 商 业 用 越 户 都 采 用 这 种 方 式 发 送 文 件 。 由于 网络 但 的开放性 ， 网络 技 术 在 带 给 我 们 方 便 的 同 时 ， 存 在 着 极 大 的安 全 隐 患 ， 互 联 网上 也 在 甚 至企 业 内部 网上 以 明 文形 式传 输 数 据 资 料 ， 遍 存 在 着 被 窃 听 、 取 ， 者 篡 改 的 普 截 或
仅 可 以 发 送 和 接 收 文 件 ， 文 件 进 行 加 密 传 薯 ， 可 以 发送 和 接 收 即 时 消 息 ， 使 得 用 户 在 传 翰 文 件 的 同 时 还 可 以进 行 即 时 交 流 。 对 ． 还 ｒ 这
文件加密解密工具的程序设计及代码示例
文件加密解密工具的程序设计及代码示例随着电子信息的快速发展，我们的个人和商业文件越来越多地存储在电脑和网络中。
为了保护这些文件的机密性，文件加密解密工具成为了必需的软件之一。
在本文中，我们将讨论文件加密解密工具的程序设计，并且提供一个代码示例来帮助你理解。
一、程序设计在设计文件加密解密工具的程序时，以下几个关键点需要考虑：1. 界面设计：一个直观友好的界面对用户来说非常重要。
应该提供简单易懂的按钮和选项，使用户可以轻松选择加密或解密文件。
2. 加密算法选择：加密算法是文件加密解密工具的核心。
现有的加密算法包括对称加密算法和非对称加密算法。
在选择算法时，安全性和性能之间的权衡需要被谨慎考虑。
3. 密钥管理：为了保证文件的安全性，密钥的管理非常重要。
工具应该提供一个方便的密钥管理界面，使用户可以生成、导入和导出密钥。
4. 异常处理：在程序设计中，应该考虑到各种异常情况，如无效的文件路径、权限问题等，以便给用户提示并提供解决方案。
二、代码示例下面是一个使用Java编写的文件加密解密工具的代码示例：```javaimport java.io.FileInputStream;import java.io.FileOutputStream;import java.security.Key;import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;public class FileEncryptDecryptTool {private static final String ALGORITHM = "AES";private static final String TRANSFORMATION ="AES/ECB/PKCS5Padding";private static final String KEY = "YourEncryptionKey";public static void encryptFile(String inputFile, String outputFile) throws Exception {doCrypto(Cipher.ENCRYPT_MODE, inputFile, outputFile);}public static void decryptFile(String inputFile, String outputFile) throws Exception {doCrypto(Cipher.DECRYPT_MODE, inputFile, outputFile);}private static void doCrypto(int cipherMode, String inputFile, String outputFile) throws Exception {FileInputStream inputStream = new FileInputStream(inputFile);FileOutputStream outputStream = newFileOutputStream(outputFile);byte[] buffer = new byte[1024];int bytesRead;Key secretKey = new SecretKeySpec(KEY.getBytes(), ALGORITHM);Cipher cipher = Cipher.getInstance(TRANSFORMATION);cipher.init(cipherMode, secretKey);while ((bytesRead = inputStream.read(buffer)) != -1) {byte[] outputBytes = cipher.update(buffer, 0, bytesRead);if (outputBytes != null) {outputStream.write(outputBytes);}}byte[] outputBytes = cipher.doFinal();if (outputBytes != null) {outputStream.write(outputBytes);}inputStream.close();outputStream.close();}public static void main(String[] args) {String inputFile = "path/to/input/file";String encryptedFile = "path/to/encrypted/file";String decryptedFile = "path/to/decrypted/file";try {encryptFile(inputFile, encryptedFile);System.out.println("File encrypted successfully!");} catch (Exception e) {System.out.println("Error encrypting file: " + e.getMessage()); }try {decryptFile(encryptedFile, decryptedFile);System.out.println("File decrypted successfully!");} catch (Exception e) {System.out.println("Error decrypting file: " + e.getMessage()); }}}```以上代码示例使用了AES对称加密算法进行文件的加密和解密。
基于JAVA的RSA文件加密软件的设计与实现论文
摘要分析RSA算法的应用现状，论证文件加密应用RSA算法的可行性和意义。
设计一套完整实用的RSA文件加密解决方案，具体编码实现。
对RSA算法进行研究，从常规RSA算法出发，用C++实现RSA加密算法类库，并在32位windows平台封装成组件。
在.Net平台引用此组件，实现可以对任意文件进行RSA加密操作的窗体应用程序。
经过加密的文件以及密钥文件都是文本文件。
给出关键类类图、整个应用程序的结构描述文档、关键模块流程图、较详细的接口文档、所有源代码。
对应用程序进行测试，对测试结果进行分析研究，进而对应用程序进行改进，对关键算法进行尽可能的优化，最终得到一个在windows运行的可以用指定密钥对任意文件进行RSA加密并可解密的完整应用程序，和一些相关的可移植组件。
关键词RSA RSA算法文件加密加密成文本AbstractDo research about the application area of RSA encryption and reason that RSA can be used for file encryption. Design a RSA file-encrypt solution and complete an application on Microsoft Windows™. Design a C++ class based on normal RSA algorithm. And make a DLL module based on the class. Then complete a .Net Framework™ window-application using that DLL. The application can encrypt any file and decrypt them. The file after encryption can be saved as a text file. And the encryption-keys also can be saved as text.Provide pivotal classes chart, project description, core algorithm flowchart, all source code, and module interfaces document. Do application performance test and record the performance data. Analyze the result then optimize core algorithm and improve the application. Finally, create a practical application using RSA algorithm that can encrypt and decrypt any file. And several modules in the project can be reuse by other applications. For instance, the C++ class can be cross-compiled for handheld devices, the DLL can be referenced by other win32 applications, and the .Net class can be easily referenced by web server applications or web services.Keywords RSA RSA algorithm file encryption encrypt to text目录前言 (4)第1章RSA应用现状及应用于文件加密的分析 (5)1.1 RSA算法介绍与应用现状 (5)1.2 RSA应用于文件加密的分析 (6)1.2.1 文件加密使用RSA的可行性 (6)1.2.2 文件加密使用RSA的意义 (7)第2章RSA文件加密软件的设计与实现 (9)2.1 需求分析与总体设计 (9)2.1.1 功能分析 (9)2.1.2 工程方案选择 (10)2.2 各部分的设计与开发 (11)2.2.1 实现RSA加密算法的C++核心类库 (11)2.2.2 封装C++核心类库的DLL组件 (21)2.2.3 引用DLL的.Net类与实现文件操作功能的窗体应用程序 (22)第3章软件整体测试与分析改进 (23)3.1 编写测试各项性能需要的精确计时类 (23)3.2 测试数据与分析改进 (23)3.2.1 密钥生成测试 (23)3.2.2 数据输入输出测试 (26)3.2.3 加密解密测试 (26)3.2.4 性能分析与改进优化 (29)3.3 使用中国余数定理 (30)第4章可移植模块的简要说明与开发前景 (32)结束语 (33)谢辞 (34)参考文献 (35)附录 (36)前言RSA公钥加密算法是第一个既能用于数据加密也能用于数字签名的算法。
java接收文件加密解密方法
java接收文件加密解密方法
在Java中接收加密文件并进行解密可以通过多种方式实现。
下面我将从多个角度介绍几种常见的方法：
1. 使用对称加密算法：
可以使用Java的javax.crypto包中的类来实现对称加密算法，如AES。
首先，接收加密文件后，可以使用FileInputStream 读取文件内容，然后使用Cipher类进行解密操作，最后使用FileOutputStream将解密后的内容写入新文件。
2. 使用非对称加密算法：
如果发送方使用了公钥加密文件，接收方可以使用私钥进行解密。
可以使用Java的java.security包中的类来实现非对称加密算法，如RSA。
首先，接收加密文件后，可以使用PrivateKey类进行解密操作，最后使用FileOutputStream将解密后的内容写入新文件。
3. 使用第三方库：
除了Java自带的加密算法外，也可以使用第三方库来简化加密解密操作，例如Bouncy Castle或者Apache Commons Crypto 等。
这些库提供了更多的加密选项和更简单的API，可以更容易地实现文件的加密和解密操作。
无论使用哪种方法，都需要注意文件的安全传输和存储，以及密钥的安全管理。
另外，要确保在解密文件时处理可能出现的异常情况，如文件损坏或者密码错误等。
希望这些信息能够帮助你实现在Java中接收文件并进行加密解密的操作。
java使用RSA与AES加密解密
java使⽤RSA与AES加密解密⾸先了解下，什么是堆成加密，什么是⾮对称加密？ 对称加密：加密与解密的密钥是相同的，加解密速度很快，⽐如AES ⾮对称加密：加密与解密的秘钥是不同的，速度较慢，⽐如RSA先看代码（先会⽤在研究） 相关依赖： <dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.58</version></dependency>1，RSA⼯具类：package cn.wangtao.utils;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import javax.crypto.Cipher;import java.io.ByteArrayOutputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectOutputStream;import java.security.*;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;/*** @ClassName RSAUtils* @Auth 桃⼦* @Date 2019-6-25 15:15* @Version 1.0* @Description**/public class RSAUtils {private static final String RSA = "RSA"; // 加密⽅式private static final Logger logger= LoggerFactory.getLogger(RSAUtils.class);//获取密钥public static KeyPair getKey() throws Exception {try {KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA, new BouncyCastleProvider()); keyPairGenerator.initialize(2048); // 初始化密钥长度KeyPair keyPair = keyPairGenerator.generateKeyPair();// ⽣成密钥对return keyPair;} catch (Exception e) {logger.error("获取RSA秘钥对异常",e);throw new Exception("获取RSA秘钥对异常",e);}}//利⽤公钥进⾏加密public static String encryptStr(RSAPublicKey publicKey, String str) throws Exception {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.ENCRYPT_MODE, publicKey);//加密byte[] bytes = getBytes(str.getBytes(), cipher);//2进⾏转换成16进制String result = CommonUtils.parseByte2HexStr(bytes);return result;} catch (Exception e) {logger.error("使⽤RSA公钥进⾏加密异常",e);throw new Exception("使⽤RSA公钥进⾏加密异常",e);}}//利⽤私钥进⾏解密public static String decryptStr(RSAPrivateKey privateKey, String str) throws Exception {try {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.DECRYPT_MODE, privateKey); // ⽤密钥初始化此Cipher对象//16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(str);//解密byte[] bs = getBytes(bytes, cipher);String content=new String(bs,"utf-8");return content;} catch (Exception e) {logger.error("使⽤RSA私钥进⾏解密异常",e);throw new Exception("使⽤RSA私钥进⾏解密异常",e);}}//通过cipher获取字节数组public static byte[] getBytes(byte[] bytes,Cipher cipher) throws Exception {int blockSize = cipher.getBlockSize(); // 返回块的⼤⼩int j = 0;ByteArrayOutputStream baos = new ByteArrayOutputStream();while (bytes.length - j * blockSize > 0) { // 将⼆进制数据分块写⼊ByteArrayOutputStream中 if(bytes.length-j*blockSize>blockSize){baos.write(cipher.doFinal(bytes, j * blockSize, blockSize));}else{baos.write(cipher.doFinal(bytes, j * blockSize,bytes.length-j*blockSize));}j++;}baos.close();byte[] byteArray = baos.toByteArray();return byteArray;}//保存秘钥对到⽂件public void saveRSAKey(String fileName) throws Exception {FileOutputStream fos=null;ObjectOutputStream oos=null;try {KeyPair keyPair = getKey();fos=new FileOutputStream(fileName);oos=new ObjectOutputStream(fos); //对象序列号oos.writeObject(keyPair);} catch (Exception e) {logger.error("RSA秘钥对保存到⽂件异常[{}]",fileName,e);throw new Exception("RSA秘钥对保存到⽂件异常",e);}finally {if(oos!=null){try {oos.close();} catch (IOException e1) {e1.printStackTrace();}if(fos!=null){try {fos.close();} catch (IOException e1) {e1.printStackTrace();}}}}}/*** @ClassName RSAUtils* @Version 1.0* @Description RSA⼯具类**/public class RSAUtils {private static final String RSA = "RSA";public static final String MD5WITHRSA="MD5withRSA";public static final String SHA1WITHRSA="SHA1withRSA";private static Logger logger= LoggerFactory.getLogger(RSAUtils.class);/*** @desc 读取秘钥⽂本内容* @createTime 2019年7⽉2⽇下午5:20:38* @param keyFile 秘钥⽂件* @return 秘钥⽂本内容* @throws Exception*/private static String initKeyByFile(File keyFile) throws Exception {if(keyFile.exists() && keyFile.isFile()) {BufferedReader bufferedReader = null;try {bufferedReader = new BufferedReader(new FileReader(keyFile));StringBuilder stringBuilder = new StringBuilder();String line = null;while ((line = bufferedReader.readLine()) != null) {if (line.length() == 0 || line.charAt(0) == '-') {continue;}stringBuilder.append(line).append(System.getProperty("line.separator")); }return stringBuilder.toString();}catch (Exception e) {logger.error("读取秘钥⽂本内容异常",e);throw new Exception("读取秘钥⽂本内容异常",e);}finally {CommonUtils.closeReaderandWriter(bufferedReader, null);}}return null;}/*** @desc 获取公钥* @author Liuweian* @createTime 2019年7⽉2⽇下午5:19:34* @param pubKeyFileName 公钥⽂件地址* @return PublicKey* @throws Exception*/public static PublicKey getPublicKeyByFile(File pubKeyFile) throws Exception {String keyContent = initKeyByFile(pubKeyFile);byte[] keyByte = Base64.decode(keyContent);KeyFactory kf = KeyFactory.getInstance(RSA);X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyByte);return kf.generatePublic(keySpec);}* @desc 获取私钥* @createTime 2019年7⽉2⽇下午5:19:16* @param priKeyFileName 私钥⽂件地址* @return PrivateKey* @throws Exception*/public static PrivateKey getPrivateKeyByFile(File priKeyFile) throws Exception {String keyContent = initKeyByFile(priKeyFile);byte[] keyByte = Base64.decode(keyContent);KeyFactory kf = KeyFactory.getInstance(RSA);PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyByte);return kf.generatePrivate(keySpec);}/*** @desc 使⽤RSA中的私钥对数据签名* @createTime 2019年7⽉2⽇下午5:24:30* @param privateKey 秘钥对中的私钥* @param data 待加签字节数组* @param signType 加签类型* @return 加签后的签名* @throws Exception*/public static String sign(byte[] data, PrivateKey privateKey, String signType) throws Exception {Signature signature = Signature.getInstance(signType);signature.initSign(privateKey);signature.update(data);byte[] signByte = signature.sign();//Base64加密return new String(Base64.encode(signByte));}/*** @desc 使⽤RSA中的公钥对签名验签* @createTime 2019年7⽉2⽇下午5:24:30* @param data 待验签字节数组* @param sign 签名* @param publicKey 秘钥对中的公钥* @param signType 加签类型* @return 验签是否成功* @throws Exception*/public static boolean verify(byte[] data, byte[] sign, PublicKey publicKey, String signType) {try {Signature signature = Signature.getInstance(signType);signature.initVerify(publicKey);signature.update(data);//Base64解密byte[] keyByte = Base64.decode(sign);return signature.verify(keyByte);} catch (Exception e) {logger.error("验签出现异常", e);return false;}}/*** @desc 使⽤RSA中的私钥对数据签名加签⽅式 MD5withRSA* @createTime 2019年7⽉2⽇下午5:24:30* @param privateKey 秘钥对中的私钥* @param data 待加签字节数组* @return 加签后的签名* @throws Exception*/public static String signMD5withRSA(byte[] data, PrivateKey privateKey) throws Exception {return sign(data, privateKey, MD5WITHRSA);}/*** @desc 使⽤RSA中的公钥对签名验签验签⽅式 MD5withRSA* @createTime 2019年7⽉2⽇下午5:24:30* @param sign 签名* @param publicKey 秘钥对中的公钥* @param signType 加签类型* @return 验签是否成功，失败则异常抛出* @throws Exception*/public static void verifyMD5withRSA(byte[] data, byte[] sign, PublicKey publicKey) throws Exception { if(!verify(data, sign, publicKey, MD5WITHRSA)) {throw new Exception("验签失败");}}/*** @desc 通过cipher获取字节数组分块* @createTime 2019年7⽉2⽇下午5:21:33* @param data 待加密的字节数组* @param cipher* @return* @throws Exception*/public static byte[] getBytes(byte[] data, Cipher cipher) throws Exception {int blockSize = cipher.getBlockSize(); // 返回块的⼤⼩int j = 0;ByteArrayOutputStream baos = new ByteArrayOutputStream();while (data.length - j * blockSize > 0) { // 将⼆进制数据分块写⼊ByteArrayOutputStream中 if(data.length - j * blockSize > blockSize) {baos.write(cipher.doFinal(data, j * blockSize, blockSize));}else{baos.write(cipher.doFinal(data, j * blockSize, data.length - j * blockSize));}j++;}baos.close();byte[] byteArray = baos.toByteArray();return byteArray;}/*** @desc 利⽤公钥进⾏加密* @createTime 2019年7⽉2⽇下午5:24:30* @param key 密钥对的⼀个* @param data 待加密字节数组* @return 密⽂* @throws Exception*/public static String encrypt(Key key, byte[] data) throws Exception {try {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.ENCRYPT_MODE, key);//加密byte[] bytes = getBytes(data, cipher);//2进⾏转换成16进制String result = CommonUtils.parseByte2HexStr(bytes);return new String(Base64.encode(result.getBytes(CommonUtils.CODE_TYPE)));} catch (Exception e) {logger.error("使⽤RSA公钥进⾏加密异常",e);throw new Exception("使⽤RSA公钥进⾏加密异常",e);}}/*** @desc 利⽤私钥进⾏解密* @createTime 2019年7⽉2⽇下午5:23:10* @param key 密钥对的⼀个* @param data 待解密的字节数组* @return 明⽂* @throws Exception*/public static String decrypt(Key key, byte[] data) throws Exception {try {Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());cipher.init(Cipher.DECRYPT_MODE, key); // ⽤密钥初始化此Cipher对象//16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(Base64.decode(data));//解密byte[] bs = getBytes(bytes, cipher);String content=new String(bs,CommonUtils.CODE_TYPE);return content;} catch (Exception e) {logger.error("使⽤RSA私钥进⾏解密异常",e);throw new Exception("使⽤RSA私钥进⾏解密异常",e);}}} 2，CommonUtils通⽤⼯具类：package cn.wangtao.utils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.io.IOException;import java.io.Reader;import java.io.Writer;/*** @ClassName CommonUtils* @Auth 桃⼦* @Date 2019-6-27 12:51* @Version 1.0* @Description**/public class CommonUtils {private static final Logger logger= LoggerFactory.getLogger(CommonUtils.class);//编码⽅式public static final String CODE_TYPE = "UTF-8";//字符补全private static final String[] consult = new String[]{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","G"}; //关流public static void closeReaderandWriter(Reader reader, Writer writer){if(writer!=null){try {writer.close();} catch (IOException e) {logger.error("关闭输出流失败",e);}}if(reader!=null){try {reader.close();} catch (IOException e) {logger.error("关闭输出流失败",e);}}}//将16进制转换为⼆进制public static byte[] parseHexStr2Byte(String hexStr) {if (hexStr.length() < 1)return null;byte[] result = new byte[hexStr.length()/2];for (int i = 0;i< hexStr.length()/2; i++) {int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);result[i] = (byte) (high * 16 + low);}return result;}//将⼆进制转换成16进制public static String parseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i < buf.length; i++) {String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}return sb.toString();}//补全字符public static String completionCodeFor16Bytes(String str) throws Exception {try{int num = str.getBytes(CODE_TYPE).length;int index = num%16;//进⾏加密内容补全操作, 加密内容应该为 16字节的倍数, 当不⾜16*n字节是进⾏补全, 差⼀位时补全16+1位 //补全字符以 $ 开始,$后⼀位代表$后补全字符位数,之后全部以0进⾏补全;if(index != 0){StringBuffer sbBuffer = new StringBuffer(str);if(16-index == 1){sbBuffer.append("$" + consult[16-1] + addStr(16-1-1));}else{sbBuffer.append("$" + consult[16-index-1] + addStr(16-index-1-1));}str = sbBuffer.toString();}return str;}catch (Exception e){logger.error("使⽤AES加密前补全字符异常",e);throw new Exception("使⽤AES加密前补全字符异常",e);}}//追加字符public static String addStr(int num){StringBuffer sbBuffer = new StringBuffer("");for (int i = 0; i < num; i++) {sbBuffer.append("0");}return sbBuffer.toString();}//还原字符(进⾏字符判断)public static String resumeCodeOf16Bytes(String str) throws Exception{int indexOf = stIndexOf("$");if(indexOf == -1){return str;}String trim = str.substring(indexOf+1,indexOf+2).trim();int num = 0;for (int i = 0; i < consult.length; i++) {if(trim.equals(consult[i])){num = i;}}if(num == 0){return str;}return str.substring(0,indexOf).trim();}}3，AESUtils通⽤⼯具类：package cn.wangtao.utils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import java.io.*;import java.security.interfaces.RSAPrivateKey;import java.util.Map;/*** @ClassName AESUtils* @Auth 桃⼦* @Date 2019-6-27 12:05* @Version 1.0* @Description**/public class AESUtils {private static final Logger logger= LoggerFactory.getLogger(AESUtils.class);//填充类型public static final String AES_TYPE = "AES/ECB/PKCS5Padding";private static final String AES = "AES"; // 加密⽅式public static final String DES_TYPE = "DES/ECB/PKCS5Padding";private static final String DES = "DES"; // 加密⽅式private final String defaultDesKey="11112222";//8位//对字符串加密public static String encryptStr(String content,String aesKey) throws Exception {try {SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(),AES );Cipher cipher = Cipher.getInstance(AES_TYPE);cipher.init(Cipher.ENCRYPT_MODE, key);//字符补全String content16Str = pletionCodeFor16Bytes(content);byte[] encryptedData = cipher.doFinal(content16Str.getBytes(CommonUtils.CODE_TYPE));//2进制转换成16进制String hexStr = CommonUtils.parseByte2HexStr(encryptedData);return hexStr;} catch (Exception e) {logger.error("使⽤AES对字符串加密异常",e);throw new Exception("使⽤AES对字符串加密异常",e);}}//对字符串解密public static String decryptStr(String content,String aesKey) throws Exception {try {//16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(content);SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(), AES);Cipher cipher = Cipher.getInstance(AES_TYPE);cipher.init(Cipher.DECRYPT_MODE, key);byte[] decryptedData = cipher.doFinal(bytes);String result=new String(decryptedData, CommonUtils.CODE_TYPE);//还原字符String orgResult = CommonUtils.resumeCodeOf16Bytes(result);return orgResult;} catch (Exception e) {logger.error("使⽤AES对字符串解密异常",e);throw new Exception("使⽤AES对字符串解密异常",e);}}//对⽂件加密public static File encryptFile(File orgFile, File encryptFile, Map<String,Object> context) throws Exception {("使⽤AES对⽂件加密开始，源⽂件地址[{}]加密后⽂件地址[{}]",orgFile.getPath(),encryptFile.getPath()); BufferedReader br=null;BufferedWriter bw=null;try{//获取AESKEY ，如果没有为默认String aesKey = (String) context.get(Dirt.AES_KEY);br=new BufferedReader(new FileReader(orgFile));bw=(BufferedWriter)context.get(Dirt.BUFFEREDWRITER);if(null==bw){bw=new BufferedWriter(new FileWriter(encryptFile));}String len=null;while (null!=(len=br.readLine())){String encrypt= encryptStr(len,aesKey);bw.write(encrypt);bw.newLine();bw.flush();}("使⽤AES对⽂件加密结束，源⽂件地址[{}]加密后⽂件地址[{}]",orgFile.getPath(),encryptFile.getPath());return encryptFile;}catch (Exception e){logger.error("使⽤AES对⽂件加密异常,源⽂件地址[{}]加密后⽂件地址[{}]",orgFile.getPath(),encryptFile.getPath(),e);throw new Exception("使⽤AES对⽂件加密异常",e);}finally {CommonUtils.closeReaderandWriter(br,bw);}}//对⽂本解密，返回解密⽂件后的⽂件public static File decryptFile(File decryptfile, File encryptFile,Map<String,Object> context) throws Exception {("使⽤AES对⽂件解密开始，源加密⽂件地址[{}]解密后⽂件地址[{}]",encryptFile.getPath(),decryptfile.getPath());BufferedReader br=null;BufferedWriter bw=null;try{if(decryptfile.exists()){decryptfile.delete();}//边读边加密边写br=new BufferedReader(new FileReader(encryptFile));bw=new BufferedWriter(new FileWriter(decryptfile));String len=null;String aesKey=null;//判断是否加密RSAPrivateKey privateKey= (RSAPrivateKey) context.get(Dirt.RSAPRIVATEKEY);if(null!=privateKey){StringBuffer sb=new StringBuffer();while ((len=br.readLine())!=null){sb.append(len);if(len.equals("\n")||len.equals("")||len.equals("\r\n")||len.equals("\r")){aesKey=RSAUtils.decryptStr(privateKey,sb.toString());break;}}}if(null==aesKey){aesKey=(String) context.get(Dirt.AES_KEY);}("aesKey[{}]",aesKey);if(aesKey!=null){while ((len=br.readLine())!=null){String decrypt= decryptStr(len,aesKey);bw.write(decrypt);bw.flush();bw.newLine();}}("使⽤AES对⽂件解密结束，源加密⽂件地址[{}]解密后⽂件地址[{}]",encryptFile.getPath(),decryptfile.getPath()); return decryptfile;}catch (Exception e){logger.error("使⽤AES对⽂件解密异常,源加密⽂件地址[{}]解密后⽂件地址[{}]",encryptFile.getPath(),decryptfile.getPath(),e); throw new Exception("使⽤AES对⽂件解密异常",e);}finally {CommonUtils.closeReaderandWriter(br,bw);}}}/*** @ClassName AESUtils* @Version 1.0* @Description AES⼯具类**/public class AESUtils {private static final Logger logger = LoggerFactory.getLogger(AESUtils.class);/** 加密⽅式 */public static final String AES = "AES";public static final String AES_Type = "AES/ECB/PKCS5Padding";/*** @desc 随机⽣成AES加密秘钥* @createTime 2019年7⽉2⽇下午5:36:00* @return 随机的AES的秘钥串 16位* @throws Exception*/public static String getAesKey() {Random random = new Random();String result = "";for(int i = 0; i< 16; i++){String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";// 输出字母还是数字if( "char".equalsIgnoreCase(charOrNum) ) {// 输出是⼤写字母还是⼩写字母// int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;result += (char)(random.nextInt(26) + 65);} else {result += String.valueOf(random.nextInt(10));}}return result;}/*** @desc AES加密操作* @createTime 2019年7⽉2⽇下午5:30:33* @param data 待加密字节数组* @param aesKey 秘钥串* @return 密⽂* @throws Exception*/public static String encrypt(byte[] data, String aesKey) throws Exception {try {SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(CommonUtils.CODE_TYPE), AES); Cipher cipher = Cipher.getInstance(AES);cipher.init(Cipher.ENCRYPT_MODE, key);byte[] encryptedData = cipher.doFinal(data);//2进制转换成16进制并返回密⽂String result = CommonUtils.parseByte2HexStr(encryptedData);return new String(Base64.encode(result.getBytes(CommonUtils.CODE_TYPE)));} catch (Exception e) {logger.error("使⽤AES对字符串加密异常", e);throw new Exception("使⽤AES对字符串加密异常", e);}}/*** @desc AES解密操作* @createTime 2019年7⽉2⽇下午5:31:37* @param data 待解密字节数组* @param aesKey 秘钥串* @return 明⽂* @throws Exception*/public static String decrypt(byte[] data, String aesKey) throws Exception {try {// 16进制转换成2进制byte[] bytes = CommonUtils.parseHexStr2Byte(Base64.decode(data));SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(CommonUtils.CODE_TYPE), AES); Cipher cipher = Cipher.getInstance(AES);cipher.init(Cipher.DECRYPT_MODE, key);//执⾏解密byte[] decryptedData = cipher.doFinal(bytes);//还原字符并返回return new String(decryptedData, CommonUtils.CODE_TYPE);} catch (Exception e) {logger.error("使⽤AES对字符串解密异常", e);throw new Exception("使⽤AES对字符串解密异常", e);}}} 4，Dirt常量package cn.wangtao.utils;import java.security.interfaces.RSAPublicKey;/*** @ClassName Dirt* @Auth 桃⼦* @Date 2019-6-27 14:20* @Version 1.0* @Description**/public class Dirt {public static final String UPLOADFILEURL="uploadFileUrl";public static final String AES_KEY="aesKey";public static final String RSAPUBLICKEY="rsaPublicKey";public static final String RSAPRIVATEKEY="rsaPrivateKey";public final static String RETURNCODE="returnCode";public final static String RETURNMSG="returnMsg";public final static String FILENAME="fileName";public final static String ORGFILENAME="orgFileName";public final static String ENCRYPTFILE="encryptFile";public static final String BUFFEREDWRITER="bufferedWriter"; //是为了在原始⽂件中进⾏补充加密 //返回码public final static String SUCCESSCODE="000000";public final static String FAILEDCODE="999999";//加密⽂件所放的⽬录public final static String BASELOCALDIR="XXX"; //基本⽬录路径public final static String ENCRYPTLOCALDIR="encrypt"; //加密⽂件⽬录}AES的介绍RSA的介绍。
JAVA使用DES加密解密
JAVA使⽤DES加密解密 在使⽤DES加密解密的时候，遇到了⼀些问题，廖记⼀下。
如有哪位⼤神亲临留⾔指点，不胜感激。
先上代码：public DESUtil() {}//密码，长度要是8的倍数注意此处为简单密码简单应⽤要求不⾼时可⽤此密码 /*DES是⼀种对称加密算法，所谓对称加密算法即：加密和解密使⽤相同密钥的算法。
DES加密算法出⾃IBM的研究，后来被美国政府正式采⽤，之后开始⼴泛流传，但是近些年使⽤越来越少，因为DES使⽤56位密钥，以现代计算能⼒，24⼩时内即可被破解。
*/private static String password = "9588888888880288";//测试public static void main(String args[]) {//待加密内容String str = "task_id=TSK_000000006870&ledger_id=0715-5572";String result = DESUtil.encrypt(str);BASE64Encoder base64en = new BASE64Encoder();// String strs = new String(base64en.encode(result));System.out.println("加密后："+result);//直接将如上内容解密try {String decryResult = DESUtil.decryptor(result);System.out.println("解密后："+new String(decryResult));} catch (Exception e1) {e1.printStackTrace();}}/**** @Method: encrypt* @Description: 加密数据* @param data* @return* @throws Exception* @date 2016年7⽉26⽇*/public static String encrypt(String data) { //对string进⾏BASE64Encoder转换byte[] bt = encryptByKey(data.getBytes(), password);BASE64Encoder base64en = new BASE64Encoder();String strs = new String(base64en.encode(bt));return strs;}/**** @Method: encrypt* @Description: 解密数据* @param data* @return* @throws Exception* @date 2016年7⽉26⽇*/public static String decryptor(String data) throws Exception { //对string进⾏BASE64Encoder转换sun.misc.BASE64Decoder base64en = new sun.misc.BASE64Decoder();byte[] bt = decrypt(base64en.decodeBuffer(data), password);String strs = new String(bt);return strs;}/*** 加密* @param datasource byte[]* @param password String* @return byte[]*/private static byte[] encryptByKey(byte[] datasource, String key) {try{SecureRandom random = new SecureRandom();DESKeySpec desKey = new DESKeySpec(key.getBytes());//创建⼀个密匙⼯⼚，然后⽤它把DESKeySpec转换成SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");SecretKey securekey = keyFactory.generateSecret(desKey);//Cipher对象实际完成加密操作Cipher cipher = Cipher.getInstance("DES");//⽤密匙初始化Cipher对象cipher.init(Cipher.ENCRYPT_MODE, securekey, random);//现在，获取数据并加密//正式执⾏加密操作return cipher.doFinal(datasource);}catch(Throwable e){e.printStackTrace();}return null;}/*** 解密* @param src byte[]* @param password String* @return byte[]* @throws Exception*/private static byte[] decrypt(byte[] src, String key) throws Exception {// DES算法要求有⼀个可信任的随机数源SecureRandom random = new SecureRandom();// 创建⼀个DESKeySpec对象DESKeySpec desKey = new DESKeySpec(key.getBytes());// 创建⼀个密匙⼯⼚SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");// 将DESKeySpec对象转换成SecretKey对象SecretKey securekey = keyFactory.generateSecret(desKey);// Cipher对象实际完成解密操作Cipher cipher = Cipher.getInstance("DES");// ⽤密匙初始化Cipher对象cipher.init(Cipher.DECRYPT_MODE, securekey, random);// 真正开始解密操作return cipher.doFinal(src);}解密过程中总有各种异常，有的说 SecureRandom 有问题需要换个⽅式⽣产随机数。
Java加密类文件保护方案设计与实现
Java加密类文件保护方案设计与实现摘要：java软件在知识产权的保护上面临着很大的安全风险。
本文针对java软件保护的需求，从java类加载机制入手，提出了加密类文件来实现软件保护的方案。
关键词：软件保护；java软件；秘钥软件是一切计算机应用的基础，满足不同行业、不同领域需求，面向各类应用的软件不断地孕育而生。
计算机软件是高级逻辑思维的产物，是典型的技术密集型产品，其价值集中体现在内部的核心技术中，一旦被窃取或者复制，由此带来的经济、社会损失有时是无法估量的。
软件保护就是在开发者被这种问题所困扰的情况下应运而生。
一、java软件保护面临的问题解析在对java体制和java类文件深入分析研究的基础上，人们从不同的角度出发，提出了多种保护技术，这些保护技术在一定程度上起到了保护java类文件的作用，但是都存在各自的缺点和不足。
本地化技术是以丧失java的跨平台性为代价的，而这恰恰是java 广受欢迎的重要原因，另外，目前的本地编译器还较不成熟，对java 类库的支持还远远不够。
远程接口访问技术只适用于分布式结构的应用软件，而无法应用于单机应用软件，同时这种方法也存在着很大的安全隐患，一旦应用服务器被攻破，那么部署在其上的全部类文件都会泄露出去，造成更大的损失。
数字水印技术目前被广泛的应用，但是数字水印技术不是一种主动的防御技术，而是一种被动的取证技术，只能在侵权行为己经发生，攻击者己经成功获得代码，为证明产权的归属提供证据时发挥作用，而不能从根本上用技术手段防止侵权行为的发生。
二、java加密类文件保护的可行性在java软件保护中，需要保护的内容是体现软件价值的创新之处和核心算法，这些都包含在不同的类文件中，如果能够确保核心类文件的内容不被攻击者获得就可以确保java软件的安全性。
密码学是研究利用数学算法将明文转变为不可能理解的密文和反过来将密文转变为可理解形式的明文的方法、手段和理论的一门科学。
java相关加密解密方法
java相关加密解密方法Java加密解密方法是保护数据安全的重要手段，本文将详细介绍几种常见的Java加密解密方法。
一、对称加密算法对称加密算法是一种使用相同的密钥进行加密和解密的算法。
这种加密方式简单高效，但存在密钥管理的问题，因为所有用户都必须知道密钥。
在Java中，常用的对称加密算法有DES、3DES、AES等。
1. DES：Data Encryption Standard，数据加密标准，是一种使用56位密钥的对称块密码算法。
在Java中，我们可以使用javax.crypto.Cipher类来实现DES 加密解密。
2. 3DES：Triple Data Encryption Algorithm，三重数据加密算法，是DES的增强版本，使用三个不同的56位密钥进行三次加密。
在Java中，我们同样可以使用Cipher类来实现3DES加密解密。
3. AES：Advanced Encryption Standard，高级加密标准，是一种使用128、192或256位密钥的对称块密码算法。
在Java中，我们可以使用Cipher类来实现AES加密解密。
二、非对称加密算法非对称加密算法是一种使用一对密钥（公钥和私钥）进行加密和解密的算法。
公钥可以公开给所有人，而私钥需要保密。
在Java中，常用的非对称加密算法有RSA、DSA等。
1. RSA：Rivest-Shamir-Adleman，一种基于大数因子分解难题的非对称加密算法。
在Java中，我们可以使用java.security.KeyPairGenerator类生成RSA密钥对，然后使用Cipher类进行RSA加密解密。
2. DSA：Digital Signature Algorithm，数字签名算法，是一种基于整数有限域离散对数难题的非对称加密算法。
在Java中，我们可以使用KeyPairGenerator类生成DSA密钥对，然后使用Signature类进行DSA签名和验证。
java rsa 加密解密流程
java rsa 加密解密流程RSA是一种非对称加密算法，用于数据的加密和解密。
它涉及到公钥和私钥的使用，其中公钥用于加密数据，私钥用于解密数据。
下面是Java中使用RSA 加密和解密的基本流程：1. 生成密钥对：首先需要生成一对RSA密钥，包括公钥和私钥。
可以使用Java提供的`KeyPairGenerator`类来生成密钥对。
```javaKeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");keyPairGenerator.initialize(2048); // 指定密钥长度KeyPair keyPair = keyPairGenerator.generateKeyPair();PublicKey publicKey = keyPair.getPublic();PrivateKey privateKey = keyPair.getPrivate();```2. 加密数据：使用公钥对需要加密的数据进行加密。
可以使用`Cipher`类来进行加密操作。
```javaString data = "Hello, World!";Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.ENCRYPT_MODE, publicKey);byte[] encryptedData = cipher.doFinal(data.getBytes());```3. 解密数据：使用私钥对加密后的数据进行解密，还原为原始数据。
```javacipher.init(Cipher.DECRYPT_MODE, privateKey);byte[] decryptedData = cipher.doFinal(encryptedData);String decryptedText = new String(decryptedData);```请注意，以上示例代码只是一个简单的RSA加密和解密流程的示例。
文本文档的加密与解密课程设计说明书
*******************实践教学*******************兰州理工大学计算机与通信学院2014年春季学期工程开发综合训练课程设计题目：文本文档的加密与解密专业班级：计算机科学与技术11级4班姓名：张有刚学号：指导教师：刘树群成绩：目录摘要.......................................... 错误!未定义书签。
1.问题描述 ................................... 错误!未定义书签。
2.系统设计 ................................... 错误!未定义书签。
3.系统实现 ................................... 错误!未定义书签。
4.系统测试 ................................... 错误!未定义书签。
5.总结 ....................................... 错误!未定义书签。
参考文献........................................ 错误!未定义书签。
摘要随着网络技术的不断发展，人们的个人信息、网络间的文件传递、电子商务等方面都需要大力的保护，文件加密技术也就随之产生。
文件的加密主要是由加密算法实现，加密算法有多种，常见的有RSA、DES、MD5等。
但是这些算法虽然原理简单，但具体实现起来却非常繁琐复杂，故而本程序设计对文件的加密使用的是最基础的异或加密算法。
Java语言具有简单、安全、可移植、面向对象、健壮、多线程、体系结构中立、解释执行、高性能、分布式和动态等主要特点。
Java是一门很优秀的编程语言，是目前软件设计中极为健壮的编程语言。
Java不仅可以用来开发大型的应用程序，而且特别适合于Internet的应用开发。
Java确实具备了“一次写成，处处运行”的特点，所以，Java已经成为网络时代最重要的编程语言之一。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
软件学院课程设计报告书课程名称面向对象程序设计设计题目文本文档的加密与解密专业班级财升本12-1班学号 1220970120 姓名王微微指导教师徐娇月2013年 1 月1 设计时间2013年1月14日-2013年1月18日2 设计目的面向对象程序设计是一门实践性很强的计算机专业基础课程。
通过实践加深学生对面向对象程序设计的理论、方法和基础知识的理解，掌握使用Java语言进行面向对象设计的基本方法，提高运用面向对象知识分析实际问题、解决实际问题的能力，提高学生的应用能力。
3 设计任务对文件进行加密解密4 设计内容4.1 需求分析(1)给定任意一个文本文件，进行加密，生成另一个文件。
(2)对加密后的文件还原。
4.2 总体设计4.2.1 包的描述导入了java.awt; java.awt.event; java.io; javax.swing等包。
4.2.2 类的描述Myframe类；E1类。
其中Myframe类继承Frame类；可以扩展Frame的功能并且可以实例化的多种功能，这个类也实现了ActionListener这个接口，它是Java中关于事件处理的一个接口，ActionListener用于接收操作事件的侦听器接口。
对处理操作事件感兴趣的类可以实现此接口，而使用该类创建的对象可使用组件的addActionListener 方法向该组件注册。
在发生操作事件时，调用该对象的actionPerformed 方法。
4.3 页面设计图4.3-1 显示页面代码实现：addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}});图4.3-2 选择所要加密的文本文件代码实现：public void actionPerformed(ActionEvent e)//查找读入文件{if(e.getSource()==itemOpen){filedialog_load.setVisible(true);texta.setText(null);String s;if(filedialog_load.getFile()!=null){try{File file=newFile(filedialog_load.getDirectory(),filedialog_load.getFile());FileReader file_reader=new FileReader(file);//读取字符流BufferedReader in=new BufferedReader(file_reader);while((s=in.readLine())!=null)texta.append(s+'\n');in.close();file_reader.close();}catch (IOException e1){}}}图4.3-3 加密后界面代码实现：if(e.getSource()==button1){char a[]=texta.getText().toCharArray();/*把texta中获得的文本，进行初始化，与原字符串长度相等，并将该字符串对象的全部字符复制到该数组a[]中*/texta.setText(null);int n;char secret=' ';for(int i=0;i<a.length;i++){char c=(char)(secret^a[i]);//进行异或运算texta.append(""+c);}}图4.3-4 解密后的界面代码实现：if(e.getSource()==button2){char a[]=texta.getText().toCharArray();texta.setText(null);int n;char secret=' ';for(int i=0;i<a.length;i++){char c=(char)(secret^a[i]);//再次异或运算，即还原texta.append(""+c);}}4.4 程序代码import java.awt.*;import java.awt.event.*;import java.io.*;import javax.swing.*;class Myframe extends Frame implements ActionListener{FileDialog filedialog_save,filedialog_load;Button button1,button2;Label label;MenuBar bar;Menu menu;MenuItem itemOpen,itemSave;TextArea texta;Myframe(String s) //创建对话框{super(s);texta= new TextArea(38,160);button1= new Button("加密");button2= new Button("解密");menu=new Menu("文件");itemOpen=new MenuItem("打开");itemSave=new MenuItem("保存");label=new Label("文件浏览窗口");itemOpen.addActionListener(this);itemSave.addActionListener(this);button1.addActionListener(this);button2.addActionListener(this);filedialog_save=new FileDialog(this,"保存文件对话框",FileDialog.SAVE); filedialog_load=new FileDialog(this,"打开文件对话框",FileDialog.LOAD); filedialog_save.addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){filedialog_save.setVisible(false);}});filedialog_load.addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){filedialog_load.setVisible(false);}});Box box1=Box.createHorizontalBox();//创建一个从左到右显示其组件的box1; Box box2=Box.createVerticalBox();//创建一个从上到下显示其组件的box2; Box box3=Box.createVerticalBox();Box boxbase=Box.createV erticalBox();Panel panel1=new Panel();Panel panel2=new Panel();setMenuBar(bar=new MenuBar());bar.add(menu);menu.add(itemOpen);menu.add(itemSave);panel1.add(button1);panel1.add(button2);box1.add(panel1);box2.add(label);panel2.add(texta);box3.add(panel2);boxbase.add(box1);boxbase.add(box2);boxbase.add(box3);add(boxbase);setLayout(new FlowLayout());setBounds(100,0,1200,750);setVisible(true);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}});}//“关闭”窗口事件;public void actionPerformed(ActionEvent e)//查找读入文件{if(e.getSource()==itemOpen){filedialog_load.setVisible(true);texta.setText(null);String s;if(filedialog_load.getFile()!=null){try{File file=newFile(filedialog_load.getDirectory(),filedialog_load.getFile());FileReader file_reader=new FileReader(file);//读取字符流BufferedReader in=new BufferedReader(file_reader);while((s=in.readLine())!=null)texta.append(s+'\n');in.close();file_reader.close();}catch (IOException e1){}}}if(e.getSource()==itemSave)//查找写入的文件{filedialog_save.setVisible(true);if(filedialog_save.getFile()!=null){try{File file=newFile(filedialog_save.getDirectory(),filedialog_save.getFile());FileWriter tofile=new FileWriter(file);//读取字符流BufferedWriter out=new BufferedWriter(tofile);out.write(texta.getText(),0,(texta.getText()).length());out.close();tofile.close();}catch (IOException e2){}}}if(e.getSource()==button1){char a[]=texta.getText().toCharArray();/*把texta中获得的文本，进行初始化，与原字符串长度相等，并将该字符串对象的全部字符复制到该数组a[]中*/texta.setText(null);int n;char secret=' ';for(int i=0;i<a.length;i++){char c=(char)(secret^a[i]);//进行异或运算texta.append(""+c);}}if(e.getSource()==button2){char a[]=texta.getText().toCharArray();texta.setText(null);int n;char secret=' ';for(int i=0;i<a.length;i++){char c=(char)(secret^a[i]);//再次异或运算，即还原texta.append(""+c);}}}}public class E1{public static void main(String args[]){Myframe frame = new Myframe("加密与解密");}}}}5 总结与展望在本次课程设计的过程中，我学到了很多，不仅对所学的知识有一个新的认识，认识到要做一个课程设计不仅需要我们有一种很严谨的态度和扎实的知识作为基础和后盾的，还要将理论知识与实际课题相结合起来，不仅培养了独立思考、动手操作的能力，在各种其它能力上也都有了提高。