原文
加密基础方法类
1 import java.security.MessageDigest;
2 import sun.misc.BASE64Decoder;
3 import sun.misc.BASE64Encoder;
4 public class SecurityBase {
5 public static final String KEY_SHA="SHA";
6 public static final String KEY_MD5="MD5";
7 //BASE64解密
8 public static byte[] decryptBASE64(String key) throws Exception{
9 return (new BASE64Decoder()).decodeBuffer(key);
10 }
11 //BASE64加密
12 public static String encryptBASE64(byte[] key)throws Exception{
13 return (new BASE64Encoder()).encodeBuffer(key);
14 }
15 //MD5加密
16 public static byte[] encryptMD5(byte[] data)throws Exception{
17 MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
18 md5.update(data);
19 return md5.digest();
20 }
21 //SHA加密
22 public static byte[] encryptSHA(byte[] data)throws Exception{
23 MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
24 sha.update(data);
25 return sha.digest();
26 }
27 }
RSA非对称加密实现类
1 import java.security.Key;
2 import java.security.KeyFactory;
3 import java.security.KeyPair;
4 import java.security.KeyPairGenerator;
5 import java.security.PrivateKey;
6 import java.security.PublicKey;
7 import java.security.Signature;
8 import java.security.interfaces.RSAPrivateKey;
9 import java.security.interfaces.RSAPublicKey;
10 import java.security.spec.PKCS8EncodedKeySpec;
11 import java.security.spec.X509EncodedKeySpec;
12 import java.util.HashMap;
13 import java.util.Map;
14 import javax.crypto.Cipher;
15 public class RSASecurity extends SecurityBase {
16 public static final String KEY_ALGORTHM="RSA";
17 public static final String SIGNATURE_ALGORITHM="MD5withRSA";
18 public static final String PUBLIC_KEY = "RSAPublicKey";//公钥
19 public static final String PRIVATE_KEY = "RSAPrivateKey";//私钥
20 /**
21 * 初始化密钥
22 * @return
23 * @throws Exception
24 */
25 public static Map<String,Key> createKeys()throws Exception{
26 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORTHM);
27 keyPairGenerator.initialize(1024);
28 KeyPair keyPair = keyPairGenerator.generateKeyPair();
29 //公钥
30 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
31 //私钥
32 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
33 Map<String,Key> keyMap = new HashMap<String, Key>(2);
34 keyMap.put(PUBLIC_KEY, publicKey);
35 keyMap.put(PRIVATE_KEY, privateKey);
36 return keyMap;
37 }
38 /**
39 * 取得公钥，并转化为String类型
40 * @param keyMap
41 * @return
42 * @throws Exception
43 */
44 public static String getPublicKey(Map<String, Key> keyMap)throws Exception{
45 Key key = keyMap.get(PUBLIC_KEY);
46 return encryptBASE64(key.getEncoded());
47 }
48 /**
49 * 取得私钥，并转化为String类型
50 * @param keyMap
51 * @return
52 * @throws Exception
53 */
54 public static String getPrivateKey(Map<String, Key> keyMap) throws Exception{
55 Key key = keyMap.get(PRIVATE_KEY);
56 return encryptBASE64(key.getEncoded());
57 }
58 /**
59 * 用私钥加密
60 * @param data 加密数据
61 * @param key 密钥
62 * @return
63 * @throws Exception
64 */
65 public static byte[] encryptByPrivateKey(byte[] data,String key)throws Exception{
66 //解密密钥
67 byte[] keyBytes = decryptBASE64(key);
68 //取私钥
69 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
70 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
71 Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
72 //对数据加密
73 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
74 cipher.init(Cipher.ENCRYPT_MODE, privateKey);
75 return cipher.doFinal(data);
76 }
77 /**
78 * 用私钥解密
79 * @param data 加密数据
80 * @param key 密钥
81 * @return
82 * @throws Exception
83 */
84 public static byte[] decryptByPrivateKey(byte[] data,String key)throws Exception{
85 //对私钥解密
86 byte[] keyBytes = decryptBASE64(key);
87 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
88 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
89 Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
90 //对数据解密
91 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
92 cipher.init(Cipher.DECRYPT_MODE, privateKey);
93 return cipher.doFinal(data);
94 }
95 /**
96 * 用公钥加密
97 * @param data 加密数据
98 * @param key 密钥
99 * @return
100 * @throws Exception
101 */
102 public static byte[] encryptByPublicKey(byte[] data,String key)throws Exception{
103 //对公钥解密
104 byte[] keyBytes = decryptBASE64(key);
105 //取公钥
106 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
107 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
108 Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
109 //对数据解密
110 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
111 cipher.init(Cipher.ENCRYPT_MODE, publicKey);
112 return cipher.doFinal(data);
113 }
114 /**
115 * 用公钥解密
116 * @param data 加密数据
117 * @param key 密钥
118 * @return
119 * @throws Exception
120 */
121 public static byte[] decryptByPublicKey(byte[] data,String key)throws Exception{
122 //对私钥解密
123 byte[] keyBytes = decryptBASE64(key);
124 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
125 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
126 Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
127 //对数据解密
128 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
129 cipher.init(Cipher.DECRYPT_MODE, publicKey);
130 return cipher.doFinal(data);
131 }
132 /**
133 * 用私钥对信息生成数字签名
134 * @param data //加密数据
135 * @param privateKey //私钥
136 * @return
137 * @throws Exception
138 */
139 public static String sign(byte[] data,String privateKey)throws Exception{
140 //解密私钥
141 byte[] keyBytes = decryptBASE64(privateKey);
142 //构造PKCS8EncodedKeySpec对象
143 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
144 //指定加密算法
145 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
146 //取私钥匙对象
147 PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
148 //用私钥对信息生成数字签名
149 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
150 signature.initSign(privateKey2);
151 signature.update(data);
152 return encryptBASE64(signature.sign());
153 }
154 /**
155 * 校验数字签名
156 * @param data 加密数据
157 * @param publicKey 公钥
158 * @param sign 数字签名
159 * @return
160 * @throws Exception
161 */
162 public static boolean verify(byte[] data,String publicKey,String sign)throws Exception{
163 //解密公钥
164 byte[] keyBytes = decryptBASE64(publicKey);
165 //构造X509EncodedKeySpec对象
166 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
167 //指定加密算法
168 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
169 //取公钥匙对象
170 PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);
171 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
172 signature.initVerify(publicKey2);
173 signature.update(data);
174 //验证签名是否正常
175 return signature.verify(decryptBASE64(sign));
176 }
177 /**
178 *
179 * @Title: main
180 * @Description: 测试
181 * @param @param args
182 * @return void
183 * @throws
184 */
185 public static void main(String[] args) {
186 try {
187 Map<String,Key> data = createKeys();
188 String content = "JavaRsaEncoder";
189 System.out.println("加密前："+content);
190 String encode = encryptBASE64(encryptByPrivateKey(content.getBytes(), getPrivateKey(data)));
191 System.out.println("加密后："+encode);
192 String decode = new String(decryptByPublicKey(decryptBASE64(encode), getPublicKey(data)));
193 System.out.println("解密后："+decode);
194 } catch (Exception e) {
195 e.printStackTrace();
196 }
197 }
198 }
运行结果
1 加密前：JavaRsaEncoder
2 加密后：l+vhbdRdq3dc5nr6m4jSIuW0ufKeCYBw4ds2Es9/SmPa/Dp298gZsT8KkZRwlKcm60+MV67fVMyG
3 OgwCZWbqQqmu8Mr+ZuqUWWnIZ0fIi1JAaqiwqsg7SaIkvixU35HHdsxmNMdK+1qPDWBE5sCjSCJ+
4 xaG0Y8BOpyGDlpL9bOc=
5 解密后：JavaRsaEncoder