主要参考: http://www.blogjava.net/icewee/archive/2012/05/19/378570.html
基于以上代码汇总而成:
实现效果
1生成公钥私钥. 保存在内存/文件中.
2从文件或者内存中读取公钥私钥.加密.
3加密后传输过程中,使用hex加密.
-------------------------------------------------------------------------------------
Coder 基础加密组件
1 package com.test; 2 3 import java.security.MessageDigest; 4 5 import javax.crypto.KeyGenerator; 6 import javax.crypto.Mac; 7 import javax.crypto.SecretKey; 8 import javax.crypto.spec.SecretKeySpec; 9 10 import sun.misc.BASE64Decoder; 11 import sun.misc.BASE64Encoder; 12 13 /** 14 * 基础加密组件 15 * @author 梁栋 16 * @version 1.0 17 * @since 1.0 18 */ 19 public abstract class Coder { 20 public static final String KEY_SHA = "SHA"; 21 public static final String KEY_MD5 = "MD5"; 22 23 /** 24 * MAC算法可选以下多种算法 25 * 26 * <pre> 27 * HmacMD5 28 * HmacSHA1 29 * HmacSHA256 30 * HmacSHA384 31 * HmacSHA512 32 * </pre> 33 */ 34 public static final String KEY_MAC = "HmacMD5"; 35 36 /** 37 * BASE64解密 38 * 39 * @param key 40 * @return 41 * @throws Exception 42 */ 43 public static byte[] decryptBASE64(String key) throws Exception { 44 return (new BASE64Decoder()).decodeBuffer(key); 45 } 46 47 /** 48 * BASE64加密 49 * 50 * @param key 51 * @return 52 * @throws Exception 53 */ 54 public static String encryptBASE64(byte[] key) throws Exception { 55 return (new BASE64Encoder()).encodeBuffer(key); 56 } 57 58 /** 59 * MD5加密 60 * 61 * @param data 62 * @return 63 * @throws Exception 64 */ 65 public static byte[] encryptMD5(byte[] data) throws Exception { 66 67 MessageDigest md5 = MessageDigest.getInstance(KEY_MD5); 68 md5.update(data); 69 70 return md5.digest(); 71 72 } 73 74 /** 75 * SHA加密 76 * 77 * @param data 78 * @return 79 * @throws Exception 80 */ 81 public static byte[] encryptSHA(byte[] data) throws Exception { 82 83 MessageDigest sha = MessageDigest.getInstance(KEY_SHA); 84 sha.update(data); 85 86 return sha.digest(); 87 88 } 89 90 /** 91 * 初始化HMAC密钥 92 * 93 * @return 94 * @throws Exception 95 */ 96 public static String initMacKey() throws Exception { 97 KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC); 98 99 SecretKey secretKey = keyGenerator.generateKey(); 100 return encryptBASE64(secretKey.getEncoded()); 101 } 102 103 /** 104 * HMAC加密 105 * 106 * @param data 107 * @param key 108 * @return 109 * @throws Exception 110 */ 111 public static byte[] encryptHMAC(byte[] data, String key) throws Exception { 112 113 SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC); 114 Mac mac = Mac.getInstance(secretKey.getAlgorithm()); 115 mac.init(secretKey); 116 117 return mac.doFinal(data); 118 119 } 120 }
RSACoder RSA加密组件
1 package com.test; 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 15 import java.util.HashMap; 16 import java.util.Map; 17 18 import javax.crypto.Cipher; 19 20 /** 21 * RSA安全编码组件 22 * 23 * @author 梁栋 24 * @version 1.0 25 * @since 1.0 26 */ 27 public abstract class RSACoder extends Coder { 28 public static final String KEY_ALGORITHM = "RSA"; 29 public static final String SIGNATURE_ALGORITHM = "MD5withRSA"; 30 31 private static final String PUBLIC_KEY = "RSAPublicKey"; 32 private static final String PRIVATE_KEY = "RSAPrivateKey"; 33 34 /** 35 * 用私钥对信息生成数字签名 36 * 37 * @param data 38 * 加密数据 39 * @param privateKey 40 * 私钥 41 * 42 * @return 43 * @throws Exception 44 */ 45 public static String sign(byte[] data, String privateKey) throws Exception { 46 // 解密由base64编码的私钥 47 byte[] keyBytes = decryptBASE64(privateKey); 48 49 // 构造PKCS8EncodedKeySpec对象 50 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 51 52 // KEY_ALGORITHM 指定的加密算法 53 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 54 55 // 取私钥匙对象 56 PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec); 57 58 // 用私钥对信息生成数字签名 59 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); 60 signature.initSign(priKey); 61 signature.update(data); 62 63 return encryptBASE64(signature.sign()); 64 } 65 66 /** 67 * 校验数字签名 68 * 69 * @param data 70 * 加密数据 71 * @param publicKey 72 * 公钥 73 * @param sign 74 * 数字签名 75 * 76 * @return 校验成功返回true 失败返回false 77 * @throws Exception 78 * 79 */ 80 public static boolean verify(byte[] data, String publicKey, String sign) 81 throws Exception { 82 83 // 解密由base64编码的公钥 84 byte[] keyBytes = decryptBASE64(publicKey); 85 86 // 构造X509EncodedKeySpec对象 87 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); 88 89 // KEY_ALGORITHM 指定的加密算法 90 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 91 92 // 取公钥匙对象 93 PublicKey pubKey = keyFactory.generatePublic(keySpec); 94 95 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); 96 signature.initVerify(pubKey); 97 signature.update(data); 98 99 // 验证签名是否正常 100 return signature.verify(decryptBASE64(sign)); 101 } 102 103 /** 104 * 解密<br> 105 * 用私钥解密 106 * 107 * @param data 108 * @param key 109 * @return 110 * @throws Exception 111 */ 112 public static byte[] decryptByPrivateKey(byte[] data, String key) 113 throws Exception { 114 // 对密钥解密 115 byte[] keyBytes = decryptBASE64(key); 116 117 // 取得私钥 118 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 119 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 120 Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec); 121 122 // 对数据解密 123 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 124 cipher.init(Cipher.DECRYPT_MODE, privateKey); 125 126 return cipher.doFinal(data); 127 } 128 129 /** 130 * 解密<br> 131 * 用公钥解密 132 * 133 * @param data 134 * @param key 135 * @return 136 * @throws Exception 137 */ 138 public static byte[] decryptByPublicKey(byte[] data, String key) 139 throws Exception { 140 // 对密钥解密 141 byte[] keyBytes = decryptBASE64(key); 142 143 // 取得公钥 144 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 145 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 146 Key publicKey = keyFactory.generatePublic(x509KeySpec); 147 148 // 对数据解密 149 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 150 cipher.init(Cipher.DECRYPT_MODE, publicKey); 151 152 return cipher.doFinal(data); 153 } 154 155 /** 156 * 加密<br> 157 * 用公钥加密 158 * 159 * @param data 160 * @param key 161 * @return 162 * @throws Exception 163 */ 164 public static byte[] encryptByPublicKey(byte[] data, String key) 165 throws Exception { 166 // 对公钥解密 167 byte[] keyBytes = decryptBASE64(key); 168 169 // 取得公钥 170 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 171 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 172 Key publicKey = keyFactory.generatePublic(x509KeySpec); 173 174 // 对数据加密 175 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 176 cipher.init(Cipher.ENCRYPT_MODE, publicKey); 177 178 return cipher.doFinal(data); 179 } 180 181 /** 182 * 加密<br> 183 * 用私钥加密 184 * 185 * @param data 186 * @param key 187 * @return 188 * @throws Exception 189 */ 190 public static byte[] encryptByPrivateKey(byte[] data, String key) 191 throws Exception { 192 // 对密钥解密 193 byte[] keyBytes = decryptBASE64(key); 194 195 // 取得私钥 196 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 197 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 198 Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec); 199 200 // 对数据加密 201 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 202 cipher.init(Cipher.ENCRYPT_MODE, privateKey); 203 204 return cipher.doFinal(data); 205 } 206 207 /** 208 * 取得私钥 209 * 210 * @param keyMap 211 * @return 212 * @throws Exception 213 */ 214 public static String getPrivateKey(Map<String, Object> keyMap) 215 throws Exception { 216 Key key = (Key) keyMap.get(PRIVATE_KEY); 217 218 return encryptBASE64(key.getEncoded()); 219 } 220 221 /** 222 * 取得公钥 223 * 224 * @param keyMap 225 * @return 226 * @throws Exception 227 */ 228 public static String getPublicKey(Map<String, Object> keyMap) 229 throws Exception { 230 Key key = (Key) keyMap.get(PUBLIC_KEY); 231 return encryptBASE64(key.getEncoded()); 232 } 233 234 /** 235 * 初始化密钥 236 * 237 * @return 238 * @throws Exception 239 */ 240 public static Map<String, Object> initKey() throws Exception { 241 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM); 242 keyPairGen.initialize(1024); 243 244 KeyPair keyPair = keyPairGen.generateKeyPair(); 245 246 // 公钥 247 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); 248 249 // 私钥 250 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); 251 252 Map<String, Object> keyMap = new HashMap<String, Object>(2); 253 254 keyMap.put(PUBLIC_KEY, publicKey); 255 keyMap.put(PRIVATE_KEY, privateKey); 256 return keyMap; 257 } 258 }
base64Util base加密解密工具类
1 package com.test; 2 3 import sun.misc.BASE64Decoder; 4 import sun.misc.BASE64Encoder; 5 6 /** 7 * BASE64 严格地说，属于编码格式，而非加密算法 8 * Base64被定义为：Base64内容传送编码被设计用来 9 * 把任意序列的8位字节描述为一种不易被人直接识别的形式。 10 * 常见于邮件、http加密，截取http信息，你就会发现登录操 11 * 作的用户名、密码字段通过BASE64加密的。 12 * @author Z10 13 * @time 2014-7-4 上午10:41:11 14 */ 15 public class base64Util { 16 17 public static void main(String[] args) { 18 String str ="我是James. 今年1岁。"; 19 // String str ="Ilovepolly"; 20 System.out.println("加密前"+str); 21 String enStr = null; 22 String deStr = null; 23 String deStr2 = null; 24 try { 25 enStr = base64Util.encryptBASE64(str.getBytes()); 26 deStr = (base64Util.decryptBASE64(enStr)).toString(); //错误用法无法将byte转为string 27 deStr2 = new String(base64Util.decryptBASE64(enStr)); 28 } catch (Exception e) { 29 e.printStackTrace(); 30 } 31 System.out.println("加密后"+enStr); 32 System.out.println("解密后"+deStr); 33 System.out.println("解密后"+deStr2); 34 35 } 36 37 /** 38 * BASE64解密 39 * 40 * @param key 41 * @return 42 * @throws Exception 43 */ 44 public static byte[] decryptBASE64(String key) throws Exception { 45 return (new BASE64Decoder()).decodeBuffer(key); 46 } 47 48 /** 49 * BASE64加密 50 * 51 * @param key 52 * @return 53 * @throws Exception 54 */ 55 public static String encryptBASE64(byte[] key) throws Exception { 56 return (new BASE64Encoder()).encodeBuffer(key); 57 } 58 }
十六进制/2进制转换工具类 hex-byte
MyUtils
1 package com.test.util; 2 3 import java.io.UnsupportedEncodingException; 4 5 public abstract class MyUtils { 6 7 public static char[] hex={'0','1','2','3', 8 '4','5','6','7', 9 '8','9','a','b', 10 'c','d','e','f',}; 11 12 public static String byteToHex(byte[] encode){ 13 14 StringBuffer sb = new StringBuffer(); 15 16 for(int i=0;i<encode.length;i++){ 17 sb.append(hex[(encode[i]>>>4) & 0xF]);//按照字节序列，从高位到低位进行解析 18 sb.append(hex[encode[i] & 0xF]); 19 } 20 21 return sb.toString(); 22 } 23 24 public static byte[] hexToByte(String strIn) throws Exception{ 25 26 byte[] buf=new byte[strIn.length()/2]; 27 28 for(int i=0;i<strIn.length();i=i+2){ 29 String s = strIn.substring(i, i+2); 30 buf[i/2]= (byte) Integer.parseInt(s,16); 31 } 32 33 return buf; 34 // System.out.println(strIn.length()); 35 // byte[] arrB = strIn.getBytes("UTF-8"); 36 // int iLen = arrB.length; 37 // 38 // // 两个字符表示一个字节，所以字节数组长度是字符串长度除以2 39 // byte[] arrOut = new byte[iLen / 2]; 40 // System.out.println(arrOut.length); 41 // for (int i = 0; i < iLen; i = i + 2) { 42 // String strTmp = new String(arrB, i, 2, "UTF-8"); 43 // arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16); 44 // } 45 // return arrOut; 46 } 47 48 }
实际RSA加密解密工具类RSAUtils_V2
1 package com.test.Rsa; 2 import java.io.ByteArrayOutputStream; 3 import java.io.File; 4 import java.io.FileInputStream; 5 import java.io.IOException; 6 import java.security.InvalidKeyException; 7 import java.security.Key; 8 import java.security.KeyFactory; 9 import java.security.KeyPair; 10 import java.security.KeyPairGenerator; 11 import java.security.NoSuchAlgorithmException; 12 import java.security.PrivateKey; 13 import java.security.PublicKey; 14 import java.security.Signature; 15 import java.security.interfaces.RSAPrivateKey; 16 import java.security.interfaces.RSAPublicKey; 17 import java.security.spec.EncodedKeySpec; 18 import java.security.spec.InvalidKeySpecException; 19 import java.security.spec.PKCS8EncodedKeySpec; 20 import java.security.spec.X509EncodedKeySpec; 21 import java.util.HashMap; 22 import java.util.Map; 23 24 import javax.crypto.BadPaddingException; 25 import javax.crypto.Cipher; 26 import javax.crypto.IllegalBlockSizeException; 27 import javax.crypto.NoSuchPaddingException; 28 29 import com.sun.org.apache.xerces.internal.impl.dv.util.Base64; 30 import com.test.util.RSACoder; 31 32 /** *//** 33 * <p> 34 * RSA公钥/私钥/签名工具包 v2 UPDATE BY ZYL 35 * </p> 36 * <p> 37 * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman） 38 * </p> 39 * <p> 40 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/> 41 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/> 42 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全 43 * </p> 44 * <P> 45 * 版本2更新变化: 46 * 1原版本密钥创建后保存在内存map中,新版本密钥创建后保存为public.key,private.key的功能(base64解码后保存). 47 * 2为保证生成文件的密钥内容可以显示并缩短加密后的长度,对需加密内容进行hex(16进制转换)处理后再加密. 48 * 即 49 * </P> 50 * 51 * @author IceWee 52 * @date 2012-4-26 53 * @version 1.0 54 */ 55 public class RSAUtils_V2 { 56 57 /** *//** 58 * 加密算法RSA 59 */ 60 public static final String KEY_ALGORITHM = "RSA"; 61 62 /** *//** 63 * 签名算法 64 */ 65 public static final String SIGNATURE_ALGORITHM = "MD5withRSA"; 66 67 /** *//** 68 * 获取公钥的key 69 */ 70 private static final String PUBLIC_KEY = "RSAPublicKey"; 71 72 /** *//** 73 * 获取私钥的key 74 */ 75 private static final String PRIVATE_KEY = "RSAPrivateKey"; 76 77 /** *//** 78 * RSA最大加密明文大小 79 */ 80 private static final int MAX_ENCRYPT_BLOCK = 117; 81 82 /** *//** 83 * RSA最大解密密文大小 84 */ 85 private static final int MAX_DECRYPT_BLOCK = 128; 86 87 /** *//** 88 * <p> 89 * 生成密钥对(公钥和私钥) 90 * </p> 91 * @return 92 * @throws Exception 93 */ 94 public static Map<String, Object> genKeyPair() throws Exception { 95 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);//"RSA" 96 keyPairGen.initialize(1024); 97 KeyPair keyPair = keyPairGen.generateKeyPair();//Generates a key pair 生成公钥私钥. 98 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();//取得公钥 99 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();//取得私钥 100 Map<String, Object> keyMap = new HashMap<String, Object>(2); 101 keyMap.put(PUBLIC_KEY, publicKey); 102 keyMap.put(PRIVATE_KEY, privateKey); 103 return keyMap; 104 } 105 106 /** 107 * 将公钥私钥(默认base64加密)并转为公钥/私钥字符串还原为对应公钥/私钥 108 * by Z10 109 * @param keyType (publicKey / privateKey) 110 * @param keystr 111 * @return 112 * @throws Exception 113 */ 114 public Key getKeybyKeyStr(String keyType,String keystr) throws Exception{ 115 if(keyType==null||!keyType.equals("")){ 116 throw new Exception("keyType can not be null"); 117 } 118 //需要返回公钥 119 if(keyType.equals(keyType)){ 120 byte[] keyBytes = Base64Utils.decode(keystr); 121 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 122 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 123 Key publicK = keyFactory.generatePublic(x509KeySpec); 124 return publicK; 125 } 126 //需要返回私钥 127 else if(keyType.equals("privateKey")){ 128 byte[] keyBytes = Base64Utils.decode(keystr); 129 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 130 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 131 Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); 132 return privateK; 133 }else{ 134 throw new Exception("keyType'value is incorrect"); 135 } 136 } 137 138 /** 139 * 根据传入的key文件名生成对应key文件. by zyl 140 * @throws IOException 141 * @throws NoSuchAlgorithmException 142 * @throws InvalidKeySpecException 143 */ 144 public static Map<String, Object> getKeyByFile() throws IOException, NoSuchAlgorithmException, InvalidKeySpecException{ 145 Map<String, Object> keyMap = new HashMap<String, Object>(2); 146 FileInputStream fin = new FileInputStream(new File("public.key")); 147 byte[] buf = new byte[fin.available()]; 148 fin.read(buf); 149 X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(Base64.decode(new String(buf))); 150 // 构建key工厂 151 KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 152 // 获取到完整的publickey对象 153 PublicKey publicKey = keyFactory.generatePublic(pubKeySpec); 154 FileInputStream fin2 = new FileInputStream(new File("private.key")); 155 byte[] buf2=new byte[fin2.available()]; 156 fin2.read(buf2); 157 KeyFactory keyFactory2 = KeyFactory.getInstance("RSA"); 158 @SuppressWarnings("static-access") 159 EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(new Base64().decode(new String(buf2))); 160 // 获取到完整的privatekey对象 161 PrivateKey privateKey = keyFactory2.generatePrivate(privateKeySpec); 162 keyMap.put(PUBLIC_KEY, publicKey); 163 keyMap.put(PRIVATE_KEY, privateKey); 164 return keyMap; 165 } 166 167 /** 168 * 生成密钥文本文件 169 * @throws Exception 170 */ 171 public static void createKeyFile(Map<String, Object> keyMap) throws Exception{ 172 //生成公钥 173 String publicKey_Str=RSACoder.getPublicKey(keyMap); 174 byte[] bytes1=publicKey_Str.getBytes("UTF-8"); 175 Base64Utils.byteArrayToFile(bytes1, "public.key"); 176 177 //生成私钥 178 String privateKey_Str=RSACoder.getPrivateKey(keyMap); 179 byte[] bytes2=privateKey_Str.getBytes("UTF-8"); 180 Base64Utils.byteArrayToFile(bytes2, "private.key"); 181 182 } 183 184 /** *//** 185 * <p> 186 * 用私钥对信息生成数字签名 187 * </p> 188 * 189 * @param data 已加密数据 190 * @param privateKey 私钥(BASE64编码) 191 * 192 * @return 193 * @throws Exception 194 */ 195 public static String sign(byte[] data, String privateKey) throws Exception { 196 byte[] keyBytes = Base64Utils.decode(privateKey); 197 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 198 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 199 PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec); 200 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); 201 signature.initSign(privateK); 202 signature.update(data); 203 return Base64Utils.encode(signature.sign()); 204 } 205 206 /** *//** 207 * 校验数字签名 208 * </p> 209 * @param data 已加密数据 210 * @param publicKey 公钥(BASE64编码) 211 * @param sign 数字签名 212 * @return 213 * @throws Exception 214 */ 215 public static boolean verify(byte[] data, String publicKey, String sign) 216 throws Exception { 217 byte[] keyBytes = Base64Utils.decode(publicKey); 218 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); 219 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 220 PublicKey publicK = keyFactory.generatePublic(keySpec); 221 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); 222 signature.initVerify(publicK); 223 signature.update(data); 224 return signature.verify(Base64Utils.decode(sign)); 225 } 226 227 228 /** 229 *私钥解密 by zyl 230 */ 231 public static byte[] decryptByPrivateKey(byte[] encryptedData, Key privateKey)throws Exception { 232 Cipher cipher = Cipher.getInstance("RSA"); 233 cipher.init(Cipher.DECRYPT_MODE, privateKey); 234 int inputLen = encryptedData.length; 235 ByteArrayOutputStream out = new ByteArrayOutputStream(); 236 int offSet = 0; 237 byte[] cache; 238 int i = 0; 239 // 对数据分段解密 240 while (inputLen - offSet > 0) { 241 if (inputLen - offSet > MAX_DECRYPT_BLOCK) { 242 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); 243 } else { 244 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); 245 } 246 out.write(cache, 0, cache.length); 247 i++; 248 offSet = i * MAX_DECRYPT_BLOCK; 249 } 250 byte[] decryptedData = out.toByteArray(); 251 out.close(); 252 return decryptedData; 253 } 254 255 /** *//** 256 * 私钥解密 257 * </p> 258 * @param encryptedData 已加密数据 259 * @param privateKey 私钥(BASE64编码) 260 * @return 261 * @throws Exception 262 */ 263 public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) 264 throws Exception { 265 byte[] keyBytes = Base64Utils.decode(privateKey); 266 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 267 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 268 Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); 269 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 270 cipher.init(Cipher.DECRYPT_MODE, privateK); 271 int inputLen = encryptedData.length; 272 ByteArrayOutputStream out = new ByteArrayOutputStream(); 273 int offSet = 0; 274 byte[] cache; 275 int i = 0; 276 // 对数据分段解密 277 while (inputLen - offSet > 0) { 278 if (inputLen - offSet > MAX_DECRYPT_BLOCK) { 279 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); 280 } else { 281 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); 282 } 283 out.write(cache, 0, cache.length); 284 i++; 285 offSet = i * MAX_DECRYPT_BLOCK; 286 } 287 byte[] decryptedData = out.toByteArray(); 288 out.close(); 289 return decryptedData; 290 } 291 292 293 /** *//** 294 * 公钥解密 295 * </p> 296 * @param encryptedData 已加密数据 297 * @param publicKey 公钥(BASE64编码) 298 * @return 299 * @throws Exception 300 */ 301 public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) 302 throws Exception { 303 304 byte[] keyBytes = Base64Utils.decode(publicKey); 305 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 306 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 307 Key publicK = keyFactory.generatePublic(x509KeySpec); 308 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 309 cipher.init(Cipher.DECRYPT_MODE, publicK); 310 int inputLen = encryptedData.length; 311 ByteArrayOutputStream out = new ByteArrayOutputStream(); 312 int offSet = 0; 313 byte[] cache; 314 int i = 0; 315 // 对数据分段解密 316 while (inputLen - offSet > 0) { 317 if (inputLen - offSet > MAX_DECRYPT_BLOCK) { 318 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); 319 } else { 320 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); 321 } 322 out.write(cache, 0, cache.length); 323 i++; 324 offSet = i * MAX_DECRYPT_BLOCK; 325 } 326 byte[] decryptedData = out.toByteArray(); 327 out.close(); 328 return decryptedData; 329 } 330 331 /** 332 * 公钥加密 by zyl 333 * @param data 334 * @param publicKey 335 * @return 336 */ 337 public static byte[] encryptByPublicKey(byte[] data, Key publicKey) throws Exception{ 338 // 对数据加密 339 /*根据公钥加密*/ 340 Cipher cipher = Cipher.getInstance("RSA"); 341 cipher.init(Cipher.ENCRYPT_MODE,publicKey); 342 int inputLen = data.length; 343 ByteArrayOutputStream out = new ByteArrayOutputStream(); 344 int offSet = 0; 345 byte[] cache; 346 int i = 0; 347 // 对数据分段加密 348 while (inputLen - offSet > 0) { 349 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { 350 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); 351 } else { 352 cache = cipher.doFinal(data, offSet, inputLen - offSet); 353 } 354 out.write(cache, 0, cache.length); 355 i++; 356 offSet = i * MAX_ENCRYPT_BLOCK; 357 } 358 byte[] encryptedData = out.toByteArray(); 359 out.close(); 360 return encryptedData; 361 } 362 363 /**<p> 364 * 公钥加密 365 * </p> 366 * @param data 源数据 367 * @param publicKey 公钥(BASE64编码) 368 * @return 369 * @throws Exception 370 */ 371 public static byte[] encryptByPublicKey(byte[] data, String publicKey) 372 throws Exception { 373 byte[] keyBytes = Base64Utils.decode(publicKey); 374 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 375 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 376 Key publicK = keyFactory.generatePublic(x509KeySpec); 377 // 对数据加密 378 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 379 cipher.init(Cipher.ENCRYPT_MODE, publicK); 380 int inputLen = data.length; 381 ByteArrayOutputStream out = new ByteArrayOutputStream(); 382 int offSet = 0; 383 byte[] cache; 384 int i = 0; 385 // 对数据分段加密 386 while (inputLen - offSet > 0) { 387 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { 388 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); 389 } else { 390 cache = cipher.doFinal(data, offSet, inputLen - offSet); 391 } 392 out.write(cache, 0, cache.length); 393 i++; 394 offSet = i * MAX_ENCRYPT_BLOCK; 395 } 396 byte[] encryptedData = out.toByteArray(); 397 out.close(); 398 return encryptedData; 399 } 400 401 /** 402 * 私钥加密by zyl 403 */ 404 public static byte[] encryptByPrivateKey(byte[] data, Key privateKey)throws Exception { 405 Cipher cipher = Cipher.getInstance("RSA"); 406 cipher.init(Cipher.ENCRYPT_MODE, privateKey); 407 int inputLen = data.length; 408 ByteArrayOutputStream out = new ByteArrayOutputStream(); 409 int offSet = 0; 410 byte[] cache; 411 int i = 0; 412 // 对数据分段加密 413 while (inputLen - offSet > 0) { 414 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { 415 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); 416 } else { 417 cache = cipher.doFinal(data, offSet, inputLen - offSet); 418 } 419 out.write(cache, 0, cache.length); 420 i++; 421 offSet = i * MAX_ENCRYPT_BLOCK; 422 } 423 byte[] encryptedData = out.toByteArray(); 424 out.close(); 425 return encryptedData; 426 } 427 428 429 /** *//** 430 * <p> 431 * 私钥加密 432 * </p> 433 * @param data 源数据 434 * @param privateKey 私钥(BASE64编码) 435 * @return 436 * @throws Exception 437 */ 438 public static byte[] encryptByPrivateKey(byte[] data, String privateKey) 439 throws Exception { 440 byte[] keyBytes = Base64Utils.decode(privateKey); 441 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 442 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); 443 Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); 444 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 445 cipher.init(Cipher.ENCRYPT_MODE, privateK); 446 int inputLen = data.length; 447 ByteArrayOutputStream out = new ByteArrayOutputStream(); 448 int offSet = 0; 449 byte[] cache; 450 int i = 0; 451 // 对数据分段加密 452 while (inputLen - offSet > 0) { 453 if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { 454 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); 455 } else { 456 cache = cipher.doFinal(data, offSet, inputLen - offSet); 457 } 458 out.write(cache, 0, cache.length); 459 i++; 460 offSet = i * MAX_ENCRYPT_BLOCK; 461 } 462 byte[] encryptedData = out.toByteArray(); 463 out.close(); 464 return encryptedData; 465 } 466 467 /** *//** 468 * <p> 469 * 获取私钥 470 * </p> 471 * @param keyMap 密钥对 472 * @return 473 * @throws Exception 474 */ 475 public static String getPrivateKey(Map<String, Object> keyMap) 476 throws Exception { 477 Key key = (Key) keyMap.get(PRIVATE_KEY); 478 return Base64Utils.encode(key.getEncoded()); 479 } 480 481 /** *//** 482 * <p> 483 * 获取公钥 484 * </p> 485 * @param keyMap 密钥对 486 * @return 487 * @throws Exception 488 */ 489 public static String getPublicKey(Map<String, Object> keyMap) 490 throws Exception { 491 Key key = (Key) keyMap.get(PUBLIC_KEY); 492 return Base64Utils.encode(key.getEncoded()); 493 } 494 }
测试类:
testRSAUnitsV2
1 package com.rsa.test; 2 3 import java.security.Key; 4 import java.util.Map; 5 6 import org.junit.Test; 7 8 import com.test.Rsa.RSAUtils_V2; 9 import com.test.util.MyUtils; 10 11 public class testRSAUnitsV2 { 12 13 static String publicKey2; 14 static String privateKey2; 15 16 public static void main(String args[]){ 17 try { 18 test3(); 19 } catch (Exception e) { 20 e.printStackTrace(); 21 } 22 23 } 24 25 /** 26 * 加密解密 27 * @throws Exception 28 */ 29 /** 30 * 生成密钥对,并保存为对应文本文件. 31 */ 32 public void test1() { 33 RSAUtils_V2 r2=new RSAUtils_V2(); 34 try { 35 Map<String, Object> keyMap=RSAUtils_V2.genKeyPair(); 36 RSAUtils_V2.createKeyFile(keyMap); 37 } catch (Exception e) { 38 e.printStackTrace(); 39 } 40 } 41 42 /** 43 * 1读取test()方法中生成的密钥文件, 并在内存中生成密钥 44 * 2使用密钥加密解密文本. 45 */ 46 public static void test2() { 47 try { 48 Map<String, Object> keyMap2=RSAUtils_V2.getKeyByFile(); 49 publicKey2 = RSAUtils_V2.getPublicKey(keyMap2);//获取公钥 50 privateKey2 = RSAUtils_V2.getPrivateKey(keyMap2);//获取私钥 51 System.err.println("公钥: " + publicKey2); 52 System.err.println("私钥： " + privateKey2); 53 54 String str="这是一行没有任何意义的文字，你看完了等于没看，不是吗？";//.来加密我吧.I M KEY! 55 System.out.println(" 加密前="+str); 56 byte[] jiami=RSAUtils_V2.encryptByPublicKey(str.getBytes(), (Key)keyMap2.get("RSAPublicKey")); 57 System.out.println(" 加密后="+new String(jiami)); 58 59 byte[] jiami2=RSAUtils_V2.decryptByPrivateKey(jiami, (Key)keyMap2.get("RSAPrivateKey")); 60 System.out.println(" 解密后="+new String(jiami2)); 61 }catch (Exception e) { 62 e.printStackTrace(); 63 } 64 } 65 /** 66 * test2基础上: 67 * 加密后可以对byte进行hex.这样内容就不是乱码,大小更小,也便于进行传播. 68 * 解密前对hex进行转换hex2byte即可,然后解密即可 69 */ 70 public static void test3(){ 71 try { 72 Map<String, Object> keyMap2 = RSAUtils_V2.getKeyByFile(); 73 publicKey2 = RSAUtils_V2.getPublicKey(keyMap2);//获取公钥 74 privateKey2 = RSAUtils_V2.getPrivateKey(keyMap2);//获取私钥 75 System.err.println("公钥: " + publicKey2); 76 System.err.println("私钥： " + privateKey2); 77 String str = "这是一行没有任何意义的文字，你看完了等于没看，不是吗？据说长度太长会有问题.于是:" + 78 "日前拜仁董事会主席鲁梅尼格表示，鉴于目前球员们的比赛压力太大，国家队比赛场次应当减少。" + 79 "鲁梅尼格表示：“球员们的压力早已经超过了健康的范围之内，已经达到了身体所允许的上限。国家队" + 80 "比赛的增长是有责任的。”鲁梅尼格呼吁国际足联以及欧足联减少国家队比赛次数。“比赛应当以质量而不" + 81 "是数量为目标。”另外鲁梅尼格举出具体的数字表示，在过去的几十年里，球员们国家队的比赛数量增长了30%，" + 82 "“贝肯鲍尔时代的球员们每年只需要参加8.5场国家队比赛，而穆勒们则需要参加大概13场。”而俱乐部则必须承担国" + 83 "家队比赛增多的风险。在周末的德甲联赛中拜仁客场0-0与汉堡互交白卷，赛前球队中场罗本已经进入首发阵容，但不慎" + 84 "在热身时受伤。据报道，罗本或将继续无缘拜仁下场对阵帕德博恩的比赛。在对阵汉堡的比赛前罗本已经被列入球队首发，但在热身时罗本再度受伤。“肌肉感觉有些紧。”随后原本计划被轮换的穆勒临时出场替代罗本。另外罗本表示这只是预防措施。但球队下一场对阵帕德博恩能够出场，罗本表示：“我也不能确定。”";//.来加密我吧.I M KEY! 85 System.out.println(" 加密前=" + str); 86 byte[] jiami = RSAUtils_V2.encryptByPublicKey(str.getBytes(), 87 (Key) keyMap2.get("RSAPublicKey")); 88 System.out.println(" 加密后=" + new String(jiami)); 89 System.out.println(" 加密后长度=" + jiami.length); 90 //加密后hex 91 String afterhex=MyUtils.byteToHex(jiami); 92 System.out.println(" 加密并hex后=" + new String(afterhex)); 93 System.out.println(" 加密并hex后长度=" + afterhex.length()); 94 //反hex 95 byte[] afterReHEX=MyUtils.hexToByte(afterhex); 96 byte[] jiami2 = RSAUtils_V2.decryptByPrivateKey(afterReHEX, 97 (Key) keyMap2.get("RSAPrivateKey")); 98 System.out.println(" 解密后=" + new String(jiami2)); 99 System.out.println(" 解密后长度=" + jiami2.length); 100 } catch (Exception e) { 101 } 102 } 103 }
执行test3 效果如下:
公钥: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCRM6FQTDPWppMTOJ3HFrpinxGUhQtQhaPXIGFBuwsqx3QsuJmVIX3DpJ0KU3cEUumDMM6qkTvFGtoIDeYQxuslUWCMFm+ma7DoDS+3RQ6nExQ5F3cTXhvXosrYYcADKP6pk8fVIiY+cq+yq/KV0OB6yOJ96N4wywhe6y3hldUXcwIDAQAB 私钥： MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJEzoVBMM9amkxM4nccWumKfEZSFC1CFo9cgYUG7CyrHdCy4mZUhfcOknQpTdwRS6YMwzqqRO8Ua2ggN5hDG6yVRYIwWb6ZrsOgNL7dFDqcTFDkXdxNeG9eiythhwAMo/qmTx9UiJj5yr7Kr8pXQ4HrI4n3o3jDLCF7rLeGV1RdzAgMBAAECgYBV0DmqBx8r4M5TMcatftUwq+nr6KVDNXgbD9vqyOxUoAQc2gyKgnydP5BAJgvU1luDWTkKvUKhvrjUwcIScD1PrhyecjVMqb8tvmexefd1bcPq9OZpxQjR64pwRPjC7krOENR5moiIKhngSk4Qp/dk/xX6l+h+wLlBjneQsVDxYQJBAOFDuPitRRPds+vd33lYNr2IEiJkvIErxZUXRu4Pfc/e4m03dcyhJ3eqn7KoBL4trYQsboYl3HYpDkHfHxWMCf0CQQClA2M2KdBB1F7Kb0TymM5CtvNfBsSqADspkJeCmANwCNPKW4hzq++YyfFX5cqkSuuTlS+7vjvlCgYiXDjpVuovAkEAvIjU0HUcopLk2l1Zg5L8RccT/ms3hhjfhnfz6p1WnFscQXKwijK6+KH6hSmwxocuebhCTM51ZQPZpfIbbwpE9QJAdN/LW0eOW7HhWZwpx3H3VUVjZsDSdl4niS8CQNsOREHcUA04vkTfNOaDa/Az8N2nsSYPYvhAT98jrR6IqKyIvQJAda1Kya8NLWtSbmHBldqhjSxhkEZRofzHO38Qldvfs3XU4bsPZ1YkFruf8ilVdaFSVznX88YaFK9zEBBAix/KcA== 加密前=这是一行没有任何意义的文字，你看完了等于没看，不是吗？据说长度太长会有问题.于是:日前拜仁董事会主席鲁梅尼格表示，鉴于目前球员们的比赛压力太大，国家队比赛场次应当减少。鲁梅尼格表示：“球员们的压力早已经超过了健康的范围之内，已经达到了身体所允许的上限。国家队比赛的增长是有责任的。”鲁梅尼格呼吁国际足联以及欧足联减少国家队比赛次数。“比赛应当以质量而不是数量为目标。”另外鲁梅尼格举出具体的数字表示，在过去的几十年里，球员们国家队的比赛数量增长了30%，“贝肯鲍尔时代的球员们每年只需要参加8.5场国家队比赛，而穆勒们则需要参加大概13场。”而俱乐部则必须承担国家队比赛增多的风险。在周末的德甲联赛中拜仁客场0-0与汉堡互交白卷，赛前球队中场罗本已经进入首发阵容，但不慎在热身时受伤。据报道，罗本或将继续无缘拜仁下场对阵帕德博恩的比赛。在对阵汉堡的比赛前罗本已经被列入球队首发，但在热身时罗本再度受伤。“肌肉感觉有些紧。”随后原本计划被轮换的穆勒临时出场替代罗本。另外罗本表示这只是预防措施。但球队下一场对阵帕德博恩能够出场，罗本表示：“我也不能确定。” 加密后=e�z]����}�t� O� `����CD��/�I�tM/��9�`�z!����W_w<��W��ޣU�|�E�)�8�z�b��.:�Ha����֏���x<�k ���,���(��l�Y%�`�aM�ji?��h�� ���pwuy��I$