java加密解密算法记录

论坛 › 期权论坛 › 脚本     
已经匿名di用户   2022-5-29 19:05   1412   0
以下内容均摘自我买的书籍《java加密与解密的艺术》作者 梁栋

复制代码 收藏代码
  1. package com.algorithm;
  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;
  17. import javax.crypto.Cipher;
  19. import org.apache.commons.codec.binary.Hex;
  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. }
  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;
  3. import java.util.Map;
  5. import org.apache.commons.codec.binary.Base64;
  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. }
  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;
  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;
  12. import javax.crypto.Cipher;
  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;
  3. import java.io.InputStream;
  5. import org.apache.commons.codec.binary.Hex;
  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. } 
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;
  3. import java.security.Key;
  5. import javax.crypto.Cipher;
  6. import javax.crypto.KeyGenerator;
  7. import javax.crypto.SecretKey;
  8. import javax.crypto.spec.SecretKeySpec;
  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. }
  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 {
  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
回复
分享到 :
0 人收藏
返回列表
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

3级会员
已经匿名di用户

积分:81
帖子:4969
精华:0
+ 关注 私信
期权论坛 期权论坛
期权网络科技版权所有
关于我们
联系我们
加入我们
反馈问题
免责声明
积分充值
统一社会信用代码
积分规则
网站地图
爱文库
下属网站
官方
新浪微博
微信公众号
◆
下载
表情包
App下载
期权论坛 期权论坛

QQ咨询|关于我们|Archiver|手机版|小黑屋|( 辽ICP备15012455号-4 ) Powered by 期权论坛 X3.2 © 2001-2016 期权工具网&期权论坛 Inc.

发布
内容

下载期权论坛手机APP