java安全（二）非对称加密RSA

一、讲点历史

　　1976年以前，所有的加密方法都是同一种模式：

（1）甲方选择某一种加密规则，对信息进行加密； 　　
（2）乙方使用同一种规则，对信息进行解密。

　　由于加密和解密使用同样规则（简称”密钥”），这被称为”对称加密算法”（Symmetric-key algorithm）。这种加密模式有一个最大弱点：甲方必须把加密规则告诉乙方，否则无法解密。保存和传递密钥，就成了最头疼的问题。1976年，两位美国计算机学家Whitfield Diffie 和 Martin Hellman，提出了一种崭新构思，可以在不直接传递密钥的情况下，完成解密。这被称为”Diffie-Hellman密钥交换算法”。这个算法启发了其他科学家。人们认识到，加密和解密可以使用不同的规则，只要这两种规则之间存在某种对应关系即可，这样就避免了直接传递密钥。
这种新的加密模式被称为”非对称加密算法“。

（1） 乙方生成两把密钥（公钥和私钥）。公钥是公开的，任何人都可以获得，私钥则是保密的。（2）甲方获取乙方的公钥，然后用它对信息加密。（3）乙方得到加密后的信息，用私钥解密。

　　如果公钥加密的信息只有私钥解得开，那么只要私钥不泄漏，通信就是安全的。1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。从那时直到现在，RSA算法一直是最广为使用的”非对称加密算法”。毫不夸张地说，只要有计算机网络的地方，就有RSA算法。这种算法非常可靠，密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最长RSA密钥是768个二进制位。也就是说，长度超过768位的密钥，还无法破解（至少没人公开宣布）。因此可以认为，1024位的RSA密钥基本安全，2048位的密钥极其安全。
下面，我就进入正题，解释RSA算法的原理。

二、RSA原理

　　我们通过下面的小例子来讲解RSA算法。假设爱丽丝要与鲍勃进行加密通信，她该怎么生成公钥和私钥呢？

第一步：随机选择两个不相等的质数p和q，实际应用中这两个质数越大越难破解。(关于质数是什么请自行学习)

爱丽丝选择了61和53。

第二步：计算p和q的乘积n。
　　爱丽丝就把 61 和 53 相乘。

n =p ×q = 61×53 = 3233

　　n 的长度就是密钥长度。3233 写成二进制是 110010100001，一共有 12 位，所以这个密钥就是 12 位。实际应用中，RSA 密钥一般是 1024 位，重要场合则为 2048 位。
第三步，计算n的欧拉函数φ(n)。
根据公式：

φ(n) = (p-1)(q-1) =60×52 = 3120 　　
爱丽丝算出φ(3233) 等于 60×52，即 3120。

第四步，随机选择一个整数e，条件是1< e < φ(n)，且e与φ(n) 互质。
　　

爱丽丝就在 1 到 3120 之间，随机选择了 17。（实际应用中，常常选择 65537。）

第五步，计算e对于φ(n)的模反元素d。
　　所谓”模反元素”就是指有一个整数d，可以使得 ed 被φ(n)除的余数为1。
ed ≡ 1 (mod φ(n)) 这个式子等价于 ed - 1 = kφ(n)
　　于是，找到模反元素d，实质上就是对下面这个二元一次方程求解。
ex + φ(n) y = 1 已知 e=17, φ(n)=3120，
17x + 3120y = 1 这个方程可以用”扩展欧几里得算法”求解，此处省略具体过程。总之，爱丽丝算出一组整数解为 (x，y)=(2753,-15)，即 d=2753。至此所有计算完成。
第六步，将n和e封装成公钥，n和d封装成私钥。
　　在爱丽丝的例子中，n=3233，e=17，d=2753，所以公钥就是 (3233,17)，私钥就是（3233, 2753）。
　　实际应用中，公钥和私钥的数据都采用 ASN.1格式表达（实例）。
第七步：最后秘钥生成好了，并使用公钥和私钥加解密数据。　
（1）加密要用公钥 (n,e)
　　假设鲍勃要向爱丽丝发送加密信息m，他就要用爱丽丝的公钥 (n,e) 对m进行加密。这里需要注意，m必须是整数（字符串可以取 ascii 值或 unicode 值），且m必须小于n。
　　所谓”加密”，就是算出下式的c：
　　me ≡ c (mod n)
　　爱丽丝的公钥是 (3233, 17)，鲍勃的m假设是 65，那么可以算出下面的等式：
6517 ≡ 2790 (mod 3233)
　　于是，c等于 2790，鲍勃就把 2790 发给了爱丽丝。
（2）解密要用私钥(n,d)
　　爱丽丝拿到鲍勃发来的 2790 以后，就用自己的私钥(3233, 2753) 进行解密。可以证明，下面的等式一定成立：
　　cd ≡ m (mod n)
　　也就是说，c的d次方除以n的余数为m。现在，c等于 2790，私钥是(3233, 2753)，那么，爱丽丝算出
　　27902753 ≡ 65 (mod 3233)
　　因此，爱丽丝知道了鲍勃加密前的原文就是 65。
　　至此，”加密–解密”的整个过程全部完成。
　　我们可以看到，如果不知道d，就没有办法从c求出m。而前面已经说过，要知道d就必须分解n，这是极难做到的，所以 RSA 算法保证了通信安全。你可能会问，公钥(n,e) 只能加密小于n的整数m，那么如果要加密大于n的整数，该怎么办？有两种解决方法：一种是把长信息分割成若干段短消息，每段分别加密；另一种是先选择一种”对称性加密算法”（比如 DES），用这种算法的密钥加密信息，再用 RSA 公钥加密 DES 密钥。

三：示例代码

package util;import java.security.Key;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.PrivateKey;import java.security.PublicKey;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;import javax.crypto.Cipher;/**  * @ClassName   : RSA  * @Description : 非对称加密 * @author      : wangdx * @date        : 2016-3-14 上午10:53:20  *   */public class RSA {    /**      * @Fields KEY_ALGORITHM : 非对称加密秘钥算法     */     public static final String KEY_ALGORITHM = "RSA";    /**      * @Fields KEY_SIZE : RSA秘钥长度     * RSA算法默认的秘钥长度为1024     * 秘钥长度必须是64的倍数,其范围在512位到1024位之间     */     private static final int KEY_SIZE = 512;    /**      * @Fields PUBLIC_KEY : 公钥     */     private static final String PUBLIC_KEY = "RSAPublicKey";    /**      * @Fields PRIVATE_KEY : 私钥     */     private static final String PRIVATE_KEY = "RSAPrivateKey";    /**      * @Title       : initKey      * @Description : 初始化甲方秘钥     * @return      : Map<String,String> 甲方秘钥Map     * @throws      */    public static Map<String, Object> initKey() throws Exception{        //实例化密钥对生成器        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);        //初始化密钥对生成器(初始化生成秘钥的长度)        keyPairGenerator.initialize(KEY_SIZE);        //生成密钥对        KeyPair keyPair = keyPairGenerator.generateKeyPair();        //甲方公钥        RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();        //甲方私钥        RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();        //将秘钥对存储到Map中        Map<String,Object> keyMap = new HashMap<String, Object>();        keyMap.put(PUBLIC_KEY, publicKey);        keyMap.put(PRIVATE_KEY, privateKey);        return keyMap;    }    /**      * @Title       : getPrivateKey      * @Description : 获得私钥      * @return      : byte[]    返回类型      * @throws      */    public static byte[] getPrivateKey(Map<String,Object> keyMap) throws Exception{        Key key = (Key) keyMap.get(PRIVATE_KEY);        return key.getEncoded();    }    /**      * @Title       : getPublicKey      * @Description : 获得公钥      * @return      : byte[]  公钥   返回类型      * @throws      */    public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{        Key key = (Key) keyMap.get(PUBLIC_KEY);        return key.getEncoded();    }    /**      * @Title       : encryptByPrivateKey      * @Description : 私钥加密     * @return      : byte[]    返回类型      * @throws      */    public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception{        //取的私钥        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        //生成秘钥        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);        //对数据解密        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.ENCRYPT_MODE, privateKey);        return cipher.doFinal(data);    }    /**      * @Title       : decryptByPrivateKey      * @Description : 私钥解密     * @return      : byte[]    返回类型      * @throws      */    public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{        //取的私钥        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        //生成秘钥        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);        //对数据解密        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.DECRYPT_MODE, privateKey);        return cipher.doFinal(data);    }    /**      * @Title       : decryptByPublicKey      * @Description : 公钥加密     * @return      : byte[]    返回类型      * @throws      */    public static byte[] encryptByPublicKey(byte[] data,byte[] key)throws Exception{        //获得公钥        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        //生成公钥        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);        //对数据解密        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);        cipher.init(Cipher.ENCRYPT_MODE, publicKey);        return cipher.doFinal(data);    }    /**      * @Title       : decryptByPublicKey      * @Description : 公钥解密     * @return      : byte[]    返回类型      * @throws      */    public static byte[] decryptByPublicKey(byte[] data,byte[] key)throws Exception{        //获得公钥        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        //生成公钥        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);        //对数据解密        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);        cipher.init(Cipher.DECRYPT_MODE, publicKey);        return cipher.doFinal(data);    }}

package test;/* * 1.原理 * 2.报错：java.security.InvalidKeyException: IOException : DER input, Integer tag error * */import java.util.Map;import org.apache.commons.codec.binary.Base64;import org.junit.Before;import org.junit.Test;import static org.junit.Assert.*;import util.RSA;public class RSATest {    //公钥    private byte[] publicKey;    //私钥    private byte[] privateKey;    @Before    public void initKey()throws Exception{        /*        公钥：        MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKikyfGIcZCH9tRdUIxJ4zy7/g+9TGSaqqVScibFBCHPHWzqidtha/fv2ZOO+djdhulw75Yqj3x4aqQpOaOJffsC        AwEAAQ==        私钥：        MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAqKTJ8YhxkIf21F1QjEnjPLv+D71MZJqqpVJyJsUEIc8dbOqJ22Fr9+/Zk4752N2G6XDvliqP        fHhqpCk5o4l9+wIDAQABAkBBHxkoHrMTx50F1l7TPXj1K/boZwXH133LxzFzTSLSVsE6YbX8p7lEvKziBJBJMx6UacqjW/8ti3oY8iUZkw1xAiEA7S3iMxQH        5fB3vwjtSrlpnzTp/ITyQRLXjil6sf3AUakCIQC2BqhwC1IPErVWnLQ2jifd9VM3hOr0o8RpZdnVxkvhAwIhAIsi9aWdRJzhmn3ZEMtbRdj9w549p5gBI67k        KnQsNhwxAiBZ81xVUiLQ9AvMq0+bDhDBbLQc4YBCOJOdCgnlzEI/BQIgUsxFFa7XtLXPEGSlDakJmnbuZc0A03MQaoPL0zJt03w=        */        Map<String,Object> keyMap = RSA.initKey();        publicKey = RSA.getPublicKey(keyMap);        privateKey = RSA.getPrivateKey(keyMap);        System.err.println("公钥：\n"+Base64.encodeBase64String(publicKey));        System.err.println("私钥：\n"+Base64.encodeBase64String(privateKey));    }    @Test    public void test()throws Exception{        System.err.println("\n-----私钥加密----公钥解密-------");        String inputStr1 = "RSA加密算法";        byte[] data1 = inputStr1.getBytes();        System.err.println("原文:\n"+inputStr1);        //加密        byte[] encodedData1 =RSA.encryptByPrivateKey(data1, privateKey);        System.err.println("加密后:\n"+Base64.encodeBase64String(encodedData1));        //解密        byte[] decodedData1 =RSA.decryptByPublicKey(encodedData1, publicKey);        String outputStr1 = new String(decodedData1);        System.err.println("解密后:\n"+outputStr1);        //校验        assertEquals(inputStr1,outputStr1);        System.err.println("\n-----公钥加密----私钥解密-------");        String inputStr2 = "RSA Encypt Algorithm";        byte[] data2 = inputStr2.getBytes();        System.err.println("原文：\n"+inputStr2);        //加密         byte[] encodedData2 = RSA.encryptByPublicKey(data2, publicKey);        System.err.println("加密后:\n"+Base64.encodeBase64String(encodedData2));        //解密        byte[] decodedData2 = RSA.decryptByPrivateKey(encodedData2, privateKey);        String outputStr2 = new String(decodedData2);        System.err.println("解密后:\n"+outputStr2);        //校验        assertEquals(inputStr2, outputStr2);    }}

以上代码经过本地测试，可以直接复制到eclipse里面直接运行。
注意：由于出口的限制，jdk的RSA加密不支持512位以上长度的秘钥
所以会报错，报错：java.security.InvalidKeyException: IOException : DER input, Integer tag error
请自行上网下载这两个jar包 local_policy.jar和US_export_policy.jar

并替换jdk目录下的jre里面的这两个jar包，网上资料很多就不详细说了。

最后本文参考网上文章和bolg：
http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html
http://news.cnblogs.com/n/181545/