RSA公钥加密算法是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密算法。

RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。

关于RSA算法的原理，这里就不再详加介绍，网上各种资源一大堆。下面就开始介绍RSA加密解密JAVA类的具体实现。

01 import java.security.MessageDigest;
02  
03 import sun.misc.BASE64Decoder;
04 import sun.misc.BASE64Encoder;
05  
06 public class Coder {
07      
08     public static final String KEY_SHA="SHA";
09     public static final String KEY_MD5="MD5";
10      
11     /**
12      * BASE64解密
13      * @param key
14      * @return
15      * @throws Exception
16      */
17     public static byte[] decryptBASE64(String key) throws Exception{
18         return (new BASE64Decoder()).decodeBuffer(key);
19     }
20      
21     /**
22      * BASE64加密
23      * @param key
24      * @return
25      * @throws Exception
26      */
27     public static String encryptBASE64(byte[] key)throws Exception{
28         return (new BASE64Encoder()).encodeBuffer(key);
29     }
30      
31     /**
32      * MD5加密
33      * @param data
34      * @return
35      * @throws Exception
36      */
37     public static byte[] encryptMD5(byte[] data)throws Exception{
38         MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
39         md5.update(data);
40         return md5.digest();
41     }
42      
43     /**
44      * SHA加密
45      * @param data
46      * @return
47      * @throws Exception
48      */
49     public static byte[] encryptSHA(byte[] data)throws Exception{
50         MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
51         sha.update(data);
52         return sha.digest();
53     }
54 }

先提供Coder编码类，该类封装了基本的Base64、md5和SHA加密解密算法。Java对这些算法的实现提供了很好的API封装，开发人员只需调用这些API就可很简单方便的实现数据的加密与解密。

下面提供RSA加密解密类，该类为Coder类子类，因为其中对RSA公私密钥的保存进行了一层Base64加密处理。

RSA加密解密类静态常量

1    public static final String KEY_ALGORTHM="RSA";//
2 public static final String SIGNATURE_ALGORITHM="MD5withRSA";
3  
4 public static final String PUBLIC_KEY = "RSAPublicKey";//公钥
5 public static final String PRIVATE_KEY = "RSAPrivateKey";//私钥

RSA加密解密的实现，需要有一对公私密钥，公私密钥的初始化如下：

01 /**
02      * 初始化密钥
03      * @return
04      * @throws Exception
05      */
06     public static Map<String,Object> initKey()throws Exception{
07         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORTHM);
08         keyPairGenerator.initialize(1024);
09         KeyPair keyPair = keyPairGenerator.generateKeyPair();
10          
11         //公钥
12         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
13         //私钥
14         RSAPrivateKey privateKey =  (RSAPrivateKey) keyPair.getPrivate();
15          
16         Map<String,Object> keyMap = new HashMap<String, Object>(2);
17         keyMap.put(PUBLIC_KEY, publicKey);
18         keyMap.put(PRIVATE_KEY, privateKey);
19          
20         return keyMap;
21     }

从代码中可以看出密钥的初始化长度为1024位，密钥的长度越长，安全性就越好，但是加密解密所用的时间就会越多。而一次能加密的密文长度也与密钥的长度成正比。一次能加密的密文长度为：密钥的长度/8-11。所以1024bit长度的密钥一次可以加密的密文为1024/8-11=117bit。所以非对称加密一般都用于加密对称加密算法的密钥，而不是直接加密内容。对于小文件可以使用RSA加密，但加密过程仍可能会使用分段加密。

从map中获取公钥、私钥

01 /**
02      * 取得公钥，并转化为String类型
03      * @param keyMap
04      * @return
05      * @throws Exception
06      */
07     public static String getPublicKey(Map<String, Object> keyMap)throws Exception{
08         Key key = (Key) keyMap.get(PUBLIC_KEY); 
09         return encryptBASE64(key.getEncoded());    
10     }
11  
12     /**
13      * 取得私钥，并转化为String类型
14      * @param keyMap
15      * @return
16      * @throws Exception
17      */
18     public static String getPrivateKey(Map<String, Object> keyMap) throws Exception{
19         Key key = (Key) keyMap.get(PRIVATE_KEY); 
20         return encryptBASE64(key.getEncoded());    
21     }

对于RSA产生的公钥、私钥，我们可以有两种方式可以对信息进行加密解密。私钥加密-公钥解密 和 公钥加密-私钥解密。

私钥加密

01 /**
02      * 用私钥加密
03      * @param data  加密数据
04      * @param key   密钥
05      * @return
06      * @throws Exception
07      */
08     public static byte[] encryptByPrivateKey(byte[] data,String key)throws Exception{
09         //解密密钥
10         byte[] keyBytes = decryptBASE64(key);
11         //取私钥
12         PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
13         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
14         Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
15          
16         //对数据加密
17         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
18         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
19          
20         return cipher.doFinal(data);
21     }

私钥解密

01 /**
02      * 用私钥解密<span style="color:#000000;"></span> * @param data  加密数据
03      * @param key   密钥
04      * @return
05      * @throws Exception
06      */
07     public static byte[] decryptByPrivateKey(byte[] data,String key)throws Exception{
08         //对私钥解密
09         byte[] keyBytes = decryptBASE64(key);
10          
11         PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
12         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
13         Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
14         //对数据解密
15         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
16         cipher.init(Cipher.DECRYPT_MODE, privateKey);
17          
18         return cipher.doFinal(data);
19     }

公钥加密

01 /**
02      * 用公钥加密
03      * @param data  加密数据
04      * @param key   密钥
05      * @return
06      * @throws Exception
07      */
08     public static byte[] encryptByPublicKey(byte[] data,String key)throws Exception{
09         //对公钥解密
10         byte[] keyBytes = decryptBASE64(key);
11         //取公钥
12         X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
13         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
14         Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
15          
16         //对数据解密
17         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
18         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
19          
20         return cipher.doFinal(data);
21     }

私钥加密

01 /**
02      * 用公钥解密
03      * @param data  加密数据
04      * @param key   密钥
05      * @return
06      * @throws Exception
07      */
08     public static byte[] decryptByPublicKey(byte[] data,String key)throws Exception{
09         //对私钥解密
10         byte[] keyBytes = decryptBASE64(key);
11         X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
12         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
13         Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
14          
15         //对数据解密
16         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
17         cipher.init(Cipher.DECRYPT_MODE, publicKey);
18          
19         return cipher.doFinal(data);
20     }

关于数字签名，先了解下何为数字签名。数字签名，就是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。数字签名是非对称密钥加密技术与数字摘要技术的应用。简单地说,所谓数字签名就是附加在数据单元上的一些数据,或是对数据单元所作的密码变换。这种数据或变换允许数据单元的接收者用以确认数据单元的来源和数据单元的完整性并保护数据,防止被人(例如接收者)进行伪造。

数字签名的主要功能如下：

保证信息传输的完整性、发送者的身份认证、防止交易中的抵赖发生。

数字签名技术是将摘要信息用发送者的私钥加密，与原文一起传送给接收者。接收者只有用发送者的公钥才能解密被加密的摘要信息，然后用对收到的原文产生一个摘要信息，与解密的摘要信息对比。如果相同，则说明收到的信息是完整的，在传输过程中没有被修改，否则说明信息被修改过，因此数字签名能够验证信息的完整性。

数字签名是个加密的过程，数字签名验证是个解密的过程。

     数字签名算法依靠公钥加密技术来实现的。在公钥加密技术里，每一个使用者有一对密钥：一把公钥和一把私钥。公钥可以自由发布，但私钥则秘密保存；还有一个要求就是要让通过公钥推算出私钥的做法不可能实现。
    普通的数字签名算法包括三种算法：
    1.密码生成算法；
    2.标记算法；

3.验证算法。

通过RSA加密解密算法，我们可以实现数字签名的功能。我们可以用私钥对信息生成数字签名，再用公钥来校验数字签名，当然也可以反过来公钥签名，私钥校验。

私钥签名

01 /**
02      *  用私钥对信息生成数字签名
03      * @param data  //加密数据
04      * @param privateKey    //私钥
05      * @return
06      * @throws Exception
07      */
08     public static String sign(byte[] data,String privateKey)throws Exception{
09         //解密私钥
10         byte[] keyBytes = decryptBASE64(privateKey);
11         //构造PKCS8EncodedKeySpec对象
12         PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
13         //指定加密算法
14         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
15         //取私钥匙对象
16         PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
17         //用私钥对信息生成数字签名
18         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
19         signature.initSign(privateKey2);
20         signature.update(data);
21          
22         return encryptBASE64(signature.sign());
23     }

公钥校验

01 /**
02      * 校验数字签名
03      * @param data  加密数据
04      * @param publicKey 公钥
05      * @param sign  数字签名
06      * @return
07      * @throws Exception
08      */
09     public static boolean verify(byte[] data,String publicKey,String sign)throws Exception{
10         //解密公钥
11         byte[] keyBytes = decryptBASE64(publicKey);
12         //构造X509EncodedKeySpec对象
13         X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
14         //指定加密算法
15         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
16         //取公钥匙对象
17         PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);
18          
19         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
20         signature.initVerify(publicKey2);
21         signature.update(data);
22         //验证签名是否正常
23         return signature.verify(decryptBASE64(sign));
24          
25     }

对于RSA如何加密文件、图片等信息，加密的信息又如何保存，怎样保存解密后的信息，以及操作过程中遇到的错误将如何处理，将在后面的文章中介绍给大家。

原文：http://www.360doc.com/content/14/0324/16/834950_363341045.shtml

RSA加密解密及数字签名Java实现--转的更多相关文章

  1. （转）RSA加密解密及数字签名Java实现

    转:http://my.oschina.net/jiangli0502/blog/171263?fromerr=hc4izFe2  RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rives ...

  2. RSA加密解密及数字签名Java实现

    http://my.oschina.net/jiangli0502/blog/171263

  3. RSA 加密 解密 (长字符串) JAVA JS版本加解密

    系统与系统的数据交互中,有些敏感数据是不能直接明文传输的,所以在发送数据之前要进行加密,在接收到数据时进行解密处理:然而由于系统与系统之间的开发语言不同. 本次需求是生成二维码是通过java生成,由p ...

  4. RSA加密解密实现（JAVA）

    1.关于RSA算法的原理解析参考:http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html 2.RSA密钥长度.明文长度和密 ...

  5. C# Java间进行RSA加密解密交互（二）

    原文:C# Java间进行RSA加密解密交互(二) 接着前面一篇文章C# Java间进行RSA加密解密交互,继续探讨这个问题. 在前面,虽然已经实现了C# Java间进行RSA加密解密交互,但是还是与 ...

  6. C# Java间进行RSA加密解密交互（三）

    原文:C# Java间进行RSA加密解密交互(三) 接着前面一篇C# Java间进行RSA加密解密交互(二)说吧,在上篇中为了实现 /** * RSA加密 * @param text--待加密的明文 ...

  7. C#-java RSA加密解密

    using Org.BouncyCastle.Math; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Securi ...

  8. java rsa加密解密

  9. 【转】 java RSA加密解密实现

    [转] java RSA加密解密实现 该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar 下载地址:http://download.csdn.net/detai ...

随机推荐

  1. OC - 16.大文件下载

    大文件下载注意事项 若不对下载的文件进行转存,会造成内存消耗急剧升高,甚至耗尽内存资源,造成程序终止. 在文件下载过程中通常会出现中途停止的状况,若不做处理,就要重新开始下载,浪费流量. 大文件下载的 ...

  2. java 懒汉式--初步解决安全问题

    2016-07-28 00:10:14 懒汉式: class text { public String k;       private static text t=null;//右边代码结构比上边饿 ...

  3. ubuntu下apache与php配置

    实验环境 uname -a Linux tomato 4.4.0-34-generic #53-Ubuntu SMP Wed Jul 27 16:06:39 UTC 2016 x86_64 x86_6 ...

  4. php小知识点

    1.字符串可以里面的字符可以像数组一样访问,比如$s = "123";$s[1]就等于2,如果字符串为中文则会乱码,需要使用mb_substr进行截取: 2.php中的单引号(' ...

  5. jQuery图片滑动

    一个非常简单实用的jQuery插件 可以用在页面的顶部广告展示 http://slidesjs.com/ 一个需要注意的问题, 就是在手机等客户端(IOS8以上), 使用此插件时, 经常会触发插件的r ...

  6. 初涉JavaScript模式 (7) : 原型模式 【三】

    组合使用构造函数模式和原型模式 上篇,我们提到了原型模式的缺点,就是每个实例不能拥有自己的属性,因为纯原型模式所有的属性都是公开给每个实例的,故我们可以组合使用构造函数模式和原型模式.构造函数用来定义 ...

  7. InstallShield安装包中集成第三方安装包的方案选择[转]

      我们在制作安装包时,有些情况下会涉及第三方安装的集成,这里将讨论如何调用安装第三方包,以及需要注意的事项. 第三方安装包的介质类型有很多,主要有:单独的一个Setup.exe,单独的一个msi包, ...

  8. Primary Expression

    Primary expressions are the building blocks of more complex expressions. They are literals, names, a ...

  9. HDU2669 第六周练习I题（扩展欧几里算法）

    第六周练习I题 I - 数论,线性方程 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u ...

  10. sql server 调优----索引未使用

    SELECT TOP 1000o.name AS 表名, i.name AS 索引名, i.index_id AS 索引id, dm_ius.user_seeks AS 搜索次数, dm_ius.us ...