文章目录

• 一，URL编码
• • 为什么要使用URL编码？
• 二，Base64编码
• 三，MD5加密
• • 常用的摘要算法
• 四，SHA-1算法
• 五，对称加密算法
• • AES加密
• 六，非对称加密算法
• • RSA加密
  • RSA分段加解密
• 七，SM4加密
• • SM4Util工具类
  • SM3Util工具类
  • 测试类

一，URL编码

为什么要使用URL编码？

我们都知道Http协议中参数的传输是"key=value"这种简直对形式的，如果要传多个参数就需要用“&”符号对键值对进行分割。如 "?name1=value1&name2=value2"，这样在服务端在收到这种字符串的时候，会用“&”分割出每一个参数，然后再用“=”来分割出参数值。

现在有这样一个问题，如果我的参数值中就包含=或&这种特殊字符的时候该怎么办。
比如说“name1=value1”,其中value1的值是“va&lu=e1”字符串，那么实际在传输过程中就会变成这样“name1=va&lu=e1”。我们的本意是就只有一个键值对，但是服务端会解析成两个键值对，这样就产生了奇异。

如何解决上述问题带来的歧义呢？解决的办法就是对参数进行URL编码？

URL编码只是简单的在特殊字符的各个字节前加上%，例如，我们对上述会产生奇异的字符进行URL编码后结果：“name1=va%26lu%3D”，这样服务端会把紧跟在“%”后的字节当成普通的字节，就是不会把它当成各个参数或键值对的分隔符。

类似于这种

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yyMpbzea-1577957094515)(加密与安全/1577150995264.png)]

实际操作

public static void main(String[] args) { 
    //url编码
    String str="测试";
    String urlStr=URLEncoder.encode(str);
    System.out.println("url编码之后："+urlStr);
    String deStr=URLDecoder.decode(urlStr);
    System.out.println("url解码之后："+deStr);
}

打印

url编码之后：%E6%B5%8B%E8%AF%95
url解密之后：测试

二，Base64编码

实际操作

String str="测试";
    String b64=Base64.getEncoder().encodeToString(str.getBytes("utf-8"));
    System.out.println("base64编码之后："+b64);
    String ori=new String(Base64.getDecoder().decode(b64),"utf-8");
    System.out.println("base64解码之后："+ori);

打印

base64编码之后：5rWL6K+V
base64解码之后：测试

url的base64编码

只需要把Base64.getEncoder()改为Base64.getUrlEncoder()，Base64.getDecoder()改为Base64.getUrlDecoder()即可。

Base64算法是编码算法，不是加密算法。Base64编码的目的是把任意二进制数据编码为文本（长度增加 1/3 ）.

三，MD5加密

MD5是一种摘要算法，所谓摘要算法，就是输入任意长度数据，而输出的是固定长度数据。

举例：java的Object.hashCode()方法就是摘要算法。

有没有可能两个不同的输入得到了相同的输出？是有可能的，这也称之为碰撞！

常用的摘要算法

实际操作

String str="测试";
    //得到md5的实例
    MessageDigest md=MessageDigest.getInstance("MD5");
    //update的是byte类型的数组
    md.update(str.getBytes());
    //加密后返回
    byte[] r=md.digest();
    System.out.println(String.format("%032x", new BigInteger(1,r)));

打印

24f93872e1db308f75eb317e3649e814

说明：MD5的输入参数是byte数组，不是字符串。

四，SHA-1算法

SHA-1和MD5其实加密过程是一样的，不过前者比后者安全一些，但是运行速度削微慢了那么一丢丢（约25%）。

只是把上面的MD5改为SHA-1即可。

实际操作

String str="测试";
    //得到md5的实例
    MessageDigest md=MessageDigest.getInstance("SHA-1");
    //update的是byte类型的数组
    md.update(str.getBytes());
    //加密后返回
    byte[] r=md.digest();
    System.out.println(String.format("%040x", new BigInteger(1,r)));

打印

0b5d7ed54bee16756a7579c6718ab01e3d1b75eb

五，对称加密算法

什么是对称加密？对称加密就是加密和解密使用的是同一个密钥。

通过传入一个密钥key和代加密的字符串进行加密。

解密：encrypt(key,message)—>得到加密后的结果

解密：decrypt(key,加密后的结果)——>解密后的结果

常用的对称加密算法

密钥长度越长，该算法的加密力度越大，说明越安全！由于DES加密算法的密钥长度太短，以至于可以被人暴力破解，因此被淘汰弃用。

AES加密

实际操作

String str="测试";
    //################## 加密 ######################
    //加密模式
    String CIPHER_NAME="AES/ECB/PKCS5Padding";
    //得到cipher实例
    Cipher cipher=Cipher.getInstance(CIPHER_NAME);
    //设置密钥
     byte[] keys="1234567890abcdef".getBytes();
    //得到key实例 参数是密钥（byte[]类型的） 和"AES"加密算法名
    SecretKeySpec key=new SecretKeySpec(keys, "AES");
    cipher.init(Cipher.ENCRYPT_MODE, key);
    //进行加密，得到的byte类型的
    byte[] b=cipher.doFinal(str.getBytes());
    System.out.println("加密后的密文(转化为Base64显示):"+Base64.getEncoder().encodeToString(b));
    //################### 解密 ########################
    //得到cipher实例
    Cipher ciphers=Cipher.getInstance(CIPHER_NAME);
    //得到key实例
    SecretKeySpec key1=new SecretKeySpec(keys, "AES");
    cipher.init(Cipher.DECRYPT_MODE, key1);
    //解密
    byte[] c=cipher.doFinal(b);
    System.out.println("解密后的明文："+new String(c));

打印

加密后的密文(转化为Base64显示):6BIemWfPl6FUC/dqx79LVw==
解密后的明文：测试

六，非对称加密算法

RSA加密

RSA非对称加密认证

前提：A和B在私底下要互换对方的公钥，而私钥则自己持有！

加密：A给B发送消息，使用B的公钥加密，然后B收到消息后使用自己的私钥解密。

签名：A使用自己的私钥对数据进行签名，然后发送给B，然后B使用A的公钥进行验签，校验数据的完整性。

说明

使用公钥加密，使用私钥解密；使用私钥签名，使用公钥验签。

签名的作用：

A给B发送消息，加密之后发送给B，此时，一个黑客使用B的公钥加密了一些数据也发送给了B，那么B怎么才能知道收到的加密数据是A发送的而不是黑客？

这时就需要签名了，A加密后并对加密后的数据进行签名，使用A自己的私钥进行签名，发送到B之后，B再使用A的公钥进行验签，如果验签通过则说明加密数据是由A发送过来的。

朕给你们提供一个RSAUtil工具类，一切加密的起源都可以源于这个工具类。

本工具类说明书

方法一：string2PublicKey（）将Base64编码的公钥转化为公钥对象

参数：（Base64格式的）公钥字符串 返回值：公钥对象

方法二：string2PrivateKey（）将Base64编码的私钥转化为私钥对象

参数：（Base64格式的）私钥字符串 返回值：私钥对象

方法三：encrypt（） 加密方法

参数：待加密的内容（字符串） 加密使用的密钥（对方公钥） 加密使用的模式（RSA）

返回值：内容加密后的Base64编码形式的字符串

方法四：decrypt（） 解密方法

参数：待解密的内容的Base64编码形式的字符串 解密使用的密钥（自己私钥） 解密使用的模式（RSA）

返回值：原文字符串

方法五：handleData（）分段处理加解密数据，放到输出流中（这里不做解释）

方法六：sign（） 签名算法

参数：要签名的数据（原文或密文均可） 签名使用的密钥（自己私钥） 签名使用的模式（SHA1withRSA）

返回值：签名字符串

方法七：verifySign（） 验签算法

参数：签名字符串 验签使用的密钥（对方公钥） 签名使用的模式（SHA1withRSA）

返回值：布尔类型

public class RSAUtil { 
    //加密算法
    private static final String KEY_ALGORITHM = "RSA";
    //密钥长度
    private static final int KEY_SIZE = 1024;
    //分块加密，单块明文的最大字节数 (KEY_SIZE/8) - 11
    private static final int MAX_ENCRYPT_BLOCK = 117;
    //分块解密，单块密文的最大字节数 KEY_SIZE/8
    private static final int MAX_DECRYPT_BLOCK = 128;
    //加密算法
    public static final String encryptAlgorithm="RSA/ECB/PKCS1Padding";
    //签名算法
    public static final String signAlgorithm="SHA1withRSA";
    /** * 将Base64编码的公钥转化为公钥对象 * create time: 2019年4月18日下午3:46:01 * @param publicKeyStr * @return * @throws IOException * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException */
    public static PublicKey string2PublicKey(String publicKeyStr) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException { 
        //把base64格式的公钥进行base64解码转为byte类型
        byte[] keyBytes = Base64.decodeBase64(publicKeyStr);
        //根据给定的编码密钥创建一个新的 X509EncodedKeySpec对象
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        //getInstance api解释：返回转换指定算法的 public/private 关键字的 KeyFactory 对象
        //keyFactory是密钥规范
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);//参数是加密算法RSA
        //根据提供的密钥规范（密钥材料）生成公钥对象
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
    /** * 将Base64编码的私钥转化为私钥对象 * create time: 2019年4月18日下午3:46:32 * @param privateKeystr * @return * @throws IOException * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException */
    public static PrivateKey string2PrivateKey(String privateKeystr) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException { 
         //把base64格式的私钥进行base64解码转为byte类型
        byte[] keyBytes = Base64.decodeBase64(privateKeystr);
        //根据给定的编码密钥创建一个新的 PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        //getInstance api解释：返回转换指定算法的 public/private 关键字的 KeyFactory 对象
        //keyFactory是密钥规范
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);//参数是加密算法RSA
        //根据提供的密钥规范（密钥材料）生成私钥对象
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }
    /** * RSA加密方法 * create time: 2019年4月18日下午3:38:18 * @param plainData 待加密的内容 * @param key 加密使用的秘钥（对方的公钥） * @param algorithm 加密使用的模式 * @return 内容加密后的Base64编码形式 * @throws Exception */
    public static String encrypt(String plainData, Key key, String algorithm) throws Exception { 
        //字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] chiperDataBytes;
        try { 
            //得到cipher实例
            Cipher cipher = Cipher.getInstance(algorithm);//参数：加密算法RSA
            //初始化 ENCRYPT_MODE：用于将 Cipher 初始化为加密模式的常量 key：密钥（对方公钥）
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //把要加密的字符串转换为byte数组
            byte[] plainDataBytes = plainData.getBytes("UTF-8");
            //调用分段加密方法进行加密
            //MAX_ENCRYPT_BLOCK：单块明文最大字节数
            //out 字节数组缓冲区，和stringbuffer类似用法
            handleData(out, cipher, plainDataBytes, MAX_ENCRYPT_BLOCK);
            //把字节数组输出流转为byte数组
            chiperDataBytes = out.toByteArray();
        } catch(Exception e) { 
            throw new Exception(e);
        } finally { 
            out.close();
        }
        //再把byte数组转为Base64编码格式的字符串并返回（加密后的Base64字符串）
        return Base64.encodeBase64String(chiperDataBytes);
    }
    /** * RSA分段解密方法 * create time: 2019年4月18日下午3:40:52 * @param cipherData 待解密的内容的Base64编码形式的数据 * @param key 解密使用的秘钥 * @param algorithm 解密使用的模式 * @return 解密后的内容 * @throws Exception */
    public static String decrypt(String cipherData, Key key, String algorithm) throws Exception, IOException { 
        //字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] plainDataBytes;
        try { 
             //得到cipher实例
            Cipher cipher = Cipher.getInstance(algorithm);//参数：加密算法RSA
            //初始化 DECRYPT_MODE:用于将 Cipher 初始化为解密模式的常量 key:密钥（自己私钥）
            cipher.init(Cipher.DECRYPT_MODE, key);
            //把要解密的字符串转换为byte数组
            byte[] chiperDataBytes = Base64.decodeBase64(cipherData);
            //调用分段解密方法进行解密
            handleData(out, cipher, chiperDataBytes, MAX_DECRYPT_BLOCK);
            //把byte 数组输出流转为byte数组
            plainDataBytes = out.toByteArray();
        } catch(Exception e) { 
            throw new Exception(e);
        } finally { 
            out.close();
        }
        //再把byte数组转为字符串并返回（解密后的字符串）
        return new String(plainDataBytes);
    }
    /** * 分段处理加解密数据，放到输出流中 * create time: 2019年4月18日下午3:42:37 * @param out 输出流 * @param cipher 加解密工具 * @param dataBytes 要处理的数据 * @param maxBlock 处理的块的最大字节数 * @throws IllegalBlockSizeException * @throws BadPaddingException */
    private static void handleData(ByteArrayOutputStream out, Cipher cipher, byte[] dataBytes, int maxBlock) throws IllegalBlockSizeException, BadPaddingException { 
        //计算待加密的byte数组的长度
        int inputLen = dataBytes.length;
        int offSet = 0;
        int i = 0;
        byte[] cache;
        //循环减去已经被加密的长度（剩余长度）
        while (inputLen - offSet > 0) { 
            if (inputLen - offSet > maxBlock) { 
         //加密操作
         //处理dataBytes字节数组的缓冲区从offset开始（包含）的前maxBlock个字节
                cache = cipher.doFinal(dataBytes, offSet, maxBlock);
            } else { 
                cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
            }
            //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * maxBlock;
        }
    }
    /** * 签名算法 * @param attributes 属性数据 要签名的字符串 * @param privateKey 签名使用的密钥 自己的私钥 * @param algorithm 签名使用的模式 SHA1withRSA * @return * @throws NoSuchAlgorithmException * @throws InvalidKeyException * @throws SignatureException */
    public static String sign(String attributes, PrivateKey privateKey, String algorithm)
            throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
        //Signature对象可用来生成和验证数字签名
        Signature signature = Signature.getInstance(algorithm);
        //初始化这个用于签名的对象
        signature.initSign(privateKey);
        //使用指定的 byte 数组更新要签名或验证的数据
        signature.update(attributes.getBytes());
        //sign()方法：返回所有已更新数据的签名字节
        byte[] signedData = signature.sign();
        //把签名字节转为Base64编码格式的字符串
        return Base64.encodeBase64String(signedData);
    }
    /** * 验签算法 * @param attributes 属性数据明文 * @param signData 签名 * @param publicKey 验签使用的公钥 * @param algorithm 验签使用的模式 * @return * @throws NoSuchAlgorithmException * @throws InvalidKeyException * @throws SignatureException */
    public static boolean verifySign(String attributes, String signData, PublicKey publicKey, String algorithm) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
        //Signature对象可用来生成和验证数字签名
        Signature signCheck = Signature.getInstance(algorithm);
        //使用来自给定证书的公钥初始化此用于验证的对象
        signCheck.initVerify(publicKey);
        //使用指定的 byte 数组更新要签名或验证的数据。
        signCheck.update(attributes.getBytes());
        //验证传入的签名
        return signCheck.verify(Base64.decodeBase64(signData));
    }
}

如果使用 RSA，对消息摘要算法则会有多种选择，因此，可以将签名算法指定为 MD2withRSA、MD5withRSA 或 SHA1withRSA。因为没有默认的算法名称，所以必须为其指定名称。

开始加密签名

首先定义一下自己的私钥和对方的公钥。

//自己的私钥
    public static final String privateKey="MIICdwIBADANBg.....";
    //对方的公钥
    public static final String thirdPublicKey="MIGfMA0GCSq.....";

加密和签名（传进的参数是待加密的数据【json串】）

public Map jmqm(String jcxx) throws Exception { 
         //得到PublicKey对象
        PublicKey publicKey = RSAUtil.string2PublicKey(thirdPublicKey);
        //进行加密并得到加密后的字符串
        String encryptParam = RSAUtil.encrypt(jcxx, publicKey, "RSA");
        //签名(这里对原文签名)
        PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKey);
        String signature = RSAUtil.sign(jcxx, privateKey, "SHA1withRSA");
        Map map=new HashMap();
        map.put("encryptParam",encryptParam);
        map.put("signature",signature);
        return map;
    }

解密和验签

public String decryptData(String encryptData) throws Exception { 
        JSONObject jsonObject = JSONObject.parseObject(encryptData);
        String encryptParam=(String) jsonObject.get("encryptParam");
        String signature=(String) jsonObject.get("signature");
        //第三方公钥转为Key对象
        PublicKey publicKey = RSAUtil.string2PublicKey(thirdPublicKey);
        //自己私钥转为Key对象
        PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKey);
        //进行解密，返回解密后的原文字符串
        String plainData = RSAUtil.decrypt(encryptParam, privateKey, "RSA");
        log.info("反馈信息解密内容："+plainData);
        //对原文进行验签
        boolean isTrue = RSAUtil.verifySign(plainData, signature, publicKey, "SHA1withRSA");
        if(isTrue){ 
            log.info("验签通过");
            return plainData;
        }else { 
            log.info("验签失败");
            return "";
        }
    }

结束语：其实只要利用好RSAUtil这一个工具类即可，然后加解密以及签名验签的过程可以任意封装。

在RSAUtil工具类中定义了一些静态变量，这些变量是要视情况而改变的。

KEY_ALGORITHM=“RSA” 这是加解密算法

KEY_SIZE=1024 这是使用密钥的长度（1024 or 2048）

MAX_ENCRYPT_BLOCK 这是单块明文的最大字节数 （KEY_SIZE 除以 8 然后减去 11 ）

MAX_DECRYPT_BLOCK 这是单块密文的最大字节数 （KEY_SIZE 除以 8 ）

encryptAlgorithm=“RSA/ECB/PKCS1Padding” 加密算法（这个没用到，用到的是第一个加密算法【RSA】）

signAlgorithm=“SHA1withRSA” 这是签名算法

以上的所有静态变量都是调用加解密方法和签名验签方法时的参数，具体的RSA加密机制可以找时间抽空了解下，包括分段加解密，不过在这个RSAUtil工具类中已经写好了，不用过多操心这个问题了。

重点：当密钥使用的是1024位长度时，KEY_SIZE要设为1024，MAX_ENCRYPT_BLOCK要设为117，MAX_DECRYPT_BLOCK要设为128；当密钥使用的是2048位长度时，KEY_SIZE要设为2048，MAX_ENCRYPT_BLOCK要设为245，MAX_DECRYPT_BLOCK要设为256；

RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常：

Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes  
    at com.sun.crypto.provider.RSACipher.a(DashoA13*..)  
    at com.sun.crypto.provider.RSACipher.engineDoFinal(DashoA13*..)  
    at javax.crypto.Cipher.doFinal(DashoA13*..)

转自网上的一篇帖子，对最大明文长度和最大密文长度做了详细的解释！

不管明文长度是多少，RSA 生成的密文长度总是固定的。但是明文长度不能超过密钥长度。比如 Java 默认的 RSA 加密实现不允许明文长度超过密钥长度减去 11(单位是字节，也就是 byte)。也就是说，如果我们定义的密钥(我们可以通过 java.security.KeyPairGenerator.initialize(int keysize)来定义密钥长度)长度为 1024(单位是位，也就是 bit)，生成的密钥长度就是 1024位 / 8位/字节 = 128字节，那么我们需要加密的明文长度不能超过 128字节 -11 字节 = 117字节。也就是说，我们最大能将 117 字节长度的明文进行加密，否则会出问题(抛诸如 javax.crypto.IllegalBlockSizeException: Data must not be longer than 53 bytes的异常)。

自己总结

相反，如果密钥长度使用的是2048位 /（8位/字节） = 256字节 的话，那么最大单块密文长度就是256字节，最大单块明文长度就是256 - 11 = 245（字节）。

这里提供一个密钥对生成工具，在 <我的下载> 列表中，可以下载使用！

RSA分段加解密

上面引入网上的帖子可以看出，RSA加密一次最多只能加密明文的117字节（如果key长度为1024位的话），那么明文太多怎么办？只能分段加密了，很好懂的道理，把明文结成一段一段的，分别进行加密，加密之后把加密后的结果再进行拼接。

下面是分段加解密的过程。

/** * 分段处理加解密数据，放到输出流中 * create time: 2019年4月18日下午3:42:37 * @param out 输出流 * @param cipher 加解密工具 * @param dataBytes 要处理的数据 * @param maxBlock 处理的块的最大字节数 * @throws IllegalBlockSizeException * @throws BadPaddingException */
    private static void handleData(ByteArrayOutputStream out, Cipher cipher, byte[] dataBytes, int maxBlock) throws IllegalBlockSizeException, BadPaddingException { 
        //计算待加密的byte数组的长度
        int inputLen = dataBytes.length;
        int offSet = 0;
        int i = 0;
        byte[] cache;
        //循环减去已经被加密的长度（剩余长度）
        while (inputLen - offSet > 0) { 
            if (inputLen - offSet > maxBlock) { 
         //加密操作
         //处理dataBytes字节数组的缓冲区从offset开始（包含）的前maxBlock个字节
                cache = cipher.doFinal(dataBytes, offSet, maxBlock);
            } else { 
                cache = cipher.doFinal(dataBytes, offSet, inputLen - offSet);
            }
            //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * maxBlock;
        }
    }

了解原理即可，会使用工具类就好啦！

七，SM4加密

SM4使用的国密算法。

SM4Util工具类

public class SM4Util { 
    public static final String ALGORITHM_NAME = "SM4";
    public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";
    public static final int DEFAULT_KEY_SIZE = 128;
     public static byte[] encrypt_Ecb_Padding(byte[] key, byte[] data)
        throws InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException,
        NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { 
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(data);
    }
    public static byte[] decrypt_Ecb_Padding(byte[] key, byte[] cipherText)
        throws IllegalBlockSizeException, BadPaddingException, InvalidKeyException,
        NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException { 
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(cipherText);
    }
     private static Cipher generateEcbCipher(String algorithmName, int mode, byte[] key)
        throws NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException,
        InvalidKeyException { 
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        Key sm4Key = new SecretKeySpec(key, ALGORITHM_NAME);
        cipher.init(mode, sm4Key);
        return cipher;
    }
     public static byte[] generateKey() throws NoSuchAlgorithmException, NoSuchProviderException { 
        return generateKey(DEFAULT_KEY_SIZE);
    }
    public static byte[] generateKey(int keySize) throws NoSuchAlgorithmException, NoSuchProviderException { 
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(keySize, new SecureRandom());
        return kg.generateKey().getEncoded();
    }
}

SM3Util工具类

public class SM3Util  { 
    public static byte[] hash(byte[] srcData) { 
        SM3Digest digest = new SM3Digest();
        digest.update(srcData, 0, srcData.length);
        byte[] hash = new byte[digest.getDigestSize()];
        digest.doFinal(hash, 0);
        return hash;
    }
}

测试类

public class DemoTest
{ 
    public static final String demo = "SM4加解密测试DEMO";
    public static final String sortparam = "参数根据key的 ASCII 码从小到大排序（字典序）";//排序使用treemap，key1=value1&key2=value2
    public static final String appsecret = "ba22726d-14aa-11ea-9b2d-b888e3ebf769";
    public static void main(String[] args) throws Exception { 
        // SM4加密原文
        byte[] bKey = SM4Util.generateKey();
        byte[] sm4 = SM4Util.encrypt_Ecb_Padding(bKey,demo.getBytes("UTF-8"));
        String encData = Base64.encodeBase64String(sm4);
        System.out.println("密文：" + encData);
        byte[] dd = SM4Util.decrypt_Ecb_Padding(bKey, Base64.decodeBase64(encData));
        String datainfo = new String(dd, "UTF-8");
        System.out.println("解密后的原文：" + datainfo);
        //sign签名
        sortparam+="&appsecret="+appsecret;
        byte[] signHash=SM3Util.hash(sortparam.getBytes("UTF-8"));
        StringBuilder signature = new StringBuilder();
        for (byte b : signHash) { 
            signature.append(byteToHexString(b));
        }
        String sign=signature.toString();
        System.out.println("签名String值为：" + sign);
    }
    public static String byteToHexString(byte ib) { 
        char[] Digit = {  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
        char[] ob = new char[2];
        ob[0] = Digit[(ib >>> 4) & 0X0f];
        ob[1] = Digit[ib & 0X0F];
        String str = new String(ob);
        return str;
    }
}