RSA非对称加密算法的使用

最新推荐文章于 2024-06-24 23:01:30 发布
最新推荐文章于 2024-06-24 23:01:30 发布
阅读量958 收藏
点赞数 1
分类专栏： 笔记 文章标签： 加密解密 rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011670474/article/details/107927673
版权

加密和解密使用的是两个不同的密钥，这种算法叫作非对称加密算法。反之，用相同的密钥去加密和解密就是对称加密算法。

非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey)

  1. 公开密钥和私有密钥是一对
  2. 如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。
  3. 如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。

优点：其安全性更好，非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，而对称加密需要在交互前将密钥告诉对方。
缺点：加密和解密花费时间长、速度慢，只适合对少量数据进行加密。

在非对称加密中使用的主要算法有：RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）等。

在对称加密中使用的主要算法有：DES（Data Encryption Standard）、3DES（Triple DES）、AES（Advanced Encryption Standard）、Blowfish等。

RSA算法原理(来自百度百科)
RSA公开密钥密码体制的原理是：根据数论，寻求两个大素数比较简单，而将它们的乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

RSA的应用场景：
在跟银行，税局等金融行业交互过程中经常用到。
下面说一种对称加密和非对称加密配合使用的例子：
客户端采用RSA非对称加密去对对称加密需要的key进行加密处理。再用未加密的密钥key，使用对称加密算法对需要传输的数据进行对称加密。
最终将非对称加密后的key和对称加密后的数据都传输给服务端。
服务端接收到数据后，就可以先采用非对称解密获取到原始的key，再使用这个key对称解密，获取到原始的数据。

其好处有两个：

  1. 非对称加密解密花费时间长，故只对对称加密需要的key进行加密处理，提升性能；
  2. 加密需要的key采用非对称加密，可确保key的安全性。

DESEncrypt.java

import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

public class DESEncrypt {
    public DESEncrypt() {
    }

    public static String getDESKey() {
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
            keyGenerator.init(56);
            SecretKey generateKey = keyGenerator.generateKey();
            byte[] encoded = generateKey.getEncoded();
            String encodeHexString = toHexString(encoded);
            return Base64.encode(encodeHexString.getBytes("UTF-8"));
        } catch (Exception e) {
            e.printStackTrace();
            return "密钥生成错误.";
        }
    }

    public static String toHexString(byte[] byteArray) {
        if (byteArray != null && byteArray.length >= 1) {
            StringBuilder hexString = new StringBuilder();

            for(int i = 0; i < byteArray.length; ++i) {
                if ((byteArray[i] & 255) < 16) {
                    hexString.append("0");
                }

                hexString.append(Integer.toHexString(255 & byteArray[i]));
            }

            return hexString.toString();
        } else {
            throw new IllegalArgumentException("this byteArray must not be null or empty");
        }
    }

    public static String encrypt(String str, String Key) {
        String encrypt = "";

        try {
            DESKeySpec desKey = new DESKeySpec(Base64.decode(Key));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(1, securekey);
            byte[] bytes = cipher.doFinal(str.getBytes("UTF-8"));
            encrypt = Base64.encode(bytes);
            return encrypt;
        } catch (Exception e) {
            e.printStackTrace();
            return "加密错误";
        }
    }

    public static String decrypt(String buff, String Key) {
        String decrypt = null;

        try {
            DESKeySpec desKey = new DESKeySpec(Base64.decode(Key));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(2, securekey);
            byte[] responseByte = cipher.doFinal(Base64.decode(buff));
            decrypt = new String(responseByte, "UTF-8");
            return decrypt;
        } catch (Exception e) {
            e.printStackTrace();
            return "解密错误";
        }
    }
}

RSAEncrypt .java

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import com.sun.org.apache.xml.internal.security.utils.Base64;

public class RSAEncrypt {

    public static RSAPublicKey getPublicKeyByStr(String publicKeyStr) throws Exception {
        try {
            byte[] buffer = Base64.decode(publicKeyStr);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
            return (RSAPublicKey)keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException var4) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException var5) {
            throw new Exception("公钥非法");
        } catch (NullPointerException var6) {
            throw new Exception("公钥数据为空");
        }
    }
    public static byte[] publicEncrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception {
        if (publicKey == null) {
            throw new Exception("加密公钥为空, 请设置");
        } else {
            Cipher cipher = null;

            try {
                cipher = Cipher.getInstance("RSA");
                cipher.init(1, publicKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException var4) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException var5) {
                var5.printStackTrace();
                return null;
            } catch (InvalidKeyException var6) {
                throw new Exception("加密公钥非法,请检查");
            } catch (IllegalBlockSizeException var7) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException var8) {
                throw new Exception("明文数据已损坏");
            }
        }
    }

    public static String publicEncrypt(String publicKeyStr, String plainText) throws Exception {
        RSAPublicKey publicKey = getPublicKeyByStr(publicKeyStr);
        byte[] plainTextData = Base64.decode(plainText);
        byte[] encrypt = publicEncrypt(publicKey, plainTextData);
        return Base64.encode(encrypt);
    }

    public static byte[] publicDecrypt(RSAPublicKey publicKey, byte[] cipherTextData) throws Exception {
        if (publicKey == null) {
            throw new Exception("解密公钥为空, 请设置");
        } else {
            Cipher cipher = null;

            try {
                cipher = Cipher.getInstance("RSA");
                cipher.init(2, publicKey);
                byte[] output = cipher.doFinal(cipherTextData);
                return output;
            } catch (NoSuchAlgorithmException var4) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException var5) {
                var5.printStackTrace();
                return null;
            } catch (InvalidKeyException var6) {
                throw new Exception("解密公钥非法,请检查");
            } catch (IllegalBlockSizeException var7) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException var8) {
                throw new Exception("密文数据已损坏");
            }
        }
    }

    public static String publicDecrypt(String publicKeyStr, String cipherText) throws Exception {
        RSAPublicKey publicKey = getPublicKeyByStr(publicKeyStr);
        byte[] cipherTextData = Base64.decode(cipherText);
        byte[] decrypt = publicDecrypt(publicKey, cipherTextData);
        return Base64.encode(decrypt);
    }

    public static byte[] privateEncrypt(RSAPrivateKey privateKey, byte[] plainTextData) throws Exception {
        if (privateKey == null) {
            throw new Exception("加密私钥为空, 请设置");
        } else {
            Cipher cipher = null;

            try {
                cipher = Cipher.getInstance("RSA");
                cipher.init(1, privateKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException var4) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException var5) {
                var5.printStackTrace();
                return null;
            } catch (InvalidKeyException var6) {
                throw new Exception("加密私钥非法,请检查");
            } catch (IllegalBlockSizeException var7) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException var8) {
                throw new Exception("明文数据已损坏");
            }
        }
    }

    public static String privateEncrypt(String privateKeyStr, String plainText) throws Exception {
        RSAPrivateKey privateKey = getPrivateKeyByStr(privateKeyStr);
        byte[] plainTextData = Base64.decode(plainText);
        byte[] encrypt = privateEncrypt(privateKey, plainTextData);
        return Base64.encode(encrypt);
    }

    public static byte[] privateDecrypt(RSAPrivateKey privateKey, byte[] cipherTextData) throws Exception {
        if (privateKey == null) {
            throw new Exception("解密私钥为空, 请设置");
        } else {
            Cipher cipher = null;

            try {
                cipher = Cipher.getInstance("RSA");
                cipher.init(2, privateKey);
                byte[] output = cipher.doFinal(cipherTextData);
                return output;
            } catch (NoSuchAlgorithmException var4) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException var5) {
                var5.printStackTrace();
                return null;
            } catch (InvalidKeyException var6) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException var7) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException var8) {
                throw new Exception("密文数据已损坏");
            }
        }
    }

    public static String privateDecrypt(String privateKeyStr, String cipherText) throws Exception {
        RSAPrivateKey privateKey = getPrivateKeyByStr(privateKeyStr);
        byte[] cipherTextData = Base64.decode(cipherText);
        byte[] decrypt = privateDecrypt(privateKey, cipherTextData);
        return Base64.encode(decrypt);
    }

    public static RSAPrivateKey getPrivateKeyByStr(String privateKeyStr) throws Exception {
        try {
            byte[] buffer = Base64.decode(privateKeyStr);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            return (RSAPrivateKey)keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException var4) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException var5) {
            throw new Exception("私钥非法");
        } catch (NullPointerException var6) {
            throw new Exception("私钥数据为空");
        }
    }
}

Test.java

public class Test {
    public static void main(String[] args) throws Exception {
        String data ="这是明文";
        String encryptData = encryptData(data);
        System.out.println(encryptData);
        String decryptData = decryptData(encryptData);
        System.out.println(decryptData);
    }

    public static String encryptData(String data) throws Exception {
        JSONObject jsonObject = new JSONObject();

        final String deskey = DESEncrypt.getDESKey();
        String publicKey ="MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqEfIceRcNHAqQ5sPOrsp6XMZt1Ne8T3BmlTL73rv0MOEO2sGruWCcKUlxl7r23aCvhfymOXNCL6TGewdLa2i7+ms/l0lQQ4OpPbTgQYKbb3NPHo2u1KSrv9twwdPgWhoTMs9MBs3kyLfnGSRG9OXxYtCc7DgJgfTTXcg9KPFoZvubwAsE5+jF8ORLQlvfXi8O66yYIeVjNpcZd3Y+vFt1N/zqHvO65l5l81pVRbk64hiVqseowTampLB9ltCDVDFKzNo/RelO8v52kdZ8/tuT8Na4lpDzPmca0b8Y3GXWLWLxw6Jb8OpbbfE+I14eQ7G5a+iwreiyt7jKgxGJYTwJwIDAQAB";

        final String desmy = RSAEncrypt.publicEncrypt(publicKey, deskey);
        final String encryptData = DESEncrypt.encrypt(data, deskey);
        jsonObject.put("data",encryptData);
        jsonObject.put("key",desmy);
        return jsonObject.toJSONString();
    }

    public static String decryptData(String encryptData) throws Exception {
        JSONObject jsonObject = JSON.parseObject(encryptData);
        String desmy = (String)jsonObject.get("key");
        String data = (String)jsonObject.get("data");
        final String deskey = DESEncrypt.getDESKey();
        String  privateKey="MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCoR8hx5Fw0cCpDmw86uynpcxm3U17xPcGaVMvveu/Qw4Q7awau5YJwpSXGXuvbdoK+F/KY5c0IvpMZ7B0traLv6az+XSVBDg6k9tOBBgptvc08eja7UpKu/23DB0+BaGhMyz0wGzeTIt+cZJEb05fFi0JzsOAmB9NNdyD0o8Whm+5vACwTn6MXw5EtCW99eLw7rrJgh5WM2lxl3dj68W3U3/Ooe87rmXmXzWlVFuTriGJWqx6jBNqaksH2W0INUMUrM2j9F6U7y/naR1nz+25Pw1riWkPM+ZxrRvxjcZdYtYvHDolvw6ltt8T4jXh5Dsblr6LCt6LK3uMqDEYlhPAnAgMBAAECggEAYInVvyjPkLGsPV6OLRZEZA3I+ffVJrZUA9KTsA4p1+ziRigPDHTUEQVdF2FLE3r4ZE9euEJVDqgtwZhH4PWU3OeEe+Q5xAlpc0+6ZHFvuCdDv2cpUOt9BPG6KUFfZhDcjPmnX5qtljZSa+jxqjIIBqbud2pIHOkuWml2OYJelWftaRSwF8Mh5V8NaRE6PJN7GM4pwEVkRzlZElXTSyht2Agp7sMcDyc/7RcVyvOaLvl5mBNerJ46Hz7JJEc0WZjR/VHsYG7DcD2+pO34pkgEGmgsziOIsSqf94gXTbMTNAQwP5BMF7MfTigTftNy7wRqeV+tpBsyCfSPZMHkS7GwoQKBgQDfQp0AXIV0U/V9csvK9rQBF2t6qWLBG2IAy2vdHy/47C6kTqV6zm05Cjzqm+CUYPtIrzQdz73NHUM+pRqkIUiNbQvvg14ZeZW4i9go3U7+sRSxd3gJuPqh/q2SpD1V9XZrij23wsMVVNcIcWhpN7wTCS5c+c9u1KZXwZ7CZfrlsQKBgQDA9S3M2vGP63mSReBj/5Vc11NGwq1sLAixsvqd6D7RcppnkH5C8JJKxyKJUXCCu89o4yq5HMgubbD2JRRogZ552Bjnu2kovAqrzxuPGzQxO3/sSX8hCVS0C3X+VeLK5VnwLJRGeLUPKz8A24Ckm8ykgGXaOUAwRu5rOCgOHGoxVwKBgQC9ykLtK7nHShhGrG/R+ibLRr13aMcqobyOMF9hekGtuhlsU+8YlqMC+lEOn7Qqbscu4sHLFe6jj1y6xGABZsnmb+zVjzdPMKy2VStMkdW1bZPJyWWh3j4xt+6V2kjJ6gDhKoOM02RDnfuukbnQuDCJfiSLpVFRRjSiJVZwq4C+AQKBgQC+ZW8i82tmgoi8D50hrwEX0hSG/vOWiECv7xYiGBdcHkRDKq2bqbwAc0wdyTFGnsFDEtyGOeNBBNWXm/DuSfAw9E1m42MZYar56uubotE2Pyqz4bXCyG0/Fwv/wYl+gR7kwWgxvUuTQy3wz6a5Rk6Ah314/gLbYDJDs+66NcmHEwKBgGTII8Tdr01h1N4wgXFD8gfjgJT+mcU4u2o0ge7BNZ4utFYh8P9R6JmUzJDLCVn8tjAVWnRHW8YW49U/VK8uwRTm66mMcCp7auZI/2LrPpBVk/0NQV1Sl4vPIEyeinQ37aHzFmukR8btDWhIIybs7rF79w5WaX/DnICFW67n1Csn";

        String key = RSAEncrypt.privateDecrypt(privateKey, desmy);
        String decrypt = DESEncrypt.decrypt(data, key);
        return decrypt;
    }
}
黄小黑
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RSA非对称加密算法
02-14
RSA 非对称加密算法 RSA 非对称加密算法是一种经典的非对称加密算法，由罗纳德·李维斯特、阿迪·萨莫尔和伦纳德·阿德曼三人于 1977 年共同提出的。该算法的主要思想是基于大素数的乘积和因式分解之间的关系，通过...
Android:使用密码技术安全地保存凭证
ultrapro的专栏
03-19 1718
Using Cryptography to Store Credentials Safely http://android-developers.blogspot.com/2013/02/using-cryptography-to-store-credentials.html Posted by Trevor Johns, Android Developer Relations tea
非对称加密RSA算法原理及实际应用场景
Doub1's Blog
12-13 5766
非对称加密RSA算法原理及实际应用场原理数学基础质数模指数运算小白理解为什么需要足够大的质数 引言 我数学差的离谱，所以我朋友去学AI，我还在这搞这些。虽然数学差也能学那些，但是毕竟不想当掉包侠，没走那条路。所以本文如果在数学方面有问题，请留言给我，避免误人子弟。 对称加密算法有AES,DES，3DES,RC4等，加密解密方共用1个密钥，这就导致了很容易被破解，因为密钥在客户端中也存在，无论你如何加密这个字符串，程序跑起来的时候这密钥总会在内存里。 一般情况下，我们会使用RSA加密，RSA使用一个公钥
Java中如何解决BadPaddingException异常？
最新发布
微赚开发者技术分享博客
06-24 577
异常在Java加密解密过程中经常遇到，通常是由于填充错误导致的。通过检查填充方式、密钥长度和异常处理等方法，可以有效地解决这个异常。希望本文介绍的方法能够帮助您更好地处理异常，提高程序的稳定性和可靠性。
【笔记】RSA非对称加密的应用
zdvhmas的博客
04-20 731
简单说明 非对称加密算法中引入了公钥和私钥的概念，他们一一对应，使用公钥加密只能使用对应私钥解密，反之亦然，非对称即是如此。 RSA是一种典型非对称加密算法，它是由三位数学家（Rivest、Shamir、Adleman）设计出来的。 应用场景 签名验证 私钥用于加密签名，公钥用于验签，签名和加密作用不同，签名并不是为了保密，而是为了保证数据是由特定的某个人提供，而不是被其它人伪造，所以私钥的私有性就适合用在签名用途上。 加密 公钥用于加密，私钥用于解密，因为公钥是公开的，很多人可以持有公钥。若用私钥加密，
非对称加密算法之RSA的详细使用
积跬步，至千里。
05-30 462
对称加密算法在加密和解密时使用的是同一个秘钥；而非对称加密算法需要两个密钥来进行加密和解密，这两个密钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。
RSA加密算法的实际使用
平凡老者
09-18 1729
RSA算法是一种非对称的加密算法，它通常是先生成一对RSA密钥，其中之一是保密密钥（私钥），由用户保存；另一个为公开密钥（公钥）， 可对外公开；要加密传输内容时，比如A要给B传输信息，此时A先用B的公钥将内容加密后传输，B收到A传输过来的信息后用自己的私钥解密。 该过程中，只要B不泄露自己的私钥，那么就算第三方截取到了该信息，没有B的私钥也无法解密获得内容信息，RSA算法的安全性依赖于大数分解，计算两个大素数的乘积很容易，但是反过来由该乘积分解成两个素数相乘，如果该乘积够大的话，分解的难度是极其大的。 .
C#实现简单的RSA非对称加密算法示例
12-31
本文实例讲述了C#实现简单的RSA非对称加密算法。分享给大家供大家参考，具体如下： 界面控件 namespace RSA算法 { partial class Form1 { /// /// 必需的设计器变量。 /// private System.ComponentModel....
PHP通用RSA非对称加密算法
11-14
加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK 。 正是基于这种理论，1978年出现了著名的RSA算法，它通常是先生成一对RSA密钥，其中之一是保密密钥，由用户保存；...
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
本实验报告主要涉及两种加密算法：对称加密算法DES（Data Encryption Standard）和非对称加密算法RSA。实验旨在帮助学生深入理解这两种算法的基本原理，并通过Python编程实现加密和解密过程。 ### **对称加密算法...
创建RSA共私钥
u012864294的博客
06-28 582
import java.security.Key; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.interfaces.RSAPrivateKey; import java...
RSA公钥加密与私钥解密算法
weixin_48526216的博客
11-14 5287
RSA公钥加密私钥解密算法
【HAVENT原创】前端使用 jsrsasign 进行 RSA 加密、解密、签名、验签
weixin_34349320的博客
05-24 5549
为什么80%的码农都做不了架构师？>>> ...
RSA-公钥加密，私钥解密 、私钥加密，公钥解密、私钥加签，公钥验签
一尘在心的博客
07-13 3697
https://blog.csdn.net/qq_31289187/article/details/85234044 一、案例内容： RSA 公钥加密，私钥解密； RSA 私钥加密，公钥解密； RSA 私钥加签，公钥验签（SHA1WithRSA或者SHA256WithRSA-数字签名） 二、引入的jar包 <dependency> ...
RSA加密算法-非对称加密算法的使用
lixuanhong的博客
10-31 738
RSA加密算法-非对称加密算法的使用
RSA非对称加密使用方式与原理浅析
dream_caoyun的博客
11-26 2159
一、非对称加密的简述： 非对称加密，顾名思义加解密用的不是同一个密钥（如此我们也能很通俗的对照理解对称加密，显然它后者是加解密为同一个密钥），那么非对称加密就得用俩个密钥，一个叫公钥，任何人都能够去获取，一个叫私钥，不会四处乱传输，保留在一个认定安全的区域，公钥和私钥任意一方加密，只能由另一方解密，自己也是无法解密的，目前全球的数据安全测试中密钥大于1024的密钥还没有人宣称能够破解，因此是安全级别很高的加密算法，关于非对称加密的历史由来可以百度，有很详细的介绍，是美国很厉害的计算机大师和数学家设计出来的。
Java笔记-非对称加密RSA的使用
IT1995的博客
08-17 1320
使用OpenSSL生成对应RSA私钥和RSA公钥： #rsa私钥： genrsa -out rsa_private_key.pem 1024 pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform pem -nocrypt -out rsa_private_key_8.pem #rsa公钥： rsa -in rsa_private_key_8.pem -pubout -out rsa_public_key.pem Base64使用的是这样Ma
RSA加密、解密、签名、验签的原理及方法
拾一二的博客
04-08 9492
所以在实际应用中，要根据情况使用，也可以同时使用加密和签名，比如A和B都有一套自己的公钥和私钥，当A要给B发送消息时，先用B的公钥对消息加密，再对加密的消息使用A的私钥加签名，达到既不泄露也不被篡改，更能保证消息的安全性。在这个过程中，只有2次传递过程，第一次是A传递加签的消息和消息本身给B，第二次是B获取A的公钥，即使都被敌方截获，也没有危险性，因为只有A的私钥才能对消息进行签名，即使知道了消息内容，也无法伪造带签名的回复给B，防止了消息内容的篡改。公钥加密，私钥解密（私钥只有一个，公钥大家都知道）。
对称与非对称加密（DES&RSA）
败在我手中之敌，从来不会被我视为对手，我给你时间追赶，直至你遥望不见。
06-19 5202
是指使用同一个密钥进行信息的加密和解密，加密和解密的过程都使用相同的密钥，因此也称为共享密钥加密。这种加密方式的优点是速度快，适合加密大量的数据，但缺点是密钥需要在通信的双方之间共享。若密钥被泄漏，则整个加密系统的安全性就会被破解。是指使用一对密钥，即公钥和私钥，进行信息的加解密。公钥可以任意发布，不需要保密，而私钥则必须严格保密。加密和解密的过程使用不同的密钥，因此也称为公开密钥加密。这种加密方式的优点是密钥不需要在通信的双方之间共享，安全性较高，但缺点是加解密速度较慢，适合加密少量的数据。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值