CPU卡校验MAC1、计算MAC2、校验TAC的方式及流程

比眉伴天荒 2022-05-16 04:10 651阅读 0赞

*   *   *   *  前言
             *  mac1验证、mac2计算、tac验证流程
             *  运行结果如下
             *  涉及的帮助类
                
                 *  DES工具类
                 *  ByteUtil

#### 前言 ####

CPU卡的各个密钥是需要通过加密机分散获得，因此这里使用的是之前自己发的一张复旦微电子的测试卡，现已经明确知道其对应的充值密钥及维护密钥，想了解简单的发卡流程可以参考之前的博客:[复旦微电子CPU卡发卡流程][CPU]

具体流程直接上代码，里面有比较详细的注释，按着代码一行一行的读就可以了

#### mac1验证、mac2计算、tac验证流程 ####

import java.util.Locale;
    
    public class CardCenter
    {
        public static void main(String[] args)
        {
    
            // 圈存的key
            String loadKey = "3F013F013F013F013F013F013F013F01";
            System.out.println("圈存的key:" + loadKey);
            // 验证tac的key
            String tacKey = "34343434343434343434343434343434";
            System.out.println("验证tac的key:" + tacKey);
    
            System.out.println();
    
            // posid
            String posid = "112233445566";
            System.out.println("终端ID:" + posid);
            // 交易金额
            String tradeAmount = "00000001";
            System.out.println("交易金额:" + tradeAmount);
            // 交易金额十进制
            int ta = 1;
            // 交易类型
            String tradeType = "02";
            System.out.println("交易类型:" + tradeType);
    
            System.out.println();
            // 预充值指令
            System.out.println("组装预充值指令:805000020b0100000001112233445566");
            // 预消费指令805000020b0100000001112233445566的指令回复
            String preTopup = "0000001a0017000106b825d7684c81ce9000";
            System.out.println("得到预充值响应:" + preTopup);
            byte[] recvByte = ByteUtil.hexStr2Byte(preTopup);
    
            // 卡余额
            String balance = ByteUtil.hexToStr(recvByte, 0, 4);
            int bal = ByteUtil.hexToInt(recvByte, 0, 4);
            System.out.println("卡余额:" + balance);
    
            // 联机计数器
            String cardCnt = ByteUtil.hexToStr(recvByte, 4, 2);
            System.out.println("联机计数器:" + cardCnt);
    
            // 密钥版本
            String keyVersion = ByteUtil.hexToStr(recvByte, 6, 1);
            System.out.println("密钥版本:" + keyVersion);
    
            // 算法标识
            String alglndMark = ByteUtil.hexToStr(recvByte, 7, 1);
            System.out.println("算法标识:" + alglndMark);
    
            // 随机数
            String random = ByteUtil.hexToStr(recvByte, 8, 4);
            System.out.println("随机数:" + random);
    
            // mac1
            String mac1 = ByteUtil.hexToStr(recvByte, 12, 4);
            System.out.println("mac1:" + mac1);
    
            System.out.println("");
            System.out.println("开始验证mac1");
            // 验证mac1的正确性
            // 输入的数据为：随机数+联机计数器+“8000”
            String inputData = random + cardCnt + "8000";
            System.out.println("计算过程密钥数据:" + inputData);
            // 计算过程密钥
            String sessionKey = Des.getHintKey(inputData, loadKey);
            System.out.println("过程密钥:" + sessionKey);
    
            // 计算mac1需要输入的数据
            // 输入的数据为：余额+交易金额+交易类型+终端编号
            inputData = balance + tradeAmount + tradeType + posid;
            String legitMac1 = Des.PBOC_DES_MAC(sessionKey, "0000000000000000", inputData, 0).substring(0, 8);
            System.out.println("标准的mac1数据:" + legitMac1);
    
            if (!mac1.toUpperCase(Locale.getDefault()).equals(legitMac1))
            {
                System.out.println("mac1校验失败！");
                return;
            }
            System.out.println("mac1校验成功！");
    
            // 开始计算Mac2用于做充值确认操作
            System.out.println("");
            System.out.println("开始计算mac2");
            // 交易日期
            String tradeDate = "20170310";
            // 交易时间
            String tradeTime = "110734";
            // 计算mac2的输入数据
            // 输入数据为：交易金额+交易类型+终端编号+交易时间+交易日期
            inputData = tradeAmount + tradeType + posid + tradeDate + tradeTime;
            String mac2 = Des.PBOC_DES_MAC(sessionKey, "0000000000000000", inputData, 0).substring(0, 8);
            // 得到mac2
            System.out.println("计算后的mac2:" + mac2);
    
            // 组装写卡指令
            System.out.println("805200000b" + tradeDate + tradeTime + mac2);
            System.out.println("开始向卡片发送充值确认的指令");
            // 向卡发送指令
            System.out.println("apdu:805200000b201703101107349C8A0625");
            // 响应tac
            System.out.println("recv:16ead5169000");
            String tac = "16ead516";
            System.out.println("得到Tac:" + tac);
    
            System.out.println("");
            System.out.println("开始验证tac");
            System.out.println("tac验证密钥:" + tacKey);
            // 对tac验证密钥左边8个字节和右边8个字节做异或处理得到tac过程密钥
            String tacTessionKey = Des.xOr(tacKey.substring(0, 16), tacKey.substring(16, 32));
            System.out.println("tac过程密钥:" + tacTessionKey);
            // 充值成功之后新的金额为00000043+00000001=00000044
            String newBalance = ByteUtil.hexToStr(ByteUtil.intToHex(bal + ta, 4));
            // 计算标准的tac的输入数据
            // 输入的数据：新的余额+旧的联机计数器+交易金额+交易类型+终端编号+交易日期+交易时间
            inputData = newBalance + cardCnt + tradeAmount + tradeType + posid + tradeDate + tradeTime;
            String legitTac = Des.PBOC_DES_MAC(tacTessionKey, "0000000000000000", inputData, 0).substring(0, 8);
            System.out.println("标准的tac数据:" + legitTac);
    
            if (!tac.toUpperCase(Locale.getDefault()).equals(legitTac))
            {
                System.out.println("tac校验错误！");
                return;
            }
            System.out.println("tac校验成功！");
        }
    }

#### 运行结果如下 ####

圈存的key:3F013F013F013F013F013F013F013F01
    验证tac的key:34343434343434343434343434343434
    
    终端ID:112233445566
    交易金额:00000001
    交易类型:02
    
    组装预充值指令:805000020b0100000001112233445566
    得到预充值响应:0000001a0017000106b825d7684c81ce9000
    卡余额:0000001a
    联机计数器:0017
    密钥版本:00
    算法标识:01
    随机数:06b825d7
    mac1:684c81ce
    
    开始验证mac1
    计算过程密钥数据:06b825d700178000
    过程密钥:6E76E8541E217D9A
    D[0]=0000001a00000001
    D[1]=0211223344556680
    1**************
    I=0000001A00000001
    O=D42EE2FF647C9F00
    I=D63FC0CC2029F980
    I=684C81CE47609B5B
    标准的mac1数据:684C81CE
    mac1校验成功！
    
    开始计算mac2
    D[0]=0000000102112233
    D[1]=4455662017031011
    D[2]=0734800000000000
    1**************
    I=0000000102112233
    O=A0D9EACF4A0A833D
    I=E48C8CEF5D09932C
    2**************
    I=E48C8CEF5D09932C
    O=6DF657FD31FBAB05
    I=6AC2D7FD31FBAB05
    I=9C8A06256ACBF60A
    计算后的mac2:9C8A0625
    805200000b201703101107349C8A0625
    开始向卡片发送充值确认的指令
    apdu:805200000b201703101107349C8A0625
    recv:16ead5169000
    得到Tac:16ead516
    
    开始验证tac
    tac验证密钥:34343434343434343434343434343434
    tac过程密钥:0000000000000000
    D[0]=0000001b00170000
    D[1]=0001021122334455
    D[2]=6620170310110734
    D[3]=8000000000000000
    1**************
    I=0000001B00170000
    O=F0DE01AF2D71051B
    I=F0DF03BE0F42414E
    2**************
    I=F0DF03BE0F42414E
    O=044D5B737F9A0282
    I=626D4C706F8B05B6
    3**************
    I=626D4C706F8B05B6
    O=2B5ED4A6C483D0BF
    I=AB5ED4A6C483D0BF
    I=16EAD5165389360A
    标准的tac数据:16EAD516
    tac校验成功！

#### 涉及的帮助类 ####

##### DES工具类 #####

import java.io.ByteArrayOutputStream;
    import java.io.UnsupportedEncodingException;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    /** * DES工具类 */
    public class Des { 
        /** * ***************************压缩替换S-Box************************************* * ************ */
        private static final int[][] s1 =
        {
        { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
        { 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
        { 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
        { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 } };
        private static final int[][] s2 =
        {
        { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
        { 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
        { 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
        { 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 } };
        private static final int[][] s3 =
        {
        { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
        { 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
        { 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
        { 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 } };
        private static final int[][] s4 =
        {
        { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
        { 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },// erorr
                { 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
                { 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 } };
        private static final int[][] s5 =
        {
        { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
        { 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
        { 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
        { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 } };
        private static final int[][] s6 =
        {
        { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
        { 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
        { 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
        { 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 } };
        private static final int[][] s7 =
        {
        { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
        { 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
        { 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
        { 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 } };
        private static final int[][] s8 =
        {
        { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
        { 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
        { 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
        { 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } };
        private static final int[] ip =
        { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25,
                17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7 };
        private static final int[] _ip =
        { 40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52,
                20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25 };
        // 每次密钥循环左移位数
        private static final int[] LS =
        { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
        private static int[][] subKey = new int[16][48];
        public static int HEX = 0;
        public static int ASC = 1;
    
        /** * 将十六进制A--F转换成对应数 * * @param ch * @return * @throws Exception */
        public static int getIntByChar(char ch) throws Exception
        {
            char t = Character.toUpperCase(ch);
            int i = 0;
            switch (t)
            {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    i = Integer.parseInt(Character.toString(t));
                    break;
                case 'A':
                    i = 10;
                    break;
                case 'B':
                    i = 11;
                    break;
                case 'C':
                    i = 12;
                    break;
                case 'D':
                    i = 13;
                    break;
                case 'E':
                    i = 14;
                    break;
                case 'F':
                    i = 15;
                    break;
                default:
                    throw new Exception("getIntByChar was wrong");
            }
            return i;
        }
    
        /** * 将字符串转换成二进制数组 * * @param source * : 16字节 * @return */
        public static int[] string2Binary(String source)
        {
            int len = source.length();
            int[] dest = new int[len * 4];
            char[] arr = source.toCharArray();
            for (int i = 0; i < len; i++)
            {
                int t = 0;
                try
                {
                    t = getIntByChar(arr[i]);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                String[] str = Integer.toBinaryString(t).split("");
                int k = i * 4 + 3;
                for (int j = str.length - 1; j > 0; j--)
                {
                    dest[k] = Integer.parseInt(str[j]);
                    k--;
                }
            }
            return dest;
        }
    
        /** * 返回x的y次方 * * @param x * @param y * @return */
        public static int getXY(int x, int y)
        {
            int temp = x;
            if (y == 0)
                x = 1;
            for (int i = 2; i <= y; i++)
            {
                x *= temp;
            }
            return x;
        }
    
        /** * s位长度的二进制字符串 * * @param s * @return */
        public static String binary2Hex(String s)
        {
            int len = s.length();
            int result = 0;
            int k = 0;
            if (len > 4)
                return null;
            for (int i = len; i > 0; i--)
            {
                result += Integer.parseInt(s.substring(i - 1, i)) * getXY(2, k);
                k++;
            }
            switch (result)
            {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                    return "" + result;
                case 10:
                    return "A";
                case 11:
                    return "B";
                case 12:
                    return "C";
                case 13:
                    return "D";
                case 14:
                    return "E";
                case 15:
                    return "F";
                default:
                    return null;
            }
        }
    
        /** * 将int转换成Hex * * @param i * @return * @throws Exception */
        public static String int2Hex(int i)
        {
            switch (i)
            {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                    return "" + i;
                case 10:
                    return "A";
                case 11:
                    return "B";
                case 12:
                    return "C";
                case 13:
                    return "D";
                case 14:
                    return "E";
                case 15:
                    return "F";
                default:
                    return null;
            }
        }
    
        /** * 将二进制字符串转换成十六进制字符 * * @param s * @return */
        public static String binary2ASC(String s)
        {
            String str = "";
            int ii = 0;
            int len = s.length();
            // 不够4bit左补0
            if (len % 4 != 0)
            {
                while (ii < 4 - len % 4)
                {
                    s = "0" + s;
                }
            }
            for (int i = 0; i < len / 4; i++)
            {
                str += binary2Hex(s.substring(i * 4, i * 4 + 4));
            }
            return str;
        }
    
        /** * IP初始置换 * * @param source * @return */
        public static int[] changeIP(int[] source)
        {
            int[] dest = new int[64];
            for (int i = 0; i < 64; i++)
            {
                dest[i] = source[ip[i] - 1];
            }
            return dest;
        }
    
        /** * IP-1逆置 * * @param source * @return */
        public static int[] changeInverseIP(int[] source)
        {
            int[] dest = new int[64];
            for (int i = 0; i < 64; i++)
            {
                dest[i] = source[_ip[i] - 1];
            }
            return dest;
        }
    
        /** * 2bit扩展8bit * * @param source * @return */
        public static int[] expend(int[] source)
        {
            int[] ret = new int[48];
            int[] temp =
            { 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17, 16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25, 24, 25,
                    26, 27, 28, 29, 28, 29, 30, 31, 32, 1 };
            for (int i = 0; i < 48; i++)
            {
                ret[i] = source[temp[i] - 1];
            }
            return ret;
        }
    
        /** * 8bit压缩2bit * * @param source * (48bit) * @return R(32bit) B=E(R)⊕K，将48 位的B 分成8 个分组，B=B1B2B3B4B5B6B7B8 */
        public static int[] press(int[] source)
        {
            int[] ret = new int[32];
            int[][] temp = new int[8][6];
            int[][][] s =
            { s1, s2, s3, s4, s5, s6, s7, s8 };
            StringBuffer str = new StringBuffer();
            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    temp[i][j] = source[i * 6 + j];
                }
            }
            for (int i = 0; i < 8; i++)
            {
                // (16)
                int x = temp[i][0] * 2 + temp[i][5];
                // (2345)
                int y = temp[i][1] * 8 + temp[i][2] * 4 + temp[i][3] * 2 + temp[i][4];
                int val = s[i][x][y];
                String ch = int2Hex(val);
                // System.out.println("x=" + x + ",y=" + y + "-->" + ch);
                // String ch = Integer.toBinaryString(val);
                str.append(ch);
            }
            // System.out.println(str.toString());
            ret = string2Binary(str.toString());
            // printArr(ret);
            // 置换P
            ret = dataP(ret);
            return ret;
        }
    
        /** * 置换P(32bit) * * @param source * @return */
        public static int[] dataP(int[] source)
        {
            int[] dest = new int[32];
            int[] temp =
            { 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10, 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25 };
            int len = source.length;
            for (int i = 0; i < len; i++)
            {
                dest[i] = source[temp[i] - 1];
            }
            return dest;
        }
    
        /** * @param R * (2bit) * @param K * (48bit的轮子密 * @return 32bit */
        public static int[] f(int[] R, int[] K)
        {
            int[] dest = new int[32];
            int[] temp = new int[48];
            // 先将输入32bit扩展8bit
            int[] expendR = expend(R);// 48bit
            // 与轮子密钥进行异或运
            temp = diffOr(expendR, K);
            // 压缩2bit
            dest = press(temp);
            // printArr(temp);
            return dest;
        }
    
        /** * 两个等长的数组做异或 * * @param source1 * @param source2 * @return */
        public static int[] diffOr(int[] source1, int[] source2)
        {
            int len = source1.length;
            int[] dest = new int[len];
            for (int i = 0; i < len; i++)
            {
                dest[i] = source1[i] ^ source2[i];
            }
            return dest;
        }
    
        /** * DES加密--->对称密钥 D = Ln(32bit)+Rn(32bit) 经过16轮置 * * @param D * (16byte)明文 * @param K * (16byte)轮子密钥 * @return (16byte)密文 */
        public static String encryption(String D, String K)
        {
            String str = "";
            int[] temp = new int[64];
            int[] data = string2Binary(D);
            // printArr(data);
            // 第一步初始置
            data = changeIP(data);
            // printArr(data);
            int[][] left = new int[17][32];
            int[][] right = new int[17][32];
            for (int j = 0; j < 32; j++)
            {
                left[0][j] = data[j];
                right[0][j] = data[j + 32];
            }
            // printArr(left[0]);
            // printArr(right[0]);
            setKey(K);// sub key ok
            for (int i = 1; i < 17; i++)
            {
                // 获取(48bit)的轮子密
                int[] key = subKey[i - 1];
                // L1 = R0
                left[i] = right[i - 1];
                // R1 = L0 ^ f(R0,K1)
                int[] fTemp = f(right[i - 1], key);// 32bit
                right[i] = diffOr(left[i - 1], fTemp);
            }
            // 组合的时候，左右调换**************************************************
            for (int i = 0; i < 32; i++)
            {
                temp[i] = right[16][i];
                temp[32 + i] = left[16][i];
            }
            temp = changeInverseIP(temp);
            str = binary2ASC(intArr2Str(temp));
            return str;
        }
    
        /** * DES解密--->对称密钥 解密算法与加密算法基本相同，不同之处仅在于轮子密钥的使用顺序逆序，即解密的第1 轮子密钥为加密的6 轮子密钥，解密的 * 轮子密钥为加密的5 轮子密钥，…， 解密的第16 轮子密钥为加密的 轮子密钥 * * @param source * 密文 * @param key * 密钥 * @return */
        public static String discryption(String source, String key)
        {
            String str = "";
            int[] data = string2Binary(source);// 64bit
            // 第一步初始置
            data = changeIP(data);
            int[] left = new int[32];
            int[] right = new int[32];
            int[] tmp = new int[32];
            for (int j = 0; j < 32; j++)
            {
                left[j] = data[j];
                right[j] = data[j + 32];
            }
            setKey(key);// sub key ok
            for (int i = 16; i > 0; i--)
            {
                // 获取(48bit)的轮子密
                /** *******不同之处********* */
                int[] sKey = subKey[i - 1];
                tmp = left;
                // R1 = L0
                left = right;
                // L1 = R0 ^ f(L0,K1)
                int[] fTemp = f(right, sKey);// 32bit
                right = diffOr(tmp, fTemp);
            }
            // 组合的时候，左右调换**************************************************
            for (int i = 0; i < 32; i++)
            {
                data[i] = right[i];
                data[32 + i] = left[i];
            }
            data = changeInverseIP(data);
            for (int i = 0; i < data.length; i++)
            {
                str += data[i];
            }
            str = binary2ASC(str);
            return str;
        }
    
        /** * 单长密钥DES(16byte) * * @param source * @param key * @param type * 0:encrypt 1:discrypt * @return */
        public static String DES_1(String source, String key, int type)
        {
            if (source.length() != 16 || key.length() != 16)
                return null;
            if (type == 0)
            {
                return encryption(source, key);
            }
            if (type == 1)
            {
                return discryption(source, key);
            }
            return null;
        }
    
        /** * @param source * @param key * @param type * 0:encrypt 1:discrypt * @return */
        public static String DES_2(String source, String key, int type)
        {
            return null;
        }
    
        /** * 三重DES算法(双长密32byte)) 密钥K1和K2 1、先用K1加密明文 2、接K2对上的结果进行解 3、然后用K1对上的结果进行加 * * @param source * @param key * @param type * 0:encrypt 1:discrypt * @return */
        public static String DES_3(String source, String key, int type)
        {
            if (key.length() != 32 || source.length() != 16)
                return null;
            String temp = null;
            String K1 = key.substring(0, key.length() / 2);
            String K2 = key.substring(key.length() / 2);
            System.out.println("K1--->" + K1);
            System.out.println("K2--->" + K2);
            if (type == 0)
            {
                temp = encryption(source, K1);
                System.out.println("step1--->" + temp);
                temp = discryption(temp, K2);
                System.out.println("step2--->" + temp);
                return encryption(temp, K1);
            }
            if (type == 1)
            {
                temp = discryption(source, K1);
                temp = encryption(temp, K2);
                return discryption(temp, K1);
            }
            return null;
        }
    
        /** * **********************************48bit的轮子密钥的生成************************** * ******************************* */
        /** * 4bit的密钥转换成56bit * * @param source * @return */
        public static int[] keyPC_1(int[] source)
        {
            int[] dest = new int[56];
            int[] temp =
            { 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7,
                    62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4 };
            for (int i = 0; i < 56; i++)
            {
                dest[i] = source[temp[i] - 1];
            }
            return dest;
        }
    
        /** * 将密钥循环左移i * * @param source * 二进制密钥数 * @param i * 循环左移位数 * @return */
        public static int[] keyLeftMove(int[] source, int i)
        {
            int temp = 0;
            int len = source.length;
            int ls = LS[i];
            for (int k = 0; k < ls; k++)
            {
                temp = source[0];
                for (int j = 0; j < len - 1; j++)
                {
                    source[j] = source[j + 1];
                }
                source[len - 1] = temp;
            }
            return source;
        }
    
        /** * 6bit的密钥转换成48bit * * @param source * @return */
        public static int[] keyPC_2(int[] source)
        {
            int[] dest = new int[48];
            int[] temp =
            { 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44,
                    49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32 };
            for (int i = 0; i < 48; i++)
            {
                dest[i] = source[temp[i] - 1];
            }
            return dest;
        }
    
        /** * 获取轮子密钥(48bit) * * @param source * @return */
        public static void setKey(String source)
        {
            if (subKey.length > 0)
                subKey = new int[16][48];
            // 装换4bit
            int[] temp = string2Binary(source);
            // 6bit均分成两部分
            int[] left = new int[28];
            int[] right = new int[28];
            // 经过PC-14bit转换6bit
            int[] temp1 = new int[56];
            temp1 = keyPC_1(temp);
            // printArr(temp1);
            // 将经过转换的temp1均分成两部分
            for (int i = 0; i < 28; i++)
            {
                left[i] = temp1[i];
                right[i] = temp1[i + 28];
            }
            // 经过16次循环左移，然后PC-2置换
            for (int i = 0; i < 16; i++)
            {
                left = keyLeftMove(left, LS[i]);
                right = keyLeftMove(right, LS[i]);
                for (int j = 0; j < 28; j++)
                {
                    temp1[j] = left[j];
                    temp1[j + 28] = right[j];
                }
                // printArr(temp1);
                subKey[i] = keyPC_2(temp1);
            }
        }
    
        public static void printArr(int[] source)
        {
            int len = source.length;
            for (int i = 0; i < len; i++)
            {
                System.out.print(source[i]);
            }
            System.out.println();
        }
    
        /** * 将ASC字符串转16进制字符 * * @param asc * @return */
        public static String ASC_2_HEX(String asc)
        {
            StringBuffer hex = new StringBuffer();
            try
            {
                byte[] bs = asc.toUpperCase().getBytes("UTF-8");
                for (byte b : bs)
                {
                    hex.append(Integer.toHexString(new Byte(b).intValue()));
                }
            }
            catch (UnsupportedEncodingException e)
            {
                e.printStackTrace();
            }
            return hex.toString();
        }
    
        /** * 16进制的字符串转换成ASC的字符串 * 16进制的字符串压缩成BCD(30313233343536373839414243444546)-->(0123456789ABCDEF) * * @param hex * @return */
        public static String HEX_2_ASC(String hex)
        {
            String asc = null;
            int len = hex.length();
            byte[] bs = new byte[len / 2];
            for (int i = 0; i < len / 2; i++)
            {
                bs[i] = Byte.parseByte(hex.substring(i * 2, i * 2 + 2), 16);
            }
            try
            {
                asc = new String(bs, "UTF-8");
            }
            catch (UnsupportedEncodingException e)
            {
                e.printStackTrace();
            }
            return asc;
        }
    
        /** * 计算MAC(hex) ANSI-X9.9-MAC(16的整数不补) PBOC-DES-MAC(16的整数补8000000000000000) * 使用单倍长密钥DES算法 * * @param key * 密钥 (16byte) * @param vector * 初始向量0000000000000000 * @param data * 数据 * @return mac */
        public static String PBOC_DES_MAC(String key, String vector, String data, int type)
        {
            if (key.length() != 16)
            {
                return null;
            }
            if (type == ASC)
            {
                data = ASC_2_HEX(data);
            }
            int len = data.length();
            int arrLen = len / 16 + 1;
            String[] D = new String[arrLen];
            if (vector == null)
                vector = "0000000000000000";
            if (len % 16 == 0)
            {
                data += "8000000000000000";
            }
            else
            {
                data += "80";
                for (int i = 0; i < 15 - len % 16; i++)
                {
                    data += "00";
                }
            }
            for (int i = 0; i < arrLen; i++)
            {
                D[i] = data.substring(i * 16, i * 16 + 16);
                System.out.println("D[" + i + "]=" + D[i]);
            }
            // D0 Xor Vector
            String I = xOr(D[0], vector);
            String O = null;
            for (int i = 1; i < arrLen; i++)
            {
                System.out.println(i + "**************");
                System.out.println("I=" + I);
                O = DES_1(I, key, 0);
                System.out.println("O=" + O);
                I = xOr(D[i], O);
                System.out.println("I=" + I);
            }
            I = DES_1(I, key, 0);
            System.out.println("I=" + I);
            return I;
        }
    
        /** * 计算MAC(hex) PBOC_3DES_MAC(16的整数补8000000000000000) 前n-1组使用单长密钥DES * CBC算法（使用密钥是密钥的左8字节） 最后1组使用双长密钥3DES CBC算法（使用全部16字节密钥） * * @param key * 密钥 (32byte) * @param vector * 初始向量0000000000000000 * @param data * 数据 * @return mac */
        public static String PBOC_3DES_MAC(String key, String vector, String data, int type)
        {
            if (key.length() != 32)
            {
                return null;
            }
            if (type == ASC)
            {
                data = ASC_2_HEX(data);
            }
            int len = data.length();
            int arrLen = len / 16 + 1;
            String[] D = new String[arrLen];
            if (vector == null)
                vector = "0000000000000000";
            if (len % 16 == 0)
            {
                data += "8000000000000000";
            }
            else
            {
                data += "80";
                for (int i = 0; i < 15 - len % 16; i++)
                {
                    data += "00";
                }
            }
            for (int i = 0; i < arrLen; i++)
            {
                D[i] = data.substring(i * 16, i * 16 + 16);
                System.out.println("D[" + i + "]=" + D[i]);
            }
            // D0 Xor Vector
            String I = xOr(D[0], vector);
            String O = null;
            String kl = key.substring(0, 16);
            System.out.println("KL8:" + kl);
            for (int i = 1; i < arrLen; i++)
            {
                System.out.println(i + "**************");
                System.out.println("I=" + I);
                O = DES_1(I, kl, 0);
                System.out.println("O=" + O);
                I = xOr(D[i], O);
                System.out.println("I=" + I);
            }
            I = DES_3(I, key, 0);
            return I;
        }
    
        /** * 将s1和s2做异或，然后返回 * * @param s1 * @param s2 * @return */
        public static String xOr(String s1, String s2)
        {
            int[] iArr = diffOr(string2Binary(s1), string2Binary(s2));
            return binary2ASC(intArr2Str(iArr));
        }
    
        /** * 将int类型数组拼接成字符串 * * @param arr * @return */
        public static String intArr2Str(int[] arr)
        {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < arr.length; i++)
            {
                sb.append(arr[i]);
            }
            return sb.toString();
        }
    
        /** * 将data分散 * * @param data * 数据8字节 16个长度 * @param key * 密钥 * @param type * @return */
        public static String divData(String data, String key, int type)
        {
            String left = null;
            String right = null;
            if (type == HEX)
            {
                left = key.substring(0, 16);
                right = key.substring(16, 32);
            }
            if (type == ASC)
            {
                left = ASC_2_HEX(key.substring(0, 8));
                right = ASC_2_HEX(key.substring(8, 16));
            }
            // 加密
            data = DES_1(data, left, 0);
            // 解密
            data = DES_1(data, right, 1);
            // 加密
            data = DES_1(data, left, 0);
            return data;
        }
    
        /** * 取反(10001)--->(01110) * * @param source * 数据源 * @return */
        public static String reverse(String source)
        {
            int[] data = string2Binary(source);
            int j = 0;
            for (int i : data)
            {
                data[j++] = 1 - i;
            }
            return binary2ASC(intArr2Str(data));
        }
    
        /** * 主密钥需要经过两次分散获得IC卡中的子密钥 空圈的通讯类过程密钥使用这种密钥分散机制 * * @param issuerFlag * 发卡方标识符 * @param appNo * 应用序列号即卡号 * @param mpk * 主密钥 * @return */
        public static String getDPK(String issuerFlag, String appNo, String mpk)
        {
            // 第一次分散
            StringBuffer issuerMPK = new StringBuffer();
            // 获取Issuer MPK左半边
            issuerMPK.append(divData(issuerFlag, mpk, 0));
            // 获取Issuer MPK右半边
            issuerMPK.append(divData(reverse(issuerFlag), mpk, 0));
            // 第二次分散
            StringBuffer dpk = new StringBuffer();
            // 获取DPK左半边
            dpk.append(divData(appNo, issuerMPK.toString(), 0));
            // 获取DPK右半边
            dpk.append(divData(reverse(appNo), issuerMPK.toString(), 0));
            return dpk.toString();
        }
    
        /** * 主密钥需要经过一次分散获得的子密钥 空圈的交易类过程密钥使用这种密钥分散机制 * * @param mpk * 主密钥 * @return */
        public static String getDPK4Once(String data, String mpk)
        {
            // 第一次分散
            StringBuffer dpk = new StringBuffer();
            // 获取DPK左半边
            dpk.append(divData(data, mpk, 0));
            // 获取DPK右半边
            dpk.append(divData(reverse(data), mpk.toString(), 0));
            return dpk.toString();
        }
    
        /** * @Title: getHintKey 获取过程密钥 * @Description: TODO * @param: @param data 加密数据 * @param: @param key 密钥 * @param: @return * @return: String * @throws: */
        public static String getHintKey(String data, String key)
        {
            if (null == data || data.length() != 16)
                return null;
            if (null != key && key.length() > 16)
                key = key.substring(0, 16);
            if (null == key || key.length() != 16)
                return null;
            // 加密数据
            return encryption(data, key);
        }
    
        // 字符串转hex玛
        public static byte[] hexStr2Byte(String hex)
        {
            int len = (hex.length() / 2);
            byte[] result = new byte[len];
            char[] achar = hex.toCharArray();
            for (int i = 0; i < len; i++)
            {
                int pos = i * 2;
                result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
            }
            return result;
        }
    
        private static byte toByte(char c)
        {
            return mask[c];
        }
    
        static byte[] mask = new byte[128];
        private static final String Algorithm = "DESede"; // 定义 加密算法,可用
    
        // DES,DESede,Blowfish
        // keybyte为加密密钥，长度为24字节
        // src为被加密的数据缓冲区（源）
        public static byte[] encryptMode(byte[] keybyte, byte[] src)
        {
            try
            {
                // 生成密钥
                SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
                // 从原始密钥数据创建DESKeySpec对象
                // DESedeKeySpec dks = new DESKeySpec(key);
                // 加密
                Cipher c1 = Cipher.getInstance(Algorithm);
                c1.init(Cipher.ENCRYPT_MODE, deskey);
                return c1.doFinal(src);
            }
            catch (java.security.NoSuchAlgorithmException e1)
            {
                e1.printStackTrace();
            }
            catch (javax.crypto.NoSuchPaddingException e2)
            {
                e2.printStackTrace();
            }
            catch (Exception e3)
            {
                e3.printStackTrace();
            }
            return null;
        }
    
        public static String printHexString(String hint, byte[] b)
        {
            System.out.print(hint);
            String abc = "";
            for (int i = 0; i < b.length; i++)
            {
                String hex = Integer.toHexString(b[i] & 0xFF);
                if (hex.length() == 1)
                {
                    hex = '0' + hex;
                }
                System.out.print(hex.toUpperCase() + " ");
                abc = abc + hex;
            }
            System.out.println("");
            return abc.toUpperCase();
        }
    
        private static String hexString = "0123456789ABCDEFabcdef";
    
        /** * 将string(包括中文)转为hex * * @param str * @return */
        public static String encode(String str)
        {
            byte[] bytes = str.getBytes();
            StringBuilder sb = new StringBuilder(bytes.length * 2);
            // 转换hex编码
            for (byte b : bytes)
            {
                sb.append(Integer.toHexString(b + 0x800).substring(1));
            }
            str = sb.toString();
            return str;
        }
    
        /** * 把hex编码转换为string * * @param bytes * @return */
        public static String decode(String bytes)
        {
            bytes = bytes.toUpperCase();
            ByteArrayOutputStream baos = new ByteArrayOutputStream(bytes.length() / 2);
            // 将每2位16进制整数组装成一个字节
            for (int i = 0; i < bytes.length(); i += 2)
                baos.write((hexString.indexOf(bytes.charAt(i)) << 4 | hexString.indexOf(bytes.charAt(i + 1))));
            return new String(baos.toByteArray());
        }
    }

##### ByteUtil #####

public class ByteUtil
    {
    
        static byte[] mask = new byte[128];
    
        static
        {
            initMask();
        }
        static byte[] asciiMask = new byte[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    
        private static void initMask()
        { // init mask
            for (int i = 0; i <= 9; i++)
            {
                mask[i + 48] = (byte) i;
            }
            for (int i = 0; i <= 5; i++)
            {
                mask[i + 97] = (byte) (10 + i);
            }
            for (int i = 0; i <= 5; i++)
            {
                mask[i + 65] = (byte) (10 + i);
            }
        }
    
        public static int[] byte2Bitmap(int b)
        {
            int[] bitmap = new int[8];
            for (int i = 0; i < 8; i++)
            {
                bitmap[i] = ((b >> (8 - i - 1)) & 0x01);
            }
            return bitmap;
        }
    
        public static byte[] intToBCD(int n, int balen)
        {
            byte[] ret = new byte[balen];
            int tmp;
            for (int i = 1; i <= balen; i++)
            {
                tmp = n % 100;
                ret[balen - i] = (byte) (tmp / 10 * 16 + tmp % 10);
    
                n -= tmp;
                if (n == 0)
                {
                    break;
                }
                n /= 100;
            }
            return ret;
        }
    
        public static int bcdToInt(byte[] ba, int idx, int len)
        {
            int jinwei = len * 2;
            int ret = 0;
            int temp = 0;
            int pow;
            int posNum; // 正数
            for (int i = 0, n = len; i < n; i++)
            {
                pow = pow(10, (jinwei - 1));
                posNum = ba[idx + i] >= 0 ? ba[idx + i] : ba[idx + i] + 256;
                temp = (posNum / 16) * pow + posNum % 16 * pow / 10;
                ret += temp;
                jinwei -= 2;
            }
            return ret;
        }
    
        public static int pow(int x, int y)
        {
            int n = x;
            for (int i = 1; i < y; i++)
            {
                n *= x;
            }
            return n;
        }
    
        public static byte[] hexStr2Byte(String hex)
        {
            int len = (hex.length() / 2);
            byte[] result = new byte[len];
            char[] achar = hex.toCharArray();
            for (int i = 0; i < len; i++)
            {
                int pos = i * 2;
                result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
            }
            return result;
        }
    
        public static int revAsciiHexToInt(byte[] ah)
        {
            int ret = 0;
            for (int i = 0; i < ah.length / 2; i++)
            {
                int hex = (mask[ah[i * 2]] << 4) + (mask[ah[i * 2 + 1]]);
                ret += (hex << (8 * i));
            }
            return ret;
        }
    
        public static int revHexToInt(byte[] data, int off, int len)
        {
            int ret = 0;
            for (int i = 0; i < len; i++)
            {
                ret += (data[off + i] & 0xff) << (8 * i);
            }
    
            return ret;
        }
    
        public static int revAsciiHexToInt(byte[] ah, int off, int len)
        {
            int ret = 0;
            for (int i = 0, n = len / 2; i < n; i++)
            {
                int hex = (mask[ah[i * 2 + off]] << 4) + (mask[ah[i * 2 + off + 1]]);
                ret += (hex << (8 * i));
            }
            return ret;
        }
    
        public static byte[] intToRevAsciiHex(int value, int hexlen)
        {
            byte[] ret = new byte[hexlen * 2];
    
            for (int i = 0; i < hexlen; i++)
            {
                if (value > 0)
                {
                    ret[i * 2] = asciiMask[((value & 0xf0) >> 4)];
                    ret[i * 2 + 1] = asciiMask[(value & 0xf)];
                    value >>= 8;
                }
                else
                {
                    ret[i * 2] = '0';
                    ret[i * 2 + 1] = '0';
                }
            }
            return ret;
        }
    
        public static String intToRevHexString(int value, int hexlen)
        {
    
            byte[] ret = new byte[hexlen];
            for (int i = 0; i < hexlen; i++)
            {
                ret[i] = (byte) (value & 0xff);
                value >>= 8;
                if (value == 0)
                    break;
            }
            return hexToStr(ret);
        }
    
        public static byte[] intToAsciiHex(int value, int len)
        {
            byte[] ret = new byte[len * 2];
            for (int i = 0; i < len; i++)
            {
                ret[i * 2] = asciiMask[((value & 0xf0) >> 4)];
                ret[i * 2 + 1] = asciiMask[value & 0xf];
                value >>= 8;
            }
            return ret;
        }
    
        public static byte[] intToHex(int value, int len)
        {
            byte[] ret = new byte[len];
            for (int i = 0; i < len; i++)
            {
                ret[i] = (byte) ((value >> 8 * (len - i - 1)) & 0xff);
            }
            return ret;
        }
    
        public static byte[] intToRevHex(int value, int len)
        {
            byte[] ret = new byte[len];
            for (int i = 0; i < len; i++)
            {
                ret[i] = (byte) (value & 0xff);
                value >>= 8;
            }
            return ret;
        }
    
        public static int hexToInt(byte[] buf, int idx, int len)
        {
            int ret = 0;
    
            final int e = idx + len;
            for (int i = idx; i < e; ++i)
            {
                ret <<= 8;
                ret |= buf[i] & 0xFF;
            }
            return ret;
        }
    
        public static int hexToInt(byte[] buf)
        {
            return hexToInt(buf, 0, buf.length);
        }
    
        public static String hexToStr(byte[] buf)
        {
            return hexToStr(buf, 0, buf.length);
        }
    
        public static String hexToStr(byte[] buf, int idx, int len)
        {
            StringBuffer sb = new StringBuffer();
            int n;
            for (int i = 0; i < len; i++)
            {
                n = buf[i + idx] & 0xff;
                if (n < 0x10)
                {
                    sb.append("0");
                }
                sb.append(Integer.toHexString(n));
            }
    
            return sb.toString();
        }
    
        private static byte toByte(char c)
        {
            return mask[c];
        }
    
    
        public static String strToHex(String str)
        {
            try
            {
                byte[] bytes = str.getBytes("GBK");
                StringBuilder sb = new StringBuilder(bytes.length * 2);
                // 转换hex编码
                for (byte b : bytes)
                {
                    sb.append(Integer.toHexString(b + 0x800).substring(1));
                }
                return sb.toString();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            return null;
        }
    
        public static String toHex(byte b) {
            String result = Integer.toHexString(b & 0xFF);
            if (result.length() == 1) {
                result = '0' + result;
            }
            return result;
        }
    
    
    }

[CPU]: https://blog.csdn.net/lupengfei1009/article/details/53002341