几个国密算法的使用sm2,sm3,sm4

   <properties>   
  <bcprov.version>1.69</bcprov.version>
   <hutool.version>5.8.4</hutool.version>
    </properties>
<!--Bouncy Castle库-->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15to18</artifactId>
            <version>${bcprov.version}</version>
        </dependency>
<!--hutool-->
    <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>${hutool.version}</version>
    </dependency>

import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.SM2;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import com.alibaba.fastjson.JSONObject;

import java.security.KeyPair;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 
 * @date 2022年08月12日 14:30
 * @description 国产加密算法
 * 非对称加密和签名：SM2
 * 摘要签名算法：SM3
 * 对称加密：SM4
 */
public class SmUtils {

    /**
     * 生成Sm2公私钥
     * @return
     */
    public static Map createSM2Key() {
        //生成公私钥
        KeyPair pair = SecureUtil.generateKeyPair("SM2");
        String privateKey = HexUtil.encodeHexStr(pair.getPrivate().getEncoded());
        String publicKey = HexUtil.encodeHexStr(pair.getPublic().getEncoded());
        return new HashMap<String,String>(){{
            put("privateKey", privateKey);
            put("publicKey", publicKey);
        }};
    }


    /**
     * SM2加密
     * @param value
     * @param publicKey
     * @return
     * @deprecated 非对称加密和签名
     * 使用随机生成的密钥对加密
     */
    public static String createSM2Str(String value, String publicKey){
        SM2 sm2E = SmUtil.sm2(null, publicKey);
        // 公钥加密，私钥解密
        String encryptStr = sm2E.encryptBcd(value, KeyType.PublicKey);
        return encryptStr;
    }


    /**
     * SM2解密
     * @param value
     * @param privateKey
     * @return
     * @deprecated 非对称加密和签名
     * 使用随机生成的密钥对解密
     */
    public static String parseSM2Str(String value, String privateKey) {
        SM2 sm2D = SmUtil.sm2(privateKey,null);
        try {
            String decryptStr = StrUtil.utf8Str(sm2D.decryptFromBcd(value, KeyType.PrivateKey));
            return decryptStr;
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * SM2加密->非对称加密和签名
     * @param value 需要加密的字符串
     * @param publicKey 公钥
     * @return 返回加密后的字符串
     */
    public static String createMapToSM2Str(Map value,String publicKey) {
        String data = JSONObject.toJSONString(value);
        return createSM2Str(data, publicKey);
    }

    /**
     * SM4解密->对称加密
     * @param data 需要加密的字符串
     * @param privateKey 私钥
     * @return 返回解密后的Map
     */
    public static Map parseStrSM2ToMap(String data,String privateKey) {
        String value = parseSM2Str(data, privateKey);
        Map resultMap = new HashMap();
        try {
            resultMap = JSONObject.parseObject(value,HashMap.class);
            return resultMap;
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * SM3加密->摘要签名算法->类似md5加密
     * @param value 需要加密的字符串
     * @return 返回加密后的字符串
     */
    public static String createSM3Str(String value) {
        return SmUtil.sm3(value);
    }



    /**
     * SM4加密->对称加密
     * @param data 需要加密的字符串
     * @param secretKey 秘钥
     * @return 返回加密后的字符串
     */
    public static String createSM4Str(String data,String secretKey) {
        SymmetricCrypto sm4 = SmUtil.sm4(secretKey.getBytes(CharsetUtil.CHARSET_UTF_8));
        return sm4.encryptHex(data, CharsetUtil.CHARSET_UTF_8).toUpperCase();
    }

    /**
     * SM4解密->对称加密
     * @param data 需要加密的字符串
     * @param secretKey 秘钥
     * @return 返回解密后的字符串
     */
    public static String parseSM4Str(String data,String secretKey) {
        try {
            SymmetricCrypto sm4 = SmUtil.sm4(secretKey.getBytes(CharsetUtil.CHARSET_UTF_8));
            return sm4.decryptStr(data, CharsetUtil.CHARSET_UTF_8);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * SM4加密->对称加密
     * @param value 需要加密的字符串
     * @param secretKey 需要加密的字符串
     * @return 返回加密后的字符串
     */
    public static String createMapToSM4Str(Map value,String secretKey) {
        String data = JSONObject.toJSONString(value);
        return createSM4Str(data, secretKey);
    }

    /**
     * SM4解密->对称加密
     * @param data 需要加密的字符串
     * @param secretKey 需要加密的字符串
     * @return 返回解密后的Map对象
     */
    public static Map parseStrSM4ToMap(String data,String secretKey) {
        String value = parseSM4Str(data, secretKey);
        Map resultMap = new HashMap();
        try {
            resultMap = JSONObject.parseObject(value,HashMap.class);
            return resultMap;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 创建sm4加密秘钥
     * @return
     */
    public static String createSM4Key() {
        String secretKey = UUID.fastUUID().toString().replace("-","").substring(0,16);
        return secretKey;
    }

    public static void main(String[] args) {
        // 创建sm2钥匙对
//        Map<String,String> keyMap = createSM2Key();
//        System.out.println(JSONObject.toJSONString(keyMap));
        String privateKey = "308193020100301306072a8648ce3d020106082a811ccf5501822d0479307702010104207ba0c4aea7a798301c41c448b2bc07d3170eac366bdf0617d60553c605cbd33ca00a06082a811ccf5501822da14403420004dcf012b9b4867346f917615fa815eebbfd1891c6c5e7fb7639430c008df9c2b668d4335ee530cc9edcb30930b5e5b2d2a4584d2e6bbcc71c84176d0f5c0b2077";
        String publicKey= "3059301306072a8648ce3d020106082a811ccf5501822d03420004dcf012b9b4867346f917615fa815eebbfd1891c6c5e7fb7639430c008df9c2b668d4335ee530cc9edcb30930b5e5b2d2a4584d2e6bbcc71c84176d0f5c0b2077";

        //
        //        String data = "测试一下11112222";
//        String sm2Str = createSM2Str(data, publicKey);
//        System.out.println("sm2Str:" + sm2Str);
//        String parseSm2 = parseSM2Str(sm2Str, privateKey);
//        System.out.println("parseSm2:" + parseSm2);

//        Map<String,Object> data = new HashMap<String,Object>() {{
//            put("test", "11111efewf粉色粉色");
//        }};
//        String sm2Str = createMapToSM2Str(data, publicKey);
//        System.out.println("sm2Str:" + sm2Str);
//        Map parseSm2 = parseStrSM2ToMap(sm2Str + "123213", privateKey);
//        System.out.println("parseSm2:" + JSONObject.toJSONString(parseSm2));


        //  SM4 requires a 128 bit key  -> 128 bit = 128 / 8 = 16 byte,秘钥只需要16个字符
        String sm4Key = createSM4Key();
        String data = "测试一下11112222";
        String sm4Str = createSM4Str(data, sm4Key);
        System.out.println("sm4Str:" + sm4Str);
        String parseSm4 = parseSM4Str(sm4Str, sm4Key);
        System.out.println("parseSm4:" + parseSm4);


        //  sm3  加密
//        String data = "测试一下1111222224231311123123123123";
//        String sm3Str = createSM3Str(data);
//        System.out.println("parseSm3:" + sm3Str);

    }


}