DES 加密算法

在项目中，会经常用到数据的加密处理，对敏感的数据处理。我在项目中用到了记录用户名和密码的功能。在做远程登陆时使用。

DES 加密，现在还没有使用加密机。 直接上代码了。

DES 加密接口

package com.hkrt.des;

public interface Encrypt {
	/**
	 * DES加密
	 * @param key 是十六进制
	 * @param src ASCII值
	 * @return ASCII 值 会有不可见字符 通常把加密后的数据转成十六进制
	 * @throws Exception
	 */
	public byte[] DesEncryptByte2(String key, byte [] src)throws Exception;//
	/**
	 * DES解密
	 * @param key 是十六进制
	 * @param src 是十六进制
	 * @return 
	 * @throws Exception
	 */
	public String DesDecrypt(String key, String src)throws Exception;//
}

DES 加密接口实现

package com.hkrt.des;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;


public class Des implements Encrypt {
	private static final String DES = "DES"; // 定义 加密算法
	private static final String CFB = "DES/ECB/NoPadding"; // 

	// DES解密
	public String DesDecrypt(String key, String szSrc) throws Exception {
		String str = "";

		if (key.length() != 16) {
			throw new Exception("DES密钥长度必须为十六进制的16字节");
		}
		byte[] srcBytes = DESdecryptMode(hexStr2ByteArr(key), hexStr2ByteArr(szSrc));
		
		byte[] srcBytesEnd = srcBytes;
		str = new String(srcBytesEnd);
		return str;
	}

	
	// DES解密方法
	public static byte[] DESdecryptMode(byte[] keybyte, byte[] src) {
		try {
			// 生成密钥
			SecretKey deskey = new SecretKeySpec(keybyte, DES);

			// 解密
			Cipher c1 = Cipher.getInstance(CFB);
			c1.init(Cipher.DECRYPT_MODE, deskey);
			return c1.doFinal(src);
		} catch (java.security.NoSuchAlgorithmException e1) {
			e1.printStackTrace();
		} catch (javax.crypto.NoSuchPaddingException e2) {
			e2.printStackTrace();
		} catch (java.lang.Exception e3) {
			e3.printStackTrace();
		}
		return null;
	}
	
	//将十六进制字符串转换成原始字节数组
	public static byte[] hexStr2ByteArr(String strIn) throws Exception {
		System.out.println("---"+strIn);
		   byte[] arrB = strIn.getBytes();
		   int iLen = arrB.length;

		   byte[] arrOut = new byte[iLen / 2];
		   for (int i = 0; i < iLen; i = i + 2) {
		    String strTmp = new String(arrB, i, 2);
		    arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
		   // System.out.println(arrOut[i/2]);
		   }
		   return arrOut;
		   
	}
	
	// DES加密 返回byte[]
	public byte[] DesEncryptByte2(String key, byte [] szSrc) throws Exception {
		if(szSrc.length %8 != 0){
			throw new Exception("数据体的长度必须为8的倍数");
		}
		if (key.length() != 16) {
			throw new Exception("DES密钥长度必须为十六进制的16字节");
		}
		byte[] encoded = DESencryptMode(hexStr2ByteArr(key), szSrc);
		
		return encoded;

	}
	// DES加密方法
	public byte[] DESencryptMode(byte[] keybyte, byte[] src) {
		try {

			// 生成密钥
			SecretKey deskey = new SecretKeySpec(keybyte, DES);
			

			// 加密
			Cipher c1 = Cipher.getInstance(CFB);
			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 (java.lang.Exception e3) {
			e3.printStackTrace();
		}
		return null;
	}
	

	
	
}

DesUtil 工具类

package com.hkrt.des;

import java.util.ArrayList;

public class DesUtil {
	/** 右补null */
	public static byte[] fillByte(byte[] bRecv) {
		int iLen;
		iLen = (bRecv.length) % 8;
		byte[] bSend;
		if (iLen != 0) {
			iLen = 8 - iLen;
			byte[] bSpace = new byte[iLen];
			bSend = new byte[bRecv.length + iLen];
			System.arraycopy(bRecv, 0, bSend, 0, bRecv.length);
			for (int i = 0; i < iLen; i++) {
				// 不足位数补空格
				bSpace[i] = (byte) 0;
			}
			System.arraycopy(bSpace, 0, bSend, bRecv.length, bSpace.length);
		} else {
			bSend = new byte[bRecv.length];
			System.arraycopy(bRecv, 0, bSend, 0, bRecv.length);
		}

		return bSend;
	}

	/** 把ASCII 转成十六进制 */
	public static String printHexString(byte[] b) {
		String result = "";
		for (int i = 0; i < b.length; i++) {
			String hex = Integer.toHexString(b[i] & 0xFF);
			if (hex.length() == 1) {
				hex = '0' + hex;
			}
			result = result + hex.toUpperCase();
		}
		return result;
	}

	/** 将十六进制字符串转换成原始字节数组 */
	public static byte[] hexStr2ByteArr(String strIn) throws Exception {
		byte[] arrB = strIn.getBytes();
		int iLen = arrB.length;

		byte[] arrOut = new byte[iLen / 2];
		for (int i = 0; i < iLen; i = i + 2) {
			String strTmp = new String(arrB, i, 2);
			arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
		}
		return arrOut;

	}

	/*** 去除不可见字符( byte 是0的不可见字符) */
	public static byte[] removeNoSeeChar(byte[] srcBytes) {
		ArrayList<Byte> listArr = new ArrayList<Byte>();
		for (int i = 0; i < srcBytes.length; i++) {
			listArr.add(srcBytes[i]);
		}
		lableB: for (int j = listArr.size() - 1; j >= 0; j--) {
			if (listArr.get(j) == 0) {
				listArr.remove(listArr.get(j));
			} else {
				// break;
				break lableB;
			}
		}
		byte[] bs = new byte[listArr.size()];
		for (int k = 0; k < listArr.size(); k++) {
			bs[k] = listArr.get(k).byteValue();
		}
		return bs;
	}

}

工厂类：

package com.hkrt.des;

public class DesFactory {
	public static Encrypt getInstance(){
		return new Des();
	}

}

测试结果：

package com.hkrt.des;


public class DesTest {
	public static void main(String[] args) {
		String srcStr="456789你";
		System.out.println("加密结果"+jiaMi(srcStr));
		System.out.println("解密结果"+jieMi("DD543BEBCB344F9B"));
	}
	/**
	 * @param srcStr 原始数据
	 * @return 十六进制数据
	 */
	private static String jiaMi(String srcStr){
		String keyStr="123456";
		String key = DesUtil.printHexString(DesUtil.fillByte(keyStr.getBytes()));//给key 补位 并转成十六进制
		byte[] src = DesUtil.fillByte(srcStr.getBytes());//给src 补位
		byte[]  result=null;
		try {
			result = DesFactory.getInstance().DesEncryptByte2(key, src);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return DesUtil.printHexString(result);
	}
	/**
	 * @param srcStr 十六进制
	 * @return 真实数据
	 */
	private static String jieMi(String srcStr){
		String keyStr="123456";
		String key = DesUtil.printHexString(DesUtil.fillByte(keyStr.getBytes()));//给key 补位 并转成十六进制
		String result =null;
		try {
			result = DesFactory.getInstance().DesDecrypt(key, srcStr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

}