注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

刘小龙

成功需要的是一场持久的战役!

 
 
 

日志

 
 

搜集的几个常用的加密Java代码工具类  

2015-04-07 17:13:45|  分类: 知识积累 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
一,Java的MD5加密一:
  1.    /** 
  2.      * MD5 加密 
  3.      */  
  4.     private String getMD5Str(String str) {  
  5.         MessageDigest messageDigest = null;  
  6.   
  7.         try {  
  8.             messageDigest = MessageDigest.getInstance("MD5");  
  9.   
  10.             messageDigest.reset();  
  11.   
  12.             messageDigest.update(str.getBytes("UTF-8"));  
  13.         } catch (NoSuchAlgorithmException e) {  
  14.             System.out.println("NoSuchAlgorithmException caught!");  
  15.             System.exit(-1);  
  16.         } catch (UnsupportedEncodingException e) {  
  17.             e.printStackTrace();  
  18.         }  
  19.   
  20.         byte[] byteArray = messageDigest.digest();  
  21.   
  22.         StringBuffer md5StrBuff = new StringBuffer();  
  23.   
  24.         for (int i = 0; i < byteArray.length; i++) {              
  25.             if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)  
  26.                 md5StrBuff.append("0").append(Integer.toHexString(0xFF & byteArray[i]));  
  27.             else  
  28.                 md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));  
  29.         }  
  30.   
  31.         return md5StrBuff.toString();  
  32.     }  


二,Java的MD5加密二:
  1. import java.security.MessageDigest;  
  2. public class MD5Util {  
  3.     public final static String MD5(String s) {  
  4.         char hexDigits[] = { '0''1''2''3''4',  
  5.                              '5''6''7''8''9',  
  6.                              'A''B''C''D''E''F' };  
  7.         try {  
  8.             byte[] btInput = s.getBytes();  
  9.      //获得MD5摘要算法的 MessageDigest 对象  
  10.             MessageDigest mdInst = MessageDigest.getInstance("MD5");  
  11.      //使用指定的字节更新摘要  
  12.             mdInst.update(btInput);  
  13.      //获得密文  
  14.             byte[] md = mdInst.digest();  
  15.      //把密文转换成十六进制的字符串形式  
  16.             int j = md.length;  
  17.             char str[] = new char[j * 2];  
  18.             int k = 0;  
  19.             for (int i = 0; i < j; i++) {  
  20.                 byte byte0 = md[i];  
  21.                 str[k++] = hexDigits[byte0 >>> 4 & 0xf];  
  22.                 str[k++] = hexDigits[byte0 & 0xf];  
  23.             }  
  24.             return new String(str);  
  25.         }  
  26.         catch (Exception e) {  
  27.             e.printStackTrace();  
  28.             return null;  
  29.         }  
  30.     }  
  31.     public static void main(String[] args) {  
  32.         System.out.print(MD5Util.MD5("password"));  
  33.     }  


三,Java的Md5测试例子:

  1. package com.zyg.security.md5;  
  2.   
  3. import java.io.UnsupportedEncodingException;  
  4. import java.security.MessageDigest;  
  5. import java.security.NoSuchAlgorithmException;  
  6. import java.security.SecureRandom;  
  7. import java.util.Arrays;  
  8.   
  9. public class MyMD5Util {  
  10.       
  11.     private static final String HEX_NUMS_STR="0123456789ABCDEF";  
  12.     private static final Integer SALT_LENGTH = 12;  
  13.       
  14.     /**  
  15.      * 将16进制字符串转换成字节数组  
  16.      * @param hex  
  17.      * @return  
  18.      */  
  19.     public static byte[] hexStringToByte(String hex) {  
  20.         int len = (hex.length() / 2);  
  21.         byte[] result = new byte[len];  
  22.         char[] hexChars = hex.toCharArray();  
  23.         for (int i = 0; i < len; i++) {  
  24.             int pos = i * 2;  
  25.             result[i] = (byte) (HEX_NUMS_STR.indexOf(hexChars[pos]) << 4   
  26.                             | HEX_NUMS_STR.indexOf(hexChars[pos + 1]));  
  27.         }  
  28.         return result;  
  29.     }  
  30.   
  31.       
  32.     /** 
  33.      * 将指定byte数组转换成16进制字符串 
  34.      * @param b 
  35.      * @return 
  36.      */  
  37.     public static String byteToHexString(byte[] b) {  
  38.         StringBuffer hexString = new StringBuffer();  
  39.         for (int i = 0; i < b.length; i++) {  
  40.             String hex = Integer.toHexString(b[i] & 0xFF);  
  41.             if (hex.length() == 1) {  
  42.                 hex = '0' + hex;  
  43.             }  
  44.             hexString.append(hex.toUpperCase());  
  45.         }  
  46.         return hexString.toString();  
  47.     }  
  48.       
  49.     /** 
  50.      * 验证口令是否合法 
  51.      * @param password 
  52.      * @param passwordInDb 
  53.      * @return 
  54.      * @throws NoSuchAlgorithmException 
  55.      * @throws UnsupportedEncodingException 
  56.      */  
  57.     public static boolean validPassword(String password, String passwordInDb)  
  58.             throws NoSuchAlgorithmException, UnsupportedEncodingException {  
  59.         //将16进制字符串格式口令转换成字节数组  
  60.         byte[] pwdInDb = hexStringToByte(passwordInDb);  
  61.         //声明盐变量  
  62.         byte[] salt = new byte[SALT_LENGTH];  
  63.         //将盐从数据库中保存的口令字节数组中提取出来  
  64.         System.arraycopy(pwdInDb, 0, salt, 0, SALT_LENGTH);  
  65.         //创建消息摘要对象  
  66.         MessageDigest md = MessageDigest.getInstance("MD5");  
  67.         //将盐数据传入消息摘要对象  
  68.         md.update(salt);  
  69.         //将口令的数据传给消息摘要对象  
  70.         md.update(password.getBytes("UTF-8"));  
  71.         //生成输入口令的消息摘要  
  72.         byte[] digest = md.digest();  
  73.         //声明一个保存数据库中口令消息摘要的变量  
  74.         byte[] digestInDb = new byte[pwdInDb.length - SALT_LENGTH];  
  75.         //取得数据库中口令的消息摘要  
  76.         System.arraycopy(pwdInDb, SALT_LENGTH, digestInDb, 0, digestInDb.length);  
  77.         //比较根据输入口令生成的消息摘要和数据库中消息摘要是否相同  
  78.         if (Arrays.equals(digest, digestInDb)) {  
  79.             //口令正确返回口令匹配消息  
  80.             return true;  
  81.         } else {  
  82.             //口令不正确返回口令不匹配消息  
  83.             return false;  
  84.         }  
  85.     }  
  86.   
  87.   
  88.     /** 
  89.      * 获得加密后的16进制形式口令 
  90.      * @param password 
  91.      * @return 
  92.      * @throws NoSuchAlgorithmException 
  93.      * @throws UnsupportedEncodingException 
  94.      */  
  95.     public static String getEncryptedPwd(String password)  
  96.             throws NoSuchAlgorithmException, UnsupportedEncodingException {  
  97.         //声明加密后的口令数组变量  
  98.         byte[] pwd = null;  
  99.         //随机数生成器  
  100.         SecureRandom random = new SecureRandom();  
  101.         //声明盐数组变量  
  102.         byte[] salt = new byte[SALT_LENGTH];  
  103.         //将随机数放入盐变量中  
  104.         random.nextBytes(salt);  
  105.   
  106.         //声明消息摘要对象  
  107.         MessageDigest md = null;  
  108.         //创建消息摘要  
  109.         md = MessageDigest.getInstance("MD5");  
  110.         //将盐数据传入消息摘要对象  
  111.         md.update(salt);  
  112.         //将口令的数据传给消息摘要对象  
  113.         md.update(password.getBytes("UTF-8"));  
  114.         //获得消息摘要的字节数组  
  115.         byte[] digest = md.digest();  
  116.   
  117.         //因为要在口令的字节数组中存放盐,所以加上盐的字节长度  
  118.         pwd = new byte[digest.length + SALT_LENGTH];  
  119.         //将盐的字节拷贝到生成的加密口令字节数组的前12个字节,以便在验证口令时取出盐  
  120.         System.arraycopy(salt, 0, pwd, 0, SALT_LENGTH);  
  121.         //将消息摘要拷贝到加密口令字节数组从第13个字节开始的字节  
  122.         System.arraycopy(digest, 0, pwd, SALT_LENGTH, digest.length);  
  123.         //将字节数组格式加密后的口令转化为16进制字符串格式的口令  
  124.         return byteToHexString(pwd);  
  125.     }  
  126. }  

 

测试类——Client,代码如下:

  1. package com.zyg.security.md5;  
  2.   
  3. import java.io.UnsupportedEncodingException;  
  4. import java.security.NoSuchAlgorithmException;  
  5. import java.util.HashMap;  
  6. import java.util.Map;  
  7.   
  8. public class Client {  
  9.     private static Map users = new HashMap();  
  10.       
  11.     public static void main(String[] args){  
  12.         String userName = "zyg";  
  13.         String password = "123";  
  14.         registerUser(userName,password);  
  15.           
  16.         userName = "changong";  
  17.         password = "456";  
  18.         registerUser(userName,password);  
  19.           
  20.         String loginUserId = "zyg";  
  21.         String pwd = "1232";  
  22.         try {  
  23.             if(loginValid(loginUserId,pwd)){  
  24.                 System.out.println("欢迎登陆!!!");  
  25.             }else{  
  26.                 System.out.println("口令错误,请重新输入!!!");  
  27.             }  
  28.         } catch (NoSuchAlgorithmException e) {  
  29.             // TODO Auto-generated catch block  
  30.             e.printStackTrace();  
  31.         } catch (UnsupportedEncodingException e) {  
  32.             // TODO Auto-generated catch block  
  33.             e.printStackTrace();  
  34.         }   
  35.     }  
  36.       
  37.     /** 
  38.      * 注册用户 
  39.      *  
  40.      * @param userName 
  41.      * @param password 
  42.      */  
  43.     public static void registerUser(String userName,String password){  
  44.         String encryptedPwd = null;  
  45.         try {  
  46.             encryptedPwd = MyMD5Util.getEncryptedPwd(password);  
  47.               
  48.             users.put(userName, encryptedPwd);  
  49.               
  50.         } catch (NoSuchAlgorithmException e) {  
  51.             // TODO Auto-generated catch block  
  52.             e.printStackTrace();  
  53.         } catch (UnsupportedEncodingException e) {  
  54.             // TODO Auto-generated catch block  
  55.             e.printStackTrace();  
  56.         }  
  57.     }  
  58.       
  59.     /** 
  60.      * 验证登陆 
  61.      *  
  62.      * @param userName 
  63.      * @param password 
  64.      * @return 
  65.      * @throws UnsupportedEncodingException  
  66.      * @throws NoSuchAlgorithmException  
  67.      */  
  68.     public static boolean loginValid(String userName,String password)   
  69.                 throws NoSuchAlgorithmException, UnsupportedEncodingException{  
  70.         String pwdInDb = (String)users.get(userName);  
  71.         if(null!=pwdInDb){ // 该用户存在  
  72.                 return MyMD5Util.validPassword(password, pwdInDb);  
  73.         }else{  
  74.             System.out.println("不存在该用户!!!");  
  75.             return false;  
  76.         }  
  77.     }  
  78. }  

四,BASE64,MD5,SHA,HMAC加密與解密算法(java)

复制代码
  1 package com.ice.webos.util.security;
2
3 import java.io.UnsupportedEncodingException;
4 import java.math.BigInteger;
5 import java.security.Key;
6 import java.security.MessageDigest;
7 import java.security.SecureRandom;
8
9 import javax.crypto.Cipher;
10 import javax.crypto.KeyGenerator;
11 import javax.crypto.Mac;
12 import javax.crypto.SecretKey;
13 import javax.crypto.SecretKeyFactory;
14 import javax.crypto.spec.DESKeySpec;
15 import javax.crypto.spec.SecretKeySpec;
16
17 import sun.misc.BASE64Decoder;
18 import sun.misc.BASE64Encoder;
19
20 /**
21 * <ul>
22 * <li>BASE64的加密解密是双向的,可以求反解。</li>
23 * <li>MD5、SHA以及HMAC是单向加密,任何数据加密后只会产生唯一的一个加密串,通常用来校验数据在传输过程中是否被修改。</li>
24 * <li>HMAC算法有一个密钥,增强了数据传输过程中的安全性,强化了算法外的不可控因素。</li>
25 * <li>DES DES-Data Encryption Standard,即数据加密算法。
26 * DES算法的入口参数有三个:Key、Data、Mode。
27 * <ul>
28 * <li>Key:8个字节共64位,是DES算法的工作密钥;</li>
29 * <li>Data:8个字节64位,是要被加密或被解密的数据;</li>
30 * <li>Mode:DES的工作方式,有两种:加密或解密。</li>
31 * </ul>
32 * </li>
33 * <ul>
34 *
35 * @author Ice_Liu
36 *
37 */
38 public class CryptUtil {
39 private static final String KEY_MD5 = "MD5";
40 private static final String KEY_SHA = "SHA";
41 /**
42 * MAC算法可选以下多种算法
43 *
44 * <pre>
45 *
46 * HmacMD5
47 * HmacSHA1
48 * HmacSHA256
49 * HmacSHA384
50 * HmacSHA512
51 * </pre>
52 */
53 public static final String KEY_MAC = "HmacMD5";
54
55 /**
56 * BASE64解密
57 *
58 * @param key
59 * @return
60 * @throws Exception
61 */
62 public static byte[] decryptBASE64(String key) throws Exception {
63 return (new BASE64Decoder()).decodeBuffer(key);
64 }
65
66 /**
67 * BASE64 加密
68 *
69 * @param key
70 * @return
71 * @throws Exception
72 */
73 public static String encryptBASE64(byte[] key) throws Exception {
74 return (new BASE64Encoder()).encodeBuffer(key);
75 }
76
77 /**
78 * MD5加密
79 *
80 * @param data
81 * @return
82 * @throws Exception
83 */
84 public static byte[] encryptMD5(byte[] data) throws Exception {
85
86 MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
87 md5.update(data);
88
89 return md5.digest();
90
91 }
92
93 /**
94 * SHA加密
95 *
96 * @param data
97 * @return
98 * @throws Exception
99 */
100 public static byte[] encryptSHA(byte[] data) throws Exception {
101
102 MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
103 sha.update(data);
104
105 return sha.digest();
106
107 }
108
109 /**
110 * 初始化HMAC密钥
111 *
112 * @return
113 * @throws Exception
114 */
115 public static String initMacKey() throws Exception {
116 KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
117 SecretKey secretKey = keyGenerator.generateKey();
118 return encryptBASE64(secretKey.getEncoded());
119 }
120
121 /**
122 * HMAC 加密
123 *
124 * @param data
125 * @param key
126 * @return
127 * @throws Exception
128 */
129 public static byte[] encryptHMAC(byte[] data, String key) throws Exception {
130 SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
131 Mac mac = Mac.getInstance(secretKey.getAlgorithm());
132 mac.init(secretKey);
133 return mac.doFinal(data);
134 }
135
136 /**
137 * DES 算法 <br>
138 * 可替换为以下任意一种算法,同时key值的size相应改变。
139 *
140 * <pre>
141 * DES key size must be equal to 56
142 * DESede(TripleDES) key size must be equal to 112 or 168
143 * AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
144 * Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
145 * RC2 key size must be between 40 and 1024 bits
146 * RC4(ARCFOUR) key size must be between 40 and 1024 bits
147 * </pre>
148 */
149 public static final String ALGORITHM = "DES";
150
151 /**
152 * DES 算法转换密钥<br>
153 *
154 * @param key
155 * @return
156 * @throws Exception
157 */
158 private static Key toKey(byte[] key) throws Exception {
159 SecretKey secretKey = null;
160 if (ALGORITHM.equals("DES") || ALGORITHM.equals("DESede")) {
161 DESKeySpec dks = new DESKeySpec(key);
162 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
163 secretKey = keyFactory.generateSecret(dks);
164 } else {
165 // 当使用其他对称加密算法时,如AES、Blowfish等算法时,用下述代码替换上述三行代码
166 secretKey = new SecretKeySpec(key, ALGORITHM);
167 }
168 return secretKey;
169 }
170
171 /**
172 * DES 算法解密
173 *
174 * @param data
175 * @param key
176 * @return
177 * @throws Exception
178 */
179 public static byte[] decrypt(byte[] data, String key) throws Exception {
180 Key k = toKey(decryptBASE64(key));
181 Cipher cipher = Cipher.getInstance(ALGORITHM);
182 cipher.init(Cipher.DECRYPT_MODE, k);
183 return cipher.doFinal(data);
184 }
185
186 /**
187 * DES 算法加密
188 *
189 * @param data
190 * @param key
191 * @return
192 * @throws Exception
193 */
194 public static byte[] encrypt(byte[] data, String key) throws Exception {
195 Key k = toKey(decryptBASE64(key));
196 Cipher cipher = Cipher.getInstance(ALGORITHM);
197 cipher.init(Cipher.ENCRYPT_MODE, k);
198 return cipher.doFinal(data);
199 }
200
201 /**
202 * DES 算法生成密钥
203 *
204 * @return
205 * @throws Exception
206 */
207 public static String initKey() throws Exception {
208 return initKey(null);
209 }
210
211 /**
212 * DES 算法生成密钥
213 *
214 * @param seed
215 * @return
216 * @throws Exception
217 */
218 public static String initKey(String seed) throws Exception {
219 SecureRandom secureRandom = null;
220 if (seed != null) {
221 secureRandom = new SecureRandom(decryptBASE64(seed));
222 } else {
223 secureRandom = new SecureRandom();
224 }
225 KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
226 kg.init(secureRandom);
227 SecretKey secretKey = kg.generateKey();
228 return encryptBASE64(secretKey.getEncoded());
229 }
230
231 public static void main(String[] args) {
232 try {
233 String s = "阿伯才的覆盖";
234 String b = CryptUtil.encryptBASE64(s.getBytes("UTF-8"));
235 System.out.println("BASE64加密后:" + b);
236 byte[] c = CryptUtil.decryptBASE64(b);
237 System.out.println("BASE64解密后:" + new String(c, "UTF-8"));
238
239 c = encryptMD5(s.getBytes());
240 System.out.println("MD5 加密后:" + new BigInteger(c).toString(16));
241
242 c = encryptSHA(s.getBytes());
243 System.out.println("SHA 加密后:" + new BigInteger(c).toString(16));
244
245 String key = initMacKey();
246 System.out.println("HMAC密匙:" + key);
247 c = encryptHMAC(s.getBytes(), key);
248 System.out.println("HMAC 加密后:" + new BigInteger(c).toString(16));
249
250 key = initKey();
251 System.out.println(ALGORITHM + "密钥:\t" + key);
252 c = encrypt(s.getBytes("UTF-8"), key);
253 System.out.println(ALGORITHM + " 加密后:" + new BigInteger(c).toString(16));
254 c = decrypt(c, key);
255 System.out.println(ALGORITHM + " 解密后:" + new String(c, "UTF-8"));
256 } catch (UnsupportedEncodingException e) {
257 // TODO Auto-generated catch block
258 e.printStackTrace();
259 } catch (Exception e) {
260 // TODO Auto-generated catch block
261 e.printStackTrace();
262 }
263 }
264 }
复制代码

 

            

  评论这张
 
阅读(48)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017