银联银行卡收单相关国密SM4计算MAC的算法-POS终端国密SM4计算MAC-银联国密SM4联机MAC计算

银联银行卡收单相关国密SM4计算MAC的算法-POS终端国密SM4计算MAC-银联国密SM4联机MAC计算

POS终端MAC的计算[国密SM4]

POS终端MAC的计算在终端上一般由密码键盘组件和终端MAC工作密钥生成
其计算规则如下:

1. 将计算数据分组 ，按16字节（SM4密钥长度）为一组
2. 对分组的数据逐组进行异或运算
3. 将十六字节的异或结果扩展为32字节
4. 取扩展后的异或结果的前16字节数据做SM4运算（使用无填充模式）
5. SM4运算结果再和扩展后的异或结果的后16字节数据进行异或
6. 然后对异或结果再次做SM4运算
7. 最后取运算结果的前8字节以十六进制编码作为mac值返回

• 计算代码示例:

/**
  * sm4国密计算mac（POS终端MAC）
  *
  * @param key  16进制字符串密钥
  * @param data
  * @return
  * @throws Exception
  */
 public static String posSm4Mac(String hexkey, byte[] data) throws Exception {
 
     if (data == null || data.length <= 0) {
         throw new Exception("数据不能为空");
     }
 
     // 将数据分组 16字节为一组,最后一组不足补0
     List<byte[]> dataGroup = EMUtil.groupBytes(data, 16);
 
     // 逐组进行异或运算
     byte[] mab = dataGroup.get(0);
     for (int i = 1; i < dataGroup.size(); i++) {
         mab = EMUtil.xor(dataGroup.get(i), mab);
     }
 
     // 十六字节异或结果扩展为32字节
     mab = Hex.encode(mab).getBytes();
 
     // 取异或结果的前16字节数据
     byte[] pre16bytes = EMUtil.readField(mab, 0, 16);
     // 取异或结果的后16字节数据
     byte[] end16bytes = EMUtil.readField(mab, mab.length - 16, 16);
 
     // 前16字节数据做SM4运算
     byte[] preData = SM4CmdUtil.sm4EcbEncrypt(pre16bytes, hexkey, E0KeyTypes.ZMK);   //这里替换为自己的算法实现 SM4/ECB/Nopadding
     // 再和后16字节数据进行异或
     mab = EMUtil.xor(preData, end16bytes);
     // 对异或结果做SM4运算
     mab = SM4CmdUtil.sm4EcbEncrypt(mab, hexkey, E0KeyTypes.ZMK); //这里替换为自己的算法实现 SM4/ECB/Nopadding
 
     // 取前8字节作为mac值返回
     return Hex.encode(EMUtil.readField(mab, 0, 8));
 }

银联CUPS联机MAC计算 [国密SM4]

联机MAC的计算用于和银联CUPS的交互
其中分为带CheckValue的，用于密钥重置类交易
而不带CheckValue的用于一般的普通交易等
其计算规则如下:

1. 将计算数据分组 ，按16字节（SM4密钥长度）为一组
2. 对第0组明文数据进行加密,得到第0组明文数据的密文
3. 从第1组开始按以下逻辑循环计算：

• 取当前组的数据和上一组的密文数据进行异或
• 将异或结果做SM4运算 （使用无填充模式）,运算结果做为下一次的异或输入数据

4. 最后取运算结果的前4字节以十六进制编码作为mac值返回

银联CUPS联机MAC之-CheckValue计算 [国密SM4]

CheckValue的计算实际也就是计算密钥的校验值，具体就是使用密钥对16字节的0x0做SM4运算

联机MAC计算代码示例:

/**
	 * sm4国密计算mac（联机MAC值）
	 *
	 * @param hexkey  16进制字符串密钥
	 * @param keyType 密钥类型
	 * @param data    待加密字符串
	 * @return
	 * @throws Exception
	 */
	public static String cupsSm4Mac(String hexkey, SM4KeyTypes keyType, byte[] data, boolean useCheckValue)
			throws Exception {
		if (data == null || data.length <= 0) {
			throw new Exception("数据不能为空");
		}

		// 将数据分组 16字节为一组
		List<byte[]> dataGroup = EMUtil.groupBytes(data, 16);

		// 开始加密过程
		// 1、对第0组明文数据进行加密 得到第0组明文数据的密文
		// 2、对第0组数据的密文与第1组明文数据进行异或 得到下次运算要加密的数据
		// 循环1、2过程
		byte[] mab = dataGroup.get(0);
		mab = SM4Util.encryptDataCBCNopadding(mab, hexkey, keyType, KeytoolConstant.POSP_34DATA_DEFAULT_IV); //这里替换为自己的算法实现 SM4/CBC/Nopadding
		for (int i = 1; i < dataGroup.size(); i++) {
			mab = EMUtil.xor(dataGroup.get(i), mab);
			mab = SM4Util.encryptDataCBCNopadding(mab, hexkey, keyType, KeytoolConstant.POSP_34DATA_DEFAULT_IV); //这里替换为自己的算法实现 SM4/CBC/Nopadding
		}

		byte[] mac = EMUtil.readField(mab, 0, 4);
		if (useCheckValue) {
			byte[] checkValue = new byte[16];
			checkValue = SM4Util.encryptDataCBCNopadding(checkValue, hexkey, keyType, KeytoolConstant.POSP_34DATA_DEFAULT_IV); //这里替换为自己的算法实现 SM4/CBC/Nopadding
			checkValue = EMUtil.readField(checkValue, 0, 4);
			mac = EMUtil.mergeByte(mac, checkValue);
		}
		return Hex.encode(mac);
	}

其他计算函数示例

/**
 * 执行异或操作
 *
 * @param a 字节数组a
 * @param b 字节数组b
 * @return
 */
public static byte[] xor(byte[] a, byte[] b) {
    if (a.length != b.length) {
        throw new IllegalArgumentException("数组长度需相同");
    }
 
    byte[] result = new byte[a.length];
    for (int i = 0; i < a.length; i++) {
        result[i] = (byte) (a[i] ^ b[i]);
    }
    return result;
}
 
/**
 * 按位取反
 * @param array 字节数组
 * @return
 */
public static byte[] invert(byte[] array) {
    byte[] inverted = new byte[array.length];
    for (int i = 0; i < array.length; i++) {
        inverted[i] = (byte) ~array[i];
    }
    return inverted;
}
 
/**
 * 读取数据域
 *
 * @param data       数据
 * @param fieldIndex 数据域起始索引
 * @param fieldLen   数据域数据长度
 * @return
 */
public static byte[] readField(byte[] data, int fieldIndex, int fieldLen) {
    byte[] filedData = new byte[fieldLen];
    System.arraycopy(data, fieldIndex, filedData, 0, fieldLen);
    return filedData;
}
 
/**
 * 合并字节数组
 *
 * @param bt1 字节数组1
 * @param bt2 字节数组2
 * @return
 * @throws Exception
 */
public static byte[] mergeByte(byte[] bt1, byte[] bt2) {
    byte[] dest = new byte[bt1.length + bt2.length];
    System.arraycopy(bt1, 0, dest, 0, bt1.length);
    int offset = bt1.length;
    System.arraycopy(bt2, 0, dest, offset, bt2.length);
    return dest;
}
 
/**
 * 对数据按指定大小分组,最后一组不足分组大小补0
 *
 * @param input     数据
 * @param groupSize 分组大小
 * @return
 */
public static List<byte[]> groupBytes(byte[] input, int groupSize) {
    return groupBytes(input, groupSize, (byte) 0x0);
}
 
/**
 * 对数据按指定大小分组
 *
 * @param input     数据
 * @param groupSize 分组大小
 * @param paddBit   补位
 * @return
 */
public static List<byte[]> groupBytes(byte[] input, int groupSize, byte paddBit) {
    List<byte[]> groups = new ArrayList<>();
    int inputLength = input.length;
    int groupsCount = (int) Math.ceil((double) inputLength / groupSize);
 
    for (int i = 0; i < groupsCount; i++) {
        int start = i * groupSize;
        int length = Math.min(groupSize, inputLength - start);
        byte[] group = new byte[groupSize];
        System.arraycopy(input, start, group, 0, length);
        if (paddBit != 0x0 && length < groupSize) {
            for (int j = length; j < groupSize; j++) {
                group[j] = paddBit;
            }
        }
        groups.add(group);
 
    }
    return groups;
}