对称加密与非对称加密浅析

最新推荐文章于 2023-06-12 12:27:31 发布

小地盘

最新推荐文章于 2023-06-12 12:27:31 发布

阅读量1.4k

点赞数

分类专栏：其他学习文章标签： RSA 对称加密非对称加密公钥私钥

本文链接：https://blog.csdn.net/wtyvhreal/article/details/46490901

版权

其他学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

对称加密

　　对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）。对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。
　　对称加密通常使用的是相对较小的密钥，一般小于256 bit。因为密钥越大，加密越强，但加密与解密的过程越慢。如果你只用1 bit来做这个密钥，那黑客们可以先试着用0来解密，不行的话就再用1解；但如果你的密钥有1 MB大，黑客们可能永远也无法破解，但加密和解密的过程要花费很长的时间。密钥的大小既要照顾到安全性，也要照顾到效率，是一个trade-off。
　　对称加密的一大缺点是密钥的管理与分配，换句话说，如何把密钥发送到需要解密你的消息的人的手里是一个问题。在发送密钥的过程中，密钥有很大的风险会被黑客们拦截。现实中通常的做法是将对称加密的密钥进行非对称加密，然后传送给需要它的人。

非对称加密

　　非对称加密为数据的加密与解密提供了一个非常安全的方法，它使用了一对密钥，公钥（public key）和私钥（private key）。私钥只能由一方安全保管，不能外泄，而公钥则可以发给任何请求它的人。非对称加密使用这对密钥中的一个进行加密，而解密则需要另一个密钥。比如，你向银行请求公钥，银行将公钥发给你，你使用公钥对消息加密，那么只有私钥的持有人–银行才能对你的消息解密。与对称加密不同的是，银行不需要将私钥通过网络发送出去，因此安全性大大提高。
　　目前最常用的非对称加密算法是RSA算法，是Rivest, Shamir, 和Adleman于1978年发明。
　　虽然非对称加密很安全，但是和对称加密比起来，它非常的慢，所以我们还是要用对称加密来传送消息，但对称加密所使用的密钥我们可以通过非对称加密的方式发送出去。为了解释这个过程，请看下面的例子：
（1） Alice需要在银行的网站做一笔交易，她的浏览器首先生成了一个随机数作为对称密钥。
（2） Alice的浏览器向银行的网站请求公钥。
（3）银行将公钥发送给Alice。
（4） Alice的浏览器使用银行的公钥将自己的对称密钥加密。
（5） Alice的浏览器将加密后的对称密钥发送给银行。
（6）银行使用私钥解密得到Alice浏览器的对称密钥。
（7） Alice与银行可以使用对称密钥来对沟通的内容进行加密与解密了。
这里写图片描述

总结

（1）对称加密加密与解密使用的是同样的密钥，所以速度快，但由于需要将密钥在网络传输，所以安全性不高。
（2）非对称加密使用了一对密钥，公钥与私钥，所以安全性高，但加密与解密速度慢。
（3）解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密，然后发送出去，接收方使用私钥进行解密得到对称加密的密钥，然后双方可以使用对称加密来进行沟通。

问题

非对称加密中：公钥加密，私钥解密；私钥数字签名，公钥验证。
但是对于私钥加密公钥解密，即验证方面，公钥既然已经公开，那就有可能被被人知晓，而只要有公钥就能解开私钥，那私钥加密的内容不就存在很高的泄露的可能性吗？
答案：
如果只是单方面采用非对称性加密算法,其实有两种方式,用于不同用处.

第一种是签名,使用私钥加密,公钥解密,用于让所有公钥所有者验证私钥所有者的身份并且用来防止私钥所有者发布的内容被篡改.但是不用来保证内容不被他人获得.
C代表Client，S代表Server
C1，C2，C3中，C1用自己的私钥key1向S发加密消息info。由于公钥公开，此时S利用公钥解密info，就可以知道info是从C1发来的(确认C1身份)。
此时由于黑客也有公钥，通过公钥解密黑客也可以获得info，但是不能篡改，因为黑客没有C的私钥，黑客篡改的内容，S不认识。
第二种是加密,用公钥加密,私钥解密,用于向公钥所有者发布信息,这个信息可能被他人篡改,但是无法被他人获得.
由于私钥解密，黑客没有私钥，当然就不可能解密获得info；但是黑客有公钥，可以自己通过公钥加密，组装篡改info发送出去。

如果甲想给乙发一个安全的保密的数据,那么应该甲乙各自有一个私钥,甲先用乙的公钥加密这段数据,再用自己的私钥加密这段加密后的数据.最后再发给乙,这样确保了内容即不会被读取,也不会被篡改.

简单实例：非对称加密算法-RSA算法

１、概述

RSA是基于大数因子分解难题。目前各种主流计算机语言都支持RSA算法的实现；
java6支持RSA算法；
RSA算法可以用于数据加密和数字签名；
RSA算法相对于DES/AES等对称加密算法，他的速度要慢的多；
总原则：公钥加密，私钥解密 / 私钥加密，公钥解密。

2、模型分析
RSA算法构建密钥对简单的很，这里我们还是以甲乙双方发送数据为模型

甲方在本地构建密钥对（公钥+私钥），并将公钥公布给乙方；
甲方将数据用私钥进行加密，发送给乙方；
乙方用甲方提供的公钥对数据进行解密。

如果乙方向传送数据给甲方：

乙方用公钥对数据进行加密，然后传送给甲方；
甲方用私钥对数据进行解密。

3、RSA简单代码实例

    package com.ca.test;  
    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;  
    import javax.crypto.interfaces.DHPrivateKey;  
    import javax.crypto.interfaces.DHPublicKey;  
    import org.apache.commons.codec.binary.Base64;  
    /** 
     * 非对称加密算法RSA算法组件 
     * 非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要 
     * 大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单 
     * @author kongqz 
     * */  
    public class RSACoder {  
        //非对称密钥算法  
        public static final String KEY_ALGORITHM="RSA";  


        /** 
         * 密钥长度，DH算法的默认密钥长度是1024 
         * 密钥长度必须是64的倍数，在512到65536位之间 
         * */  
        private static final int KEY_SIZE=512;  
        //公钥  
        private static final String PUBLIC_KEY="RSAPublicKey";  

        //私钥  
        private static final String PRIVATE_KEY="RSAPrivateKey";  

        /** 
         * 初始化密钥对 
         * @return Map 甲方密钥的Map 
         * */  
        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;  

        }  


        /** 
         * 私钥加密 
         * @param data待加密数据 
         * @param key 密钥 
         * @return byte[] 加密数据 
         * */  
        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);  
        }  
        /** 
         * 公钥加密 
         * @param data待加密数据 
         * @param key 密钥 
         * @return byte[] 加密数据 
         * */  
        public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{  

            //实例化密钥工厂  
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
            //初始化公钥  
            //密钥材料转换  
            X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
            //产生公钥  
            PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  

            //数据加密  
            Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);  
            return cipher.doFinal(data);  
        }  
        /** 
         * 私钥解密 
         * @param data 待解密数据 
         * @param key 密钥 
         * @return byte[] 解密数据 
         * */  
        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);  
        }  
        /** 
         * 公钥解密 
         * @param data 待解密数据 
         * @param key 密钥 
         * @return byte[] 解密数据 
         * */  
        public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{  

            //实例化密钥工厂  
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
            //初始化公钥  
            //密钥材料转换  
            X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
            //产生公钥  
            PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
            //数据解密  
            Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
            cipher.init(Cipher.DECRYPT_MODE, pubKey);  
            return cipher.doFinal(data);  
        }  
        /** 
         * 取得私钥 
         * @param keyMap 密钥map 
         * @return byte[] 私钥 
         * */  
        public static byte[] getPrivateKey(Map<String,Object> keyMap){  
            Key key=(Key)keyMap.get(PRIVATE_KEY);  
            return key.getEncoded();  
        }  
        /** 
         * 取得公钥 
         * @param keyMap 密钥map 
         * @return byte[] 公钥 
         * */  
        public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{  
            Key key=(Key) keyMap.get(PUBLIC_KEY);  
            return key.getEncoded();  
        }  
        /** 
         * @param args 
         * @throws Exception  
         */  
        public static void main(String[] args) throws Exception {  
            //初始化密钥  
            //生成密钥对  
            Map<String,Object> keyMap=RSACoder.initKey();  
            //公钥  
            byte[] publicKey=RSACoder.getPublicKey(keyMap);  

            //私钥  
            byte[] privateKey=RSACoder.getPrivateKey(keyMap);  
            System.out.println("公钥：/n"+Base64.encodeBase64String(publicKey));  
            System.out.println("私钥：/n"+Base64.encodeBase64String(privateKey));  

            System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");  
            String str="RSA密码交换算法";  
            System.out.println("/n===========甲方向乙方发送加密数据==============");  
            System.out.println("原文:"+str);  
            //甲方进行数据的加密  
            byte[] code1=RSACoder.encryptByPrivateKey(str.getBytes(), privateKey);  
            System.out.println("加密后的数据："+Base64.encodeBase64String(code1));  
            System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");  
            //乙方进行数据的解密  
            byte[] decode1=RSACoder.decryptByPublicKey(code1, publicKey);  
            System.out.println("乙方解密后的数据："+new String(decode1)+"/n/n");  

            System.out.println("===========反向进行操作，乙方向甲方发送数据==============/n/n");  

            str="乙方向甲方发送数据RSA算法";  

            System.out.println("原文:"+str);  

            //乙方使用公钥对数据进行加密  
            byte[] code2=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);  
            System.out.println("===========乙方使用公钥对数据进行加密==============");  
            System.out.println("加密后的数据："+Base64.encodeBase64String(code2));  

            System.out.println("=============乙方将数据传送给甲方======================");  
            System.out.println("===========甲方使用私钥对数据进行解密==============");  

            //甲方使用私钥对数据进行解密  
            byte[] decode2=RSACoder.decryptByPrivateKey(code2, privateKey);  

            System.out.println("甲方解密后的数据："+new String(decode2));  
        }  
    }  

    控制台输出：  
    公钥：  
    MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM0qc+eVm4pyBbCBuM4jRxOYsxWkylLXVklyWp3JNs71  
    B6vLVg2Iwh6TwPbpXbGWOI11RMLhe5bwLpdeBqP4f4MCAwEAAQ==  
    私钥：  
    MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAzSpz55WbinIFsIG4ziNHE5izFaTK  
    UtdWSXJanck2zvUHq8tWDYjCHpPA9uldsZY4jXVEwuF7lvAul14Go/h/gwIDAQABAkByhW3pKSOH  
    Zhoy6lYkCqEUGTptrGybTUQG/2QBi12iqzenm7rKlasjdMEr6Q8RX5RpGArzvhvLepAPqPZ5LXjR  
    AiEA7vI8/9HHrZSbHQ4Up7xby7bOULknoRjZy68HRMPRSXUCIQDbzwQfvrYNqLiauTcNsg6ejCJw  
    cxSCLlJupgwBBjyOFwIgVEbWIviPr/ZpGz9bI6o4ykoozKnxg01ri/6o1qUmTP0CIQDBC0XO73oJ  
    8vT2BdZA8/D884vHgHoxfqcswC3otGZ4TwIhANGXz8GHxM0zuOg8pds54S1ARlrkUXFULocVZ2Ka  
    ngFf  
    ================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============  
    ===========甲方向乙方发送加密数据==============  
    原文:RSA密码交换算法  
    加密后的数据：kF3vekz0DpJmLzwdrWjfZLyGBWsKzFOwm+8im85KZr6QA49csvCl9KgsfjSVLuXwgsPrFoEhkiqQ  
    0+VApr001A==  
    ===========乙方使用甲方提供的公钥对数据进行解密==============  
    乙方解密后的数据：RSA密码交换算法  

    ===========反向进行操作，乙方向甲方发送数据==============  

    原文:乙方向甲方发送数据RSA算法  
    ===========乙方使用公钥对数据进行加密==============  
    加密后的数据：xM1MB3DlDKRwSozf9z8YQlftrWpKT8lkabi17cN/ZLOEkOO8jVLKVAjpjsMwtJMcpHTjntdkHKOm  
    s1V8xbh3og==  
    =============乙方将数据传送给甲方======================  
    ===========甲方使用私钥对数据进行解密==============  
    甲方解密后的数据：乙方向甲方发送数据RSA算法

参考引用

小地盘

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
对称加密与非对称加密浅析

对称加密　　对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）。对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。　　对称加密通常使用的是相对较小的密钥，一般小于256 bit。因为密钥越大，加密越强，但加密与解密的过程越慢。如果你只用1 bit来做这个密钥，那黑客们可以先试着用0
复制链接

扫一扫