RSA非对称加密Java实现

 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 }

  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