PBOC-DES-MAC 加密

package com.IBus.Servlet;

import java.security.spec.KeySpec;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

/**
 * DES加密、解密
 * @ClassName DES
 * @author 张月
 * @date 2013年8月8日
 */
public class DES{
    
     /**
      * DES加密
      * @param HexString  字符串（16位16进制字符串）
      * @param keyStr     密钥16个1
      * @throws Exception
      */
     public static byte[] SEncrypt_DES(byte[] HexString,byte[] keyStr) throws Exception{
             try {
                 byte[] theCph = new byte[8];
                    try {
                       byte[] theKey = null;
                       byte[] theMsg = null;
                       theMsg = HexString;
                       theKey = keyStr;
                       KeySpec ks = new DESKeySpec(theKey);
                       SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
                       SecretKey ky = kf.generateSecret(ks);
                       Cipher cf = Cipher.getInstance("DES/ECB/NoPadding");
                       cf.init(Cipher.ENCRYPT_MODE,ky);
                       theCph = cf.doFinal(theMsg);
//                       System.out.println("*************DES加密****************");
//                       System.out.println("密钥    : "+bytesToHex(keyStr));
//                       System.out.println("字符串: "+bytesToHex(theMsg));
//                       System.out.println("加密后: "+bytesToHex(theCph));
                    } catch (Exception e) {
                       e.printStackTrace();
                    }
                    return theCph;
            } catch (Exception e) {
                throw e;
            }
         }
     
//     //进行ECB模式的DES加密，已验证成功
//     public static void main(String[] args) throws Exception {
//         byte[] s = SEncrypt_DES(PBOCDESConvertUtil.hexStringToByte("0123456789ABCDEF"),PBOCDESConvertUtil.hexStringToByte("1111111111111111"));
//         System.out.println(s.length);
//    }
     
        /**
         * DES解密
         * 
         * @param hexStr  16位十六进制字符串
         * @param keyStr  密钥16个1
         * @param modeStr 解密模式:ECB
         * @throws Exception
         */
         public static byte[] SDecrypt_DES(byte[] hexStr,byte[] keyStr) throws Exception{
                 try {
                      String algorithm = "DES/ECB/NoPadding";
                      byte[] theCph = new byte[8];
                       byte[] theKey = null;
                       byte[] theMsg = null;
                       theMsg = hexStr;
                       theKey = keyStr;
                       KeySpec ks = new DESKeySpec(theKey);
                       SecretKeyFactory kf
                          = SecretKeyFactory.getInstance("DES");
                       SecretKey ky = kf.generateSecret(ks);
                       Cipher cf = Cipher.getInstance(algorithm);
                       cf.init(Cipher.DECRYPT_MODE,ky);
                       theCph = cf.doFinal(theMsg);
//                           System.out.println("*************DES解密****************");
//                           System.out.println("密钥    : "+bytesToHex(theKey));
//                           System.out.println("字符串: "+bytesToHex(theMsg));
//                           System.out.println("解密后: "+bytesToHex(theCph));
                       
                    return theCph; 
                 
                } catch (Exception e) {
                    throw e;
                }
         }
     
     public static byte[] hexToBytes(String str) {
         try {
             if (str==null) {
                  return null;
               } else if (str.length() < 2) {
                  return null;
               } else {
                  int len = str.length() / 2;
                  byte[] buffer = new byte[len];
                  for (int i=0; i<len; i++) {
                      buffer[i] = (byte) Integer.parseInt(
                         str.substring(i*2,i*2+2),16);
                  }
                  return buffer;
               }

        } catch (Exception e) {
            throw e;
        }
    }
    public static String bytesToHex(byte[] data) {
        try {
            if (data==null) {
                return null;
                 } else {
                  int len = data.length;
                  String str = "";
                  for (int i=0; i<len; i++) {
                   if ((data[i]&0xFF)<16) str = str + "0"
                             + java.lang.Integer.toHexString(data[i]&0xFF);
                   else str = str
                             + java.lang.Integer.toHexString(data[i]&0xFF);
                      }
                  return str.toUpperCase();
             }
        } catch (Exception e) {
            throw e;
        }
    }  
    
   
}

package com.IBus.Servlet;

//PBOCDES算法
public class PBOCDES {

    public static void main(String[] args) {
        //测试
//        String str= "182012121102335900010000000100000";
        String str= "000001000200000031323320150715181901";
//        String str= "303030303031303030323030303030303331333233333230313530373135313831393031";
        String result = Get_PBOC_DES_HEX(str,"D4A2A9F58CA33E75", "0000000000000000");
        System.out.println(result);
    }
    
    /*
     *  PBOCDES加密
     *  @param shuju:加密的数据的byte[]
     *  @param key:密钥 16位十六进制
     *  @param IV:初始向量，默认为0000000000000000
     */
    public static String Get_PBOC_DES_ASCII(byte[] shuju, String key, String IV)
    {
        String returntype = "";
        try
        {
             //----------------------------------------
             byte[] keyss = new byte[8];
             byte[] IVS = new byte[8];
             keyss = PBOCDESConvertUtil.hexStringToByte(key);
             IVS = PBOCDESConvertUtil.hexStringToByte(IV);
             //----------------------------------------
             byte[] keys = keyss;
             //数据内容字节数组
             String slshuju = PBOCDESConvertUtil.bytesToHexString(shuju);
             int TLen = 0;
             int DBz = 0;
             if (slshuju.length() % 16 != 0 || slshuju.length() % 16 == 0)
             {
                 TLen = (((int)(slshuju.length() / 16)) + 1) * 16;
                 DBz = (slshuju.length() / 16) + 1;
                 slshuju = slshuju + "8";
                 TLen = TLen - slshuju.length();
                 for (int i = 0; i < TLen; i++)
                 {
                     slshuju = slshuju + "0";
                 }
             }
             byte[] Zshuju = new byte[slshuju.length() / 2];
             Zshuju = PBOCDESConvertUtil.hexStringToByte(slshuju);
             
             byte[] D1 = new byte[8];
             byte[] D2 = new byte[8];
             byte[] I2 = new byte[8];
             byte[] I3 = new byte[8];
             byte[] bytTemp = new byte[8];
             byte[] bytTempX = new byte[8];
             //初始向量
             byte[] I0 = IVS;
             if (DBz >= 1)
             {
                 for (int i = 0; i < 8; i++)
                 {
                     D1[i] = Zshuju[i];
                 }
                 for (int i = 0; i < 8; i++)
                 {
                     bytTemp[i] = (byte)(I0[i] ^ D1[i]);
                 }
                 I2 = bytTemp;
                 bytTempX = DES.SEncrypt_DES(I2, keys);
             }
             if (DBz >= 2)
             {
                 for (int j = 2; j <= DBz; j++)
                 {
                     for (int i = (j - 1) * 8; i < j * 8; i++)
                     {
                         D2[i - (j - 1) * 8] = Zshuju[i];
                     }
                     for (int i = 0; i < 8; i++)
                     {
                         bytTemp[i] =  (byte)(bytTempX[i] ^ D2[i]);
                     }
                     I3 = bytTemp;
                     bytTempX = DES.SEncrypt_DES(I3, keys);
                 }
             }
             
             returntype = PBOCDESConvertUtil.bytesToHexString(bytTempX);
             
        }catch(Exception e)
        {
            returntype = "";
        }
        return returntype;
    }
    
    /*
     *  PBOCDES加密
     *  @param shuju:加密的数据的byte[]
     *  @param key:密钥 16位十六进制
     *  @param IV:初始向量，默认为0000000000000000
     */
    public static String Get_PBOC_DES_HEX(String slshuju, String key, String IV)
    {
        String returntype = "";
        try
        {
            //----------------------------------------
            byte[] keyss = new byte[8];
            byte[] IVS = new byte[8];
            keyss = PBOCDESConvertUtil.hexStringToByte(key);
            IVS = PBOCDESConvertUtil.hexStringToByte(IV);
            //----------------------------------------
            byte[] keys = keyss;
            int TLen = 0;
            int DBz = 0;
            if (slshuju.length() % 16 != 0 || slshuju.length() % 16 == 0)
            {
                TLen = (((int)(slshuju.length() / 16)) + 1) * 16;
                DBz = (slshuju.length() / 16) + 1;
                slshuju = slshuju + "8";
                TLen = TLen - slshuju.length();
                for (int i = 0; i < TLen; i++)
                {
                    slshuju = slshuju + "0";
                }
            }
            byte[] Zshuju = new byte[slshuju.length() / 2];
            Zshuju = PBOCDESConvertUtil.hexStringToByte(slshuju);
            
            byte[] D1 = new byte[8];
            byte[] D2 = new byte[8];
            byte[] I2 = new byte[8];
            byte[] I3 = new byte[8];
            byte[] bytTemp = new byte[8];
            byte[] bytTempX = new byte[8];
            //初始向量
            byte[] I0 = IVS;
            if (DBz >= 1)
            {
                for (int i = 0; i < 8; i++)
                {
                    D1[i] = Zshuju[i];
                }
                for (int i = 0; i < 8; i++)
                {
                    bytTemp[i] = (byte)(I0[i] ^ D1[i]);
                }
                I2 = bytTemp;
                bytTempX = DES.SEncrypt_DES(I2, keys);
            }
            if (DBz >= 2)
            {
                for (int j = 2; j <= DBz; j++)
                {
                    for (int i = (j - 1) * 8; i < j * 8; i++)
                    {
                        D2[i - (j - 1) * 8] = Zshuju[i];
                    }
                    for (int i = 0; i < 8; i++)
                    {
                        bytTemp[i] =  (byte)(bytTempX[i] ^ D2[i]);
                    }
                    I3 = bytTemp;
                    bytTempX = DES.SEncrypt_DES(I3, keys);
                }
            }
            
            returntype = PBOCDESConvertUtil.bytesToHexString(bytTempX);
            
        }catch(Exception e)
        {
            returntype = "";
        }
        return returntype;
    }
    
}

package com.IBus.Servlet;

import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.io.Serializable;  
import java.security.MessageDigest;  
import java.security.NoSuchAlgorithmException;  

//帮助类
public class PBOCDESConvertUtil {
         public final static char[] BToA = "0123456789abcdef".toCharArray();  
      
        private PBOCDESConvertUtil() {  
      
        }  
      
        /** 
         * 把16进制字符串转换成字节数组 
         *  
         * @param hex 
         * @return 
         */  
        public static byte[] hexStringToByte(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) {  
            byte b = (byte) "0123456789ABCDEF".indexOf(c);  
            return b;  
        }  
      
        /** 
         * 把字节数组转换成16进制字符串 
         *  
         * @param bArray 
         * @return 
         */  
        public static final String bytesToHexString(byte[] bArray) {  
            if(bArray == null )  
            {  
                return "";  
            }  
            StringBuffer sb = new StringBuffer(bArray.length);  
            String sTemp;  
            for (int i = 0; i < bArray.length; i++) {  
                sTemp = Integer.toHexString(0xFF & bArray[i]);  
                if (sTemp.length() < 2)  
                    sb.append(0);  
                sb.append(sTemp.toUpperCase());  
            }  
            return sb.toString();  
        }  
      
        /** 
         * 把字节数组转换为对象 
         *  
         * @param bytes 
         * @return 
         * @throws IOException 
         * @throws ClassNotFoundException 
         */  
        public static final Object bytesToObject(byte[] bytes) throws IOException,  
                ClassNotFoundException {  
            ByteArrayInputStream in = new ByteArrayInputStream(bytes);  
            ObjectInputStream oi = new ObjectInputStream(in);  
            Object o = oi.readObject();  
            oi.close();  
            return o;  
        }  
      
        /** 
         * 把可序列化对象转换成字节数组 
         *  
         * @param s 
         * @return 
         * @throws IOException 
         */  
        public static final byte[] objectToBytes(Serializable s) throws IOException {  
            ByteArrayOutputStream out = new ByteArrayOutputStream();  
            ObjectOutputStream ot = new ObjectOutputStream(out);  
            ot.writeObject(s);  
            ot.flush();  
            ot.close();  
            return out.toByteArray();  
        }  
      
        public static final String objectToHexString(Serializable s)  
                throws IOException {  
            return bytesToHexString(objectToBytes(s));  
        }  
      
        public static final Object hexStringToObject(String hex)  
                throws IOException, ClassNotFoundException {  
            return bytesToObject(hexStringToByte(hex));  
        }  
      
        /** 
         * @函数功能: BCD码转为10进制串(阿拉伯数据) 
         * @输入参数: BCD码 
         * @输出结果: 10进制串 
         */  
        public static String bcd2Str(byte[] bytes) {  
            StringBuffer temp = new StringBuffer(bytes.length * 2);  
      
            for (int i = 0; i < bytes.length; i++) {  
                temp.append((byte) ((bytes[i] & 0xf0) >>> 4));  
                temp.append((byte) (bytes[i] & 0x0f));  
            }  
            return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp  
                    .toString().substring(1) : temp.toString();  
        }  
      
        /** 
         * @函数功能: 10进制串转为BCD码 
         * @输入参数: 10进制串 
         * @输出结果: BCD码 
         */  
        public static byte[] str2Bcd(String asc) {  
            int len = asc.length();  
            int mod = len % 2;  
      
            if (mod != 0) {  
                asc = "0" + asc;  
                len = asc.length();  
            }  
      
            byte abt[] = new byte[len];  
            if (len >= 2) {  
                len = len / 2;  
            }  
      
            byte bbt[] = new byte[len];  
            abt = asc.getBytes();  
            int j, k;  
      
            for (int p = 0; p < asc.length() / 2; p++) {  
                if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {  
                    j = abt[2 * p] - '0';  
                } else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {  
                    j = abt[2 * p] - 'a' + 0x0a;  
                } else {  
                    j = abt[2 * p] - 'A' + 0x0a;  
                }  
      
                if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {  
                    k = abt[2 * p + 1] - '0';  
                } else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {  
                    k = abt[2 * p + 1] - 'a' + 0x0a;  
                } else {  
                    k = abt[2 * p + 1] - 'A' + 0x0a;  
                }  
      
                int a = (j << 4) + k;  
                byte b = (byte) a;  
                bbt[p] = b;  
            }  
            return bbt;  
        }  
      
        public static String BCD2ASC(byte[] bytes) {  
            StringBuffer temp = new StringBuffer(bytes.length * 2);  
      
            for (int i = 0; i < bytes.length; i++) {  
                int h = ((bytes[i] & 0xf0) >>> 4);  
                int l = (bytes[i] & 0x0f);  
                temp.append(BToA[h]).append(BToA[l]);  
            }  
            return temp.toString();  
        }  
      
        /** 
         * 两字符数组异或 
         */  
        public static byte[] byteArrXor(byte[] arr1, byte[] arr2, int len){  
            byte[] dest = new byte[len];  
              
            if((arr1.length < len) || (arr2.length < len)){  
                return null;  
            }  
              
            for(int i = 0;i < len;i++){  
                dest[i] = (byte)(arr1[i] ^ arr2[i]);  
            }  
              
            return dest;  
        }  
          
      
        /** 
         * MD5加密字符串，返回加密后的16进制字符串 
         * @param origin 
         * @return 
         */  
        public static String MD5EncodeToHex(String origin) {  
            return bytesToHexString(MD5Encode(origin));  
        }  
      
        /** 
         * MD5加密字符串，返回加密后的字节数组 
         *  
         * @param origin 
         * @return 
         */  
        public static byte[] MD5Encode(String origin) {  
            return MD5Encode(origin.getBytes());  
        }  
      
        /** 
         * MD5加密字节数组，返回加密后的字节数组 
         *  
         * @param bytes 
         * @return 
         */  
        public static byte[] MD5Encode(byte[] bytes) {  
            MessageDigest md = null;  
            try {  
                md = MessageDigest.getInstance("MD5");  
                return md.digest(bytes);  
            } catch (NoSuchAlgorithmException e) {  
                e.printStackTrace();  
                return new byte[0];  
            }  
      
        }  
}