Java 10进制byte数组与16进制byte数组互转 及 在DES加解密中的使用

一、10进制byte数组与16进制byte数组互转

1. 10进制byte数组转成16进制byte数组

    Java中10进制byte用二进制表示占用8位，16进制的每个字符需要用4位二进制位来表示，则将每一个10进制

字节的高4位、低4位分别进行处理，对应到16进制字符（通过与0xf0或0x0f进行&位运算将4位转成0~15范围内

的一个数,与这个数对应的有一个16进制字符），取该字符对应的字节，最终组成一个16进制字节数组。

2. 10进制byte数组转成16进制byte数组


      处理过程与上面的正好相反。16进制的两个字节对应到10进制字节的一个字节，则将相邻两个16进制字节的

第一个字节对应到16进制数字并向左移动4位（作为10进制字节的高4位）、第二个字节对应到16进制数字，并

将两者进行|位运算，结果作为一个10进制字节，最终组成一个10进制字节数组

代码实现如下：

/**
*
* ClassName: HexUtil <br/>
* Function: 16进制字节数组与10进制字节数组转换工具类 <br/>
* date: 2017年1月23日 下午10:58:17 <br/>
*
* @author JohnFNash
* @version
* @since JDK 1.6
*/
public class HexUtil {

/** 16进制中的字符集 */
private static final String HEX_CHAR = "0123456789ABCDEF";

/** 16进制中的字符集对应的字节数组 */
private static final byte[] HEX_STRING_BYTE = HEX_CHAR.getBytes();

/**
* 10进制字节数组转换为16进制字节数组
*
* byte用二进制表示占用8位，16进制的每个字符需要用4位二进制位来表示，则可以把每个byte
* 转换成两个相应的16进制字符，即把byte的高4位和低4位分别转换成相应的16进制字符，再取对应16进制字符的字节
*
* @param b 10进制字节数组
* @return 16进制字节数组
*/
public static byte[] byte2hex(byte[] b) {
int length = b.length;
byte[] b2 = new byte[length << 1];
int pos;
for(int i=0; i<length; i++) {
pos = 2*i;
b2[pos] = HEX_STRING_BYTE[(b[i] & 0xf0) >> 4];
b2[pos+1] = HEX_STRING_BYTE[b[i] & 0x0f];
}
return b2;
}

/**
* 16进制字节数组转换为10进制字节数组
*
* 两个16进制字节对应一个10进制字节，则将第一个16进制字节对应成16进制字符表中的位置(0~15)并向左移动4位，
* 再与第二个16进制字节对应成16进制字符表中的位置(0~15)进行或运算，则得到对应的10进制字节
* @param b 10进制字节数组
* @return 16进制字节数组
*/
public static byte[] hex2byte(byte[] b) {
if(b.length%2 != 0) {
throw new IllegalArgumentException("byte array length is not even!");
}

int length = b.length >> 1;
byte[] b2 = new byte[length];
int pos;
for(int i=0; i<length; i++) {
pos = i << 1;
b2[i] = (byte) (HEX_CHAR.indexOf( b[pos] ) << 4 | HEX_CHAR.indexOf( b[pos+1] ) );
}
return b2;
}

/**
* 将16进制字节数组转成10进制字符串
* @param b 16进制字节数组
* @return 10进制字符串
*/
public static String hex2Str(byte[] b) {
return new String(hex2byte(b));
}

/**
* 将10进制字节数组转成16进制字符串
* @param b 10进制字节数组
* @return 16进制字符串
*/
public static String byte2HexStr(byte[] b) {
return Integer.toHexString(Integer.parseInt(new String(b)));
}

public static void main(String[] args) {
System.out.println(hex2Str(byte2hex("60".getBytes())));
System.out.println(byte2HexStr("60".getBytes()));
}

}

二、DES加解密
使用Java提供的工具类实现DES加解密

1. DES加密

      先使用java提供的工具类加密得到10进制字节数组，再将10进制字节数组转成16进制字节数组（使用上面

进制转换的工具类），最后将16进制字节数组转成16进制字符串。

2. DES解密

       先将16进制字符串对应的字节数组转成10进制字节数组，再将10进制字节数组使用java提供的工具类进行

解密，最后将解密得到的字节数组转成10进制字符串。

代码实现如下：

import java.security.SecureRandom;

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

/**
*
* ClassName: EncryptUtil <br/>
* Function: 加解密工具类 <br/>
* date: 2017年1月22日 下午9:12:22 <br/>
*
* @author JohnFNash
* @version
* @since JDK 1.6
*/
public class EncryptUtil {

/** 加密、解密key. */
private static final String PASSWORD_CRYPT_KEY = "johnfnash";

/** 加密、解密key对应字节数组. */
private static final byte[] PASSWORD_CRYPT_KEY_BYTE = PASSWORD_CRYPT_KEY.getBytes();

/** 加密算法,可用 DES,DESede,Blowfish. */
private final static String ALGORITHM = "DES";

/**
* 用DES对数据进行加密(先加密得到10进制字节数组，再将10进制字节数组转成16进制字节数组，最后将16进制字节数组转成16进制字符串)
* @param data 待加密数据
* @return 加密后的数据
* @throws Exception
*/
public final static String encrypt(String data) throws Exception {
return new String(HexUtil.byte2hex(encrypt(data.getBytes(), PASSWORD_CRYPT_KEY_BYTE)));
}

/**
* 用指定的key对数据进行DES加密.
* @param data 待加密的数据
* @param key DES加密的key
* @return 返回DES加密后的数据
* @throws Exception
*/
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
return operate(data, key, Cipher.ENCRYPT_MODE);
}

/**
* 用DES对数据进行解密(先将16进制字符串对应的字节数组转成10进制字节数组，再将10进制字节数组进行解密，最后将解密得到的字节数组转成10进制字符串)
* @param data 加密数据
* @return 解密后的数据
* @throws Exception
*/
public final static String decrypt(String data) throws Exception {
return new String(decrypt(HexUtil.hex2byte(data.getBytes()), PASSWORD_CRYPT_KEY_BYTE));
}

/**
* 用指定的key对数据进行DES解密
* @param data 带解密的数据
* @param key DES解密的key
* @return 解密后的数据
* @throws Exception
*/
private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
return operate(data, key, Cipher.DECRYPT_MODE);
}

/**
* 加密/解密操作
* @param data 待加密/解密数据
* @param key 加密/解密的key
* @param opMode 操作模式，Cipher.ENCRYPT_MODE(加密)/Cipher.DECRYPT_MODE(解密)
* @return 加密/解密的结果
* @throws Exception
*/
private static byte[] operate(byte[] data, byte[]key, int opMode) throws Exception {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks =  new DESKeySpec(key);
// 创建一个密钥工厂，然后用它把DESKeySpec转换成一个SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
SecretKey secretKey = keyFactory.generateSecret(dks);
// Cipher对象实际完成加密/解密操作
Cipher cipher = Cipher.getInstance(ALGORITHM);
// 用密钥初始化Cipher对象
cipher.init(opMode, secretKey, sr);
// 获取数据并加密/解密
return cipher.doFinal(data);
}

public static void main(String[] args) throws Exception {
String user = "root";
System.out.println("加密后的用户名: " + encrypt(user));
System.out.println("解密后的用户名: " + decrypt(encrypt(user)));
}

}

参考文章：

http://aub.iteye.com/blog/1129228

http://www.blogjava.net/amigoxie/archive/2007/07/31/133544.html

http://www.cnblogs.com/freeliver54/archive/2012/07/30/2615149.html