精华内容
下载资源
问答
  • 英文 非对加密
    2021-12-21 16:06:58

    原文链接: nodejs crypto 加密 对称加密 非对称加密

    上一篇: nodejs cluster 利用多核cpu

    下一篇: VirtualBox 不能为虚拟电脑 [xxx] 打开一个新任务 已解决

    nodejs 中的 crypto 模块提供了各种各样加密算法的 API。这篇文章记录了常用加密算法的种类、特点、用途和代码实现。其中涉及算法较多,应用面较广,每类算法都有自己适用的场景。为了使行文流畅,列出了本文记录的几类常用算法:

    • 内容摘要:散列 (Hash) 算法
    • 内容摘要:HMac 算法
    • 内容加解密:对称加密 (AES) 与非对称加密解密 (RSA)
    • 内容签名:签名和验证算法

    散列 (Hash) 算法

    散列函数(英语:Hash function)又称散列算法、哈希函数,是一种从任何一种数据中创建小的数字 “指纹” 的方法。基本原理是将任意长度数据输入,最后输出固定长度的结果。

    hash 算法具有以下特点:

    • 不能从 hash 值倒推原数据
    • 不同的输入,会有不同的输出
    • 好的 hash 算法冲突概率更低

    正因为 hash 算法的这些特点,因此 hash 算法主要用于:加密、数据检验、版本标识、负载均衡、分布式(一致性 hash)。

    下面实现了一个获取文件标识的函数:

    const crypto = require("crypto");
    const fs = require("fs");
    
    function getFileHash(file, algorithm) {
        if (!crypto.getHashes().includes(algorithm)) {
            throw new Error("不支持此哈希函数");
        }
    
        return new Promise(resolve => {
            const hash = crypto.createHash(algorithm);
    
            const rs = fs.createReadStream(file);
            rs.on("readable", () => {
                const data = rs.read();
                if (data) {
                    hash.update(data);
                }
            });
            rs.on("end", () => {
                resolve(hash.digest("hex"));
            });
        });
    }
    
    // 用法:获取文件md5
    getFileHash("./db.json", "md5").then(val => {
        console.log(val);
    });
    复制代码

    HMac 算法

    攻击者可以借助 “彩虹表” 来破解哈希表。应对彩虹表的方法,是给密码加盐值(salt),将 pwd 和 salt 一起计算 hash 值。其中,salt 是随机生成的,越长越好,并且需要和用户名、密码对应保存在数据表中。

    虽然通过加盐,实现了哈希长度扩展,但是攻击者通过提交密码和哈希值也可以破解攻击。服务器会把提交的密码和 salt 构成字符串,然后和提交的哈希值对比。如果系统不能提交哈希值,不会受到此类攻击。

    显然,没有绝对安全的方法。但是不推荐使用密码加盐,而是 HMac 算法。它可以使用任意的 Hash 函数,例如 md5 => HmacMD5、sha1 => HmacSHA1。

    下面是利用 Hmac 实现加密数据的函数:

    const crypto = require("crypto");
    
    function encryptData(data, key, algorithm) {
        if (!crypto.getHashes().includes(algorithm)) {
            throw new Error("不支持此哈希函数");
        }
    
        const hmac = crypto.createHmac(algorithm, key);
        hmac.update(data);
        return hmac.digest("hex");
    }
    
    // output: 30267bcf2a476abaa9b9a87dd39a1f8d6906d1180451abdcb8145b384b9f76a5
    console.log(encryptData("root", "7(23y*&745^%I", "sha256"));
    复制代码

    对称加密 (AES) 与非对称加密解密 (RSA)

    有很多数据需要加密存储,并且需要解密后进行使用。这和前面不可逆的哈希函数不同。此类算法一共分为两类:

    • 对称加密 (AES):加密和解密使用同一个密钥
    • 非对称加密解密 (RSA):公钥加密,私钥解密

    对称加密 (AES)

    查看 nodejs 支持的所有加密算法:

    crypto.getCiphers();
    复制代码

    Nodejs 提供了 Cipher 类和 Decipher 类,分别用于加密和解密。两者都继承 Transfrom Stream,API 的使用方法和哈希函数的 API 使用方法类似。

    下面是用 aes-256-cbc 算法对明文进行加密:

    const crypto = require("crypto");
    
    const secret = crypto.randomBytes(32); // 密钥
    const content = "hello world!"; // 要加密的明文
    
    const cipher = crypto.createCipheriv(
        "aes-256-cbc",
        secret,
        Buffer.alloc(16, 0)
    );
    cipher.update(content, "utf8");
    // 加密后的结果:e2a927165757acc609a89c093d8e3af5
    console.log(cipher.final("hex"));
    复制代码

    注意 :在使用加密算法的时候,给定的密钥长度是有要求的,否则会爆出 this[kHandle].initiv(cipher, credential, iv, authTagLength); Error: Invalid key length... 的错误。以 aes-256-cbc 算法为例,需要 256 bits = 32 bytes 大小的密钥。同样地,AES 的 IV 也是有要求的,需要 128bits。(请参考 “参考链接” 部分)

    使用 32 个连续 I 作为密钥,用 aes-256-cbc 加密后的结果是 a061e67f5643d948418fdb150745f24d。下面是逆向解密的过程:

    const secret = "I".repeat(32);
    const decipher = crypto.createDecipheriv(
        "aes-256-cbc",
        secret,
        Buffer.alloc(16, 0)
    );
    decipher.update("a061e67f5643d948418fdb150745f24d", "hex");
    console.log(decipher.final("utf8")); // 解密后的结果:hello world!
    复制代码

    非对称加密解密 (RSA)

    借助 openssl 生成私钥和公钥:

    # 生成私钥
    openssl genrsa -out privatekey.pem 1024
    # 生成公钥
    openssl rsa -in privatekey.pem -pubout -out publickey.pem
    复制代码

    hello world! 加密和解密的代码如下:

    const crypto = require("crypto");
    const fs = require("fs");
    
    const privateKey = fs.readFileSync("./privatekey.pem");
    const publicKey = fs.readFileSync("./publickey.pem");
    
    const content = "hello world!"; // 待加密的明文内容
    
    // 公钥加密
    const encodeData = crypto.publicEncrypt(publicKey, Buffer.from(content));
    console.log(encodeData.toString("base64"));
    // 私钥解密
    const decodeData = crypto.privateDecrypt(privateKey, encodeData);
    console.log(decodeData.toString("utf8"));
    复制代码

    签名和验证算法

    除了不可逆的哈希算法、数据加密算法,还有专门用于签名和验证的算法。这里也需要用 openssl 生成公钥和私钥。

    代码示范如下:

    const crypto = require("crypto");
    const fs = require("fs");
    const assert = require("assert");
    
    const privateKey = fs.readFileSync("./privatekey.pem");
    const publicKey = fs.readFileSync("./publickey.pem");
    
    const data = "传输的数据";
    
    // 第一步:用私钥对传输的数据,生成对应的签名
    const sign = crypto.createSign("sha256");
    // 添加数据
    sign.update(data, "utf8");
    sign.end();
    // 根据私钥,生成签名
    const signature = sign.sign(privateKey, "hex");
    
    // 第二步:借助公钥验证签名的准确性
    const verify = crypto.createVerify("sha256");
    verify.update(data, "utf8");
    verify.end();
    assert.ok(verify.verify(publicKey, signature, "hex"));
    复制代码

    从前面这段代码可以看到,利用私钥进行加密,得到签名值;最后利用公钥进行验证。

    总结

    之前一直是一知半解,一些概念很模糊,经常混淆散列算法和加密算法。整理完这篇笔记,我才理清楚了常见的加密算法的功能和用途。

    除此之外,crypto 模块还提供了其他算法工具,例如 ECDH 在区块链中有应用。这篇文章没有再记录,感兴趣的同学可以去查阅相关资料

    更多相关内容
  • 凯撒密码作为一种最为古老的对称加密体制,在古罗马的时候都已经很流行,他的基本思想是:通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换...
  • 对称加密对称加密深度解析

    千次阅读 2022-03-15 21:23:26
    * 对称加密加密密钥和解密密钥相同 * 对称加密加密密钥和解密密钥不相同

    密码学的发展

    加密的发展史随着人类的进化逐步复杂、严谨也更安全,对于早期的移位和字母对应等加密方式我们不难理解。

    • 移位 : 比如恺撒密码, 简单点说将 26个英文字母的顺序打乱,得到一个新的字母顺序,之后的英文或是拼英组成的单词就无法直接看出是什么了。
    • 字母对应 :比如使用一个密码本, 原文通过对应的字母进行转换。

    后来出现了更高级的使用密钥的方式加密,加密和解密使用相同的密钥, 密钥越长,解密就越难。 到1976年出现了非对称加密。

    加密的分类

    按照密文是否可以被还原,可以将加密分为可逆加密和不可逆加密。严格意义上说,不可逆加密应该算不上加解密的范畴,但是实际开发过程中,还是会使用到使用不可逆加密的方法对某些信息进行加密,比如用户的登录密码。

    不可逆加密和可逆加密

    • 不可逆加密: 信息摘要和安全散列。将任意大小的原始数据变换成规定长度的输出,获取内容的数字指纹。算法比如MD5,SHA1,PBKDF2,bcrypt。
    • 可逆加密: 基于算法,可逆加密又分为对称加密和非对称加密。

    对称加密和非对称加密

    • 对称加密: 加密密钥和解密密钥相同
    • 非对称加密: 加密密钥和解密密钥不相同

    在对称加密中,密钥就是一个数字,长度越长, 破解越困难,加解密流程如下:
    在这里插入图片描述

    非对称加密有两个密钥,一个公钥一个私钥。 加密和解密使用不同的密钥。加解密流程如下:
    在这里插入图片描述

    除了公钥加密,私钥解密;也可以使用私钥加密,公钥解密。两者都有着实际的应用。

    • 公钥加密,私钥解密。主要用于通信
    • 私钥加密(签名),公钥解密(验证), 用于数字签名

    加密算法汇总

    不同的加密类型,对应的加密算法有:

    1. 基于算法的加密算法, 也称为古典加密算法, 比如base64, 比特币生成地址使用的base58。 这类算法对原始内容进行置换和替换得到密文, 安全性依赖于算法是否外泄。
    2. 对称加密算法。 加解密使用同一个密钥。算法常见的有DES、3DES、AES。安全性从依赖算法转向依赖于密钥。
    3. 非对称加密。 加解密使用同不同的密钥。常见算法:RSA, DH , ECC。
    对称加密非对称加密
    DES , AES ,3DES,PBERSA ,DH, ECC
    • DES已经被AES所取代

    对称加密算法

    1. DES , 数据加密算法
      DEA( Data Encryption Algorithm, 数据加密算法)。
    • 1997 年 DES标准正式发布, 分组长度64比特,其中8比特为奇偶校验位, 所以实际长度为56比特。

    DES密钥的实质长度是56比特(7个字节)。
    示例:

    • 二进制: 01010001 11101100 01001011 00010010 00111101 01000010 00000010
    • 十六进制:51 EC 4B 12 3D 42 02
    • 十进制:2305928028626269954

    可以使用两个DES密钥(DES-EDE2)和三个DES密钥(DES-EDE3)。DES-EDE2长度112比特(14个字节),DES-EDE3长度168比特(21字节)。
    示例:

    • DES-EDE2: 51 EC 4B 12 3D 42 03 30 04 D8 98 95 93 3F
    • DES-EDE3: 51 EC 4B 12 3D 42 03 30 04 D8 98 95 93 3F 24 9F 61 2A 2F D9 96
    1. AES
      密钥长度可以从128、192和256个比特中选择。

    2. PBE 基于口令的密码
      PBE ( Password Based Encryption, 基于口令的密码)。是一种基于口令生成密钥, 并使用该密钥进行加密的方法。
      加密和解密使用的是同一个密钥。

    • 如同饭菜上加盐会改变饭菜的味道, 口令中加盐会改变生成的KEK值。

    • KEK (Key Encryting Key,密钥加密密钥), 将盐和口令通过单向散列函数, 得到的散列值就是用来加密密钥的密钥。

    在Java语言中使用PBE 加密可以参考:
    Java使用PBE算法进行对称加解密最简入门和示例

    非对称加密的理解

    非对称加密来源于数学中的大质因数分解很难的问题,基于欧几里得的证明, 每个数只有一种质因数分解, 一个大整数分解成一堆质数很难。
    理解非对称加密, 需要回顾一下下面的数学概念:

    • 素数:又称质数,指在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数。
    • 互质,又称互素。若N个整数的最大公因子是1,则称这N个整数互质。
    • 模运算即求余运算。比如 10%3 , 10除以3的余数是1, 所以求模的结果是1。
    • 欧拉函数

    任意给定正整数n,请问在小于等于n的正整数之中,有多少个与n构成互质关系?
    计算这个值的方法就叫做欧拉函数,以φ(n)表示

    举例来说:
    对于一个很小的数 7, 分解为两个质因数的乘积很容易。但是对于一个大一点的数 589 就很难直接得到答案了(589 =19*31),如果一个更大的数呢?比如54225。
    以RSA算法为例,公钥与私钥虽然是一对密钥,但密钥值不同,这对密钥值的生成就建基于大素数的乘积与分解上。

    如果上面对非对称加密还不够了解的话,也可以从颜色的角度理解非对称加密的公私钥。

    颜色的比喻

    混合颜色是一个单向函数, 两个颜色混合输出第三种颜色很简单, 但是反过来就很难。

    首先了解一下什么是互补色:每个颜色都有一个互补色,两个互补色叠加得到白光。

    • 张三选了两个互补的颜色, 将其中一个作为公钥发给李四
    • 李四选了一个颜色, 他将这个颜色和张三混合色的颜色发给张三
    • 张三使用自己保留的颜色,叠加到李四的混合色上面。就得到了李四的颜色。
      即使李四混合后的颜色被别人知道了, 也很难破译出李四的颜色。

    对称加密和非对称加密的优缺点和应用

    • 对称加密速度快
    • 非对称加密更安全

    非对称加密在实际中会结合对称加密使用。常用的使用非对称算法获得共享密钥,使用对称加密处理数据。这也是https 采用的方式。

    展开全文
  • Java实现对称加密

    2022-05-04 13:51:59
    公开密钥密码学(英语:Public-key ...由于加密和解密需要两个不同的密钥,故被称为对称加密;不同于加密和解密都使用同一个密钥的对称加密。公钥可以公开,可任意向外发布;私钥不可以公开,必须由用户自行严

    1. 简介

            公开密钥密码学(英语:Public-key cryptography)也称非对称式密码学(英语:Asymmetric cryptography)是密码学的一种算法,它需要两个密钥,一个是公开密钥,另一个是私有密钥;公钥用作加密,私钥则用作解密。使用公钥把明文加密后所得的密文,只能用相对应的私钥才能解密并得到原本的明文,最初用来加密的公钥不能用作解密。由于加密和解密需要两个不同的密钥,故被称为非对称加密;不同于加密和解密都使用同一个密钥的对称加密。公钥可以公开,可任意向外发布;私钥不可以公开,必须由用户自行严格秘密保管,绝不透过任何途径向任何人提供,也不会透露给被信任的要通信的另一方。

            基于公开密钥加密的特性,它还能提供数字签名的功能,使电子文件可以得到如同在纸本文件上亲笔签署的效果。公开密钥基础建设透过信任数字证书认证机构的根证书、及其使用公开密钥加密作数字签名核发的公开密钥认证,形成信任链架构,已在TLS实现并在万维网的HTTP以HTTPS、在电子邮件的SMTP以SMTPS或STARTTLS引入。

            在现实世界上可作比拟的例子是,一个传统保管箱,开门和关门都是使用同一条钥匙,这是对称加密;而一个公开的邮箱,投递口是任何人都可以寄信进去的,这可视为公钥;而只有信箱主人拥有钥匙可以打开信箱,这就视为私钥。

            非对称加密过程:

            此流程图显示非对称加密过程是单向的,其中一条密钥加密后只能用相对应的另一条密钥解密。 

    2. 非对称加密算法--DH(密钥交换)

    密钥长度默认工作模式填充方式实现方
    512~1024(64倍数)1024JDK

            DH加解密应用:   

    package com.bity.dh;
    
    import org.apache.commons.codec.binary.Base64;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyAgreement;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    import javax.crypto.interfaces.DHPublicKey;
    import javax.crypto.spec.DHParameterSpec;
    import java.nio.charset.StandardCharsets;
    import java.security.InvalidAlgorithmParameterException;
    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Objects;
    
    import static java.lang.System.*;
    
    /**
     * <p>Title: JdkDh</p >
     * <p>Description: DH非对称算法实现 </p >
     * <p>Company: http://www.agree.com</p >
     * <p>Project: security</p >
     *
     * @author <a href="mailto:weiqi@agree.com.cn">WEIQI</a>
     * @version 1.0
     * @date 2022-04-27 19:51
     */
    public class JdkDh {
        
        private static final String SRC = "I'm DH encryption algorithm";
        
        public static void main(String[] args) {
            // 解决 Unsupported secret key algorithm: DES 异常
            System.getProperties().setProperty("jdk.crypto.KeyAgreement.legacyKDF", "true");
            jdkDh();
        }
        
        private static void jdkDh() {
            try {
                // 初始化发送方密钥
                KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
                senderKeyPairGenerator.initialize(512);
                KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
                // 发送方密钥,发送给接收方(可以通过文件、优盘、网络等...)
                byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();
                
                // 初始化接收方密钥,注意在实际环境中接收方和发送方肯定不会在一个函数中
                KeyFactory keyFactory = KeyFactory.getInstance("DH");
                X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
                PublicKey receiverPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);
                DHParameterSpec dhParameterSpec = ((DHPublicKey)receiverPublicKey).getParams();
                KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
                receiverKeyPairGenerator.initialize(dhParameterSpec);
                KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();
                PrivateKey receiverPrivateKey = receiverKeyPair.getPrivate();
                byte[] receiverPublicKeyEnc = receiverKeyPair.getPublic().getEncoded();
                
                // 构建密钥
                KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
                receiverKeyAgreement.init(receiverPrivateKey);
                receiverKeyAgreement.doPhase(receiverPublicKey, true);
                SecretKey receiverSecretKey = receiverKeyAgreement.generateSecret("DES");
                
                KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
                x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
                PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);
                KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");
                senderKeyAgreement.init(senderKeyPair.getPrivate());
                senderKeyAgreement.doPhase(senderPublicKey, true);
                SecretKey senderSecretKey = senderKeyAgreement.generateSecret("DES");
                
                if (Objects.equals(receiverSecretKey, senderSecretKey)) {
                    out.println("双方密钥相同");
                }
                
                // 加密
                Cipher cipher = Cipher.getInstance("DES");
                cipher.init(Cipher.ENCRYPT_MODE, senderSecretKey);
                byte[] result = cipher.doFinal(SRC.getBytes(StandardCharsets.UTF_8));
                out.println("jdk dh encryption is : " + Base64.encodeBase64String(result));
                
                // 解密
                cipher.init(Cipher.DECRYPT_MODE, receiverSecretKey);
                result = cipher.doFinal(result);
                out.println("jdk dh decrypt is : " + new String(result));
                
            } catch (NoSuchAlgorithmException | InvalidKeySpecException | InvalidAlgorithmParameterException | InvalidKeyException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e) {
                e.printStackTrace();
            }
        }
    }

            运行结果:

    双方密钥相同
    jdk dh encryption is : Be3LeXqV/q1PDEbpH62LL129gaV5Og0Eo3GY9e00B4o=
    jdk dh decrypt is : I'm DH encryption algorithm

            注意:由于JDK8 update 161之后,DH的密钥长度至少为512位,但DES算法密钥不能达到这样的长度,所以运行会抛出Unsupported secret key algorithm: DES异常。解决办法有两种如下:

            1. 在代码中加如下代码:

    System.getProperties().setProperty("jdk.crypto.KeyAgreement.legacyKDF", "true");
    

            2. 在启动的时候添加JVM变量:-Djdk.crypto.KeyAgreement.legacyKDF=true

     

            DH数据加密传输图示: 

    3. 非对称加密算法--RSA

            RSA加密算法是一种非对称加密算法,在公开密钥加密和电子商业中被广泛使用。RSA是由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)在1977年一起提出的。当时他们三人都在麻省理工学院工作。RSA 就是他们三人姓氏开头字母拼在一起组成的。

            对极大整数做因数分解的难度决定了 RSA 算法的可靠性。换言之,对一极大整数做因数分解愈困难,RSA 算法愈可靠。假如有人找到一种快速因数分解的算法的话,那么用 RSA 加密的信息的可靠性就会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的 RSA 钥匙才可能被强力方式破解。到2020年为止,世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长,用RSA加密的信息实际上是不能被破解的。

            RSA算法加密实现:

    package com.bity.rsa;
    
    import org.apache.commons.codec.binary.Base64;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import java.nio.charset.StandardCharsets;
    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    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 static java.lang.System.*;
    
    /**
     * <p>Title: JdkRsa</p >
     * <p>Description: RSA非对称加密算法实现 </p >
     * <p>Company: http://www.agree.com</p >
     * <p>Project: security</p >
     *
     * @author <a href="mailto:weiqi@agree.com.cn">WEIQI</a>
     * @version 1.0
     * @date 2022-04-27 21:38
     */
    public class JdkRsa {
        
        private static final String SRC = "I'm RSA encryption algorithm";
        
        public static void main(String[] args) {
            jdkRsa();
        }
        
        /**
         * JDK-RSA算法实现
         * 
         * @author: <a href="mailto:weiqi@agree.com.cn">WEIQI</a>
         * @date: 2022-04-28 0:15
         */
        private static void jdkRsa() {
            try {
                // 初始化密钥
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                keyPairGenerator.initialize(512);
                KeyPair keyPair = keyPairGenerator.generateKeyPair();
                RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
                RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
                
                out.println("public key is : " + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
                out.println("private key is : " + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));
                
                // 私钥加密,公钥解密 -- 加密
                PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                byte[] result = cipher.doFinal(SRC.getBytes(StandardCharsets.UTF_8));
                out.println("私钥加密,公钥解密 -- 加密 : " + Base64.encodeBase64String(result));
                
                // 私钥加密,公钥解密 -- 解密
                X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
                keyFactory = KeyFactory.getInstance("RSA");
                PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                result = cipher.doFinal(result);
                out.println("私钥加密,公钥解密 -- 解密 : " + new String(result));
        
                // 公钥加密,私钥解密 -- 加密
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] res = cipher.doFinal(SRC.getBytes(StandardCharsets.UTF_8));
                out.println("公钥加密,私钥解密 -- 加密 : " + Base64.encodeBase64String(res));
                // 公钥加密,私钥解密 -- 解密
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                res = cipher.doFinal(res);
                out.println("公钥加密,私钥解密 -- 解密 : " + new String(res));
            } catch (NoSuchAlgorithmException | InvalidKeySpecException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
                e.printStackTrace();
            }
        }
    }

            运行结果: 

    public key is : MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIfDTXqCrjGHP9tCmLujavsngP8nqSHIl/JkFN8ZmQEcn48xzSXdijEG8Ssgm3SkDWICT0cW9wf3mZ+UkVxLx90CAwEAAQ==
    private key is : MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAh8NNeoKuMYc/20KYu6Nq+yeA/yepIciX8mQU3xmZARyfjzHNJd2KMQbxKyCbdKQNYgJPRxb3B/eZn5SRXEvH3QIDAQABAkASyfa5E8jj1eICiE72+QDfTXJO3cBMiqRsyWkSD0rbmlL/Qv1xDDQonWM58sIR6DOBWQZ+uXbkL1VtOuZ9sgfBAiEA9IxhRwkTYA1GVUKmgZPX+7CsfUmIZi8P/r9/C29XQZUCIQCOHtBkIOupaTLPv3A4yznEidygfbL8nrLV2Xhf6wVrKQIhAJ+RdewPDPhw0QLTIaiNWrIdXv/FWl4quUolk/VXKl1dAiASpbpkGOmy7cmr9otr+EZZIlmfeT695LjEVGd19mlcmQIhAJfua+j3/PT0+z0nPIaGDvczviyl5SxmDo79rfMNpi10
    私钥加密,公钥解密 -- 加密 : AiYjJSlGlz5x86mwVW/wjieG/uJsoLEqF+xRcPLzq2HL7yIrSrE3oT4wibrvUDR6kp37eHvFaAT+/wVYCreVvg==
    私钥加密,公钥解密 -- 解密 : I'm RSA encryption algorithm
    公钥加密,私钥解密 -- 加密 : Io2diORtKbeTz5eOOziHrqZKzS1K19U4t3YPydhM4w2LrzW7bJK/d4DQrWTBAhg8rt28OjbGcJfqd1w8MMy4iw==
    公钥加密,私钥解密 -- 解密 : I'm RSA encryption algorithm

            从上面例子可以看出RSA算法是支持私钥加密、公钥解密和公钥加密、私钥解密的算法。RSA也是唯一被广泛接受并实现的非对称加密算法,从某种程度来说,RSA已经成为非对称加密算法的一个标准了。 

            RSA数据加密传输图示:

    ​​​​​​​4. 非对称加密算法--EIGamal

            在密码学中,ElGamal加密算法是一个基于迪菲-赫尔曼密钥交换的非对称加密算法。它在1985年由塔希尔·盖莫尔提出。GnuPG和PGP等很多密码学系统中都应用到了ElGamal算法。

            ElGamal加密算法由三部分组成:密钥生成、加密和解密。

            ElGamal算法加解密应用:

    package com.bity.eigamal;
    
    import org.apache.commons.codec.binary.Base64;
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.spec.DHParameterSpec;
    import java.nio.charset.StandardCharsets;
    import java.security.AlgorithmParameterGenerator;
    import java.security.AlgorithmParameters;
    import java.security.InvalidAlgorithmParameterException;
    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.SecureRandom;
    import java.security.Security;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.InvalidParameterSpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    import static java.lang.System.out;
    
    /**
     * <p>Title: BouncyCastleEiGamal</p >
     * <p>Description: ElGamal加密算法实现 </p >
     * <p>Company: http://www.agree.com</p >
     * <p>Project: security</p >
     *
     * @author <a href="mailto:weiqi@agree.com.cn">WEIQI</a>
     * @version 1.0
     * @date 2022-04-28 0:38
     */
    public class BouncyCastleElGamal {
        
        private static final String SRC = "I'm ElGamal encryption algorithm";
        
        public static void main(String[] args) {
            bcElGamal();
        }
        
        private static void bcElGamal() {
            try {
                Security.addProvider(new BouncyCastleProvider());
                
                AlgorithmParameterGenerator algorithmParameterGenerator = AlgorithmParameterGenerator
                        .getInstance("ElGamal");
                algorithmParameterGenerator.init(256);
                AlgorithmParameters algorithmParameters = algorithmParameterGenerator.generateParameters();
                DHParameterSpec dhParameterSpec = algorithmParameters.getParameterSpec(DHParameterSpec.class);
                
                // 初始化密钥
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ElGamal");
                keyPairGenerator.initialize(dhParameterSpec, new SecureRandom());
                KeyPair keyPair = keyPairGenerator.generateKeyPair();
                PublicKey elGamalPublicKey = keyPair.getPublic();
                PrivateKey elGamalPrivateKey = keyPair.getPrivate();
                
                out.println("public key is : " + Base64.encodeBase64String(elGamalPublicKey.getEncoded()));
                out.println("private key is : " + Base64.encodeBase64String(elGamalPrivateKey.getEncoded()));
                
                // 公钥加密,私钥解密 -- 加密
                X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(elGamalPublicKey.getEncoded());
                KeyFactory keyFactory = KeyFactory.getInstance("ElGamal");
                PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
                Cipher cipher = Cipher.getInstance("ElGamal");
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] result = cipher.doFinal(SRC.getBytes(StandardCharsets.UTF_8));
                
                out.println("私钥加密,公钥解密 -- 解密 : " + Base64.encodeBase64String(result));
                // 公钥加密,私钥解密 -- 解密
                PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(elGamalPrivateKey.getEncoded());
                keyFactory = KeyFactory.getInstance("ElGamal");
                PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                result = cipher.doFinal(result);
                out.println("私钥加密,公钥解密 -- 加密 : " + new String(result));
            } catch (NoSuchAlgorithmException | InvalidKeySpecException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException | InvalidParameterSpecException | InvalidAlgorithmParameterException e) {
                e.printStackTrace();
            }
        }
    }
    

             运行结果:

    
    public key is : MHYwTwYGKw4HAgEBMEUCIQCxvT1SNSrVl1/8KpvPhaE1MKiaXOHWk5SACDd39SfnHwIgQ5O8oKi9mIKhEDOCKwvYB+mozFgvmuoipw/ZDl6xCicDIwACIBh0K6bn2mtdvmiSMJj/HDlotAGOmTRFMZs+PFoIobQG
    private key is : MHgCAQAwTwYGKw4HAgEBMEUCIQCxvT1SNSrVl1/8KpvPhaE1MKiaXOHWk5SACDd39SfnHwIgQ5O8oKi9mIKhEDOCKwvYB+mozFgvmuoipw/ZDl6xCicEIgIge9eM9ELM12n6bQKkj8iBtIXjvPeN5mwX9clNriqfSsA=
    私钥加密,公钥解密 -- 解密 : e39h4LkKXQn1EIXdDkIxmWiB2pwgO5dZJcNfSmlXqS07SrW1VSLrx0L3RhdWm8hPLaqBZieR5quU/7oTzH/uuA==
    私钥加密,公钥解密 -- 加密 : I'm ElGamal encryption algorithm

    ElGamal数据加密传输图示:

     5. 总结

            对称密码是指在加密和解密时使用同一个密钥的方式,公钥密码则是指在加密和解密时使用不同密钥的方式。

            对称密钥加密牵涉到密钥管理的问题,尤其是密钥交换,它需要通信双方在通信之前先透过另一个安全的渠道交换共享的密钥,才可以安全地把密文透过不安全的渠道发送;对称密钥一旦被窃,其所作的加密将即时失效;而在互联网,如果通信双方分隔异地而素未谋面,则对称加密事先所需要的“安全渠道”变得不可行;非对称加密则容许加密公钥随便散布,解密的私钥不发往任何用户,只在单方保管;如此,即使公钥在网上被截获,如果没有与其匹配的私钥,也无法解密,极为适合在互联网上使用。

            另一方面,公钥解密的特性可以形成数字签名,使数据和文件受到保护并可信赖;如果公钥透过数字证书认证机构签授成为电子证书,更可作为数字身份的认证,这都是对称密钥加密无法实现的。不过,公钥加密在在计算上相当复杂,性能欠佳、远远不比对称加密;因此,在一般实际情况下,往往通过公钥加密来随机创建临时的对称秘钥,亦即对话键,然后才通过对称加密来传输大量、主体的数据。

            以上就是非对称加密算法的内容,在实际工作中可以根据具体业务的需求进行数据加密算法选择。

    附加

            关于加解密相关系列文章会在微信公众号《编程之艺术》中每天连载分享,感兴趣的朋友可以关注下,可以及时获取最新文章连载信息。

                                                

     

     

    展开全文
  • 对称加密详解

    千次阅读 2020-12-13 23:27:58
    对称加密1. 对称加密1.1 什么是非对称加密 1. 对称加密 1.1 什么是非对称加密对称加密也叫公钥密码:...发送者用加密密钥消息进行加密,接收者用解密密钥密文进行解密。需理解公钥密码,清楚地分加密

    1. 非对称加密

    1.1 什么是非对称加密

    “非对称加密也叫公钥密码:使用公钥加密,使用私钥解密”

    非对称加密和加密密钥不同
    在对称密码中,由于加密和解密的密钥是相同的,因此必须向接收者配送密钥。用于解密的密钥必须被配送给接收者,这一问题称为密钥配送问题。如果使用非对称加密,则无需向接收者配送用于解密的密钥,这样就解决了密钥配送的问题。

    非对称加密中,密钥分为加密密钥和解密密钥两种。发送者用加密密钥对消息进行加密,接收者用解密密钥对密文进行解密。需理解公钥密码,清楚地分加密密钥和解密密钥是非常重要的。加密密钥是发送者加密时使用的,而解密密钥则是接收者解密时使用的。

    加密密钥和解密密钥的区别
    发送者只需要加密密钥
    接收者只需要解密密钥
    解密密钥不可以被窃听者获取
    加密密钥被窃听者获取也没关系

    也就是说,解密密钥从一开始就是由接收者自己保管的,因此只要将加密密钥发给发送者就可以解决密钥配送问题了,而根本不需要配送解密密钥。

    非对称加密中,加密密钥一般是公开的。真是由于加密密钥可以任意公开,因此该密钥被称为公钥(pulickey)。相对地解密密钥是绝对不能公开的,这个密钥只能由你自己来使用,因此称为私钥(privatekey)****。私钥不可以被别人知道,也不可以将它发送给别人。

    公钥和私钥是"一一对应的",一对公钥和私钥统称为密钥对(keypair)。由公钥进行加密的密文,必须使用与该公钥配对的私钥才能解密。密钥对中的两个密钥之间具有非常密切的的关系(数学上的关系)。因此公钥和私钥不能分别单独生成。

    公钥密码的使用者需要生成一个包括公钥和私钥的密钥对,其中公钥会被发送给别人,而私钥则仅供自己使用。

    1.2 非对称加密通信流程

    非对称加密通讯流程

    假设A要给B发一条信息,A是发送者,B是接收者,窃听者C可以窃听他们之间的通讯内容。

    1. B生成一个包含公钥和私钥的密钥对

      私钥由B自行妥善保管

    2. B将自己的公钥发送给A

      B的公钥被C截获也没关系。
      将公钥发给A,表示B请A用这个公钥对消息进行加密并发送给他。

    3. A用B的公钥对消息进行加密

      加密后的消息只有B的西药才能够解密。
      虽然A拥有B的公钥,但用B的公钥是无法对密文进行解密的。

    4. A将密文发送给B

      密文被C截获也没关系,C可能拥有B的公钥,但是B的公钥是无法进行解密的。

    5. B用自己的私钥对密文进行解密。

      参考下图

    RSA加密流程

    A和B之间传输的信息有两个,一个是B的公钥,一个是B公钥加密的密文,由于B的私钥没有出现在通信内容中,因此C无法对密文进行解密。

    1.3 RSA

    RSA是一种非对称加密算法,它的名字由三位开发者。即RonRivest、AdiShamir和LeonardAdleman 的姓氏的首字母组成的(Rivest-Shamir-Leonard)

    1.3.1 RSA加密

    RSA的加密工程可以用下来公式来表达,如下。
    RSA加密公式
    也就是说,RSA的密文是对代表明文的数字的E次方求modN的结果。换句话说,就是将明文自己做E次乘法,然后将其结果除以N求余数,这个余数就是密文。

    RSA的加密是求明文的E次方modN,因此只要知道E和N这两个数,任何人都可以完成加密的运算。所以说E和N是RSA加密的密钥。也就是说E和N的组合就是公钥

    有一个很容易引起误解的地方需要大家注意一一E和N这两个数并不是密钥对(公钥和私钥的密钥对)。E和N两个数才组成了一个公钥,因此我们一般会写成 “公钥是(E,N)” 或者 “公钥是{E, N}" 这样的形式,将E和N用括号括起来。

    1.3.2 RSA解密

    RSA的解密和加密一样简单,可以用下面的公式来表达:
    RSA解密公式

    也就是说,对表示密文的数字的D次方求modN就可以得到明文。换句话说,将密文自己做D次乘法,在对其结果除以N求余数,就可以得到明文。

    这里所使用的数字N和加密时使用的数字N是相同的。数D和数N组合起来就是RSA的解密密钥,因此D和N的组合就是私钥。只有知道D和N两个数的人才能够完成解密的运算。

    大家应该已经注意到,在RSA中,加密和解密的形式是相同的。加密是求 "E次方的mod N”,而解密则是求 "D次方的modN”,这真是太美妙了。

    当然,D也并不是随便什么数都可以的,作为解密密钥的D,和数字E有着相当紧密的联系。否则,用E加密的结果可以用D来解密这样的机制是无法实现的。

    顺便说一句,D是解密〈Decryption)的首字母,N是数字(Number)的首字母

    1.3.3 总结

    总结表格
    RSA加密和解密
    RSA加密和解密

    1.4 ECC椭圆曲线

    椭圆曲线密码学(英语:Elliptic curve cryptography,缩写为 ECC),一种建立公开密钥加密的算法,基于椭圆曲线数学。椭圆曲线在密码学中的使用是在1985年由Neal Koblitz和Victor Miller分别独立提出的。

    ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全。

    椭圆曲线密码学的许多形式有稍微的不同,所有的都依赖于被广泛承认的解决椭圆曲线离散对数问题的困难性上。与传统的基于大质数因子分解困难性的加密方法不同,ECC通过椭圆曲线方程式的性质产生密钥。

    ECC 164位的密钥产生的一个安全级相当于RSA 1024位密钥提供的保密强度,而且计算量较小,处理速度更快,存储空间和传输带宽占用较少。目前我国居民二代身份证正在使用 256 位的椭圆曲线密码,虚拟货币比特币也选择ECC作为加密算法。
    具体算法详解:
    链接:算法详解

    不管是RSA还是ECC或者其它,公钥加密算法都是依赖于某个正向计算很简单(多项式时间复杂度),而逆向计算很难(指数级时间复杂度)的数学问题。

    椭圆曲线依赖的数学难题是:

    k为正整数,P是椭圆曲线上的点(称为基点), k*P=Q , 已知Q和P,很难计算出k

    展开全文
  • 一、加密的方式 1. 对称加密 1. 简介 2. 优缺点: 3. 经典对称加密: ...2. 前端利用公钥数据进行加密 3. 后端利用私钥数据进行解密 2. 对称加密 AES 3. 单向散列加密 MD5 SHA1 三、加密算法比较
  • 散列加密、对称加密对称加密、数字签名搞不懂?就这篇博客给你安排的明明白白
  • 按照密码体制分类,密码加密主要分为对称加密对称加密两大类。接下来,主要讲解这两者的原理与区别。 一、对称加密 1、原理 通信双方使用同一个密钥,使用加密算法配合上密钥来加密,解密时使用加密...
  • 1:对称加密 对称加密加密方和解密方需要约定一个相同的秘钥(加密秘钥和解密秘钥相同...缺点:双方使用同一份秘钥,安全性得不到保证,每用户每次使用对称加密算法时,都需要使用其他人不知道的惟一钥匙,这会...
  • 当我们拿到加密数据后,肯定希望能够解密,因为我们需要当中的数据,跟前面不可逆的加密是不一样的,本篇文章学的是我们需要的数据进行加密 通常密钥是一串数字或者字符串,类似于规则,告诉明文该如何加密 不同...
  • 对称加密对称加密

    千次阅读 2019-06-15 20:36:31
    对称加密 ...加密计算量小、速度块,适合大量数据进行加密的场景。(记住这个特点,实际使用是会用到的) 对称加密的两大不足 密钥传输问题:如上所说,由于对称加密加密和解密使用的是同一...
  • 文章目录前言一、密钥二、对称加密颜色混合方法乘法把戏迪菲–赫尔曼密钥交换算法AES对称加密算法三、对称加密四、摘要五、数字签名数字签名的作用六.数字签名 前言 这篇记录笔者进行计算机网络相关知识学习过程...
  • 最近看了一些关于加密传输方面的文章,借鉴这些文章,把大概的原理做一个整理,用到了知乎大佬总结的流程图,简单易懂,做一个笔记。 1.对称加密 1.1 直接key加密 在账号登陆中,密码明文传输存在风险,很容易被截获...
  • 对称加密算法和对称加密算法

    千次阅读 2019-03-17 15:59:04
    有一种加密算法叫做对称加密,对称加密是以前比较常见的一种加密方式。所谓对称加密的意思是说假如有一个人A,他想把一个信号m传递给B,他不能直接将这个信息传递给B,否则会有人可能会窃听。于是通过一些算法,...
  • 文章目录1.1 密码学基本概念1.1.1 古典密码学1.1.2 近代密码学1.1.3 现代密码学1.1.4 如何设置密码才安全1.2 ASCII编码1.3 恺撒加密...英文对应的字节1.6 常见加密方式1.6.1 对称加密的概念1.6.2 DES 加密解密1)DES 加
  • 对称加密英语:asymmetric cryptography),是密码学的一种算法,它需要两个密钥,一个是公开密钥,另一个是私有密钥;一个用作加密的时候,另一个则用作解密。使用其中一个密钥把明文加密后所得的密文,只能用...
  • 因此,需要消息进行加密,在这里我们使用RSA对称加密。 RSA对称加密方法中,存在一对密钥,分别为公钥和私钥。其中公钥公开,私钥秘密保存。在RSA加密通信中,发送端和接收端各有一对密钥,且不相同。发送信息...
  • RSA对称加密算法详解

    万次阅读 多人点赞 2019-01-28 17:11:57
    RSA加密算法是最常用的对称加密算法,由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)于1977年一起提出,RSA就是他们三人姓氏开头字母拼在一起组成的。对称...
  • 在对称加密的过程中,明文和密文都只通过同一把密钥加密解密。 密钥最大的好处在于摆脱了之前依靠加密算法保密的问题,而现在我只需要保密这个密钥,算法公开都完全没事,保密的难度大大减小。 那么密钥的管理和...
  • 2、3DES(Triple DES):是基于DES的对称算法,一块数据用三个不同的密钥进行三次加密,强度更高; 3、RC2和RC4:对称算法,用变长密钥大量数据进行加密,比 DES 快; 4、IDEA(International Data Encryption ...
  • 现在网络的安全性已经变得越来越重要,各位程序员在开发过程中或多或少都会遇到公钥、私钥、加密、签名等一些相关名词。这些概念比较杂乱,容易混淆,下面就来梳理一下这部分的内容。 对称加密 在重要的信息的传递...
  • 而不可逆加密算法又分为对称加密对称加密 不可逆加密:不可逆加密算法最大的特点就是不需要密钥,但是HMAC是需要密钥的! 常见的不可逆加密算法有MD5,HMAC,SHA1、SHA-224、SHA-256、SHA-384,和SHA-
  • 本文主要对称加密对称加密的原理以及过程进行分析,同时还会简单介绍一下TLS/SSL的一些相关内容,并且对比TLSv1.2和TLSv1.3的不同。 1、SSL和TLS的历史 其实早期的互联网协议基本都是不加密进行传输的,如...
  • 目录 内容简介 1. 前言 2. 对称加密 3. 用 SSH 创建一个安全的通信管道 4. 用 SSH 进行连接 ...5. 用密钥实现自动身份验证 ... 对称加密 ...所以我们来学习对称加密,它可以为我们加密用于对称...
  • 1.10 对称加密 简介: ① 对称加密算法又称现代加密算法。 ② 对称加密是计算机通信安全的基石,保证了加密数据不会被破解。 ③ 与对称加密算法不同,对称加密算法需要两个密钥:公开密钥(publickey)和...
  • 加密秘钥,我规定,每个英文字母对应的字母+1,a变成b 传输信息, how are you 加密后,就变成了 ipx bsf zpv(为了方便看,转码时候忽略了空格) 信息接收方: 依次将字母向前移动一位就可以还原成原来的信息how are...
  • 对称加密对称加密(DES or RSA)

    千次阅读 2019-06-22 18:24:45
    在 对称加密算法 中,使用的密钥只有一个,发送 和 接收 双方都使用这个密钥数据进行 加密 和 解密。这就要求加密和解密方事先都必须知道加密的密钥。 数据加密过程:在对称加密算法中,数据发送方 将 明文 ...
  • AES,高级加密标准(英语:Advanced Encryption Standard)。是用来替代DES,目前比较流行的加密算法。 它是一种对称加密算法,与上一篇博文提到过的RSA对称算法不同,AES只有一个密钥,这个密钥既用来加密,也...
  • RSA AES-对称加密对称加密

    千次阅读 2018-11-11 02:50:35
    2.客户端:身份证信息(重要信息)进行AES加密 3.客户端:通过使用RSAAES密钥进行公钥加密 4.服务端:对加密后的AES密钥进行RSA私钥解密,拿到密钥原文; 5.服务端:对加密后的重要信息进行AES解密,拿到原始...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,698
精华内容 21,479
关键字:

英文 非对加密