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 }

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
时间: 2024-11-05 13:28:44

RSA非对称加密Java实现的相关文章

c#与JavaScript实现对用户名、密码进行RSA非对称加密

原文:c#与JavaScript实现对用户名.密码进行RSA非对称加密 博主最近手上这个项目呢(就是有上百个万恶的复杂excel需要解析的那个项目,参见博客:http://www.cnblogs.com/csqb-511612371/p/4885930.html),由于是一个内网项目,安全性要求很低,不需要做什么报文加密. 但是总觉得用户名密码都是明文传输,略微有点坑甲方... 想了想,那就做个RSA加密,把用户名.密码做密文传输吧...至于为什么是RSA,因为也想趁机学习一下,DES.MD5什

RSA 非对称加密,私钥转码为pkcs8 错误总结

RSA 非对称加密,私钥转码为pkcs8 错误总结 最近在和某上市公司对接金融方面的业务时,关于RSA对接过程中遇到了一个坑,特来分享下解决方案. 该上市公司简称为A公司,我们简称为B公司.A-B两家公司通信采用HTTPS协议,加密方式选择RSA非对称加密+签名的方式,以保障数据通信安全,不被篡改. 虽然对于数据通信来说,安全是有了保障.但对于开发来说,却添了不少的麻烦.麻烦就在于加解密十分繁琐. A 公司提供了自己的公钥,以及我们公司(B)的私钥.我们需要将私钥转换成pkcs8 的格式.然后从

RSA非对称加密,使用OpenSSL生成证书,iOS加密,java解密

最近换了一份工作,工作了大概一个多月了吧.差不多得有两个月没有更新博客了吧.在新公司自己写了一个iOS的比较通用的可以架构一个中型应用的不算是框架的一个结构,并已经投入使用.哈哈 说说文章标题的相关的内容吧 很多对安全要求比较高的应用都要使用加密,加密后与后端沟通数据,这样能防止被别人截获数据包,直接把借口的参数数据暴露.我上一家公司是做P2P互联网金融的,就使用了多种加密方式,有对称的也有非对称的.最近新公司的APP也有意向使用加密,思考了一下,最成熟的解决方案就是使用RSA非对称的加密了.就

再谈加密-RSA非对称加密的理解和使用

html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption

RSA 非对称加密【转】

演示代码:https://pan.baidu.com/s/10rfSUUDEEHvCDEYH0oEVCw Base64工具类,可以让rsa编码的乱码变成一串字符序列 1 package com.utils; 2 3 import java.io.ByteArrayInputStream; 4 import java.io.ByteArrayOutputStream; 5 import java.io.File; 6 import java.io.FileInputStream; 7 import

(转)C#实现RSA非对称加密解密

转自:http://blog.csdn.net/u010678947/article/details/48652875 一.RSA简介 RSA公钥加密算法是1977年由Ron Rivest.Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的.RSA取名来自开发他们三者的名字.RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准.RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式

python使用rsa非对称加密

1.安装rsa 支持python 2.7 或者 python 3.5 以上版本 使用豆瓣pypi源来安装rsa pip install -i https://pypi.douban.com/simple rsa 2.加密解密 2.1.生成公私钥对 import rsa # 1.接收者(A)生成512位公私钥对 # a. lemon_pub为PublicKey对象, lemon_priv为PrivateKey对象 # b. 512为秘钥的位数, 可以自定义指定, 例如: 128.256.512.1

关于rsa非对称加密、解密、签名、验签

测试数据: 1 var xmlprikey =""; 2 var xmlpubkey =""; 3 rsa = new RSACryption(); 4 //待处理字符串 5 var str="hello成功啊啊!¥%……&*([email protected]#$%^&*()@#$%^&*()_}::{>>?}{>?{?"; 6 var strlen= str.Length; 7 rsa.RSAKey(

RSA js加密 java解密

1. 首先你要拥有一对公钥.私钥: ``` pubKeyStr = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC1gr+rIfYlaNUNLiFsK/Knb54nQrCRTRMOdujTwkpqKLo4pNYj2StmryWETeFxOCFtCt/7ixTUrU2RGGjkIOlYC3144h0dJKDtPXw9+mFyW1VwWvtfoiSUeKTEbz1tSHghEcdEvVq6qlSQukiLAEZabiwfEE30TQ6g979X6YXhnQIDAQA