非对称加密算法

简介
特点
常见算法——RSA
常见算法——ECC
Java-RSA加解密完整实践

简介

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

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

③ 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（public key）和私有密钥（private key）

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

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

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

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

特点

加密和解密使用不同的密钥
如果使用私钥加密, 只能使用公钥解密
如果使用公钥加密, 只能使用私钥解密
处理数据的速度较慢, 因为安全级别高

常见算法——RSA

RSA算法是一种非对称加密算法，由罗纳德·李维斯特和阿迪·萨莫尔等人发明的。RSA算法的原理基于数论中的大数分解问题，即将一个大数分解为其质因数的乘积。因为大数分解是一个非常困难的问题，使得RSA算法能够提供较高的安全性。

RSA算法的原理是基于两个密钥，分别为公钥和私钥。公钥用于加密数据，私钥用于解密数据。首先，生成一对公钥和私钥，并将公钥发布给他人，而私钥保密。当他人想要向你发送加密的数据时，他们使用你的公钥对数据进行加密，只有持有私钥的你才能解密数据。

RSA算法广泛应用在安全传输和加密通信领域，如HTTPS通信、数字签名、加密文档等。其安全性和可靠性使得RSA成为公认的重要加密算法之一。

原理

假设Alice想要向Bob发送加密的消息，他们采用RSA算法进行加密和解密。

生成公钥和私钥： Alice生成公钥(n, e)和私钥(n, d)。其中，n是两个大素数p和q的乘积，e是与(d * e mod φ(n) = 1)互质的数，d是e的模φ(n)的乘法逆元。
加密消息： Alice获取Bob的公钥(n, e)，并将消息M转换为整数m。然后，使用公钥进行加密，计算密文c = m^e mod n。
解密消息： Bob收到密文c后，使用自己的私钥进行解密，计算明文消息m = c^d mod n。

这样，Bob就成功解密了Alice发送的消息。RSA算法通过公钥和私钥的配对来保证数据的安全传输和机密性。

数字示例

首先生成密钥对, 公钥为(5,14), 私钥为(11,14)

现在A希望将原文2发送给B

A使用公钥加密数据， 2的5次方mod 14 = 4 , 将密文4发送给B

B使用私钥解密数据， 4的11次方mod14 = 2, 得到原文2

Python实战RSA

以下是一个使用Python实现RSA算法的示例，并对给定明文进行加密和解密：

RSA算法示例：

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5

# 生成RSA密钥对
key = RSA.generate(2048)
public_key = key.publickey()
private_key = key

# 加密和解密操作
cipher = PKCS1_v1_5.new(public_key)
text = "新中国还在黎明中等待复苏"
encrypted = cipher.encrypt(text.encode('utf-8'))

decrypt_cipher = PKCS1_v1_5.new(private_key)
decrypted = decrypt_cipher.decrypt(encrypted, None).decode('utf-8')

print("RSA加密后的密文：", encrypted)
print("RSA解密后的明文：", decrypted)

这两个示例演示了如何使用Python中的RSA和ECC算法对给定的明文进行加密和解密操作。请注意，为了运行这些示例，您可能需要安装相应的密码学库（如pycryptodome和cryptography）。

JavaScript实战RSA

以下是一个使用JavaScript调用RSA算法的示例：

RSA算法示例：

// 使用CryptoJS库进行RSA加密
const publicKey = "<公钥>";  // 公钥需要替换为实际的公钥
const plainText = "新中国还在黎明中等待复苏";
const encrypted = CryptoJS.AES.encrypt(plainText, publicKey).toString();

console.log("RSA加密后的密文：", encrypted);

以上示例中使用了CryptoJS库进行RSA加密，具体的实现细节需要您根据实际情况调整。

常见算法——ECC

椭圆曲线密码学（ECC）是一种基于椭圆曲线理论的密码学技术。ECC的起源可追溯到1985年，由Neal Koblitz和Victor Miller提出。ECC算法在比传统RSA算法更短的密钥长度下，提供了相同甚至更高的安全性，因此在资源受限的环境中广泛应用。

ECC算法的原理是基于椭圆曲线上的点运算。椭圆曲线是由满足特定方程的点构成的集合，具有一些特殊的数学性质。对于给定的椭圆曲线、基点和一条直线，通过多次点运算，可以实现椭圆曲线上的加法、减法、倍乘等操作。ECC算法使用这些点运算来实现加密和签名操作。

ECC算法的应用包括加密通信、数字签名、身份认证等领域。在移动设备、IoT设备和智能卡等资源受限的环境中，ECC算法可以提供更高效的安全解决方案。随着量子计算机等新兴技术的发展，ECC算法也被认为是一种抵御量子计算攻击的有效手段。因此，ECC算法在密码学领域具有重要的地位和广泛的应用前景。

原理

假设Alice和Bob想要使用ECC算法进行加密和解密通信。

生成公钥和私钥： Alice和Bob各自生成一对公钥和私钥。每对密钥包括一个椭圆曲线上的点作为公钥，以及一个私钥作为椭圆曲线上的一个整数。
加密消息： Alice先将消息m转换为椭圆曲线上的点P，然后使用Bob的公钥点Q对P进行倍乘运算，得到密文点C = k * Q。将C发送给Bob。
解密消息： Bob收到密文点C后，使用自己的私钥整数k对C进行倍乘运算，计算得到解密后的点P = k * C。然后将P转换为明文消息m。

这样，Bob成功解密了Alice发送的消息。ECC算法通过椭圆曲线上的点运算来保证数据的安全传输和机密性。

Python实战ECC

以下是一个使用Python实现ECC算法的示例，并对给定明文进行加密和解密：

ECC算法示例：

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.backends import default_backend

# 生成ECC密钥对
private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
public_key = private_key.public_key()

# 加密和解密操作
encrypted = public_key.encrypt(b"新中国还在黎明中等待复苏", ec.ECIES())
decrypted = private_key.decrypt(encrypted, ec.ECIES())

print("ECC加密后的密文：", encrypted)
print("ECC解密后的明文：", decrypted.decode('utf-8'))

JavaScript实战ECC

以下是一个使用JavaScript调用ECC算法的示例：

ECC算法示例：

// 使用elliptic库进行ECC加密
const EC = require('elliptic').ec;
const ec = new EC('secp256k1');  // 选择椭圆曲线参数
const key = ec.genKeyPair();

const plainText = "新中国还在黎明中等待复苏";
const message = Buffer.from(plainText, 'utf8');

const signature = key.sign(message);
const validSignature = key.verify(message, signature);

console.log("ECC签名：", signature);
console.log("ECC签名验证结果：", validSignature);

以上示例中使用了elliptic库进行ECC签名和验证操作，具体的实现细节需要您根据实际情况调整。请注意，为了运行这些示例，您可能需要安装相应的JavaScript密码学库。

Java-RSA加解密完整实践

生成公钥和私钥

生成RSA的公钥私钥：KeyPairGenerator类

package code.async;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);
        // 打印私钥
        System.out.println(privateKeyString);
        // 打印公钥
        System.out.println(publicKeyString);
    }
}

运行程序：先打印的是私钥，后面打印的是公钥

私钥加密

package code.async;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        String plainText = "硅谷没有包子，就像中南海没有小李子一样。没有鸡翅，你吃的什么？";

        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);

        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        // 私钥加密
        byte[] bytes = cipher.doFinal(plainText.getBytes());
        System.out.println(Base64.getEncoder().encodeToString(bytes));
    }
}

私钥加密私钥解密

package code.async;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        String plainText = "硅谷没有包子，就像中南海没有小李子一样。没有鸡翅，你吃的什么？";

        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);

        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        // 私钥加密
        byte[] bytes = cipher.doFinal(plainText.getBytes());
        System.out.println(Base64.getEncoder().encodeToString(bytes));

        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(bytes);
        System.out.println(new String(bytes1));
    }
}

运行程序，报错。

原因：私钥加密，只能公钥解密

私钥加密公钥解密

package code.async;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        String plainText = "硅谷没有包子，就像中南海没有小李子一样。没有鸡翅，你吃的什么？";

        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);

        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        // 私钥加密
        byte[] bytes = cipher.doFinal(plainText.getBytes());
        System.out.println(Base64.getEncoder().encodeToString(bytes));

        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(bytes);
        System.out.println(new String(bytes1));
    }
}

成功输出明文。

保存公钥和私钥

package com.TianHan;

import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.util.Base64;
import org.apache.commons.io.FileUtils;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        // 加密算法
        String algorithm = "RSA";

        //生成密钥对并保存在本地文件中
        generateKeyToFile(algorithm, "./code/src/main/resources/a.pub", "./code/src/main/resources/a.pri");
    }

    /**
     * 生成密钥对并保存在本地文件中
     *
     * @param algorithm : 算法
     * @param pubPath   : 公钥保存路径
     * @param priPath   : 私钥保存路径
     * @throws Exception
     */
    private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);
        // 保存文件

        FileUtils.writeStringToFile(new File(pubPath), publicKeyString, StandardCharsets.UTF_8);
        FileUtils.writeStringToFile(new File(priPath), privateKeyString, StandardCharsets.UTF_8);
    }

    /**
     * 解密数据
     *
     * @param algorithm      : 算法
     * @param encrypted      : 密文
     * @param key            : 密钥
     * @return : 原文
     * @throws Exception
     */
    public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,key);
        // 由于密文进行了Base64编码, 在这里需要进行解码
        byte[] decode = Base64.getDecoder().decode(encrypted);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(decode);
        System.out.println(new String(bytes1));
        return new String(bytes1);

    }
    /**
     * 使用密钥加密数据
     *
     * @param algorithm      : 算法
     * @param input          : 原文
     * @param key            : 密钥
     * @return : 密文
     * @throws Exception
     */
    public static String encryptRSA(String algorithm, Key key, String input) throws Exception{
        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE, key);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        // 对密文进行Base64编码
        System.out.println(Base64.getEncoder().encodeToString(bytes));
        return Base64.getEncoder().encodeToString(bytes);
    }
}

运行在项目目录下生成私钥

运行在项目目录下生成公钥

读取私钥

package com.TianHan;

import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
import org.apache.commons.io.FileUtils;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        String path = "./code/src/main/resources/";

        // 加密算法
        String algorithm = "RSA";
        // 从文件读取私钥 ，这个是自定义的方法
        PrivateKey privateKey = getPrivateKey(path + "a.pri", algorithm);
        System.out.println("privateKey: " + privateKey);
    }

    public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
        // 将文件内容转为字符串
        String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKeyString));
        // 生成私钥
        return keyFactory.generatePrivate(spec);
    }
}

读取公钥

package com.TianHan;

import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import org.apache.commons.io.FileUtils;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        String path = "./code/src/main/resources/";

        // 加密算法
        String algorithm = "RSA";
        PublicKey publicKey = getPublicKey(path + "a.pub", algorithm);
        System.out.println(publicKey);
    }

    public static PublicKey getPublicKey(String publicPath, String algorithm) throws Exception{
        // 将文件内容转为字符串
        String publicKeyString = FileUtils.readFileToString(new File(publicPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyString));
        // 生成公钥
        return keyFactory.generatePublic(spec);
    }
}

RSA加解密完整代码

package com.TianHan;

import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import org.apache.commons.io.FileUtils;

public class RSADemo {
    public static void main(String[] args) throws Exception {

        String plainText = "硅谷没有包子，就像中南海没有小李子一样。没有鸡翅，你吃的什么？";

        String path = "./code/src/main/resources/";
        // 加密算法
        String algorithm = "RSA";
        // 从文件读取私钥 ，这个是自定义的方法
        PrivateKey privateKey = getPrivateKey(path + "a.pri", algorithm);
        PublicKey publicKey = getPublicKey(path + "a.pub", algorithm);

        String encryptStr = encryptRSA(algorithm, privateKey, plainText);
        String decryptStr = decryptRSA(algorithm, publicKey, encryptStr);
        System.out.println(decryptStr);
    }

    public static PublicKey getPublicKey(String publicPath, String algorithm) throws Exception{
        // 将文件内容转为字符串
        String publicKeyString = FileUtils.readFileToString(new File(publicPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyString));
        // 生成公钥
        return keyFactory.generatePublic(spec);
    }

    public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
        // 将文件内容转为字符串
        String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKeyString));
        // 生成私钥
        return keyFactory.generatePrivate(spec);
    }

    /**
     * 生成密钥对并保存在本地文件中
     *
     * @param algorithm : 算法
     * @param pubPath   : 公钥保存路径
     * @param priPath   : 私钥保存路径
     * @throws Exception
     */
    private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.getEncoder().encodeToString(privateKeyEncoded);
        String publicKeyString = Base64.getEncoder().encodeToString(publicKeyEncoded);
        // 保存文件

        FileUtils.writeStringToFile(new File(pubPath), publicKeyString, StandardCharsets.UTF_8);
        FileUtils.writeStringToFile(new File(priPath), privateKeyString, StandardCharsets.UTF_8);
    }

    /**
     * 解密数据
     *
     * @param algorithm      : 算法
     * @param encrypted      : 密文
     * @param key            : 密钥
     * @return : 原文
     * @throws Exception
     */
    public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,key);
        // 由于密文进行了Base64编码, 在这里需要进行解码
        byte[] decode = Base64.getDecoder().decode(encrypted);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(decode);
        //System.out.println(new String(bytes1));
        return new String(bytes1);

    }
    /**
     * 使用密钥加密数据
     *
     * @param algorithm      : 算法
     * @param input          : 原文
     * @param key            : 密钥
     * @return : 密文
     * @throws Exception
     */
    public static String encryptRSA(String algorithm, Key key, String input) throws Exception{
        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE, key);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        // 对密文进行Base64编码
        //System.out.println(Base64.getEncoder().encodeToString(bytes));
        return Base64.getEncoder().encodeToString(bytes);
    }
}

信息安全