java加密解密算法记录

以下内容均摘自我买的书籍《java加密与解密的艺术》作者 梁栋

   

   

1. package com.algorithm;     
2.      
3. import java.security.Key;     
4. import java.security.KeyFactory;     
5. import java.security.KeyPair;     
6. import java.security.KeyPairGenerator;     
7. import java.security.PrivateKey;     
8. import java.security.PublicKey;     
9. import java.security.Signature;     
10. import java.security.interfaces.RSAPrivateKey;     
11. import java.security.interfaces.RSAPublicKey;     
12. import java.security.spec.PKCS8EncodedKeySpec;     
13. import java.security.spec.X509EncodedKeySpec;     
14. import java.util.HashMap;     
15. import java.util.Map;     
16.      
17. import javax.crypto.Cipher;     
18.      
19. import org.apache.commons.codec.binary.Hex;     
20.      
21. /**   
22. * RSA非对称加密算法安全编码组件   
23. * @author Administrator   
24. *   
25. */     
26. public abstract class RSACoder {     
27.    //非对称加密密钥算法     
28.    public static final String KEY_ALGORITHM="RSA";     
29.    //数字签名 签名/验证算法     
30.    public static final String SIGNATURE_ALGORRITHM="SHA1withRSA";     
31.    //公钥     
32.    private static final String PUBLIC_KEY="RSAPublicKey";     
33.    //私钥     
34.    private static final String PRIVATE_KEY="RSAPrivateKey";     
35.    //RSA密钥长度,默认为1024,密钥长度必须是64的倍数,范围在521~65526位之间     
36.    private static final int KEY_SIZE=512;     
37.    /**   
38.     * 私钥解密   
39.     * @param data 待解密数据   
40.     * @param key 私钥   
41.     * @return byte[] 解密数据   
42.     * @throws Exception   
43.     */     
44.    public static byte[] decryptByPrivateKey(byte[] data,byte[]key) throws Exception     
45.    {     
46.    //取得私钥     
47.    PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);     
48.    KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);     
49.    //生成私钥     
50.    PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);     
51.    //对数据解密     
52.    Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());     
53.    cipher.init(Cipher.DECRYPT_MODE, privateKey);     
54.    return cipher.doFinal(data);     
55.    }     
56.    /**   
57.     * 私钥解密   
58.     * @param data 待解密数据   
59.     * @param key 私钥   
60.     * @return byte[] 解密数据   
61.     * @throws Exception   
62.     */     
63.    public static byte[] decryptByPrivateKey(byte[] data,String privateKey) throws Exception     
64.    {     
65.    return decryptByPrivateKey(data,getKey(privateKey));     
66.    }     
67.    /**   
68.     * 公钥解密   
69.     * @param data 待解密数据   
70.     * @param key 公钥   
71.     * @return byte[] 解密数据   
72.     * @throws Exception   
73.     */     
74.    public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception     
75.    {     
76.    //取得公钥     
77.    X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);     
78.    KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);     
79.    //生成公钥     
80.    PublicKey publicKey=keyFactory.generatePublic(x509KeySpec);     
81.    //对数据解密     
82.    Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());     
83.    cipher.init(Cipher.DECRYPT_MODE, publicKey);     
84.    return cipher.doFinal(data);     
85.    }     
86.    /**   
87.     * 公钥解密   
88.     * @param data 待解密数据   
89.     * @param key 公钥   
90.     * @return byte[] 解密数据   
91.     * @throws Exception   
92.     */     
93.    public static byte[] decryptByPublicKey(byte[] data,String publicKey) throws Exception     
94.    {     
95.    return decryptByPublicKey(data,getKey(publicKey));     
96.    }     
97.    /**   
98.     * 公钥加密   
99.     * @param data 待加密数据   
100.     * @param key 公钥   
101.     * @return byte[] 加密数据   
102.     * @throws Exception   
103.     */     
104.    public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception     
105.    {     
106.    //取得公钥     
107.    X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);     
108.    KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);     
109.    PublicKey publicKey=keyFactory.generatePublic(x509KeySpec);     
110.   //对数据加密     
111.    Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());     
112.    cipher.init(Cipher.ENCRYPT_MODE, publicKey);     
113.    return cipher.doFinal(data);     
114.    }     
115.    /**   
116.     * 公钥加密   
117.     * @param data 待加密数据   
118.     * @param key 公钥   
119.     * @return byte[] 加密数据   
120.     * @throws Exception   
121.     */     
122.    public static byte[] encryptByPublicKey(byte[] data,String publicKey) throws Exception     
123.    {     
124.    return encryptByPublicKey(data,getKey(publicKey));     
125.    }     
126.    /**   
127.     * 私钥加密   
128.     * @param data 待加密数据   
129.     * @param key 私钥   
130.     * @return byte[] 加密数据   
131.     * @throws Exception   
132.     */     
133.    public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception     
134.    {     
135.    //取得私钥     
136.    PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);     
137.    KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);     
138.    //生成私钥     
139.    PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);     
140.    //对数据加密     
141.    Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());     
142.    cipher.init(Cipher.ENCRYPT_MODE, privateKey);     
143.    return cipher.doFinal(data);     
144.    }     
145.    /**   
146.     * 私钥加密   
147.     * @param data 待加密数据   
148.     * @param key 私钥   
149.     * @return byte[] 加密数据   
150.     * @throws Exception   
151.     */     
152.    public static byte[] encryptByPrivateKey(byte[] data,String key) throws Exception     
153.    {     
154.    return encryptByPrivateKey(data,getKey(key));     
155.    }     
156.    /**   
157.     * 取得私钥   
158.     * @param keyMap 密钥Map   
159.     * @return byte[] 私钥   
160.     * @throws Exception   
161.     */     
162.    public static byte[] getPrivateKey(Map<String,Object> keyMap) throws Exception     
163.    {     
164.    Key key=(Key)keyMap.get(PRIVATE_KEY);     
165.    return key.getEncoded();     
166.    }     
167.    /**   
168.     * 取得公钥   
169.     * @param keyMap 密钥Map   
170.     * @return byte[] 公钥   
171.     * @throws Exception   
172.     */     
173.    public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception     
174.    {     
175.    Key key=(Key)keyMap.get(PUBLIC_KEY);     
176.    return key.getEncoded();     
177.    }     
178.    /**   
179.     * 初始化密钥   
180.     * @return 密钥Map   
181.     * @throws Exception   
182.     */     
183.    public static Map<String,Object> initKey() throws Exception     
184.    {     
185.    //实例化实钥对生成器     
186.    KeyPairGenerator keyPairGen=KeyPairGenerator.getInstance(KEY_ALGORITHM);     
187.    //初始化密钥对生成器     
188.    keyPairGen.initialize(KEY_SIZE);     
189.    //生成密钥对     
190.    KeyPair keyPair=keyPairGen.generateKeyPair();     
191.    //公钥     
192.    RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();     
193.    //私钥     
194.    RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();     
195.    //封装密钥     
196.    Map<String,Object> keyMap=new HashMap<String,Object>(2);     
197.    keyMap.put(PUBLIC_KEY, publicKey);     
198.    keyMap.put(PRIVATE_KEY, privateKey);     
199.    return keyMap;     
200.    }     
201.    /**   
202.     * 签名   
203.     * @param data 待签名数据   
204.     * @param privateKey 私钥   
205.     * @return byte[] 数字签名   
206.     * @throws Exception   
207.     */     
208.    public static byte[] sign(byte[] data,byte[] privateKey) throws Exception     
209.    {     
210.    //转接私钥材料     
211.    PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(privateKey);     
212.    //实例化密钥工厂     
213.    KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);     
214.    //取私钥对象     
215.    PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);     
216.    //实例化Signature     
217.    Signature signature=Signature.getInstance(SIGNATURE_ALGORRITHM);     
218.    //初始化Signature     
219.    signature.initSign(priKey);     
220.    //更新     
221.    signature.update(data);     
222.    //签名     
223.    return signature.sign();     
224.    }     
225.    /**   
226.     * 公钥校验   
227.     * @param data 待校验数据   
228.     * @param publicKey 公钥   
229.     * @param sign 数字签名   
230.     * @return   
231.     * @throws Exception   
232.     */     
233.    public static boolean verify(byte[] data,byte[] publicKey,byte[] sign) throws Exception     
234.    {     
235.    //转接公钥材料     
236.    X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(publicKey);     
237.    //实例化密钥工厂     
238.    KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);     
239.    //生成公钥     
240.    PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);     
241.    //实例化Signature     
242.    Signature signature=Signature.getInstance(SIGNATURE_ALGORRITHM);     
243.    //初始化Signature     
244.    signature.initVerify(pubKey);     
245.    //更新     
246.    signature.update(data);     
247.    //验证     
248.    return signature.verify(sign);     
249.    }     
250.    /**   
251.     * 私钥签名   
252.     * @param data 待签名数据   
253.     * @param privateKey 私钥   
254.     * @return String 十六进制签名字符串   
255.     * @throws Exception   
256.     */     
257.    public static String sign(byte[] data,String privateKey) throws Exception     
258.    {     
259.    byte[] sign=sign(data,getKey(privateKey));     
260.    return Hex.encodeHexString(sign);     
261.    }     
262.    /**   
263.     * 公钥校验   
264.     * @param data 待验证数据   
265.     * @param publicKey 公钥   
266.     * @param sign 签名   
267.     * @return boolean 成功返回true,失败返回false   
268.     * @throws Exception   
269.     */     
270.    public static boolean verify(byte[] data,String publicKey,String sign) throws Exception     
271.    {     
272.    return verify(data,getKey(publicKey),Hex.decodeHex(sign.toCharArray()));     
273.    }     
274.      
275.    /**   
276.     * 取得私钥十六进制表示形式   
277.     * @param keyMap 密钥Map   
278.     * @return String 私钥十六进制字符串   
279.     * @throws Exception   
280.     */     
281.    public static String getPrivateKeyString(Map<String,Object> keyMap) throws Exception     
282.    {     
283.    return Hex.encodeHexString(getPrivateKey(keyMap));     
284.    }     
285.    /**   
286.     * 取得公钥十六进制表示形式   
287.     * @param keyMap 密钥Map   
288.     * @return String 公钥十六进制字符串   
289.     * @throws Exception   
290.     */     
291.    public static String getPublicKeyString(Map<String,Object> keyMap) throws Exception     
292.    {     
293.    return Hex.encodeHexString(getPublicKey(keyMap));     
294.    }     
295.    /**   
296.     * 获取密钥   
297.     * @param key 密钥   
298.     * @return byte[] 密钥   
299.     * @throws Exception   
300.     */     
301.    public static byte[] getKey(String key) throws Exception     
302.    {     
303.    return Hex.decodeHex(key.toCharArray());     
304.    }     
305. }     

    package com.algorithm;  
      
    import java.security.Key;  
    import java.security.KeyFactory;  
    import java.security.KeyPair;  
    import java.security.KeyPairGenerator;  
    import java.security.PrivateKey;  
    import java.security.PublicKey;  
    import java.security.Signature;  
    import java.security.interfaces.RSAPrivateKey;  
    import java.security.interfaces.RSAPublicKey;  
    import java.security.spec.PKCS8EncodedKeySpec;  
    import java.security.spec.X509EncodedKeySpec;  
    import java.util.HashMap;  
    import java.util.Map;  
      
    import javax.crypto.Cipher;  
      
    import org.apache.commons.codec.binary.Hex;  
      
    /** 
    * RSA非对称加密算法安全编码组件 
    * @author Administrator 
    * 
    */  
    public abstract class RSACoder {  
       //非对称加密密钥算法  
       public static final String KEY_ALGORITHM="RSA";  
       //数字签名 签名/验证算法  
       public static final String SIGNATURE_ALGORRITHM="SHA1withRSA";  
       //公钥  
       private static final String PUBLIC_KEY="RSAPublicKey";  
       //私钥  
       private static final String PRIVATE_KEY="RSAPrivateKey";  
       //RSA密钥长度,默认为1024,密钥长度必须是64的倍数,范围在521~65526位之间  
       private static final int KEY_SIZE=512;  
       /** 
        * 私钥解密 
        * @param data 待解密数据 
        * @param key 私钥 
        * @return byte[] 解密数据 
        * @throws Exception 
        */  
       public static byte[] decryptByPrivateKey(byte[] data,byte[]key) throws Exception  
       {  
       //取得私钥  
       PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);  
       KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
       //生成私钥  
       PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);  
       //对数据解密  
       Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
       cipher.init(Cipher.DECRYPT_MODE, privateKey);  
       return cipher.doFinal(data);  
       }  
       /** 
        * 私钥解密 
        * @param data 待解密数据 
        * @param key 私钥 
        * @return byte[] 解密数据 
        * @throws Exception 
        */  
       public static byte[] decryptByPrivateKey(byte[] data,String privateKey) throws Exception  
       {  
       return decryptByPrivateKey(data,getKey(privateKey));  
       }  
       /** 
        * 公钥解密 
        * @param data 待解密数据 
        * @param key 公钥 
        * @return byte[] 解密数据 
        * @throws Exception 
        */  
       public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception  
       {  
       //取得公钥  
       X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
       KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
       //生成公钥  
       PublicKey publicKey=keyFactory.generatePublic(x509KeySpec);  
       //对数据解密  
       Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
       cipher.init(Cipher.DECRYPT_MODE, publicKey);  
       return cipher.doFinal(data);  
       }  
       /** 
        * 公钥解密 
        * @param data 待解密数据 
        * @param key 公钥 
        * @return byte[] 解密数据 
        * @throws Exception 
        */  
       public static byte[] decryptByPublicKey(byte[] data,String publicKey) throws Exception  
       {  
       return decryptByPublicKey(data,getKey(publicKey));  
       }  
       /** 
        * 公钥加密 
        * @param data 待加密数据 
        * @param key 公钥 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception  
       {  
       //取得公钥  
       X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
       KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
       PublicKey publicKey=keyFactory.generatePublic(x509KeySpec);  
      //对数据加密  
       Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
       cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
       return cipher.doFinal(data);  
       }  
       /** 
        * 公钥加密 
        * @param data 待加密数据 
        * @param key 公钥 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] encryptByPublicKey(byte[] data,String publicKey) throws Exception  
       {  
       return encryptByPublicKey(data,getKey(publicKey));  
       }  
       /** 
        * 私钥加密 
        * @param data 待加密数据 
        * @param key 私钥 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception  
       {  
       //取得私钥  
       PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);  
       KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
       //生成私钥  
       PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);  
       //对数据加密  
       Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
       cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
       return cipher.doFinal(data);  
       }  
       /** 
        * 私钥加密 
        * @param data 待加密数据 
        * @param key 私钥 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] encryptByPrivateKey(byte[] data,String key) throws Exception  
       {  
       return encryptByPrivateKey(data,getKey(key));  
       }  
       /** 
        * 取得私钥 
        * @param keyMap 密钥Map 
        * @return byte[] 私钥 
        * @throws Exception 
        */  
       public static byte[] getPrivateKey(Map<String,Object> keyMap) throws Exception  
       {  
       Key key=(Key)keyMap.get(PRIVATE_KEY);  
       return key.getEncoded();  
       }  
       /** 
        * 取得公钥 
        * @param keyMap 密钥Map 
        * @return byte[] 公钥 
        * @throws Exception 
        */  
       public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception  
       {  
       Key key=(Key)keyMap.get(PUBLIC_KEY);  
       return key.getEncoded();  
       }  
       /** 
        * 初始化密钥 
        * @return 密钥Map 
        * @throws Exception 
        */  
       public static Map<String,Object> initKey() throws Exception  
       {  
       //实例化实钥对生成器  
       KeyPairGenerator keyPairGen=KeyPairGenerator.getInstance(KEY_ALGORITHM);  
       //初始化密钥对生成器  
       keyPairGen.initialize(KEY_SIZE);  
       //生成密钥对  
       KeyPair keyPair=keyPairGen.generateKeyPair();  
       //公钥  
       RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();  
       //私钥  
       RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();  
       //封装密钥  
       Map<String,Object> keyMap=new HashMap<String,Object>(2);  
       keyMap.put(PUBLIC_KEY, publicKey);  
       keyMap.put(PRIVATE_KEY, privateKey);  
       return keyMap;  
       }  
       /** 
        * 签名 
        * @param data 待签名数据 
        * @param privateKey 私钥 
        * @return byte[] 数字签名 
        * @throws Exception 
        */  
       public static byte[] sign(byte[] data,byte[] privateKey) throws Exception  
       {  
       //转接私钥材料  
       PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(privateKey);  
       //实例化密钥工厂  
       KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
       //取私钥对象  
       PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);  
       //实例化Signature  
       Signature signature=Signature.getInstance(SIGNATURE_ALGORRITHM);  
       //初始化Signature  
       signature.initSign(priKey);  
       //更新  
       signature.update(data);  
       //签名  
       return signature.sign();  
       }  
       /** 
        * 公钥校验 
        * @param data 待校验数据 
        * @param publicKey 公钥 
        * @param sign 数字签名 
        * @return 
        * @throws Exception 
        */  
       public static boolean verify(byte[] data,byte[] publicKey,byte[] sign) throws Exception  
       {  
       //转接公钥材料  
       X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(publicKey);  
       //实例化密钥工厂  
       KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
       //生成公钥  
       PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
       //实例化Signature  
       Signature signature=Signature.getInstance(SIGNATURE_ALGORRITHM);  
       //初始化Signature  
       signature.initVerify(pubKey);  
       //更新  
       signature.update(data);  
       //验证  
       return signature.verify(sign);  
       }  
       /** 
        * 私钥签名 
        * @param data 待签名数据 
        * @param privateKey 私钥 
        * @return String 十六进制签名字符串 
        * @throws Exception 
        */  
       public static String sign(byte[] data,String privateKey) throws Exception  
       {  
       byte[] sign=sign(data,getKey(privateKey));  
       return Hex.encodeHexString(sign);  
       }  
       /** 
        * 公钥校验 
        * @param data 待验证数据 
        * @param publicKey 公钥 
        * @param sign 签名 
        * @return boolean 成功返回true,失败返回false 
        * @throws Exception 
        */  
       public static boolean verify(byte[] data,String publicKey,String sign) throws Exception  
       {  
       return verify(data,getKey(publicKey),Hex.decodeHex(sign.toCharArray()));  
       }  
      
       /** 
        * 取得私钥十六进制表示形式 
        * @param keyMap 密钥Map 
        * @return String 私钥十六进制字符串 
        * @throws Exception 
        */  
       public static String getPrivateKeyString(Map<String,Object> keyMap) throws Exception  
       {  
       return Hex.encodeHexString(getPrivateKey(keyMap));  
       }  
       /** 
        * 取得公钥十六进制表示形式 
        * @param keyMap 密钥Map 
        * @return String 公钥十六进制字符串 
        * @throws Exception 
        */  
       public static String getPublicKeyString(Map<String,Object> keyMap) throws Exception  
       {  
       return Hex.encodeHexString(getPublicKey(keyMap));  
       }  
       /** 
        * 获取密钥 
        * @param key 密钥 
        * @return byte[] 密钥 
        * @throws Exception 
        */  
       public static byte[] getKey(String key) throws Exception  
       {  
       return Hex.decodeHex(key.toCharArray());  
       }  
    }  
	

   

Java代码  

1. package com.algorithm;     
2.      
3. import java.util.Map;     
4.      
5. import org.apache.commons.codec.binary.Base64;     
6.      
7. /**   
8.  * RSA算法测试用例   
9.  * @author Administrator   
10.  *   
11.  */     
12. public class RSACoderTest {     
13.     //公钥     
14.     private static byte[] publicKey;     
15.     //私钥     
16.     private static byte[] privateKey;     
17.     /**   
18.      * 初始化密钥   
19.      * @throws Exception   
20.      */     
21.     public static void initKey() throws Exception     
22.     {     
23.         //初始化密钥     
24.         Map<String,Object> keyMap=RSACoder.initKey();     
25.         publicKey=RSACoder.getPublicKey(keyMap);     
26.         privateKey=RSACoder.getPrivateKey(keyMap);     
27.         System.out.println("公钥:"+Base64.encodeBase64String(publicKey));     
28.         System.out.println("私钥:"+Base64.encodeBase64String(privateKey));     
29.     }     
30.     public static void test() throws Exception     
31.     {     
32.         String inputStr="RSA加密算法,私钥加密,公钥解密";     
33.         byte[] data=inputStr.getBytes();     
34.         //私钥加密     
35.         byte[] enCodeData=RSACoder.encryptByPrivateKey(data,privateKey);     
36.         System.out.println("加密字符串:"+Base64.encodeBase64String(enCodeData));     
37.         //公钥解密     
38.         byte[] deCodeData=RSACoder.decryptByPublicKey(enCodeData, publicKey);     
39.         System.out.println(new String(deCodeData).equals(inputStr));     
40.     }     
41.     /**   
42.      * @param args   
43.      * @throws Exception    
44.      */     
45.     public static void main(String[] args) throws Exception {     
46.          // TODO Auto-generated method stub     
47.          initKey();     
48.          RSACoderTest.test();     
49.     }     
50.      
51. }     

    package com.algorithm;  
      
    import java.util.Map;  
      
    import org.apache.commons.codec.binary.Base64;  
      
    /** 
     * RSA算法测试用例 
     * @author Administrator 
     * 
     */  
    public class RSACoderTest {  
        //公钥  
        private static byte[] publicKey;  
        //私钥  
        private static byte[] privateKey;  
        /** 
         * 初始化密钥 
         * @throws Exception 
         */  
        public static void initKey() throws Exception  
        {  
            //初始化密钥  
            Map<String,Object> keyMap=RSACoder.initKey();  
            publicKey=RSACoder.getPublicKey(keyMap);  
            privateKey=RSACoder.getPrivateKey(keyMap);  
            System.out.println("公钥:"+Base64.encodeBase64String(publicKey));  
            System.out.println("私钥:"+Base64.encodeBase64String(privateKey));  
        }  
        public static void test() throws Exception  
        {  
            String inputStr="RSA加密算法,私钥加密,公钥解密";  
            byte[] data=inputStr.getBytes();  
            //私钥加密  
            byte[] enCodeData=RSACoder.encryptByPrivateKey(data,privateKey);  
            System.out.println("加密字符串:"+Base64.encodeBase64String(enCodeData));  
            //公钥解密  
            byte[] deCodeData=RSACoder.decryptByPublicKey(enCodeData, publicKey);  
            System.out.println(new String(deCodeData).equals(inputStr));  
        }  
        /** 
         * @param args 
         * @throws Exception  
         */  
        public static void main(String[] args) throws Exception {  
             // TODO Auto-generated method stub  
             initKey();  
             RSACoderTest.test();  
        }  
      
    }  
    

   

Java代码  

1. package com.algorithm;     
2.      
3. import java.io.FileInputStream;     
4. import java.security.KeyStore;     
5. import java.security.PrivateKey;     
6. import java.security.PublicKey;     
7. import java.security.Signature;     
8. import java.security.cert.Certificate;     
9. import java.security.cert.CertificateFactory;     
10. import java.security.cert.X509Certificate;     
11.      
12. import javax.crypto.Cipher;     
13.      
14. /**   
15.  * 证书组件   
16.  * @author Administrator   
17.  */     
18. public abstract class CertificateCoder {     
19.    //类型证书     
20.    private static final String CERT_TYPE="X.509";     
21.    /**   
22.     * 由KeyStore获得私钥   
23.     * @param keyStorePath 密钥库路径   
24.     * @param alias 别名   
25.     * @param password 密码   
26.     * @return PrivateKey 密钥   
27.     * @throws Exception   
28.     */     
29.    private static PrivateKey getPrivateKeyByKeyStore(String keyStorePath,String alias,String password) throws Exception     
30.    {     
31.        //获得密钥库     
32.        KeyStore ks=getKeyStore(keyStorePath,password);     
33.        //获得私钥     
34.        return (PrivateKey)ks.getKey(alias, password.toCharArray());     
35.    }     
36.    /**   
37.     * 由Certificate获得公钥   
38.     * @param certificatePath 证书路径   
39.     * @return PublicKey 公钥   
40.     */     
41.    private static PublicKey getPublicKeyByCertificate(String certificatePath) throws Exception     
42.    {     
43.        //获得证书     
44.        Certificate certificate=getCertificate(certificatePath);     
45.        //获得公钥     
46.        return certificate.getPublicKey();     
47.    }     
48.    /**   
49.     * 获得certificate   
50.     * @param certificatePath 证书路径   
51.     * @return Certificate 证书   
52.     * @throws Exception   
53.     */     
54.    private static Certificate getCertificate(String certificatePath) throws Exception     
55.    {     
56.        //实例化证书工厂     
57.        CertificateFactory certificateFactory=CertificateFactory.getInstance(CERT_TYPE);     
58.        //取得证书文件流     
59.        FileInputStream in=new FileInputStream(certificatePath);     
60.        //生成证书     
61.        Certificate certificate=certificateFactory.generateCertificate(in);     
62.        //关闭证书文件流     
63.        in.close();     
64.        return certificate;     
65.    }     
66.    /**   
67.     * 取得Certificate   
68.     * @param keyStorePath 密钥库路径   
69.     * @param alias 别名   
70.     * @param password 密码   
71.     * @return Certificate 证书   
72.     * @throws Exception   
73.     */     
74.    private static Certificate getCertificate(String keyStorePath,String alias,String password) throws Exception     
75.    {     
76.        //获得密钥库     
77.        KeyStore ks=getKeyStore(keyStorePath,password);     
78.        //获得证书     
79.        return ks.getCertificate(alias);     
80.    }     
81.    /**   
82.     * 获得密钥库   
83.     * @param keyStorePath 密钥库路径   
84.     * @param password 密码   
85.     * @return KeyStore 密钥库   
86.     * @throws Exception   
87.     */     
88.    private static KeyStore getKeyStore(String keyStorePath,String password) throws Exception     
89.    {     
90.        //实例化密钥库     
91.        KeyStore ks=KeyStore.getInstance(KeyStore.getDefaultType());     
92.        //获得密钥库文件流     
93.        FileInputStream in=new FileInputStream(keyStorePath);     
94.        //加载密钥库     
95.        ks.load(in, password.toCharArray());     
96.        //关闭密钥库文件流     
97.        in.close();     
98.        return ks;     
99.    }     
100.    /**   
101.     * 私钥加密   
102.     * @param data 待加密数据   
103.     * @param keyStorePath 密钥库路径   
104.     * @param alias 别名   
105.     * @param password 密码   
106.     * @return byte[] 加密数据   
107.     * @throws Exception   
108.     */     
109.    public static byte[] encryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password) throws Exception     
110.    {     
111.        //取得私钥     
112.        PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath,alias,password);     
113.        //对数据加密     
114.        Cipher cipher=Cipher.getInstance(privateKey.getAlgorithm());     
115.        cipher.init(Cipher.ENCRYPT_MODE, privateKey);     
116.        return cipher.doFinal(data);     
117.    }     
118.    /**   
119.     * 私钥解密   
120.     * @param data 待解密数据   
121.     * @param keyStorePath 密钥库路径   
122.     * @param alias 别名   
123.     * @param password 密码   
124.     * @return byte[] 加密数据   
125.     * @throws Exception   
126.     */     
127.    public static byte[] decryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password) throws Exception     
128.    {     
129.        //取得私钥     
130.        PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath,alias,password);     
131.        //对数据解密     
132.        Cipher cipher=Cipher.getInstance(privateKey.getAlgorithm());     
133.        cipher.init(Cipher.DECRYPT_MODE, privateKey);     
134.        return cipher.doFinal(data);     
135.    }     
136.    /**   
137.     * 公钥加密   
138.     * @param data 待加密数据   
139.     * @param certificatePath 证书路径   
140.     * @return byte[] 加密数据   
141.     * @throws Exception   
142.     */     
143.    public static byte[] encryptByPublicKey(byte[] data,String certificatePath) throws Exception     
144.    {     
145.        //取得公钥     
146.        PublicKey publicKey=getPublicKeyByCertificate(certificatePath);     
147.        //对数据加密     
148.        Cipher cipher=Cipher.getInstance(publicKey.getAlgorithm());     
149.        cipher.init(Cipher.ENCRYPT_MODE, publicKey);     
150.        return cipher.doFinal(data);     
151.    }     
152.    /**   
153.     * 公钥解密   
154.     * @param data 待解密数据   
155.     * @param certificatePath 证书路径   
156.     * @return byte[] 解密数据   
157.     * @throws Exception   
158.     */     
159.    public static byte[] decryptByPublicKey(byte[] data,String certificatePath) throws Exception     
160.    {     
161.        //取得公钥     
162.        PublicKey publicKey=getPublicKeyByCertificate(certificatePath);     
163.        //对数据解密     
164.        Cipher cipher=Cipher.getInstance(publicKey.getAlgorithm());     
165.        cipher.init(Cipher.DECRYPT_MODE, publicKey);     
166.        return cipher.doFinal(data);     
167.    }     
168.    /**   
169.     * 签名   
170.     * @param data 待签名数据   
171.     * @param keyStorePath 密钥库路径   
172.     * @param alias 别名   
173.     * @param password 密码   
174.     * @return byte[] 签名   
175.     * @throws Exception   
176.     */     
177.    public static byte[] sign(byte[] data,String keyStorePath,String alias,String password) throws Exception     
178.    {     
179.        //获得证书     
180.        X509Certificate x509Certificate=(X509Certificate)getCertificate(keyStorePath,alias,password);     
181.        //构建签名,由证书指定签名算法     
182.        Signature signature=Signature.getInstance(x509Certificate.getSigAlgName());     
183.        //获取私钥     
184.        PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath, alias, password);     
185.        //初始化签名,由私钥构建     
186.        signature.initSign(privateKey);     
187.        signature.update(data);     
188.        return signature.sign();     
189.    }     
190.    /**   
191.     * 签名验证   
192.     * @param data 数据   
193.     * @param sign 签名   
194.     * @param certificatePath 证书路径   
195.     * @return boolean 验证通过为true   
196.     * @throws Exception   
197.     */     
198.    public static boolean verify(byte[] data,byte[] sign,String certificatePath) throws Exception     
199.    {     
200.        //获得证书     
201.        X509Certificate x509Certificate=(X509Certificate)getCertificate(certificatePath);     
202.        //构建签名,由证书指定签名算法     
203.        Signature signature=Signature.getInstance(x509Certificate.getSigAlgName());     
204.        //由证书初始化签名,实际上是使用了证书中的公钥     
205.        signature.initVerify(x509Certificate);     
206.        signature.update(data);     
207.        return signature.verify(sign);     
208.    }     
209. }     

    package com.algorithm;  
      
    import java.io.FileInputStream;  
    import java.security.KeyStore;  
    import java.security.PrivateKey;  
    import java.security.PublicKey;  
    import java.security.Signature;  
    import java.security.cert.Certificate;  
    import java.security.cert.CertificateFactory;  
    import java.security.cert.X509Certificate;  
      
    import javax.crypto.Cipher;  
      
    /** 
     * 证书组件 
     * @author Administrator 
     */  
    public abstract class CertificateCoder {  
       //类型证书  
       private static final String CERT_TYPE="X.509";  
       /** 
        * 由KeyStore获得私钥 
        * @param keyStorePath 密钥库路径 
        * @param alias 别名 
        * @param password 密码 
        * @return PrivateKey 密钥 
        * @throws Exception 
        */  
       private static PrivateKey getPrivateKeyByKeyStore(String keyStorePath,String alias,String password) throws Exception  
       {  
           //获得密钥库  
           KeyStore ks=getKeyStore(keyStorePath,password);  
           //获得私钥  
           return (PrivateKey)ks.getKey(alias, password.toCharArray());  
       }  
       /** 
        * 由Certificate获得公钥 
        * @param certificatePath 证书路径 
        * @return PublicKey 公钥 
        */  
       private static PublicKey getPublicKeyByCertificate(String certificatePath) throws Exception  
       {  
           //获得证书  
           Certificate certificate=getCertificate(certificatePath);  
           //获得公钥  
           return certificate.getPublicKey();  
       }  
       /** 
        * 获得certificate 
        * @param certificatePath 证书路径 
        * @return Certificate 证书 
        * @throws Exception 
        */  
       private static Certificate getCertificate(String certificatePath) throws Exception  
       {  
           //实例化证书工厂  
           CertificateFactory certificateFactory=CertificateFactory.getInstance(CERT_TYPE);  
           //取得证书文件流  
           FileInputStream in=new FileInputStream(certificatePath);  
           //生成证书  
           Certificate certificate=certificateFactory.generateCertificate(in);  
           //关闭证书文件流  
           in.close();  
           return certificate;  
       }  
       /** 
        * 取得Certificate 
        * @param keyStorePath 密钥库路径 
        * @param alias 别名 
        * @param password 密码 
        * @return Certificate 证书 
        * @throws Exception 
        */  
       private static Certificate getCertificate(String keyStorePath,String alias,String password) throws Exception  
       {  
           //获得密钥库  
           KeyStore ks=getKeyStore(keyStorePath,password);  
           //获得证书  
           return ks.getCertificate(alias);  
       }  
       /** 
        * 获得密钥库 
        * @param keyStorePath 密钥库路径 
        * @param password 密码 
        * @return KeyStore 密钥库 
        * @throws Exception 
        */  
       private static KeyStore getKeyStore(String keyStorePath,String password) throws Exception  
       {  
           //实例化密钥库  
           KeyStore ks=KeyStore.getInstance(KeyStore.getDefaultType());  
           //获得密钥库文件流  
           FileInputStream in=new FileInputStream(keyStorePath);  
           //加载密钥库  
           ks.load(in, password.toCharArray());  
           //关闭密钥库文件流  
           in.close();  
           return ks;  
       }  
       /** 
        * 私钥加密 
        * @param data 待加密数据 
        * @param keyStorePath 密钥库路径 
        * @param alias 别名 
        * @param password 密码 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] encryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password) throws Exception  
       {  
           //取得私钥  
           PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath,alias,password);  
           //对数据加密  
           Cipher cipher=Cipher.getInstance(privateKey.getAlgorithm());  
           cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
           return cipher.doFinal(data);  
       }  
       /** 
        * 私钥解密 
        * @param data 待解密数据 
        * @param keyStorePath 密钥库路径 
        * @param alias 别名 
        * @param password 密码 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] decryptByPrivateKey(byte[] data,String keyStorePath,String alias,String password) throws Exception  
       {  
           //取得私钥  
           PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath,alias,password);  
           //对数据解密  
           Cipher cipher=Cipher.getInstance(privateKey.getAlgorithm());  
           cipher.init(Cipher.DECRYPT_MODE, privateKey);  
           return cipher.doFinal(data);  
       }  
       /** 
        * 公钥加密 
        * @param data 待加密数据 
        * @param certificatePath 证书路径 
        * @return byte[] 加密数据 
        * @throws Exception 
        */  
       public static byte[] encryptByPublicKey(byte[] data,String certificatePath) throws Exception  
       {  
           //取得公钥  
           PublicKey publicKey=getPublicKeyByCertificate(certificatePath);  
           //对数据加密  
           Cipher cipher=Cipher.getInstance(publicKey.getAlgorithm());  
           cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
           return cipher.doFinal(data);  
       }  
       /** 
        * 公钥解密 
        * @param data 待解密数据 
        * @param certificatePath 证书路径 
        * @return byte[] 解密数据 
        * @throws Exception 
        */  
       public static byte[] decryptByPublicKey(byte[] data,String certificatePath) throws Exception  
       {  
           //取得公钥  
           PublicKey publicKey=getPublicKeyByCertificate(certificatePath);  
           //对数据解密  
           Cipher cipher=Cipher.getInstance(publicKey.getAlgorithm());  
           cipher.init(Cipher.DECRYPT_MODE, publicKey);  
           return cipher.doFinal(data);  
       }  
       /** 
        * 签名 
        * @param data 待签名数据 
        * @param keyStorePath 密钥库路径 
        * @param alias 别名 
        * @param password 密码 
        * @return byte[] 签名 
        * @throws Exception 
        */  
       public static byte[] sign(byte[] data,String keyStorePath,String alias,String password) throws Exception  
       {  
           //获得证书  
           X509Certificate x509Certificate=(X509Certificate)getCertificate(keyStorePath,alias,password);  
           //构建签名,由证书指定签名算法  
           Signature signature=Signature.getInstance(x509Certificate.getSigAlgName());  
           //获取私钥  
           PrivateKey privateKey=getPrivateKeyByKeyStore(keyStorePath, alias, password);  
           //初始化签名,由私钥构建  
           signature.initSign(privateKey);  
           signature.update(data);  
           return signature.sign();  
       }  
       /** 
        * 签名验证 
        * @param data 数据 
        * @param sign 签名 
        * @param certificatePath 证书路径 
        * @return boolean 验证通过为true 
        * @throws Exception 
        */  
       public static boolean verify(byte[] data,byte[] sign,String certificatePath) throws Exception  
       {  
           //获得证书  
           X509Certificate x509Certificate=(X509Certificate)getCertificate(certificatePath);  
           //构建签名,由证书指定签名算法  
           Signature signature=Signature.getInstance(x509Certificate.getSigAlgName());  
           //由证书初始化签名,实际上是使用了证书中的公钥  
           signature.initVerify(x509Certificate);  
           signature.update(data);  
           return signature.verify(sign);  
       }  
    }  
    

   

Java代码  

1. package com.algorithm;     
2.          
3.     import java.io.InputStream;     
4.          
5.     import org.apache.commons.codec.binary.Hex;     
6.          
7.     /**   
8.      * 数字证书测试用例   
9.      * @author Administrator   
10.      *   
11.      */     
12.     public class CertificateCoderTest {     
13.         //生成证书时的密码     
14.         private static String password="123456";     
15.         //别名     
16.         private static String alias="www.dominic.com";     
17.         //证书路径     
18.         private static String certificatePath="D:\\Program Files\\OpenSSL-Win32\\ca\\certs\\dominic.cer";     
19.         //密钥库路径     
20.         private static String keyStorePath="D:\\Program Files\\OpenSSL-Win32\\ca\\certs\\domini.keystore";     
21.         /**   
22.          * 公钥加密私钥解密   
23.          */     
24.         public static void test1() throws Exception     
25.         {     
26.             String inputStr="数字证书";     
27.             byte[] data=inputStr.getBytes();     
28.             //公钥加密     
29.             byte[] encrypt=CertificateCoder.encryptByPublicKey(data, certificatePath);     
30.             //私钥解密     
31.             byte[] decrypt=CertificateCoder.decryptByPrivateKey(encrypt, keyStorePath, alias, password);     
32.             System.out.println(new String(decrypt).equals(inputStr));     
33.         }     
34.         /**   
35.          * 私加密公钥解密   
36.          */     
37.         public static void test2() throws Exception     
38.         {     
39.             String inputStr="数字证书";     
40.             byte[] data=inputStr.getBytes();     
41.             //私钥加密     
42.             byte[] encrypt=CertificateCoder.encryptByPrivateKey(data, keyStorePath, alias, password);     
43.             //公钥解密     
44.             byte[] decrypt=CertificateCoder.decryptByPublicKey(encrypt, certificatePath);     
45.             System.out.println(new String(decrypt).equals(inputStr));     
46.         }     
47.         /**   
48.          * 签名验证   
49.          */     
50.         public static void test3() throws Exception     
51.         {     
52.             String inputStr="数字签名";     
53.             byte[] data=inputStr.getBytes();     
54.             //私钥签名     
55.             byte[] sign=CertificateCoder.sign(data, keyStorePath, alias, password);     
56.             System.out.println("签名:"+Hex.encodeHexString(sign));     
57.             //公钥验证     
58.             System.out.println(CertificateCoder.verify(data, sign, certificatePath));     
59.         }     
60.         public static void main(String[] args) throws Exception     
61.         {     
62.             CertificateCoderTest.test1();     
63.             CertificateCoderTest.test2();     
64.             CertificateCoderTest.test3();     
65.         }     
66.     }     
67.       

package com.algorithm;  
      
    import java.io.InputStream;  
      
    import org.apache.commons.codec.binary.Hex;  
      
    /** 
     * 数字证书测试用例 
     * @author Administrator 
     * 
     */  
    public class CertificateCoderTest {  
        //生成证书时的密码  
        private static String password="123456";  
        //别名  
        private static String alias="www.dominic.com";  
        //证书路径  
        private static String certificatePath="D:\\Program Files\\OpenSSL-Win32\\ca\\certs\\dominic.cer";  
        //密钥库路径  
        private static String keyStorePath="D:\\Program Files\\OpenSSL-Win32\\ca\\certs\\domini.keystore";  
        /** 
         * 公钥加密私钥解密 
         */  
        public static void test1() throws Exception  
        {  
            String inputStr="数字证书";  
            byte[] data=inputStr.getBytes();  
            //公钥加密  
            byte[] encrypt=CertificateCoder.encryptByPublicKey(data, certificatePath);  
            //私钥解密  
            byte[] decrypt=CertificateCoder.decryptByPrivateKey(encrypt, keyStorePath, alias, password);  
            System.out.println(new String(decrypt).equals(inputStr));  
        }  
        /** 
         * 私加密公钥解密 
         */  
        public static void test2() throws Exception  
        {  
            String inputStr="数字证书";  
            byte[] data=inputStr.getBytes();  
            //私钥加密  
            byte[] encrypt=CertificateCoder.encryptByPrivateKey(data, keyStorePath, alias, password);  
            //公钥解密  
            byte[] decrypt=CertificateCoder.decryptByPublicKey(encrypt, certificatePath);  
            System.out.println(new String(decrypt).equals(inputStr));  
        }  
        /** 
         * 签名验证 
         */  
        public static void test3() throws Exception  
        {  
            String inputStr="数字签名";  
            byte[] data=inputStr.getBytes();  
            //私钥签名  
            byte[] sign=CertificateCoder.sign(data, keyStorePath, alias, password);  
            System.out.println("签名:"+Hex.encodeHexString(sign));  
            //公钥验证  
            System.out.println(CertificateCoder.verify(data, sign, certificatePath));  
        }  
        public static void main(String[] args) throws Exception  
        {  
            CertificateCoderTest.test1();  
            CertificateCoderTest.test2();  
            CertificateCoderTest.test3();  
        }  
    }  
	

   

Java代码  

1. package com.algorithm;     
2.      
3. import java.security.Key;     
4.      
5. import javax.crypto.Cipher;     
6. import javax.crypto.KeyGenerator;     
7. import javax.crypto.SecretKey;     
8. import javax.crypto.spec.SecretKeySpec;     
9.      
10. import org.apache.commons.codec.binary.Base64;     
11. import org.apache.commons.codec.digest.DigestUtils;     
12. /**   
13.  * AES对称加密算法,组件类   
14.  * @author Administrator   
15.  *   
16.  */     
17. public abstract class AESCoder {     
18.   //密钥算法     
19.   public static final String ALGORITHM="AES";     
20.   //密钥长度(java默认只能处理128位以内的长度,如果需要处理大于128位可以使用JCE解除密钥长度限制)     
21.   public static final int KEY_SIZE=128;     
22.   /**   
23.    * 转换密钥   
24.    * @param key 二进制密钥   
25.    * @return Key 密钥   
26.    * @throws Exception   
27.    */     
28.   private static Key toKey(byte[] key) throws Exception      
29.   {     
30.       //实例化AES密钥材料     
31.       SecretKey secretKey=new SecretKeySpec(key,ALGORITHM);     
32.       return secretKey;     
33.   }     
34.   /**   
35.    * 解密   
36.    * @param data 待解密数据   
37.    * @param key 密钥   
38.    * @return byte[] 解密数据   
39.    * @throws Exception   
40.    */     
41.   public static byte[] decrypt(byte[] data,byte[] key) throws Exception      
42.   {     
43.       //还原密钥     
44.       Key k=toKey(key);     
45.       //实例化     
46.       Cipher cipher=Cipher.getInstance(ALGORITHM);     
47.       //初始化,设置为解密模式     
48.       cipher.init(Cipher.DECRYPT_MODE, k);     
49.       //执行操作     
50.       return cipher.doFinal(data);     
51.   }     
52.   /**   
53.    * 解密   
54.    * @param data 待解密数据   
55.    * @param key 密钥   
56.    * @return byte[] 解密数据   
57.    * @throws Exception   
58.    */     
59.   public static byte[] decrypt(byte[] data,String key) throws Exception      
60.   {     
61.       return decrypt(data,getKey(key));     
62.   }     
63.   /**   
64.    * 加密   
65.    * @param data 待加密数据   
66.    * @param key 密钥   
67.    * @return byte[] 加密数据   
68.    * @throws Exception   
69.    */     
70.   public static byte[] encrypt(byte[] data,byte[] key) throws Exception      
71.   {     
72.       //还原密钥     
73.       Key k=toKey(key);     
74.       //实例化     
75.       Cipher cipher=Cipher.getInstance(ALGORITHM);     
76.       //初始化,设置为加密模式     
77.       cipher.init(Cipher.ENCRYPT_MODE, k);     
78.       //执行操作     
79.       return cipher.doFinal(data);     
80.   }     
81.   /**   
82.    * 加密   
83.    * @param data 待加密数据   
84.    * @param key 密钥   
85.    * @return byte[] 加密数据   
86.    * @throws Exception   
87.    */     
88.   public static byte[] encrypt(byte[] data,String key) throws Exception      
89.   {     
90.       return encrypt(data,getKey(key));     
91.   }     
92.   /**   
93.    * 生成密钥   
94.    * @return byte[] 二进制密钥   
95.    * @throws Exception   
96.    */     
97.   public static byte[] initKey() throws Exception      
98.   {     
99.       //实例化     
100.       KeyGenerator kg=KeyGenerator.getInstance(ALGORITHM);     
101.       //初始化密钥长度     
102.       kg.init(KEY_SIZE);     
103.       //生成秘密密钥     
104.       SecretKey secretKey=kg.generateKey();     
105.       //获得密钥的二进制编码形式     
106.       return secretKey.getEncoded();     
107.   }     
108.   /**   
109.    * 初始化密钥   
110.    * @return String Base64编码密钥   
111.    * @throws Exception   
112.    */     
113.   public static String initKeyString() throws Exception      
114.   {     
115.       return Base64.encodeBase64String(initKey());     
116.   }     
117.   /**   
118.    * 获取密钥   
119.    * @param key   
120.    * @return byte[] 密钥   
121.    * @throws Exception   
122.    */     
123.   public static byte[] getKey(String key) throws Exception      
124.   {     
125.       return Base64.decodeBase64(key);     
126.   }     
127.   /**   
128.    * 摘要处理   
129.    * @param data 待摘要数据   
130.    * @return String 摘要字符串   
131.    */     
132.   public static String shaHex(byte[] data)     
133.   {     
134.       return DigestUtils.md5Hex(data);     
135.   }     
136.   /**   
137.    * 验证   
138.    * @param data 待摘要数据   
139.    * @param messageDigest 摘要字符串   
140.    * @return 验证结果   
141.    */     
142.   public static boolean validate(byte[] data,String messageDigest)     
143.   {     
144.       return messageDigest.equals(shaHex(data));     
145.   }     
146.        
147. }     

   
    package com.algorithm;  
      
    import java.security.Key;  
      
    import javax.crypto.Cipher;  
    import javax.crypto.KeyGenerator;  
    import javax.crypto.SecretKey;  
    import javax.crypto.spec.SecretKeySpec;  
      
    import org.apache.commons.codec.binary.Base64;  
    import org.apache.commons.codec.digest.DigestUtils;  
    /** 
     * AES对称加密算法,组件类 
     * @author Administrator 
     * 
     */  
    public abstract class AESCoder {  
      //密钥算法  
      public static final String ALGORITHM="AES";  
      //密钥长度(java默认只能处理128位以内的长度,如果需要处理大于128位可以使用JCE解除密钥长度限制)  
      public static final int KEY_SIZE=128;  
      /** 
       * 转换密钥 
       * @param key 二进制密钥 
       * @return Key 密钥 
       * @throws Exception 
       */  
      private static Key toKey(byte[] key) throws Exception   
      {  
          //实例化AES密钥材料  
          SecretKey secretKey=new SecretKeySpec(key,ALGORITHM);  
          return secretKey;  
      }  
      /** 
       * 解密 
       * @param data 待解密数据 
       * @param key 密钥 
       * @return byte[] 解密数据 
       * @throws Exception 
       */  
      public static byte[] decrypt(byte[] data,byte[] key) throws Exception   
      {  
          //还原密钥  
          Key k=toKey(key);  
          //实例化  
          Cipher cipher=Cipher.getInstance(ALGORITHM);  
          //初始化,设置为解密模式  
          cipher.init(Cipher.DECRYPT_MODE, k);  
          //执行操作  
          return cipher.doFinal(data);  
      }  
      /** 
       * 解密 
       * @param data 待解密数据 
       * @param key 密钥 
       * @return byte[] 解密数据 
       * @throws Exception 
       */  
      public static byte[] decrypt(byte[] data,String key) throws Exception   
      {  
          return decrypt(data,getKey(key));  
      }  
      /** 
       * 加密 
       * @param data 待加密数据 
       * @param key 密钥 
       * @return byte[] 加密数据 
       * @throws Exception 
       */  
      public static byte[] encrypt(byte[] data,byte[] key) throws Exception   
      {  
          //还原密钥  
          Key k=toKey(key);  
          //实例化  
          Cipher cipher=Cipher.getInstance(ALGORITHM);  
          //初始化,设置为加密模式  
          cipher.init(Cipher.ENCRYPT_MODE, k);  
          //执行操作  
          return cipher.doFinal(data);  
      }  
      /** 
       * 加密 
       * @param data 待加密数据 
       * @param key 密钥 
       * @return byte[] 加密数据 
       * @throws Exception 
       */  
      public static byte[] encrypt(byte[] data,String key) throws Exception   
      {  
          return encrypt(data,getKey(key));  
      }  
      /** 
       * 生成密钥 
       * @return byte[] 二进制密钥 
       * @throws Exception 
       */  
      public static byte[] initKey() throws Exception   
      {  
          //实例化  
          KeyGenerator kg=KeyGenerator.getInstance(ALGORITHM);  
          //初始化密钥长度  
          kg.init(KEY_SIZE);  
          //生成秘密密钥  
          SecretKey secretKey=kg.generateKey();  
          //获得密钥的二进制编码形式  
          return secretKey.getEncoded();  
      }  
      /** 
       * 初始化密钥 
       * @return String Base64编码密钥 
       * @throws Exception 
       */  
      public static String initKeyString() throws Exception   
      {  
          return Base64.encodeBase64String(initKey());  
      }  
      /** 
       * 获取密钥 
       * @param key 
       * @return byte[] 密钥 
       * @throws Exception 
       */  
      public static byte[] getKey(String key) throws Exception   
      {  
          return Base64.decodeBase64(key);  
      }  
      /** 
       * 摘要处理 
       * @param data 待摘要数据 
       * @return String 摘要字符串 
       */  
      public static String shaHex(byte[] data)  
      {  
          return DigestUtils.md5Hex(data);  
      }  
      /** 
       * 验证 
       * @param data 待摘要数据 
       * @param messageDigest 摘要字符串 
       * @return 验证结果 
       */  
      public static boolean validate(byte[] data,String messageDigest)  
      {  
          return messageDigest.equals(shaHex(data));  
      }  
        
    }  
    

   

Java代码  

1. package com.algorithm;     
2. /**   
3.  * 对称加密算法测试用例   
4.  * @author Administrator   
5.  *   
6.  */     
7. public class AESCoderTest {     
8.            
9.       public static void main(String args[])     
10.       {     
11.           try {     
12.              //初始化密钥     
13.              String secretKey=AESCoder.initKeyString();     
14.              System.out.println("密钥为:"+secretKey);     
15.              String s="我们的大中国";     
16.              //加密数据     
17.              byte[] encryptData=AESCoder.encrypt(s.getBytes(), secretKey);     
18.              //解密数据     
19.              byte[] data=AESCoder.decrypt(encryptData, secretKey);     
20.              //比较     
21.              System.out.println(new String(data).equals(s));     
22.           } catch (Exception e) {     
23.             // TODO Auto-generated catch block     
24.             e.printStackTrace();     
25.         }     
26.       }     
27. }  

 
    package com.algorithm;  
    /** 
     * 对称加密算法测试用例 
     * @author Administrator 
     * 
     */  
    public class AESCoderTest {  
            
          public static void main(String args[])  
          {  
              try {  
                 //初始化密钥  
                 String secretKey=AESCoder.initKeyString();  
                 System.out.println("密钥为:"+secretKey);  
                 String s="我们的大中国";  
                 //加密数据  
                 byte[] encryptData=AESCoder.encrypt(s.getBytes(), secretKey);  
                 //解密数据  
                 byte[] data=AESCoder.decrypt(encryptData, secretKey);  
                 //比较  
                 System.out.println(new String(data).equals(s));  
              } catch (Exception e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
          }  
    }

 


附证书生成命令：
  keytool生成证书
  keytool -genkeypair -keyalg RSA -keysize 2048 -sigalg SHA1withRSA -validity 360 -alias www.dominic.com -keystore dominic.keystore
  导出数字证书
  keytool -exportcert -alias www.dominic.com -keystore dominic.keystore -file dominic.cer -rfc 
  打印数字证书
  keytool -printcert -file dominic.cer
  这里是自制证书，如果需要权威机构签发，需要导出证书申请文件由第三方签发
 
  openssl证书创建
 
  根证书构建命令？
  echo 构建随机数 private/.rand
  openssl rand -out private/.rand 1000
  echo 构建根证书私钥 private/ca.key.pem
  openssl genrsa -aes256 -out private/ca.key.pem 2048
  echo 生成根证书签发申请 private/ca.csr
  openssl req -new -key private/ca.key.pem -out private/ca.csr -subj "/C=CN/ST=BJ/L=BJ/O=dominic/OU=dominic/CN=www.dominic.com"
  echo 签发根证书 private/ca.cer
  openssl x509 -req -days 10000 -sha1 -extensions v3_ca -signkey private/ca.key.pem -in private/ca.csr -out certs/ca.cer
  echo 根证书转换 private/ca.p12
  openssl pkcs12 -export -cacerts inkey private/ca.key.pem -in private/ca.csr -out certs/ca.cer
 
  服务器证书构建步骤命令?
  (1)echo 构建服务器私钥 private/server.key.pem
  (2)openssl genrsa -aes256 -out private/server.key.pem 2048
     echo 生成服务器证书签发申请 private/server.csr
  (3)openssl req -new -key private/server.key.pem -out private/server.csr -subj "/C=CN/ST=BJ/L=BJ/O=dominic/OU=dominic/CN=www.dominic.com"
      echo 签发服务器证书 private/server.cer
  openssl x509 -req -days 3650 -sha1 -extensions v3_req -CA certs/ca.cer -CAkey private/ca.key.pem -CAserial ca.srl -CAcreateserial -in private/server.csr -out certs/server.cer
      echo 服务器证书转换 private/server.p12
  openssl pkcs12 -export -clcerts -inkey private/server.key.pem -in certs/server.cer -out certs/server.p12
  
   客户证书构建命令？
   echo 构建客户私钥 private/client.key.pem
   openssl genrsa -aes256 -out private/client.key.pem 2048
   echo 生成服务器证书签发申请 private/client.csr
   openssl req -new -key private/client.key.pem -out private/client.csr -subj "/C=CN/ST=BJ/L=BJ/O=dominic/OU=dominic/CN=www.dominic.com"
   echo 签发客户证书 private/server.cer
   openssl ca -days 3650 -in private/client.csr -out certs/client.cer -cert certs/ca.cer -keyfile private/ca.key.pem
   echo 客户证书转换 certs/client.p12
   openssl pkcs12 -export -inkey private/client.key.pem -in certs/client.cer -out certs/client.p12