【烦人的加密算法】国密 SM4 的使用--Java版本

谁践踏了优雅 2022-09-10 06:25 140阅读 0赞

和 SM2 引入的包一样， SM2 为非对称算案发，SM4 为对称算法  
[【烦人的加密算法】国密SM2的使用–Java版本][SM2_Java]

> SM4Utils 直接可用

import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
    
    import javax.crypto.Cipher;
    import javax.crypto.CipherInputStream;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.nio.charset.Charset;
    import java.security.Key;
    import java.security.Security;
    import java.util.Base64;
    
    /** * SM4加密算法 * * @author hcf * @date 2021/8/31 16:51 */
    @Slf4j
    public class SM4Utils { 
    
        public static final String ALGORITHM_NAME = "SM4";
        public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS7Padding";
    
        public SM4Utils() { 
        }
    
        static { 
            Security.addProvider(new BouncyCastleProvider());
        }
    
        /** * 加密 * * @param hexKey 明文密钥 * @param content 内容 * @param charset 编码 * @return 加密数据 */
        public static String encrypt(String hexKey, String content, Charset charset) { 
            String encryptContent = StringUtils.EMPTY;
            try { 
                byte[] keyData = ByteUtils.fromHexString(hexKey);
                byte[] contentData = content.getBytes(charset);
                byte[] encryptData = encryptEcbPadding(keyData, contentData);
                encryptContent = Base64.getEncoder().encodeToString(encryptData);
            } catch (Exception e) { 
                log.error("SM4Utils.encrypt(String hexKey, String content, String charset) error {}", e.getMessage(), e);
            }
            return encryptContent;
        }
    
        public static byte[] encryptEcbPadding(byte[] key, byte[] data) throws Exception { 
            Cipher cipher = generateEcbCipher(Cipher.ENCRYPT_MODE, key);
            return cipher.doFinal(data);
        }
    
        /** * 解密 * * @param hexKey 密钥 * @param encryptContent 密文 * @param charset 编码 * @return 解密数据 */
        public static String decrypt(String hexKey, String encryptContent, Charset charset) { 
    
            String content = StringUtils.EMPTY;
            try { 
                byte[] keyData = ByteUtils.fromHexString(hexKey);
                byte[] encryptData = Base64.getDecoder().decode(encryptContent);
                byte[] contentData = decryptEcbPadding(keyData, encryptData);
                content = new String(contentData, charset);
            } catch (Exception e) { 
                log.error("SM4Utils.encrypt(String hexKey, String content, String charset) error {}", e.getMessage(), e);
            }
            return content;
        }
    
        private static byte[] decryptEcbPadding(byte[] key, byte[] cipherText) throws Exception { 
            Cipher cipher = generateEcbCipher(Cipher.DECRYPT_MODE, key);
            return cipher.doFinal(cipherText);
        }
    
        private static Cipher generateEcbCipher(int mode, byte[] key) throws Exception { 
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME_ECB_PADDING, BouncyCastleProvider.PROVIDER_NAME);
            Key sm4Key = new SecretKeySpec(key, ALGORITHM_NAME);
            cipher.init(mode, sm4Key);
            return cipher;
        }
    
    
        public static void main(String[] args) throws Exception { 
            String hexCipher = CipherUtils.randomHexCipher();
            String encrypt = encrypt(hexCipher, "content", StandardCharsets.UTF_8);
            System.out.println(encrypt);
            System.out.println(decrypt(hexCipher, encrypt, StandardCharsets.UTF_8));
        }
    
    }

> CipherUtils

import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import java.security.SecureRandom;
    import java.util.Random;
    
    /** * 密钥生成工具类 * * @author hcf * @date 2021/9/1 17:44 */
    @Slf4j
    public class CipherUtils { 
    
        private static final int AES_KEY_LENGTH = 16;
    
        public static String randomHexCipher() { 
            String cipher = randomCipher();
            StringBuilder hexCipher = new StringBuilder(StringUtils.EMPTY);
            for (int i = 0; i < cipher.length(); i++) { 
                int ch = cipher.charAt(i);
                String s4 = Integer.toHexString(ch);
                hexCipher.append(s4);
            }
            return hexCipher.toString();
        }
    
        /** * 生成密钥 * * @return 密钥 */
        public static String randomCipher() { 
            char[] chars = new char[AES_KEY_LENGTH];
            SecureRandom rnd = new SecureRandom();
            chars[nextIndex(chars, rnd)] = nextUpperlLetter(rnd);
            chars[nextIndex(chars, rnd)] = nextLowerLetter(rnd);
            chars[nextIndex(chars, rnd)] = nextNumLetter(rnd);
            for (int i = 0; i < chars.length; i++) { 
                if (chars[i] == 0) { 
                    chars[i] = nextChar(rnd);
                }
            }
            return new String(chars);
        }
    
        private static int nextIndex(char[] chars, SecureRandom rnd) { 
    
            int index = rnd.nextInt(chars.length);
            while (chars[index] != 0) { 
                index = rnd.nextInt(chars.length);
            }
            return index;
        }
    
        private static char nextUpperlLetter(Random rnd) { 
            return (char) ('A' + rnd.nextInt(26));
        }
    
        private static char nextLowerLetter(Random rnd) { 
            return (char) ('a' + rnd.nextInt(26));
        }
    
        private static char nextNumLetter(Random rnd) { 
            return (char) ('0' + rnd.nextInt(10));
        }
    
        private static char nextChar(SecureRandom rnd) { 
            switch (rnd.nextInt(3)) { 
                case 0:
                    return (char) ('a' + rnd.nextInt(26));
                case 1:
                    return (char) ('A' + rnd.nextInt(26));
                default:
                    return (char) ('0' + rnd.nextInt(10));
            }
        }
    }

[SM2_Java]: https://blog.csdn.net/qq_27631797/article/details/120045171?spm=1001.2014.3001.5501