国密算法使用-SM4

1.概念介绍

SM4：无线局域网标准的分组数据算法。对称加密，密钥长度和分组长度均为128位。

2.算法介绍

此算法是一个分组算法，用于无线局域网产品。该算法的分组长度为128比特，密钥长度为128比特。加密算法与密钥扩展算法都采用32轮非线性迭代结构。解密算法与加密算法的结构相同，只是轮密钥的使用顺序相反，解密轮密钥是加密轮密钥的逆序。

此算法采用非线性迭代结构，每次迭代由一个轮函数给出，其中轮函数由一个非线性变换和线性变换复合而成，非线性变换由S盒所给出。其中rki为轮密钥，合成置换T组成轮函数。轮密钥的产生与上图流程类似，由加密密钥作为输入生成，轮函数中的线性变换不同，还有些参数的区别。

过程:

基本运算：SM4密码算法使用模2加和循环移位作为基本运算。

　　基本密码部件：SM4密码算法使用了S盒、非线性变换τ、线性变换部件L、合成变换T基本密码部件。

　　轮函数：SM4密码算法采用对基本轮函数进行迭代的结构。利用上述基本密码部件，便可构成轮函数。SM4密码算法的轮函数是一种以字为处理单位的密码函数。

　　加密算法：SM4密码算法是一个分组算法。数据分组长度为128比特，密钥长度为128比特。加密算法采用32轮迭代结构，每轮使用一个轮密钥。

　　解密算法：SM4密码算法是对合运算，因此解密算法与加密算法的结构相同，只是轮密铝的使用顺序相反，解密轮密钥是加密轮密钥的逆序。

　　密钥扩展算法：SM4密码算法使用128位的加密密钥，并采用32轮法代加密结构，每一轮加密使用一个32位的轮密钥，共使用32个轮密钥。因此需要使用密钥扩展算法，从加密密钥产生出32个轮密钥。

　　SM4的安全性：SM4密码算法经过我国专业密码机构的充分分析测试，可以抵抗差分攻击、线性攻击等现有攻击，因此是安全的。

3.与DES、AES算法比较

用法上基本一样，只不过密钥变成16字节，加密数据16字节，结果也是16字节。

4.SM4在Java中加密案例

public class Sm4Utils {
	// 编码
    private static final String ENCODING = "UTF-8";
    // 加密名称
    public static final String ALGORIGTHM_NAME = "SM4";
    // 加密分组方式
    public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS7Padding";
    //KEY长度
    public static final int DEFAULT_KEY_SIZE = 128;
 
    public Sm4Utils() {
    }
 
    static {
        Security.addProvider(new BouncyCastleProvider());
    }
 
   // 生成ecb暗号
    private static Cipher generateEcbCipher(String algorithmName, int mode, byte[] key) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithmName,BouncyCastleProvider.PROVIDER_NAME);
        Key sm4Key = new SecretKeySpec(key, ALGORIGTHM_NAME);
        cipher.init(mode, sm4Key);
        return cipher;
    }
 
   // 生成密钥
    public static byte[] generateKey() throws Exception {
        return generateKey(DEFAULT_KEY_SIZE);
    }
 
    public static byte[] generateKey(int keySize) throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance(ALGORIGTHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(keySize, new SecureRandom());
        return kg.generateKey().getEncoded();
    }
 
   // 加密
    public static String encryptEcb(String hexKey, String paramStr, String charset) throws Exception {
        String cipherText = "";
        if (null != paramStr && !"".equals(paramStr)) {
            byte[] keyData = ByteUtils.fromHexString(hexKey);
            charset = charset.trim();
            if (charset.length() <= 0) {
                charset = ENCODING;
            }
            byte[] srcData = paramStr.getBytes(charset);
            byte[] cipherArray = encrypt_Ecb_Padding(keyData, srcData);
            cipherText = ByteUtils.toHexString(cipherArray);
        }
        return cipherText;
    }
 
   // 加密模式之ecb
    public static byte[] encrypt_Ecb_Padding(byte[] key, byte[] data) throws Exception {
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);
        byte[] bs = cipher.doFinal(data);
        return bs;
    }
 
   // Sm4解密
    public static String decryptEcb(String hexKey, String cipherText, String charset) throws Exception {
        String decryptStr = "";
        byte[] keyData = ByteUtils.fromHexString(hexKey);
        byte[] cipherData = ByteUtils.fromHexString(cipherText);
        byte[] srcData = decrypt_Ecb_Padding(keyData, cipherData);
        charset = charset.trim();
        if (charset.length() <= 0) {
            charset = ENCODING;
        }
        decryptStr = new String(srcData, charset);
        return decryptStr;
    }
 
    // 解密
    public static byte[] decrypt_Ecb_Padding(byte[] key, byte[] cipherText) throws Exception {
        Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(cipherText);
    }
 
    // 密码校验
    public static boolean verifyEcb(String hexKey,String cipherText,String paramStr) throws Exception {
        boolean flag = false;
        byte[] keyData = ByteUtils.fromHexString(hexKey);
        byte[] cipherData = ByteUtils.fromHexString(cipherText);
        byte[] decryptData = decrypt_Ecb_Padding(keyData,cipherData);
        byte[] srcData = paramStr.getBytes(ENCODING);
        flag = Arrays.equals(decryptData,srcData);
        return flag;
    }
 
    
    public static void main(String[] args) {
        try {
            String json = "{\"name\":\"Devil\"}";
            System.out.println("json: " + json);
            String key = ByteUtils.toHexString(Sm4Utils.generateKey());
            System.out.println("key: " + key);
            String encryptJson= Sm4Utils.encryptEcb(key, json,ENCODING);
            System.out.println("encryptJson: " + encryptJson);
            System.out.println(Sm4Utils.verifyEcb(key, encryptJson, json));
            String decryptJson = Sm4Utils.decryptEcb(key, encryptJson,ENCODING);
            System.out.println("decryptJson: " + decryptJson);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
}