加密与安全_三种方式实现基于国密非对称加密算法的加解密和签名验签

文章目录

  • 国际算法
  • 基础概念
  • 常见的加密算法及分类
  • 签名和验签
    • 基础概念
    • 常见的签名算法
    • 应用场景
  • 国密算法
    • 对称加密（DES/AES⇒SM4）
    • 非对称加密（RSA/ECC⇒SM2）
    • 散列(摘要/哈希)算法（MD5/SHA⇒SM3）
  • Code
    • 方式一 使用Bouncy Castle库实现国密SM2算法的加解密和签名验签功能
    • 方式二 基于Kona库从证书里读取公钥进行加解密和签名验签
    • 方式三 使用基于Bouncy Castle库封装的gm-java库
      • 密码算法
      • 证书
      • 密钥协商
      • 实现

在这里插入图片描述

国际算法

基础概念

  • 加密：将明文转换为密文，以保护数据的机密性。
  • 解密：将密文还原为明文，以便数据可被读取。

常见的加密算法及分类

加密算法主要分为对称加密和非对称加密两大类。

  1. 对称加密：

    • 概念：使用相同的密钥进行加密和解密。
    • 优点：加密速度快，适合大数据量加密。
    • 缺点：密钥分发困难，密钥管理复杂。
    • 常见算法：
      • AES（高级加密标准）：广泛应用于各类数据加密。
      • DES（数据加密标准）：已被认为不够安全，逐渐被淘汰。
      • 3DES（三重数据加密标准）：通过三次加密提高安全性，但速度较慢。

  2. 非对称加密：

    • 概念：使用一对公钥和私钥，其中公钥用于加密，私钥用于解密。
    • 优点：解决了密钥分发问题，公钥可以公开，而私钥需要保密。
    • 缺点：加密和解密速度较慢，通常用于加密小数据或密钥交换。
    • 常见算法：
      • RSA：基于大素数分解，广泛用于数字签名和密钥交换。
      • ECC（椭圆曲线密码学）：相对于RSA，提供更高的安全性和效率。

签名和验签

基础概念

  • 数字签名：生成消息摘要并使用私钥对摘要进行加密，确保消息的完整性和发送者的身份。
  • 验签：使用发送者的公钥解密消息摘要，并与接收到的消息计算出的摘要进行比较，验证消息的完整性和发送者的身份。

常见的签名算法

  • RSA：常用的数字签名算法，基于公钥和私钥对消息摘要进行加密和解密。
  • DSA（数字签名算法）：专为数字签名设计，使用SHA-1或SHA-2生成消息摘要。
  • ECDSA（椭圆曲线数字签名算法）：基于椭圆曲线密码学，提供更高效的签名和验证过程。

应用场景

  • 数据传输安全：SSL/TLS协议通过加密和签名技术确保数据传输的机密性和完整性。
  • 身份验证：数字签名用于验证身份，防止数据被篡改。
  • 电子邮件安全：PGP和S/MIME通过加密和签名保护电子邮件内容。
  • 区块链和加密货币：使用数字签名验证交易的合法性。

国密算法

在这里插入图片描述

国产密码算法（国密算法）是指国家密码局认定的国产商用密码算法，在一般信息化系统开发中主要使用公开的SM2（非对称）、SM3（摘要）、SM4（对称）三类算法。

Base64是一种编码格式，并不属于加密，常用于数据传输、兼容性问题。Base64编码本质上是一种将二进制数据转成文本数据的方案，将一些不适合传输的数据内容进行编码来适合传输。

对称加密（DES/AES⇒SM4）

🔸基本特点：

  • 同一个秘钥进行加密、解密。因此秘钥的保密性就很重要，不能泄漏。
  • 计算量小、效率高。

🔸应用场景：

  • 数据加密存储。
  • 加密通信，如HTTPS、SSL、VPN，会与其他加密算法混合使用。

非对称加密（RSA/ECC⇒SM2）

🔸基本特点：

  • 密钥配对：一个私钥、一个公钥，用私钥加密，用公钥解密。注意每一个密钥对都是独一无二、天生一对的，只能配对的秘钥加密、解密。简单来说，公钥加密的数据，只能配对的私钥才能解密。
  • 安全性高，但计算量大。
  • 基本原理：利用某一数学公式，正向计算容易，反向推理则非常难。

🔸应用场景：

  • HPPTS、SSH协议，如Git的ssh认证。
  • HTTPS的安全传输就是混合了非对称加密、对称加密，非对称加密协商会话秘钥，用会话秘钥对称加密传输数据。
  • 敏感数据的加密传输，如客户端登录时传输用户名、密码信息时，采用公钥加密数据，服务端私钥解密。
  • 对数据进行签名、验签，保障数据的完整性，同时验证身份。

散列(摘要/哈希)算法（MD5/SHA⇒SM3）

🔸基本特点：

  • 无需秘钥，“加密”后的数据不可逆。所以这也不算是“加密”，一般称为哈希（Hash）。
  • 任何长度的数据生成的哈希值长度都固定。
  • 相同数据每次生成的哈希值相同，不同的数据则不同。

🔸应用场景：

  • 数据摘要/哈希，验证数据是否被篡改、或数据丢失，保障数据的完整性、不可篡改性。
  • 单向加密保存数据，如密码的保存，密码的存储普遍都是存的哈希值，登录时比较其hash值即可。

🔸彩虹表破解：

由于散列算法的特点（同一数据生成哈希值始终一样），如果存储了大量（海量）字符内容的哈希值，就很容易进行查询破解了，这就是彩虹表，暴力破解也是一样的道理。常用的6位数字密码是相当容易破解的，如CMD5这个网站就利用存储的大量密文字典，反向查询破解。怎么解决呢？

  • 提升散列算法的安全性，常用方法就是加“盐”，核心思想就是在哈希过程中添加一些自定义的内容、规则，仅自己知道，从而避免被字典破解。

  • 最简单的比如在密文中某一位置添加一串随机字符，只有自己知道，使用的时候去掉干扰字符即可。

  • 加盐的具体方式很多，可以自己DIV，常用的一种模式如下图，加盐+双重哈希。 MD5(MD5(password) + salt)

  • 如果加盐的规则被窃取了，对于现代的硬件是挺容易被破解的，只能设置尽量复杂的密码+定期更换了。

📢实际应用中，可能会多种加密算法组合使用。

  • 比如HTTPS的安全数据传输就是同时用了对称加密、非对称加密，用非对称传送（动态）密钥，对称加密传输数据。 《HTTP协议图文简述》

  • 对一个数据进行多重加密，以防被破解

Code

方式一 使用Bouncy Castle库实现国密SM2算法的加解密和签名验签功能

    <!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk18on -->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk18on</artifactId>
            <version>1.78.1</version>
        </dependency>

package com.artisan.gmja;


import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.ECGenParameterSpec;
import java.util.Base64;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class Sm2Example {

    /**
     * 静态初始化块，在类加载时执行。用于向Java安全提供者列表中添加Bouncy Castle提供者。
     *
     * Bouncy Castle提供者是一个著名的加密库，添加它是为了支持更多的加密算法和操作。
     * 这种做法通常用于需要加强加密能力的场景，比如数字签名、加密解密等操作。
     *
     * 选择在静态初始化块中添加提供者，是因为它在类加载时只执行一次，确保了提供者的添加是全局的和一次性的。
     * 这样做可以避免在每次使用加密操作时重复添加提供者，提高了代码的效率和可维护性。
     */
    static {
        Security.addProvider(new BouncyCastleProvider());
    }


    /**
     * 生成SM2密钥对。
     *
     * @return KeyPair 生成的密钥对，包括公钥和私钥。
     * @throws Exception 如果密钥对生成过程中发生错误，将抛出异常。
     */
    // 生成密钥对
    public static KeyPair generateKeyPair() throws Exception {
        // 实例化KeyPairGenerator对象，并指定算法为EC(椭圆曲线)，提供者为BC(Bouncy Castle)
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC");

        // 设置椭圆曲线参数为sm2p256v1，这是SM2算法所使用的特定椭圆曲线
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("sm2p256v1");

        // 初始化KeyPairGenerator对象，使用随机数生成器以增加密钥的随机性
        kpg.initialize(ecSpec, new SecureRandom());

        // 生成密钥对，并返回
        return kpg.generateKeyPair();
    }


    /**
     * 使用SM2算法和公钥对数据进行加密。
     *
     * @param publicKey 公钥，用于加密数据。公钥是密钥对的一部分，用于加密操作，而私钥用于解密。
     * @param data      待加密的原始明文数据。
     * @return 加密后的数据以字节数组形式返回。
     * @throws Exception 如果加密过程中发生错误，将抛出异常。
     */
    // 加密
    public static byte[] encrypt(PublicKey publicKey, byte[] data) throws Exception {
        // 实例化Cipher对象，并指定使用SM2算法和BC提供者。
        Cipher cipher = Cipher.getInstance("SM2", "BC");
        // 初始化Cipher对象为加密模式，使用给定的公钥。
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 执行加密操作，返回加密后的数据。
        return cipher.doFinal(data);
    }


    /**
     * 使用SM2算法和私钥对加密数据进行解密。
     *
     * @param privateKey    解密所需的私钥。私钥是加密过程中使用的公钥的对应部分，
     *                      只有持有相应私钥的个体才能解密由公钥加密的数据。
     * @param encryptedData 待解密的加密数据。这些数据是由SM2算法和相应的公钥加密得到的。
     * @return 返回解密后的原始数据。这些数据在加密前是明文状态，通过解密操作恢复成原始形态。
     * @throws Exception 如果解密过程中发生错误，例如私钥无效或加密数据格式不正确，将抛出异常。
     */
    // 解密
    public static byte[] decrypt(PrivateKey privateKey, byte[] encryptedData) throws Exception {
        // 实例化Cipher对象，用于执行解密操作。Cipher是Java加密/解密的核心类。
        Cipher cipher = Cipher.getInstance("SM2", "BC");
        // 初始化Cipher对象为解密模式，使用提供的私钥。
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // 执行解密操作，返回解密后的数据。
        return cipher.doFinal(encryptedData);
    }


    /**
     * 使用SM2算法和私钥对数据进行数字签名。
     *
     * @param privateKey 私钥，用于生成数字签名。私钥必须与用于验证签名的公钥匹配。
     * @param data       待签名的数据，通常为原始消息或消息的哈希值。
     * @return 返回使用SM2算法和私钥对数据签名后的字节数组。
     * @throws Exception 如果签名过程中发生错误，将抛出异常。
     */
    // 签名
    public static byte[] sign(PrivateKey privateKey, byte[] data) throws Exception {
        // 初始化签名对象，指定使用SM3withSM2算法和BC提供者。
        Signature signature = Signature.getInstance("SM3withSM2", "BC");
        // 使用私钥初始化签名对象，准备进行签名操作。
        signature.initSign(privateKey);
        // 更新签名对象，将待签名的数据加载到签名算法中。
        signature.update(data);
        // 执行签名操作，生成数字签名。
        return signature.sign();
    }


    /**
     * 使用SM2算法和SM3哈希函数验证数据的数字签名。
     * 此函数用于确认给定的数据是否是由对应的私钥进行签名的，通过公钥进行验证。
     *
     * @param publicKey      公钥，用于验证签名。
     * @param data           原始数据，被签名的数据。
     * @param signatureBytes 数字签名，用于验证数据的真实性和完整性。
     * @return boolean，如果签名验证成功，则返回true；否则返回false。
     * @throws Exception 如果在签名验证过程中发生错误，则抛出异常。
     */
    // 验签
    public static boolean verify(PublicKey publicKey, byte[] data, byte[] signatureBytes) throws Exception {
        // 实例化签名对象，指定使用SM2算法和SM3哈希函数。
        Signature signature = Signature.getInstance("SM3withSM2", "BC");
        // 初始化签名对象为验证模式，使用提供的公钥。
        signature.initVerify(publicKey);
        // 更新签名对象，将待验证的数据输入。
        signature.update(data);
        // 执行签名验证，返回验证结果。
        return signature.verify(signatureBytes);
    }


    /**
     * 主函数，用于演示SM2加密算法的使用。
     * 生成SM2密钥对，并进行加密、解密以及签名、验签操作。
     *
     * @param args 命令行参数
     * @throws Exception 如果密钥生成或加解密过程中发生错误
     */
    public static void main(String[] args) throws Exception {
        // 生成SM2密钥对
        // 生成密钥对
        KeyPair keyPair = generateKeyPair();
        // 获取公钥，并将其转换为Base64编码
        PublicKey publicKey = keyPair.getPublic();
        String publicKeyBase64 = Base64.getEncoder().encodeToString(publicKey.getEncoded());
        // 输出公钥
        System.out.println("公钥(Base64): " + publicKeyBase64);
        // 获取私钥，并将其转换为Base64编码
        PrivateKey privateKey = keyPair.getPrivate();
        String privateKeyBase64 = Base64.getEncoder().encodeToString(privateKey.getEncoded());
        // 输出私钥
        System.out.println("私钥(Base64): " + privateKeyBase64);

        // 准备待加密的明文
        String plaintext = "I'm Artisan ; 加密算法主要分为对称加密和非对称加密两大类";
        // 使用公钥加密明文
        byte[] encryptedData = encrypt(publicKey, plaintext.getBytes());
        // 使用私钥解密密文
        byte[] decryptedData = decrypt(privateKey, encryptedData);
        // 输出明文和解密后的明文
        System.out.println("原文: " + plaintext);
        System.out.println("解密后: " + new String(decryptedData));

        // 将加密后的数据转换为Base64编码，方便展示和传输
        // 加密数据转Base64字符串
        String encodedData = Base64.getEncoder().encodeToString(encryptedData);
        // 从Base64编码还原回加密数据，用于解密
        // 需要时，从Base64字符串还原回字节数组进行解密
        byte[] decodedData = Base64.getDecoder().decode(encodedData);
        // 输出密文（Base64编码）
        System.out.println("密文: " + encodedData);

        // 使用私钥对明文进行签名
        byte[] signature = sign(privateKey, plaintext.getBytes());
        // 使用公钥验证签名的合法性
        boolean isVerified = verify(publicKey, plaintext.getBytes(), signature);
        // 输出签名验证结果
        System.out.println("签名验证结果: " + isVerified);
    }

}

代码演示了如何使用Bouncy Castle库实现国密SM2算法的加解密和签名验签功能。具体流程如下：

  • 生成SM2密钥对。
  • 使用公钥加密数据，私钥解密数据。
  • 使用私钥对数据签名，公钥验证签名。
  • 输出相关的密钥、密文、解密结果和签名验证结果。

在这里插入图片描述

方式二 基于Kona库从证书里读取公钥进行加解密和签名验签

  <!-- https://mvnrepository.com/artifact/com.tencent.kona/kona-crypto -->
        <dependency>
            <groupId>com.tencent.kona</groupId>
            <artifactId>kona-crypto</artifactId>
            <version>1.0.12</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/com.tencent.kona/kona-pkix -->
        <dependency>
            <groupId>com.tencent.kona</groupId>
            <artifactId>kona-pkix</artifactId>
            <version>1.0.12</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/com.tencent.kona/kona-provider -->
        <dependency>
            <groupId>com.tencent.kona</groupId>
            <artifactId>kona-provider</artifactId>
            <version>1.0.12</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/com.tencent.kona/kona-ssl -->
        <dependency>
            <groupId>com.tencent.kona</groupId>
            <artifactId>kona-ssl</artifactId>
            <version>1.0.12</version>
        </dependency>


package com.artisan.kona;

import com.tencent.kona.crypto.CryptoInsts;
import com.tencent.kona.crypto.KonaCryptoProvider;
import com.tencent.kona.pkix.KonaPKIXProvider;
import com.tencent.kona.pkix.PKIXInsts;
import com.tencent.kona.ssl.KonaSSLProvider;
import com.tencent.kona.sun.security.x509.SMCertificate;

import javax.crypto.Cipher;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */


public class GmEnDeUtil {
    /**
     * 私钥字符串
     */
    private static String privateKey = "MIGHAgEA省略省略省略-----ODxilTt74";

    /**
     * 公钥证书字符串
     */
    private static String publicPEM = "-----BEGIN CERTIFICATE-----\n" +
            "MII省略省略省略-----d/s8iNVcYJ1\n" +
            "-----END CERTIFICATE-----\n";

    /**
     * 使用EC（椭圆曲线）加密算法进行加解密和数字签名的操作。
     * 包括了私钥的解码和生成、公钥证书的加载、数据的签名和验证、以及数据的加密和解密。
     *
     * @param args 命令行参数
     * @throws Exception 如果操作过程中发生错误
     */
    public static void main(String[] args) throws Exception {
        // 注册加密、PKIX和SSL提供者，这些提供者为Java加密系统提供了额外的功能和支持。
        Security.addProvider(new KonaCryptoProvider());
        Security.addProvider(new KonaPKIXProvider());
        Security.addProvider(new KonaSSLProvider());


        // 解码私钥并生成私钥对象，用于后续的签名操作。
        byte[] privateKeyBytes = Base64.getDecoder().decode(privateKey);
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
        KeyFactory keyFactory = CryptoInsts.getKeyFactory("EC");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        // 输出私钥的算法和格式信息。
        System.out.println("私钥算法" + privateKey.getAlgorithm());
        System.out.println("私钥格式" +privateKey.getFormat());


        // 对字符串进行签名，证明数据的完整性和来源。
        String message = "I‘ artisan ,这是基于Tencent的Kona库实现的签名验签";
        // 私钥签名
        String sign = sign(message, privateKey);
        System.out.println("签名：" + sign);

        // 加载公钥证书，用于验证签名和加密数据。
        // 加载公钥证书
        X509Certificate certificate = loadCert(publicPEM, "9876543210");
        System.out.println("证书主题：" + certificate.getSubjectX500Principal().getName());

        PublicKey publicKey = certificate.getPublicKey();

        // 验证签名的有效性。
        System.out.println("验证结果：" + verify(message, publicKey, sign));

        // 使用公钥加密字符串。
        // 加密和解密字符串 (公钥加密，私钥解密)
        String encryptedString = encrypt(message, publicKey);
        System.out.println("加密字符串：" + encryptedString);

        // 使用私钥解密字符串。
        String decryptedString = decrypt(encryptedString, privateKey);
        System.out.println("解密字符串：" + decryptedString);
    }



    /**
     * 从PEM格式的字符串加载X.509证书。
     *
     * @param certPEM 证书的PEM格式字符串。
     * @param id      证书的唯一标识符，可选。
     * @return 加载成功的X.509证书。
     * @throws Exception 如果加载过程中发生错误。
     */
    private static X509Certificate loadCert(String certPEM, String id) throws Exception {
        // 创建X.509证书工厂
        CertificateFactory certFactory = PKIXInsts.getCertificateFactory("X.509");
        // 从PEM格式的字符串生成证书对象
        X509Certificate x509Cert = (X509Certificate) certFactory.generateCertificate(
                new ByteArrayInputStream(certPEM.getBytes()));

        // 如果提供了ID，并且ID不为空，则为证书设置ID
        if (id != null && !id.isEmpty()) {
            // 这里假设SMCertificate是X509Certificate的一个子类，且提供了setId方法
            ((SMCertificate) x509Cert).setId(id.getBytes(StandardCharsets.UTF_8));
        }

        // 返回加载成功的证书
        return x509Cert;
    }


    /**
     * 使用SM2私钥对给定字符串进行数字签名。
     * <p>
     * 数字签名用于验证消息的完整性和发送者的身份。此方法使用SM2加密算法，
     * 基于给定的私钥对字符串进行签名，以确保数据在传输过程中的安全性和真实性。
     *
     * @param str        待签名的字符串。
     * @param privateKey 用于签名的私钥。
     * @return 返回经过SM2签名算法处理后的签名字符串，使用Base64编码。
     * @throws Exception 如果签名过程中发生错误，则抛出异常。
     */
    private static String sign(String str, PrivateKey privateKey) throws Exception {
        // 获取SM2签名实例
        Signature signature = CryptoInsts.getSignature("SM2");
        // 初始化签名过程，使用提供的私钥
        signature.initSign(privateKey);
        // 更新待签名的数据
        signature.update(str.getBytes());
        // 执行签名操作，并将结果编码为Base64字符串返回
        return Base64.getEncoder().encodeToString(signature.sign());
    }


    /**
     * 使用SM2公钥验证数据的签名是否有效。
     *
     * @param str       待验证签名的数据。
     * @param publicKey 用于验证签名的公钥。
     * @param sign      待验证的签名字符串。
     * @return 如果签名验证通过，则返回true；否则返回false。
     * @throws Exception 如果加密操作失败，抛出异常。
     */
    private static boolean verify(String str, PublicKey publicKey, String sign) throws Exception {
        // 获取SM2签名实例
        Signature signature = CryptoInsts.getSignature("SM2");
        // 初始化签名验证器
        signature.initVerify(publicKey);
        // 更新待验证数据
        signature.update(str.getBytes());
        // 验证签名，返回验证结果
        return signature.verify(Base64.getDecoder().decode(sign));
    }


    /**
     * 使用SM2公钥对字符串进行加密。
     * <p>
     * SM2是一种基于椭圆曲线密码学的加密算法，适用于我国的加密技术标准。
     * 本方法通过获取SM2加密实例，使用给定的公钥将原始字符串加密为密文。
     * 加密后的密文通过Base64编码转换为字符串形式返回，便于存储或传输。
     *
     * @param str       待加密的原始字符串。
     * @param publicKey 用于加密的SM2公钥。
     * @return 加密后的密文，以Base64编码的字符串形式表示。
     * @throws Exception 如果加密过程中发生错误，将抛出异常。
     */
    private static String encrypt(String str, PublicKey publicKey) throws Exception {
        // 获取SM2加密实例
        Cipher cipher = CryptoInsts.getCipher("SM2");
        // 初始化加密器，设置为加密模式，并使用给定的公钥
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 执行加密操作，将原始字符串转换为加密后的字节数组
        byte[] encryptedBytes = cipher.doFinal(str.getBytes());
        // 将加密后的字节数组通过Base64编码转换为字符串形式返回
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }


    /**
     * 使用SM2私钥解密字符串。
     * <p>
     * SM2是一种国密算法，适用于数据解密。本方法接收一个经Base64编码的加密字符串和对应的私钥，
     * 通过SM2算法解密后返回原始字符串。
     *
     * @param str        经Base64编码且使用SM2算法加密的字符串。
     * @param privateKey 解密所需的SM2私钥。
     * @return 解密后的原始字符串。
     * @throws Exception 如果解密过程中发生错误，则抛出异常。
     */
    // 使用私钥解密字符串
    private static String decrypt(String str, PrivateKey privateKey) throws Exception {
        // 获取SM2加密算法的Cipher实例
        Cipher cipher = CryptoInsts.getCipher("SM2");
        // 初始化Cipher为解密模式，使用提供的私钥
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // 解密Base64编码的字符串，得到原始字节数组
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(str));
        // 将解密后的字节数组转换为字符串并返回
        return new String(decryptedBytes);
    }

}

在这里插入图片描述

方式三 使用基于Bouncy Castle库封装的gm-java库

https://gitee.com/RuanKongkong/gm-java

密码算法

  • 对称密码算法 SM4（ECB/CBC/CTR/GCM）
  • 非对称密码算法 SM2（加解密/签名验签）
  • Hash算法 SM3
  • 基于SM3实现的随机数生成器（多线程加速）

证书

  • 证书解析以及证书SHA1指纹计算
  • SM2证书生成

密钥协商

  • 模拟TLS握手协议，通信双方协商会话密钥

实现

  <dependency>
            <groupId>io.github.KongkongRuan</groupId>
            <artifactId>gm-java</artifactId>
            <version>1.0.3</version>
        </dependency>

在这里插入图片描述

package com.artisan.gmja;

import com.yxj.gm.SM2.Cipher.SM2Cipher;
import com.yxj.gm.SM2.Key.SM2KeyPairGenerate;
import com.yxj.gm.SM2.Signature.SM2Signature;
import com.yxj.gm.SM3.SM3Digest;
import com.yxj.gm.SM4.SM4Cipher;
import com.yxj.gm.SM4.dto.AEADExecution;
import com.yxj.gm.enums.ModeEnum;
import com.yxj.gm.random.Random;
import org.bouncycastle.util.encoders.Hex;

import java.security.KeyPair;
import java.security.SecureRandom;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class GmJavaExample {

    /**
     * 主函数，用于演示各种密码学算法的使用，包括SM2加解密、签名验签、SM3摘要计算、SM4加解密。
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 定义测试消息
        String msg = "I'm artisan , 使用基于Bouncy Castle库封装的gm-java库";

        // 生成SM2密钥对
        KeyPair keyPair = SM2KeyPairGenerate.generateSM2KeyPair();

        // 使用SM2密钥对进行加密和解密
        SM2Cipher sm2Cipher = new SM2Cipher();
        byte[] encrypted = sm2Cipher.SM2CipherEncrypt(msg.getBytes(), keyPair.getPublic().getEncoded());
        byte[] decrypted = sm2Cipher.SM2CipherDecrypt(encrypted, keyPair.getPrivate().getEncoded());
        // 输出解密结果
        System.out.println("SM2解密结果：" + new String(decrypted));

        // 使用SM2密钥对进行签名和验证
        SM2Signature signature = new SM2Signature();
        byte[] signatureBytes = signature.signature(msg.getBytes(), null, keyPair.getPrivate().getEncoded());
        boolean verificationResult = signature.verify(msg.getBytes(), null, signatureBytes, keyPair.getPublic().getEncoded());
        // 输出验签结果
        System.out.println("SM2验签结果：" + verificationResult);

        // SM3摘要计算示例
        SM3Digest sm3Digest = new SM3Digest();
        sm3Digest.update(msg.getBytes());
        byte[] digest1 = sm3Digest.doFinal();
        byte[] digest2 = sm3Digest.doFinal(msg.getBytes());
        sm3Digest.update("gm-java-".getBytes());
        sm3Digest.update("1.0".getBytes());
        byte[] digest3 = sm3Digest.doFinal();
        // 输出摘要的十六进制表示
        System.out.println(Hex.toHexString(digest1));
        System.out.println(Hex.toHexString(digest2));
        System.out.println(Hex.toHexString(digest3));

        // 通过SM3算法生成随机数
        byte[] random = Random.RandomBySM3(16);
        System.out.println(Hex.toHexString(random));

        // SM4加解密示例，包括ECB、CBC、CTR和GCM模式
        SecureRandom secureRandom = new SecureRandom();
        byte[] key = new byte[16];
        byte[] iv = new byte[16];
        secureRandom.nextBytes(key);
        secureRandom.nextBytes(iv);

        // ECB模式
        SM4Cipher sm4CipherECB = new SM4Cipher(ModeEnum.ECB);
        byte[] encryptedECB = sm4CipherECB.cipherEncrypt(key, msg.getBytes(), null);
        byte[] decryptedECB = sm4CipherECB.cipherDecrypt(key, encryptedECB, iv);
        System.out.println("ECB明文：" + new String(decryptedECB));

        // CBC模式
        SM4Cipher sm4CipherCBC = new SM4Cipher(ModeEnum.CBC);
        byte[] encryptedCBC = sm4CipherCBC.cipherEncrypt(key, msg.getBytes(), iv);
        byte[] decryptedCBC = sm4CipherCBC.cipherDecrypt(key, encryptedCBC, iv);
        System.out.println("CBC明文：" + new String(decryptedCBC));

        // CTR模式
        SM4Cipher sm4CipherCTR = new SM4Cipher(ModeEnum.CTR);
        byte[] encryptedCTR = sm4CipherCTR.cipherEncrypt(key, msg.getBytes(), iv);
        byte[] decryptedCTR = sm4CipherCTR.cipherDecrypt(key, encryptedCTR, iv);
        System.out.println("CTR明文：" + new String(decryptedCTR));

        // GCM模式
        SM4Cipher sm4_gcm = new SM4Cipher();
        AEADExecution aeadExecution = sm4_gcm.cipherEncryptGCM(key, msg.getBytes(), new byte[12], "aad".getBytes(), 16);
        System.out.println("GCM密文：" + Hex.toHexString(aeadExecution.getCipherText()));
        System.out.println("GCMtag：" + Hex.toHexString(aeadExecution.getTag()));
        byte[] decryptedGCM = sm4_gcm.cipherDecryptGCM(key, aeadExecution.getCipherText(), new byte[12], "aad".getBytes(), aeadExecution.getTag());
        System.out.println("GCM明文：" + new String(decryptedGCM));
    }

}

输出如下：

SM2解密结果：I'm artisan , 使用基于Bouncy Castle库封装的gm-java库
SM2验签结果：true
080239d4f27412428a25c1f86d2523e4e9c6ed1d9b94e579632d77bc6d44794f
080239d4f27412428a25c1f86d2523e4e9c6ed1d9b94e579632d77bc6d44794f
cc7e992374984c82ab13f3f117d52849970628d16acf4cc1d9c137953e23a418
c963dee9f6945ec7c0a42379a576dabe
ECB明文：I'm artisan , 使用基于Bouncy Castle库封装的gm-java库
CBC明文：I'm artisan , 使用基于Bouncy Castle库封装的gm-java库
CTR明文：I'm artisan , 使用基于Bouncy Castle库封装的gm-java库
GCM密文：742d77292544e52da4c8f098dd5bd93b3bf8e9fd93a99bba1f0ab61a438074a9389ba6484664bb7dc899592e849b4c5cc2b3db0d9590e0e45b91fad85b
GCMtag：aac12ba04924fef14eaa0e896a346a45
GCM明文：I'm artisan , 使用基于Bouncy Castle库封装的gm-java库

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/758432.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

3、Redis集群原理分析

3、Redis集群原理分析

槽定位 (Slot Mapping): Redis Cluster 将所有数据划分为 16384 个槽位&#xff08;slots&#xff09;&#xff0c;每个槽位由一个或多个节点负责管理。Redis 集群通过 CRC16 哈希算法来计算每个 key 的哈希值&#xff0c;并对 16384 取模以确定该 key 应该存储在哪个槽位上。…
阅读更多...
Maven基础学习

Maven基础学习

一、Why? 1.真的需要吗？ 2.究竟为什么？ 二、What? 1.Maven简介 2.什么是构建 3.构建过程的几个主要环节 4.自动化构建 5.Maven核心概念 6.安装Maven 三、How? 四、约定的目录结构
阅读更多...
详解HTTP：常用的密钥交换算法RSA与ECDHE

详解HTTP：常用的密钥交换算法RSA与ECDHE

HTTPS 常用的密钥交换算法&#xff1a;RSA 与 ECDHE 在 HTTPS 中&#xff0c;密钥交换算法扮演了至关重要的角色&#xff0c;确保数据在传输过程中的安全性。目前常用的密钥交换算法主要有两种&#xff1a;RSA 和 ECDHE。相比于较为传统的 RSA&#xff0c;ECDHE 由于具备前向安…
阅读更多...
“论大数据处理架构及其应用”写作框架，软考高级，系统架构设计师

“论大数据处理架构及其应用”写作框架，软考高级，系统架构设计师

论文真题 大数据处理架构是专门用于处理和分析巨量复杂数据集的软件架构。它通常包括数据收集、存储、处理、分析和可视化等多个层面&#xff0c;旨在从海量、多样化的数据中提取有价值的信息。Lambda架构是大数据平台里最成熟、最稳定的架构&#xff0c;它是一种将批处理和流…
阅读更多...
FFmpeg 命令行 音视频格式转换

FFmpeg 命令行 音视频格式转换

&#x1f4da;&#xff1a;FFmpeg 提供了丰富的命令行选项和功能&#xff0c;可以用来处理音视频文件、流媒体等&#xff0c;掌握命令行的使用&#xff0c;可以有效提高工作效率。 目录 一、视频转换和格式转换 &#x1f535; 将视频文件转换为另一种格式 &#x1f535; 指定…
阅读更多...
C语言分支和循环（下）

C语言分支和循环（下）

C语言分支和循环&#xff08;下&#xff09; 1. 随机数生成1.1 rand1.2 srand1.3 time1.4 设置随机数的范围 2. 猜数字游戏实现 掌握了前面学习的这些知识&#xff0c;我们就可以写⼀些稍微有趣的代码了&#xff0c;比如&#xff1a; 写⼀个猜数字游戏 游戏要求&#xff1a; 电…
阅读更多...
文华均线交叉多空买卖点-支撑压力自动画线-波浪AB画线指标公式

文华均线交叉多空买卖点-支撑压力自动画线-波浪AB画线指标公式

A1:MA(C,5); A2:MA(C,10); MA1:MA(A1,15); MA2:MA(A2,15); JC:CROSS(MA1,MA2); SC:CROSSDOWN(MA1,MA2); N:1; JC1:BARSLAST(JC)N; SC1:BARSLAST(SC)N; VERTLINE(SC,COLORRED),DOT; VERTLINE(JC,COLORGREEN),DOT; H1:VALUEWHEN(SC,HHV(H,JC1)),COLORRED;//当前死叉到…
阅读更多...
算法设计与分析--近似算法内容整理

算法设计与分析--近似算法内容整理

文章目录 P、NP、NP-hard 和 NPC多项式时间概念区分NP-hard 的证明例题 1 证明 T S P TSP TSP 问题是 N P − h a r d NP-hard NP−hard 问题 。例题 2 证明最大加权独立集问题是 N P − h a r d NP-hard NP−hard 问题。 扩展 NP-hard 问题3-SAT 问题TSP 旅行商问题 Load B…
阅读更多...
笔记本电脑部署VMware ESXi 6.0系统

笔记本电脑部署VMware ESXi 6.0系统

正文共&#xff1a;888 字 18 图&#xff0c;预估阅读时间&#xff1a;1 分钟 前面我们介绍了在笔记本上安装Windows 11操作系统&#xff08;Windows 11升级不了&#xff1f;但Win10就要停服了啊&#xff01;来&#xff0c;我教你&#xff01;&#xff09;&#xff0c;也介绍了…
阅读更多...
摸鱼大数据——Spark基础——Spark环境安装——PySpark搭建

摸鱼大数据——Spark基础——Spark环境安装——PySpark搭建

三、PySpark环境安装 PySpark: 是Python的库, 由Spark官方提供. 专供Python语言使用. 类似Pandas一样,是一个库 Spark: 是一个独立的框架, 包含PySpark的全部功能, 除此之外, Spark框架还包含了对R语言\ Java语言\ Scala语言的支持. 功能更全. 可以认为是通用Spark。 功能 P…
阅读更多...
Linux开发讲课29---Linux USB 设备驱动模型

Linux开发讲课29---Linux USB 设备驱动模型

Linux 内核源码&#xff1a;include\linux\usb.h Linux 内核源码&#xff1a;drivers\hid\usbhid\usbmouse.c 1. BUS/DEV/DRV 模型 "USB 接口"是逻辑上的 USB 设备&#xff0c;编写的 usb_driver 驱动程序&#xff0c;支持的是"USB 接口"&#xff1a; US…
阅读更多...
单片机的学习（15）--LCD1602

单片机的学习（15）--LCD1602

LCD1602 14.1LCD1602的基础知识1.LCD1602介绍2.引脚及应用电路3.内部结构框图4.时序结构5.LCD1602指令集6.字符值7.LCD1602操作流程 14.2LCD1602功能函数代码1.显示一个字符&#xff08;1&#xff09;工程目录&#xff08;2&#xff09;main.c函数&#xff08;3&#xff09;LCD…
阅读更多...
当晋升受阻或待遇不公时应怎么办？

当晋升受阻或待遇不公时应怎么办？

当晋升受阻或待遇不公时应怎么办&#xff1f;
阅读更多...
C语言中的基础指针操作

C语言中的基础指针操作

在C语言中&#xff0c;指针是一个非常重要的概念&#xff0c;它提供了直接访问内存地址的能力。指针变量用于存储内存地址&#xff0c;而不是数据值&#xff0c;在某种意义上和门牌号具有相似含义&#xff1a;指针是一个变量&#xff0c;其存储的是另一个变量的内存地址&#x…
阅读更多...
6.27-6.29 旧c语言

6.27-6.29 旧c语言

#include<stdio.h> struct stu {int num;float score;struct stu *next; }; void main() {struct stu a,b,c,*head;//静态链表a.num 1;a.score 10;b.num 2;b.score 20;c.num 3;c.score 30;head &a;a.next &b;b.next &c;do{printf("%d,%5.1f\n&…
阅读更多...
Cesium Model 中的剪裁平面 (ClippingPlane)

Cesium Model 中的剪裁平面 (ClippingPlane)

Cesium Model 中的剪裁平面 (ClippingPlane) 参考: https://www.cnblogs.com/webgl-angela/p/9197672.html Cesium Model 中的剪裁平面 (ClippingPlane) // 相关类: class ClippingPlaneCollection {} class ClippingPlane {}// 剪裁的整体流程: Model.prototype.update () …
阅读更多...
LINGO：生产计划问题

LINGO：生产计划问题

模型&#xff1a;有瓶颈设备的多级生产计划问题 某工厂的主要任务是通过组装生产产品 A &#xff0c;用于满足外部市场需求。产品 A 的构成与组装过程见下图 &#xff0c;即 D , E , F , G 是从外部采购的零件&#xff0c;先将零件 D , E 组装成部件 B &#xff0c;零…
阅读更多...
看你那样，超出你想像：羊、羊、羊

看你那样，超出你想像：羊、羊、羊

一、I am me，羊羊羊英文中的 我就是我（I am me），其实就是：羊 羊 羊，为什么会有这么一个结论呢？请往下看：I，就是羊am（是），也是羊me（我），还是羊我就是我，不一样的烟火。其实，我就是我（I am me），没有什么不一样，因为全是羊。二、羊都一样吗？among（在...当中…
阅读更多...
斜率优化DP——AcWing 303. 运输小猫

斜率优化DP——AcWing 303. 运输小猫

斜率优化DP 定义 斜率优化DP&#xff08;Slope Optimization Dynamic Programming&#xff09;是一种高级动态规划技巧&#xff0c;用于优化具有特定形式的状态转移方程。它主要应用于那些状态转移涉及求极值&#xff08;如最小值或最大值&#xff09;的问题中&#xff0c;通…
阅读更多...
c++重载（运算符）

c++重载（运算符）

1&#xff09;C入门级小知识&#xff0c;分享给将要学习或者正在学习C开发的同学。 2&#xff09;内容属于原创&#xff0c;若转载&#xff0c;请说明出处。 3&#xff09;提供相关问题有偿答疑和支持。 对于系统的所有操作符&#xff0c;一般情况下&#xff0c;只支持基本数…
阅读更多...
最新文章

Copyright @ 2022~2023