设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java加密解密工具（适用于JavaSE/JavaEE/Android）

2016-7-29 15:37| 发布者: zhangjf| 查看: 642| 评论: 0

摘要: 本文实例为大家分享了一个适用于JavaSE/JavaEE/Android的Java加密解密工具，供大家学习，具体内容如下 package longshu.utils.security; import java.lang.reflect.Method;import java.security.InvalidKeyException ...

本文实例为大家分享了一个适用于JavaSE/JavaEE/Android的Java加密解密工具，供大家学习，具体内容如下

  2. package longshu.utils.security;
  4. import java.lang.reflect.Method;
  5. import java.security.InvalidKeyException;
  6. import java.security.Key;
  7. import java.security.MessageDigest;
  8. import java.security.NoSuchAlgorithmException;
  9. import java.security.SecureRandom;
  11. import javax.crypto.BadPaddingException;
  12. import javax.crypto.Cipher;
  13. import javax.crypto.IllegalBlockSizeException;
  14. import javax.crypto.KeyGenerator;
  15. import javax.crypto.NoSuchPaddingException;
  16. import javax.crypto.SecretKey;
  17. import javax.crypto.spec.SecretKeySpec;
  19. /**
  20. * Java加密解密工具.
  21. * JavaSE/JavaEE/Android都适用
  22. *
  23. * @author longshu 2016年4月13日
  24. */
  25. public class EncryptDecrypt {
  26. // 无需创建对象
  27. private EncryptDecrypt() {
  28. }
  30. /**
  31. * SHA1加密Bit数据
  32. * @param source byte数组
  33. * @return 加密后的byte数组
  34. */
  35. public static byte[] SHA1Bit(byte[] source) {
  36. try {
  37. MessageDigest sha1Digest = MessageDigest.getInstance("SHA-1");
  38. sha1Digest.update(source);
  39. byte targetDigest[] = sha1Digest.digest();
  40. return targetDigest;
  41. } catch (NoSuchAlgorithmException e) {
  42. throw new RuntimeException(e);
  43. }
  44. }
  46. /**
  47. * SHA1加密字符串数据
  48. * @param source 要加密的字符串
  49. * @return 加密后的字符串
  50. */
  51. public static String SHA1(String source) {
  52. return byte2HexStr(SHA1Bit(source.getBytes()));
  53. }
  55. /**
  56. * MD5加密Bit数据
  57. * @param source byte数组
  58. * @return 加密后的byte数组
  59. */
  60. public static byte[] MD5Bit(byte[] source) {
  61. try {
  62. // 获得MD5摘要算法的 MessageDigest对象
  63. MessageDigest md5Digest = MessageDigest.getInstance("MD5");
  64. // 使用指定的字节更新摘要
  65. md5Digest.update(source);
  66. // 获得密文
  67. return md5Digest.digest();
  68. } catch (NoSuchAlgorithmException e) {
  69. throw new RuntimeException(e);
  70. }
  71. }
  73. /**
  74. * MD5加密字符串,32位长
  75. * @param source 要加密的内容
  76. * @return 加密后的内容
  77. */
  78. public static String MD5(String source) {
  79. return byte2HexStr(MD5Bit(source.getBytes()));
  80. }
  82. /**
  83. * BASE64编码
  84. * @param source 要编码的字符串
  85. * @return 编码过的字符串
  86. */
  87. public static String encodeBASE64(String source) {
  88. Class<?> clazz = null;
  89. Method encodeMethod = null;
  90. try {// 优先使用第三方库
  91. clazz = Class.forName("org.apache.commons.codec.binary.Base64");
  92. encodeMethod = clazz.getMethod("encodeBase64", byte[].class);
  93. System.out.println("encodeBASE64-->" + clazz);
  94. System.out.println("encodeMethod-->" + encodeMethod);
  95. // 反射方法 静态方法执行无需对象
  96. return new String((byte[]) encodeMethod.invoke(null, source.getBytes()));
  97. } catch (ClassNotFoundException e) {
  98. String vm = System.getProperty("java.vm.name");
  99. System.out.println(vm);
  100. try {
  101. if ("Dalvik".equals(vm)) {// Android
  102. clazz = Class.forName("android.util.Base64");
  103. // byte[] Base64.encode(byte[] input,int flags)
  104. encodeMethod = clazz.getMethod("encode", byte[].class, int.class);
  105. System.out.println("encodeBASE64-->" + clazz);
  106. System.out.println("encodeMethod-->" + encodeMethod);
  107. return new String((byte[]) encodeMethod.invoke(null, source.getBytes(), 0));
  108. } else {// JavaSE/JavaEE
  109. clazz = Class.forName("sun.misc.BASE64Encoder");
  110. encodeMethod = clazz.getMethod("encode", byte[].class);
  111. System.out.println("encodeBASE64-->" + clazz);
  112. System.out.println("encodeMethod-->" + encodeMethod);
  113. return (String) encodeMethod.invoke(clazz.newInstance(), source.getBytes());
  114. }
  115. } catch (ClassNotFoundException e1) {
  116. return null;
  117. } catch (Exception e1) {
  118. return null;
  119. }
  120. } catch (Exception e) {
  121. return null;
  122. }
  123. /*
  124. * Android
  125. * android.util.Base64
  126. */
  127. // return Base64.encodeToString(source, Base64.DEFAULT);
  128. // return new String(Base64.encode(source.getBytes(), Base64.DEFAULT));
  130. /*
  131. * JavaSE/JavaEE
  132. */
  133. // sun.misc.BASE64Encoder
  134. // BASE64Encoder encoder = new BASE64Encoder();
  135. // return encoder.encode(source.getBytes());
  137. // org.apache.commons.codec.binary.Base64
  138. // return new String(Base64.encodeBase64(source.getBytes()));
  139. }
  141. /**
  142. * BASE64解码
  143. * @param encodeSource 编码过的字符串
  144. * @return 编码前的字符串
  145. */
  146. public static String decodeBASE64(String encodeSource) {
  147. Class<?> clazz = null;
  148. Method decodeMethod = null;
  150. try {// 优先使用第三方库
  151. clazz = Class.forName("org.apache.commons.codec.binary.Base64");
  152. decodeMethod = clazz.getMethod("decodeBase64", byte[].class);
  153. System.out.println("decodeBASE64-->" + clazz);
  154. System.out.println("decodeMethod-->" + decodeMethod);
  155. // 反射方法 静态方法执行无需对象
  156. return new String((byte[]) decodeMethod.invoke(null, encodeSource.getBytes()));
  157. } catch (ClassNotFoundException e) {
  158. String vm = System.getProperty("java.vm.name");
  159. System.out.println(vm);
  160. try {
  161. if ("Dalvik".equals(vm)) {// Android
  162. clazz = Class.forName("android.util.Base64");
  163. // byte[] Base64.decode(byte[] input, int flags)
  164. decodeMethod = clazz.getMethod("decode", byte[].class, int.class);
  165. System.out.println("decodeBASE64-->" + clazz);
  166. System.out.println("decodeMethod-->" + decodeMethod);
  167. return new String((byte[]) decodeMethod.invoke(null, encodeSource.getBytes(), 0));
  168. } else { // JavaSE/JavaEE
  169. clazz = Class.forName("sun.misc.BASE64Decoder");
  170. decodeMethod = clazz.getMethod("decodeBuffer", String.class);
  171. System.out.println("decodeBASE64-->" + clazz);
  172. System.out.println("decodeMethod-->" + decodeMethod);
  173. return new String((byte[]) decodeMethod.invoke(clazz.newInstance(), encodeSource));
  174. }
  175. } catch (ClassNotFoundException e1) {
  176. return null;
  177. } catch (Exception e1) {
  178. return null;
  179. }
  180. } catch (Exception e) {
  181. return null;
  182. }
  183. /*
  184. * Android
  185. * android.util.Base64
  186. */
  187. // return new
  188. // String(Base64.decode(encodeSource.getBytes(),Base64.DEFAULT));
  190. /*
  191. * JavaSE/JavaEE
  192. */
  193. // sun.misc.BASE64Decoder
  194. // try {
  195. // BASE64Decoder decoder = new BASE64Decoder();
  196. // return new String(decoder.decodeBuffer(encodeSource));
  197. // } catch (IOException e) {
  198. // throw new RuntimeException(e);
  199. // }
  201. // org.apache.commons.codec.binary.Base64
  202. // return new String(Base64.decodeBase64(encodeSource.getBytes()));
  203. }
  205. /**
  206. * AES加密
  207. * @param content 待加密的内容
  208. * @param password 加密密码
  209. * @return
  210. */
  211. public static byte[] encryptBitAES(byte[] content, String password) {
  212. try {
  213. Cipher encryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// 创建密码器
  214. encryptCipher.init(Cipher.ENCRYPT_MODE, getKey(password));// 初始化
  215. byte[] result = encryptCipher.doFinal(content);
  216. return result; // 加密
  217. } catch (NoSuchAlgorithmException e) {
  218. e.printStackTrace();
  219. } catch (NoSuchPaddingException e) {
  220. e.printStackTrace();
  221. } catch (InvalidKeyException e) {
  222. e.printStackTrace();
  223. } catch (IllegalBlockSizeException e) {
  224. e.printStackTrace();
  225. } catch (BadPaddingException e) {
  226. e.printStackTrace();
  227. }
  228. return null;
  229. }
  231. /**
  232. * AES解密
  233. * @param content 待解密内容
  234. * @param password 解密密钥
  235. * @return
  236. */
  237. public static byte[] decryptBitAES(byte[] content, String password) {
  238. try {
  239. Cipher decryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// 创建密码器
  240. decryptCipher.init(Cipher.DECRYPT_MODE, getKey(password));// 初始化
  241. byte[] result = decryptCipher.doFinal(content);
  242. return result; // 加密结果
  243. } catch (InvalidKeyException e) {
  244. e.printStackTrace();
  245. } catch (NoSuchAlgorithmException e) {
  246. e.printStackTrace();
  247. } catch (NoSuchPaddingException e) {
  248. e.printStackTrace();
  249. } catch (IllegalBlockSizeException e) {
  250. e.printStackTrace();
  251. } catch (BadPaddingException e) {
  252. e.printStackTrace();
  253. }
  254. return null;
  255. }
  257. /**
  258. * AES字符串加密
  259. * @param content 待加密的内容
  260. * @param password 加密密码
  261. * @return
  262. */
  263. public static String encryptAES(String content, String password) {
  264. return byte2HexStr(encryptBitAES(content.getBytes(), password));
  265. }
  267. /**
  268. * AES字符串解密
  269. * @param content 待解密内容
  270. * @param password 解密密钥
  271. * @return
  272. */
  273. public static String decryptAES(String content, String password) {
  274. return new String(decryptBitAES(hexStr2Bytes(content), password));
  275. }
  277. /**
  278. * 从指定字符串生成密钥
  279. * @param password 构成该秘钥的字符串
  280. * @return 生成的密钥
  281. * @throws NoSuchAlgorithmException
  282. */
  283. private static Key getKey(String password) throws NoSuchAlgorithmException {
  284. SecureRandom secureRandom = new SecureRandom(password.getBytes());
  285. // 生成KEY
  286. KeyGenerator kgen = KeyGenerator.getInstance("AES");
  287. kgen.init(128, secureRandom);
  288. SecretKey secretKey = kgen.generateKey();
  289. byte[] enCodeFormat = secretKey.getEncoded();
  290. // 转换KEY
  291. SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
  292. return key;
  293. }
  295. /**
  296. * 将byte数组转换为表示16进制值的字符串.
  297. * 如：byte[]{8,18}转换为：0812
  298. * 和 byte[] hexStr2Bytes(String strIn) 互为可逆的转换过程.
  299. * @param bytes 需要转换的byte数组
  300. * @return 转换后的字符串
  301. */
  302. public static String byte2HexStr(byte[] bytes) {
  303. int bytesLen = bytes.length;
  304. // 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍
  305. StringBuffer hexString = new StringBuffer(bytesLen * 2);
  306. for (int i = 0; i < bytesLen; i++) {
  307. // 将每个字节与0xFF进行与运算，然后转化为10进制，然后借助于Integer再转化为16进制
  308. String hex = Integer.toHexString(bytes[i] & 0xFF);
  309. if (hex.length() < 2) {
  310. hexString.append(0);// 如果为1位 前面补个0
  311. }
  312. hexString.append(hex);
  313. }
  314. return hexString.toString();
  315. }
  317. /**
  318. * 将表示16进制值的字符串转换为byte数组,
  319. * 和 String byte2HexStr(byte[] bytes) 互为可逆的转换过程.
  320. * @param bytes
  321. * @return 转换后的byte数组
  322. */
  323. public static byte[] hexStr2Bytes(String strIn) {
  324. byte[] arrB = strIn.getBytes();
  325. int iLen = arrB.length;
  327. // 两个字符表示一个字节，所以字节数组长度是字符串长度除以2
  328. byte[] arrOut = new byte[iLen / 2];
  329. for (int i = 0; i < iLen; i = i + 2) {
  330. String strTmp = new String(arrB, i, 2);
  331. arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
  332. }
  333. return arrOut;
  334. }
  336. }
复制代码

以上就是本文的全部内容，希望对大家学习java程序设计有所帮助。

收藏 邀请
上一篇：Java FTPClient实现文件上传下载下一篇：Java使用递归法解决汉诺塔问题的代码示例

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-5-8 01:17

Copyright 2015-2025 djqfx

返回顶部