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

最新推荐文章于 2023-06-18 11:53:52 发布

Not_Lost_Yesterday

最新推荐文章于 2023-06-18 11:53:52 发布

阅读量2.6k

点赞数

分类专栏： java 密码安全文章标签： java安全算法 rsa 安全加密

本文链接：https://blog.csdn.net/Not_Lost_Yesterday/article/details/50936539

版权

java 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

密码安全

8 篇文章 0 订阅

订阅专栏

一、讲点历史

　　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/

Not_Lost_Yesterday

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java安全（二）非对称加密RSA

一、讲点历史　　1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；　　（2）乙方使用同一种规则，对信息进行解密。　　由于加密和解密使用同样规则（简称”密钥”），这被称为”对称加密算法”（Symmetric-key algorithm）。这种加密模式有一个最大弱点：甲方必须把加密规则告诉乙方，否则无法解密。保存和传递密钥，就成了最头疼的问题。
复制链接

扫一扫