精华内容
下载资源
问答
  • 非对称加密算法

    2020-09-22 20:51:14
    非对称加密算法又称现代加密算法。 ② 非对称加密是计算机通信安全的基石,保证了加密数据不会被破解。 ③ 与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密(privatekey) ④ ...

    非对称加密

    简介:

    ① 非对称加密算法又称现代加密算法

    ② 非对称加密是计算机通信安全的基石,保证了加密数据不会被破解

    ③ 与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey) 和私有密(privatekey)

    ④ 公开密钥和私有密钥是一对

    ⑤ 如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密

    ⑥ 如果用私有密钥对数据进行加密,只有用对应的公开密钥才能解密

    ⑦ 因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法

    • 示例
      • 首先生成密钥对, 公钥为(5,14), 私钥为(11,14)
      • 现在A希望将原文2发送给B
      • A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B
      • B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文2
    • 特点
      • 加密和解密使用不同的密钥
      • 如果使用私钥加密, 只能使用公钥解密
      • 如果使用公钥加密, 只能使用私钥解密
      • 处理数据的速度较慢, 因为安全级别高
    • 常见算法
      • RSA
      • ECC

     

    展开全文
  • 文章目录对称加密与非对称加密优缺点详解对称加密简介优点缺点对称加密算法非对称加密简介优点缺点非对称加密算法 对称加密与非对称加密优缺点详解 对称加密 简介 双方使用的同一个秘钥,既可以进行加密也可以进行...

    对称加密与非对称加密优缺点详解

    对称加密

    简介

    双方使用的同一个秘钥,既可以进行加密也可以进行解密,这种加密方式被称为 对称加密

    优点

    速度快,对称性加密通常在消息发送方需要加密大量数据时使用,算法公开,计算量小,加密速度快,加密速度高

    缺点

    • 数据传送前,发送方和接收方必须商定好秘钥
    • 双方都能保存好秘钥,如果一方的秘钥被泄露,加密信息不安全
    • 每对用户进行使用加密算法时,都需要使用其他人不知道的唯一秘钥,这会使得收、发双方所拥有的钥匙数量巨大,称为负担

    对称加密算法

    • DES
    • AES

    非对称加密

    简介

    一对秘钥由公钥和私钥组成,私钥解密公钥加密数据,公钥解密私钥加密数据
    私钥只能由一方保管,不能外泄。公钥可以交给任何请求方

    优点

    安全

    缺点

    速度较慢

    非对称加密算法

    • RSA
    展开全文
  • 对称加密算法和非对称加密算法的区别 1.对称加密算法加密和解密使用的密钥的是相同的,也就是只有一个密钥,而非对称加密算法有两个密钥,也就是加密和解密所使用的密钥是不同的 2.各自算法不同 3.对称加密算法加密...

    对称加密算法和非对称加密算法的区别

    1.对称加密算法加密和解密使用的密钥的是相同的,也就是只有一个密钥,而非对称加密算法有两个密钥,也就是加密和解密所使用的密钥是不同的

    2.各自算法不同

    3.对称加密算法加密速度快(相对的),非对称算法,密钥成对生成,公钥对外发布,但是对大数据的加解密速度比对称算法慢。

    4.还有就是安全性不同,对称加密算法,在传输的过程中被窃听那就玩完了,而非对称加密算法就可以很好的避免这个问题

    5.数字签名,对称加密不可以用于数字签名和数字鉴别,非对称加密可以用于数字签名和数字鉴别。

    对称加密算法与非对称加密算法的相同点

    废话一句:都是加密算法

    咳咳…

    1.都是可逆的

    2.然后…

    然后…

    emm

    暂时没有想到

    对称加密算法和非对称加密算法的优缺点

    对称加密算法:速度快但是安全性不可保证、安全性取决于密钥的长度、对称加密算法是可逆的、占用的资源空间较少、源认证存在问题

    非对称加密算法:安全性高但是速度慢、非对称加密算法压缩可逆、占用运算空间资源较多、源认证存在问题

    常见的算法

    对称加密算法:DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK、AES等等

    非对称加密算法:RSA、Elgamal、背包算法、Rabin、D-H、ECC等等

    ps:

    ECC:椭圆曲线加密算法

    其他链接

    哔哩哔哩
    会同步该博客发一些自制视频

    微博
    用的比较少

    Github
    一些源代码

    知乎
    不懂的我一般会在上面提问

    简书
    同步该博客内容相同

    CSDN
    同步该博客内容相同
    博客首页

    个人联系方式

    QQ:2446264712

    微信:X15019749137

    邮箱:xiaoyangaichibaozi@yeah.net

    有意添加请备注 啊啊啊啊

    展开全文
  • Java加密技术(四)——非对称加密算法RSA 非对称加密算法——RSA 基本概念 非对称加密算法是一种密钥的保密方法。 非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有...

    Java加密技术(四)——非对称加密算法RSA

    非对称加密算法——RSA 基本概念

             非对称加密算法是一种密钥的保密方法。

             非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。 非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开;得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方;甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。

              另一方面,甲方可以使用乙方的公钥对机密信息进行签名后再发送给乙方;乙方再用自己的私匙对数据进行验签。

    甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。 非对称加密算法的保密性比较好,它消除了最终用户交换密钥的需要。

    非对称密码体制的特点:

    算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂,而使得加密解密速度没有对称加密解密的速度快。对称密码体制中只有一种密钥,并且是非公开的,如果要解密就得让对方知道密钥。所以保证其安全性就是保证密钥的安全,而非对称密钥体制有两种密钥,其中一个是公开的,这样就可以不需要像对称密码那样传输对方的密钥了。这样安全性就大了很多。

    工作原理

    1.A要向B发送信息,A和B都要产生一对用于加密和解密的公钥和私钥。

    2.A的私钥保密,A的公钥告诉B;B的私钥保密,B的公钥告诉A。

    3.A要给B发送信息时,A用B的公钥加密信息,因为A知道B的公钥。

    4.A将这个消息发给B(已经用B的公钥加密消息)。

    5.B收到这个消息后,B用自己的私钥解密A的消息。其他所有收到这个报文的人都无法解密,因为只有B才有B的私钥。

    RSA 

        这种算法1978年就出现了,它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作,也很流行。算法的名字以发明者的名字命名:Ron Rivest, AdiShamir 和Leonard Adleman。 

        这种加密算法的特点主要是密钥的变化,上文我们看到DES只有一个密钥。相当于只有一把钥匙,如果这把钥匙丢了,数据也就不安全了。RSA同时有两把钥匙,公钥与私钥。同时支持数字签名。数字签名的意义在于,对传输过来的数据进行校验。确保数据在传输工程中不被修改。 

    流程分析: 

    1. 甲方构建密钥对儿,将公钥公布给乙方,将私钥保留。

    2. 甲方使用私钥加密数据,然后用私钥对加密后的数据签名,发送给乙方签名以及加密后的数据;乙方使用公钥、签名来验证待解密数据是否有效,如果有效使用公钥对数据解密。

    3. 乙方使用公钥加密数据,向甲方发送经过加密后的数据;甲方获得加密数据,通过私钥解密。

    按如上步骤给出序列图,如下: 

     

     

     

    Demo

    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.Signature;  

    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;  

      

    /** 

     * RSA安全编码组件 

     *  

     * @author Sunny 

     * @version 1.0 

     * @since 1.0 

     */  

    public abstract class RSACoder extends Coder {  

        public static final String KEY_ALGORITHM = "RSA";  

        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  

      

        private static final String PUBLIC_KEY = "RSAPublicKey";  

        private static final String PRIVATE_KEY = "RSAPrivateKey";  

      

        /** 

         * 用私钥对信息生成数字签名 

         *  

         * @param data 

         *            加密数据 

         * @param privateKey 

         *            私钥 

         *  

         * @return 

         * @throws Exception 

         */  

        public static String sign(byte[] data, String privateKey) throws Exception {  

            // 解密由base64编码的私钥  

            byte[] keyBytes = decryptBASE64(privateKey);  

      

            // 构造PKCS8EncodedKeySpec对象  

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  

      

            // KEY_ALGORITHM 指定的加密算法  

            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  

      

            // 取私钥匙对象  

            PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);  

      

            // 用私钥对信息生成数字签名  

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  

            signature.initSign(priKey);  

            signature.update(data);  

      

            return encryptBASE64(signature.sign());  

        }  

      

        /** 

         * 校验数字签名 

         *  

         * @param data 

         *            加密数据 

         * @param publicKey 

         *            公钥 

         * @param sign 

         *            数字签名 

         *  

         * @return 校验成功返回true 失败返回false 

         * @throws Exception 

         *  

         */  

        public static boolean verify(byte[] data, String publicKey, String sign)  

                throws Exception {  

      

            // 解密由base64编码的公钥  

            byte[] keyBytes = decryptBASE64(publicKey);  

      

            // 构造X509EncodedKeySpec对象  

            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  

      

            // KEY_ALGORITHM 指定的加密算法  

            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  

      

            // 取公钥匙对象  

            PublicKey pubKey = keyFactory.generatePublic(keySpec);  

      

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  

            signature.initVerify(pubKey);  

            signature.update(data);  

      

            // 验证签名是否正常  

            return signature.verify(decryptBASE64(sign));  

        }  

      

        /** 

         * 解密<br> 

         * 用私钥解密 

         *  

         * @param data 

         * @param key 

         * @return 

         * @throws Exception 

         */  

        public static byte[] decryptByPrivateKey(byte[] data, String key)  

                throws Exception {  

            // 对密钥解密  

            byte[] keyBytes = decryptBASE64(key);  

      

            // 取得私钥  

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  

            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  

            Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  

      

            // 对数据解密  

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  

            cipher.init(Cipher.DECRYPT_MODE, privateKey);  

      

            return cipher.doFinal(data);  

        }  

      

        /** 

         * 解密<br> 

         * 用公钥解密 

         *  

         * @param data 

         * @param key 

         * @return 

         * @throws Exception 

         */  

        public static byte[] decryptByPublicKey(byte[] data, String key)  

                throws Exception {  

            // 对密钥解密  

            byte[] keyBytes = decryptBASE64(key);  

      

            // 取得公钥  

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  

            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  

            Key publicKey = keyFactory.generatePublic(x509KeySpec);  

      

            // 对数据解密  

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  

            cipher.init(Cipher.DECRYPT_MODE, publicKey);  

      

            return cipher.doFinal(data);  

        }  

      

        /** 

         * 加密<br> 

         * 用公钥加密 

         *  

         * @param data 

         * @param key 

         * @return 

         * @throws Exception 

         */  

        public static byte[] encryptByPublicKey(byte[] data, String key)  

                throws Exception {  

            // 对公钥解密  

            byte[] keyBytes = decryptBASE64(key);  

      

            // 取得公钥  

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  

            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  

            Key publicKey = keyFactory.generatePublic(x509KeySpec);  

      

            // 对数据加密  

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  

            cipher.init(Cipher.ENCRYPT_MODE, publicKey);  

      

            return cipher.doFinal(data);  

        }  

      

        /** 

         * 加密<br> 

         * 用私钥加密 

         *  

         * @param data 

         * @param key 

         * @return 

         * @throws Exception 

         */  

        public static byte[] encryptByPrivateKey(byte[] data, String key)  

                throws Exception {  

            // 对密钥解密  

            byte[] keyBytes = decryptBASE64(key);  

      

            // 取得私钥  

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  

            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  

            Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  

      

            // 对数据加密  

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  

            cipher.init(Cipher.ENCRYPT_MODE, privateKey);  

      

            return cipher.doFinal(data);  

        }  

      

        /** 

         * 取得私钥 

         *  

         * @param keyMap 

         * @return 

         * @throws Exception 

         */  

        public static String getPrivateKey(Map<String, Object> keyMap)  

                throws Exception {  

            Key key = (Key) keyMap.get(PRIVATE_KEY);  

      

            return encryptBASE64(key.getEncoded());  

        }  

      

        /** 

         * 取得公钥 

         *  

         * @param keyMap 

         * @return 

         * @throws Exception 

         */  

        public static String getPublicKey(Map<String, Object> keyMap)  

                throws Exception {  

            Key key = (Key) keyMap.get(PUBLIC_KEY);  

      

            return encryptBASE64(key.getEncoded());  

        }  

      

        /** 

         * 初始化密钥 

         *  

         * @return 

         * @throws Exception 

         */  

        public static Map<String, Object> initKey() throws Exception {  

            KeyPairGenerator keyPairGen = KeyPairGenerator  

                    .getInstance(KEY_ALGORITHM);  

            keyPairGen.initialize(1024);  

      

            KeyPair keyPair = keyPairGen.generateKeyPair();  

      

            // 公钥  

            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  

      

            // 私钥  

            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  

      

            Map<String, Object> keyMap = new HashMap<String, Object>(2);  

      

            keyMap.put(PUBLIC_KEY, publicKey);  

            keyMap.put(PRIVATE_KEY, privateKey);  

            return keyMap;  

        }  

    }  

     

    再给出一个测试类: 

     

    import static org.junit.Assert.*;  

      

    import org.junit.Before;  

    import org.junit.Test;  

      

    import java.util.Map;  

      

    /** 

     *  

     * @author Sunny 

     * @version 1.0 

     * @since 1.0 

     */  

    public class RSACoderTest {  

        private String publicKey;  

        private String privateKey;  

      

        @Before  

        public void setUp() throws Exception {  

            Map<String, Object> keyMap = RSACoder.initKey();  

      

            publicKey = RSACoder.getPublicKey(keyMap);  

            privateKey = RSACoder.getPrivateKey(keyMap);  

            System.err.println("公钥: \n\r" + publicKey);  

            System.err.println("私钥: \n\r" + privateKey);  

        }  

      

        @Test  

        public void test() throws Exception {  

            System.err.println("公钥加密——私钥解密");  

            String inputStr = "abc";  

            byte[] data = inputStr.getBytes();  

      

            byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);  

      

            byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,  

                    privateKey);  

      

            String outputStr = new String(decodedData);  

            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  

            assertEquals(inputStr, outputStr);  

      

        }  

      

        @Test  

        public void testSign() throws Exception {  

            System.err.println("私钥加密——公钥解密");  

            String inputStr = "sign";  

            byte[] data = inputStr.getBytes();  

      

            byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);  

      

            byte[] decodedData = RSACoder  

                    .decryptByPublicKey(encodedData, publicKey);  

      

            String outputStr = new String(decodedData);  

            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  

            assertEquals(inputStr, outputStr);  

      

            System.err.println("私钥签名——公钥验证签名");  

            // 产生签名  

            String sign = RSACoder.sign(encodedData, privateKey);  

            System.err.println("签名:\r" + sign);  

      

            // 验证签名  

            boolean status = RSACoder.verify(encodedData, publicKey, sign);  

            System.err.println("状态:\r" + status);  

            assertTrue(status);  

        }  

    }  

     

    控制台输出: 

    公钥:   

     

    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89J  

    EcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm  

    1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+o6FbAZCyHBd7wIDAQAB  

      

    私钥:   

      

    MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJhT/4jT7PVoGXlfoNRQ4dDsVmmY  

    FINspO3Hz0kRwHriMUKS6cQtPyqIqXLt/MSoPTeDwAuW7le9f5sGocXLtg8kk/R6QTZffCNSeHY3  

    GWqkff8H/GbVl1KULAMiRuKOEFUOMD9u7kE5uFmpCYPAjGVAicv2hXP6joVsBkLIcF3vAgMBAAEC  

    gYBvZHWoZHmS2EZQqKqeuGr58eobG9hcZzWQoJ4nq/CarBAjw/VovUHE490uK3S9ht4FW7Yzg3LV  

    /MB06Huifh6qf/X9NQA7SeZRRC8gnCQk6JuDIEVJOud5jU+9tyumJakDKodQ3Jf2zQtNr+5ZdEPl  

    uwWgv9c4kmpjhAdyMuQmYQJBANn6pcgvyYaia52dnu+yBUsGkaFfwXkzFSExIbi0MXTkhEb/ER/D  

    rLytukkUu5S5ecz/KBa8U4xIslZDYQbLz5ECQQCy5dutt7RsxN4+dxCWn0/1FrkWl2G329Ucewm3  

    QU9CKu4D+7Kqdj+Ha3lXP8F0Etaaapi7+EfkRUpukn2ItZV/AkEAlk+I0iphxT1rCB0Q5CjWDY5S  

    Df2B5JmdEG5Y2o0nLXwG2w44OLct/k2uD4cEcuITY5Dvi/4BftMCZwm/dnhEgQJACIktJSnJwxLV  

    o9dchENPtlsCM9C/Sd2EWpqISSUlmfugZbJBwR5pQ5XeMUqKeXZYpP+HEBj1nS+tMH9u2/IGEwJA  

    fL8mZiZXan/oBKrblAbplNcKWGRVD/3y65042PAEeghahlJMiYquV5DzZajuuT0wbJ5xQuZB01+X  

    nfpFpBJ2dw==  

      

    公钥加密——私钥解密  

    加密前: abc  

      

    解密后: abc  

    公钥:   

      

    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdOj40yEB48XqWxmPILmJAc7UecIN7F32etSHF  

    9rwbuEh3+iTPOGSxhoSQpOED0vOb0ZIMkBXZSgsxLaBSin2RZ09YKWRjtpCA0kDkiD11gj4tzTiM  

    l9qq1kwSK7ZkGAgodEn3yIILVmQDuEImHOXFtulvJ71ka07u3LuwUNdB/wIDAQAB  

      

    私钥:   

      

    MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN06PjTIQHjxepbGY8guYkBztR5w  

    g3sXfZ61IcX2vBu4SHf6JM84ZLGGhJCk4QPS85vRkgyQFdlKCzEtoFKKfZFnT1gpZGO2kIDSQOSI  

    PXWCPi3NOIyX2qrWTBIrtmQYCCh0SffIggtWZAO4QiYc5cW26W8nvWRrTu7cu7BQ10H/AgMBAAEC  

    gYEAz2JWBizjI31bqhP4XiP9PuY5F3vqBW4T+L9cFbQiyumKJc58yzTWUAUGKIIn3enXLG7dNqGr  

    mbJro4JeFIJ3CiVDpXR9+FluIgI4SXm7ioGKF2NOMA9LR5Fu82W+pLfpTN2y2SaLYWEDZyp53BxY  

    j9gUxaxi1MQs+C1ZgDF2xmECQQDy70bQntbRfysP+ppCtd56YRnES1Tyekw0wryS2tr+ivQJl7JF  

    gp5rPAOXpgrq36xHDwUspQ0sJ0vj0O7ywxr1AkEA6SAaLhrJJrYucC0jxwAhUYyaPN+aOsWymaRh  

    9jA/Wc0wp29SbGTh5CcMuGpXm1g0M+FKW3dGiHgS3rVUKim4owJAbnxgapUzAgiiHxxMeDaavnHW  

    9C2GrtjsO7qtZOTgYI/1uT8itvZW8lJTF+9OW8/qXE76fXl7ai9dFnl5kzMk2QJBALfHz/vCsArt  

    mkRiwY6zApE4Z6tPl1V33ymSVovvUzHnOdD1SKQdD5t+UV/crb3QVi8ED0t2B0u0ZSPfDT/D7kMC  

    QDpwdj9k2F5aokLHBHUNJPFDAp7a5QMaT64gv/d48ITJ68Co+v5WzLMpzJBYXK6PAtqIhxbuPEc2  

    I2k1Afmrwyw=  

      

    私钥加密——公钥解密  

    加密前: sign  

      

    解密后: sign  

    私钥签名——公钥验证签名  

    签名:  

    ud1RsIwmSC1pN22I4IXteg1VD2FbiehKUfNxgVSHzvQNIK+d20FCkHCqh9djP3h94iWnIUY0ifU+  

    mbJkhAl/i5krExOE0hknOnPMcEP+lZV1RbJI2zG2YooSp2XDleqrQk5e/QF2Mx0Zxt8Xsg7ucVpn  

    i3wwbYWs9wSzIf0UjlM=  

      

    状态:  

    true  

    总结

        简要总结一下,使用公钥加密、私钥解密,完成了乙方到甲方的一次数据传递,通过私钥加密、公钥解密,同时通过私钥签名、公钥验证签名,完成了一次甲方到乙方的数据传递与验证,两次数据传递完成一整套的数据交互! 

     

    类似数字签名,数字信封是这样描述的: 

     

    数字信封 

      数字信封用加密技术来保证只有特定的收信人才能阅读信的内容。 

    流程: 

        信息发送方采用对称密钥来加密信息,然后再用接收方的公钥来加密此对称密钥(这部分称为数字信封),再将它和信息一起发送给接收方;接收方先用相应的私钥打开数字信封,得到对称密钥,然后使用对称密钥再解开信息。 

     

    展开全文
  • 2.2 方案 搭建实验环境,如图-2所示。 图-2 2.3 步骤 实现此案例需要按照如下步骤进行。 步骤一:对称加密解密 ...步骤二:非对称加密算法 图-5 图-6 图-7 图-8 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,502
精华内容 3,400
关键字:

非对称加密算法