讲文之前，简单介绍一下SM3算法

SM3算法：SM3杂凑算法是我国自主设计的密码杂凑算法，适用于商用密码应用中的数字签名和验证消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求。为了保证杂凑算法的安全性，其产生的杂凑值的长度不应太短，例如MD5输出128 比特 杂凑值，输出长度太短，影响其安全性SHA-1算法的输出长度为160比特，SM3算法的输出长度为256比特，因此SM3算法的安全性要高于MD5算法和SHA-1算法。

此算法适用于商用密码应用中的数字签名和验证，消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求。再SM2，SM9标准中使用。 此算法对输入长度小于2的64次方的比特消息，经过填充和迭代压缩，生成长度为256比特的杂凑值，其中使用了异或，模，模加，移位，与，或，非运算，由填充，迭代过程，消息扩展和压缩函数所构成。具体算法及运算示例见SM3标准。

有兴趣可以自己下去在做补充。

本次讲的SM3算法我运用在了支付密码的加密情景中

情景加密逻辑

先将加密逻辑，给大家展示一下:

首先由数字数字键盘 输入一个6位数的password(密码)，然后调用接口， 然后由后台获得密码，然后进行密码的拆分， 如: 123456 拆解 1,2,3,4,5,6 然后存入数组

然后进行第一步的特定解码。 如：自定义的解码表

根据不同的原始数据 先转换成对应的自定义规则，然后再进行加密 依次加密之后，紧接着进行拼装

如: 1 转码 后为 bb 然后加密后 xxxxxx 2 转码后为 cc 然后加密后 cccccc … 依次向下

然后拼接 xxxxxxcccccc…依次拼接

再把拼接后的数据做最后一次SM3加密

得出最终我们需要的 EncryptionPassword(加密密码)

好了直接上代码

进入主题

SM3加密需要的pom.xml依赖

有两个

         //密码加密包
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.62</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
            <optional>true</optional>
        </dependency>
复制代码  

添加完依赖后

我的SM3简单的目录结构

开始啃码

从上到下说

SM3Rule.class (加密规则类)

 /**
 * 加密规则
 * @author FYF
 * @date Created in 11:16 2020/6/4
 */public enum SM3Rule {
    /**
     * 转码规则 与上面讲的对应
     */    ZERO("0", "aa"),
    ONE("1", "bb"),
    TWO("2", "cc"),
    THREE("3", "dd"),
    FOUR("4", "ee"),
    FIVE("5", "ff"),
    SIX("6", "gg"),
    SEVEN("7", "hh"),
    EIGHT("8", "ii"),
    NINE("9", "jj")
    ;

    @Getter
    private String code;
    @Getter
    private String  msg ;

    SM3Rule(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public static String valueOfCode(String code) {
        for (SM3Rule sm3Rule : values()) {
            if (StringUtils.equals(code, sm3Rule.code)) {
                return sm3Rule.msg;
            }
        }
        throw new IllegalStateException("数字转换异常");
    }

}
复制代码  

这个类其实就是简单的枚举类，把我们需要的转码规则封装进了里面 通过 valueOfCode方法 取出对应的转码后的值

主角：SM3Util.class (SM3算法工具类)

 /**
 * sm3加密算法工具类
 *
 * @author FYF
 * @date Created in 16:02 2020/6/3
 */@ Slf4j 
public class SM3Util {

    private static final String ENCODING = "UTF-8";

    static {
        Security.addProvider(new BouncyCastleProvider());
    }
    /**
     * 密码加密方法总和
     * @param pwd 密码
     * @return 逻辑加密后的返回密码
     */    public static String pwdEncrypt(String pwd){
        if (StringUtils.isNotEmpty(pwd)){
            String pwdConvert = pwdEncryptAssembly(pwd);
            String encryptPwd = encrypt(pwdConvert);
            return encryptPwd;
        }
        throw new IllegalStateException("密码不能为空!");
    }

    /**
    * 获取前端传来的密码数字，然后加密拼接
     * @param pwd 密码
     * @return 加密拼接完的密码
    */    public static String pwdEncryptAssembly(String pwd) {
            StringBuffer stringPwd = new StringBuffer();
            for (char key : pwd.toCharArray()) {
                String s = SM3Rule.valueOfCode(String.valueOf(key));
                String encrypt = encrypt(s);
                stringPwd.append(encrypt);
            }
            String jsonPwd = stringPwd.toString();
            return jsonPwd.toUpperCase();
    }

    /**
     * sm3算法加密
     *
     * @param paramStr 待加密 字符串 
     * @return 返回加密后，固定长度=32的16 进制 字符串
     */    public static String encrypt(String paramStr) {
        // 将返回的 hash 值转换成16进制字符串
        String resultHexString = "";
        try {
            // 将字符串转换成 byte 数组
            byte[] srcData = paramStr.getBytes(ENCODING);
            // 调用hash()
            byte[] resultHash = hash(srcData);
            // 将返回的hash值转换成16进制字符串
            resultHexString = ByteUtils.toHexString(resultHash);
            return resultHexString.toUpperCase();
        } catch (UnsupportedEncodingException e) {
           log.info("SM3算法加密失败：",e);
           throw new  IllegalStateException("SM3算法加密异常");
        }

    }

    /**
     * 返回长度=32的byte数组
     *
     * @param srcData
     * @return 数组
     * @explain 生成对应的hash值
     */    public static byte[] hash(byte[] srcData) {

        try {
            SM3Digest digest = new SM3Digest();
            digest.update(srcData, 0, srcData.length);
            byte[] hash = new byte[digest.getDigestSize()];
            digest.doFinal(hash, 0);
            return hash;
        }catch (Exception e){
            log.info("返回byte数组失败：",e);
            throw new IllegalStateException("返回byte数组异常");
        }
    }

    /**
     * 通过密钥进行加密
     *
     * @param key     密钥
     * @param srcData 被加密的byte数组
     * @return
     * @explain 指定密钥进行加密
     */    public static byte[] hmac(byte[] key, byte[] srcData) {

        try {
            KeyParameter keyParameter = new KeyParameter(key);
            SM3Digest digest = new SM3Digest();
            HMac mac = new HMac(digest);
            mac.init(keyParameter);
            mac.update(srcData, 0, srcData.length);
            byte[] result = new byte[mac.getMacSize()];
            mac.doFinal(result, 0);
            return result;
        }catch (Exception e){
            log.info("通过秘钥加密失败：",e);
            throw new IllegalStateException("通过秘钥加密异常");
        }
    }

    /**
     * 判断源数据与加密数据是否一致
     *
     * @param srcStr       原字符串
     * @param sm3HexString 16进制字符串
     * @return 校验结果
     * @explain 通过验证原数组和生成的hash数组是否为同一数组，验证2者是否为同一数据
     */    public static boolean verify(String srcStr, String sm3HexString) {
        boolean flag = false;
        try {
            byte[] srcData = srcStr.getBytes(ENCODING);
            byte[] sm3Hash = ByteUtils.fromHexString(sm3HexString);
            byte[] newHash = hash(srcData);
            if (Arrays.equals(newHash, sm3Hash)) {
                flag = true;
            }
            return flag;
        } catch (UnsupportedEncodingException e) {
            log.info("判断源数据与加密数据错误：",e);
            throw new IllegalStateException("判断源数据与加密数据异常");
        }

    }

}
复制代码  

这个是我封装的SM3Utils.class工具类，里面注释已经把每个方法讲述的很清楚了。而且包括异常捕获我也写完了。

简单的加密思路就是 :我们先拿到前台的密码，然后划分成数组，数组循环转码并加密，然后放入 StringBuffer 中，拼接完成后，拿着返回的 StringBuffer 然后去进行加密，加密会把字符串变为byte类型然后在通过特定的 杂凑算法 规则，进行最后一层返回。也就是我们最后得到的加密后的杂凑字符。 （有兴趣的小伙伴可以去啃一下杂凑算法的底层原理）

最后的话就是我们的测试类

SM3UtilTest.class (测试类)

我测试类写的简单的写了一下，并不是很正规，其实直接写main方法调用主函数(pwdEncrypt方法)直接传参进行加密即可 如果按照TDD的测试方式规范来写，我这样肯定少了很多东西，还望见谅。

 /**
 * @author FYF
 * @date Created in 15:27 2020/6/4
 */@Slf4j
public class SM3UtilTest {

    public static final String PWD_LENGTH_EX_MSG = "密码的长度必须等于6";

    /**
     * 密码
     */    private String password;
    /**
     * 密码长度
     */    private final Integer pwdLength=6;

    /**
     * 密码加密组合之后
     */    private String pwdEncryptAssembly;

    /**
     * 密码长度
     */    private Integer pwdSize;

    /**
     * 密码加密最终结果
     */    private String pwdEncrypt;

    @BeforeEach
    public void testbefore(){
        password="135790";
        pwdSize=password.length();
        pwdEncryptAssembly=SM3Util.pwdEncryptAssembly(password);

    }

    @Test
    public void testEncrypt(){
        if (pwdSize.equals(pwdLength)){
            assertAll("SM3加密",
            ()->{
                log.info("您输入的密码:{}",password);
                log.info("您密码加密组合并组合:{}",pwdEncryptAssembly);
                pwdEncrypt = SM3Util.pwdEncrypt(password);
                assertTrue(StringUtils.isNotBlank(pwdEncrypt));
                log.info("最终组合密码结果:{}",pwdEncrypt);
            });
        }else {
            log.info("错误信息:{}",PWD_LENGTH_EX_MSG);
        }
    }
}