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. 解决tomcat占用8080端口问题

    在dos下,输入  netstat   -ano|findstr  8080 //说明:查看占用8080端口的进程 显示占用端口的进程 askkill  /pid  44464  /f  //说明,运 ...

  2. rhel-server-6.2-i386安装gcc、g++步骤

    安装的版本:rhel-server-6.2-i386 RHEL 6.2默认是没有gcc和gcc-c++环境的,而且我也没有$购买正版服务.只能本地安装了,总结方法如下: 上传安装镜像rhel-serv ...

  3. 字符串转换成JSON(js)

    JSON.parse('{"site":"zlog"}'); 使用JSON.parse需严格遵守JSON规范, 属性都需用双引号引起来, 一定是双引号!! 相反 ...

  4. SQL Server 2008连接字符串写法大全(摘自网络)

    一..NET Framework Data Provider for SQL Server 类型:.NET Framework类库使用:System.Data.SqlClient.SqlConnect ...

  5. java保留两位小数的方法

    01.import java.math.BigDecimal; 02.import java.text.DecimalFormat; 03.import java.text.NumberFormat; ...

  6. Git 远程仓库的管理和使用

    要参与任何一个 Git 项目的协作,必须要了解该如何管理远程仓库.远程仓库是指托管在网络上的项目仓库,可能会有好多个,其中有些你只能读,另外有些可以写.同他人协作开发某 个项目时,需要管理这些远程仓库 ...

  7. linux c信息验证程序（分享）

    程序来源是Hirst First c,程序很简单,但却是很好的说明了一个检测信息是否被串改的原理.下载程序的时候是否都有看到提供md5效验值的呢,原理其实和这个小程序相似:就是对程序的内容进行某种计算 ...

  8. Hazelcase 简介

    原博客地址:http://blog.csdn.net/zhu_tianwei/article/details/47984599 Hazelcast是一种内存数据网格in-memory data gri ...

  9. 点击itemView选中checkbox

    在Listview中如果item中含有checkbox会使itemview的setonitemchecklistingner失效,我们可以通过设置checkbox的clickbale的值为false来 ...

  10. 【jQuery】jQuery API 过 一 遍

    closest, parents <!DOCTYPE html> <html> <head> <meta charset="utf-8"& ...