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. CSS 布局Float 【0】

    float是 css 样式的定位属性.我们在印刷排版中,文本可以按照需要围绕图片.一般把这种方式称为“文本环绕”.在网页设计中,应用了CSS的float属性的页面元素就像在印刷布局里面的被文字包围的图 ...

  2. 144 Binary Tree Preorder Traversal(二叉树先序遍历Medium)

    题目意思:二叉树先序遍历,结果存在vector<int>中 解题思路:1.递归(题目中说用递归做没什么意义,我也就贴贴代码吧) 2.迭代 迭代实现: class Solution { pu ...

  3. php中json_decode()和json_encode()

    1.json_decode() json_decode (PHP 5 >= 5.2.0, PECL json >= 1.2.0) json_decode — 对 JSON 格式的字符串进行 ...

  4. lua学习-1

    最近打算学习quick cocos2dx,所以首先打算学习一下lua这门语言,Lua 是一个小巧的脚本语言,轻量级,便于扩展. Lua脚本基本的数据类型:nil.boolean.number.stri ...

  5. 快速排序（Quick Sort）的C语言实现

    快速排序(Quick Sort)的基本思想是通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对着两部分记录继续进行排序,以达到整个序列有序,具体步骤 ...

  6. codeforces567E. President and Roads

    题目大意:总统要回家,会经过一些街道,每条街道都是单向的并且拥有权值.现在,为了让总统更好的回家,要对每一条街道进行操作:1)如果该街道一定在最短路上,则输出“YES”.2)如果该街道修理过后,该边所 ...

  7. FFT快速傅立叶

    Description 给出两个n位10进制整数x和y,你需要计算x*y. Input 第一行一个正整数n.第二行描述一个位数为n的正整数x.第三行描述一个位数为n的正整数y. Output 输出一行 ...

  8. 通过ctypes获得python windows process的内存使用情况

    通过ctypes 类库中的win32方法GetProcessMemoryInfo()获得当前进程的内存使用情况.该函数可以在32或者64位,python2.6+及python3.x之上都能有用. &q ...

  9. Solr4.8.0源码分析(8)之Lucene的索引文件(1)

    Solr4.8.0源码分析(8)之Lucene的索引文件(1) 题记:最近有幸看到觉先大神的Lucene的博客,感觉自己之前学习的以及工作的太为肤浅,所以决定先跟随觉先大神的博客学习下Lucene的原 ...

  10. ExtJS 4 MVC架构讲解

    大规模客户端应用通常不好实现不好组织也不好维护,因为功能和人力的不断增加,这些应用的规模很快就会超出掌控能力,ExtJS 4 带来了一个新的应用架构,不但可以组织代码,还可以减少实现的内容新的应用架构 ...