java DES加密代码收藏

Des对称加密，是一种对称加密算法。

import java.security.Key;
import java.security.Security;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;

/**
 * DES 加密方法
 * 
 * @author silence
 * 
 */
public class HTest {
	private static String strDefaultKey = "national";
	private Cipher encryptCipher = null;
	private Cipher decryptCipher = null;

	/**
	 * 将byte数组转换为表示16进制值的字符串， 如：byte[]{8,18}转换为：0813， 和public static byte[]
	 * hexStr2ByteArr(String strIn) 互为可逆的转换过程
	 * 
	 * @param arrB
	 *            需要转换的byte数组
	 * @return 转换后的字符串
	 * @throws Exception
	 *             本方法不处理任何异常，所有异常全部抛出
	 */
	public static String byteArr2HexStr(byte[] arrB) {
		int iLen = arrB.length;
		// 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍
		StringBuffer sb = new StringBuffer(iLen * 2);
		for (int i = 0; i < iLen; i++) {
			int intTmp = arrB[i];
			// 把负数转换为正数
			while (intTmp < 0) {
				intTmp = intTmp + 256;
			}
			// 小于0F的数需要在前面补0
			if (intTmp < 16) {
				sb.append("0");
			}
			sb.append(Integer.toString(intTmp, 16));
		}
		return sb.toString();
	}

	/**
	 * 将表示16进制值的字符串转换为byte数组， 和public static String byteArr2HexStr(byte[] arrB)
	 * 互为可逆的转换过程
	 * 
	 * @param strIn
	 *            需要转换的字符串
	 * @return 转换后的byte数组
	 */
	public static byte[] hexStr2ByteArr(String strIn) {
		byte[] arrB = strIn.getBytes();
		int iLen = arrB.length;
		// 两个字符表示一个字节，所以字节数组长度是字符串长度除以2
		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;
	}

	/**
	 * 默认构造方法，使用默认密钥
	 * 
	 * @throws Exception
	 */
	public HTest() throws Exception {
		this(strDefaultKey);
	}

	/**
	 * 指定密钥构造方法
	 * 
	 * @param strKey
	 *            指定的密钥
	 * @throws Exception
	 */
	public HTest(String strKey) {
		Security.addProvider(new com.sun.crypto.provider.SunJCE());
		Key key;
		try {
			key = getKey(strKey.getBytes());
			encryptCipher = Cipher.getInstance("DES");
			encryptCipher.init(Cipher.ENCRYPT_MODE, key);
			decryptCipher = Cipher.getInstance("DES");
			decryptCipher.init(Cipher.DECRYPT_MODE, key);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 加密字节数组
	 */
	public byte[] encrypt(byte[] arrB) {
		byte[] s = null;
		try {
			s = encryptCipher.doFinal(arrB);
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return s;
	}

	/**
	 * 将启动码strIn加密，返回加密后的启动码
	 */
	public String encrypt(String strIn) {
		return byteArr2HexStr(encrypt(strIn.getBytes()));
	}

	/**
	 * 解密字节数组
	 */
	public byte[] decrypt(byte[] arrB) {
		byte[] s = null;
		try {
			s = decryptCipher.doFinal(arrB);
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}
		return s;
	}

	/**
	 * 解密 strIn
	 */
	public String decrypt(String strIn) {
		return new String(decrypt(hexStr2ByteArr(strIn)));
	}

	/**
	 * 从指定字符串生成密钥，密钥所需的字节数组长度为8位 不足8位时后面补0，超出8位只取前8位
	 * 
	 * @param arrBTmp
	 *            构成该字符串的字节数组
	 * @return 生成的密钥
	 * @throws java.lang.Exception
	 */
	private Key getKey(byte[] arrBTmp) {
		// 创建一个空的8位字节数组（默认值为0）
		byte[] arrB = new byte[8];
		// 将原始字节数组转换为8位
		for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
			arrB[i] = arrBTmp[i];
		}
		// 生成密钥
		Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");
		return key;
	}

	public static void main(String[] args) {
		try {
			String test = "理智";
			// 自定义密钥
			HTest des = new HTest("www"); 
			System.out.println("加密前的字符：" + test);
			System.out.println("加密后的字符：" + des.encrypt(test));
			System.out.println("解密后的字符：" + des.decrypt(des.encrypt(test)));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
};

import java.io.RandomAccessFile;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

public class DESUtil
{
  public static String strEncode;
  public static final int[] A = { 31, -42, 53, -64, 75, -86, 97, -108 };
  private static final String keyStr = "LONGTOP.COM.CDWEI";

  private static void saveFile(byte[] strcont, String filename)
    throws Exception
  {
    RandomAccessFile infile = null;
    try {
      infile = new RandomAccessFile(filename, "rw");
      infile.write(strcont);
    } catch (Exception e) {
      throw e;
    } finally {
      infile.close();
    }
  }

  private static byte[] readFile(String strfilename)
    throws Exception
  {
    byte[] filecontent = null;
    int i_size = 0;
    RandomAccessFile infile = null;
    try {
      infile = new RandomAccessFile(strfilename, "rw");
      i_size = (int)infile.length();
      filecontent = new byte[i_size];
      infile.read(filecontent, 0, i_size);
    } catch (Exception e) {
      throw e;
    } finally {
      infile.close();
    }
    return filecontent;
  }

  private static void getKeyFile()
    throws Exception
  {
    SecureRandom sr = new SecureRandom();

    KeyGenerator kg = KeyGenerator.getInstance("DES");
    kg.init(sr);

    SecretKey key = kg.generateKey();

    byte[] rawKeyData = key.getEncoded();
    saveFile(rawKeyData, "deskeyfile");
  }

  public static boolean isAsCII(char ch1, int iLength)
  {
    int iLevel = 0;
    int ch = 0;
    ch = ch1;
    do
    {
      ch += iLength;
      if (ch < 0)
        ch += 256;
      if (ch > 256)
        ch -= 256;
      iLevel++;
    }while ((ch < 33) || (ch > 126));
    temp.iLength = iLevel;
    temp.ch = String.valueOf(ch);
    return true;
  }

  public static boolean isAsCII_DeCode(char ch1, int iLength, char iFlag)
  {
    int ch = 0;
    ch = ch1;
    do
    {
      ch += iLength * Integer.parseInt(String.valueOf(iFlag));

      if (ch < 0)
        ch += 256;
      if (ch > 256)
        ch -= 256;
    }
    while ((ch < 0) || (ch > 256));
    temp.ch = String.valueOf(ch);
    return true;
  }

  public static String pwdEncode(String strsrc)
  {
    strsrc = strsrc.trim();
    StringBuffer strBufSrc = new StringBuffer("");
    StringBuffer strBufFlag = new StringBuffer("");

    if (strsrc.equals("")) {
      return "";
    }

    for (int i = 0; i < strsrc.length(); i++) {
      if (isAsCII(strsrc.charAt(i), A[i])) {
        strBufSrc.append(String.valueOf((char)Integer.parseInt(temp.ch)));
        strBufFlag.append(String.valueOf(temp.iLength));
      }
    }
    strEncode = strBufFlag.toString().trim();
    return strBufSrc.toString();
  }

  public static String pwdDecode(String strsrc, String strFlag)
  {
    strsrc = strsrc.trim();
    strFlag = strFlag.trim();
    StringBuffer strBuf = new StringBuffer("");
    int tmpvalue = 0;

    if (strsrc.equals("")) {
      return "";
    }
    if (strsrc.length() != strFlag.length()) {
      return "长度不一样，该串不能解码！";
    }

    for (int i = 0; i < strsrc.length(); i++) {
      tmpvalue = strsrc.charAt(i) - A[i] * Integer.parseInt(String.valueOf(strFlag.charAt(i)));
      if (tmpvalue > 0)
        tmpvalue %= 256;
      else if (tmpvalue < 0) {
        tmpvalue = 256 - Math.abs(tmpvalue) % 256;
      }
      strBuf.append(String.valueOf((char)tmpvalue));
    }
    return strBuf.toString();
  }

  public static byte[] encode(byte[] data)
    throws Exception
  {
    if ((data == null) || (data.length == 0)) {
      return data;
    }

    SecureRandom sr = new SecureRandom();

    byte[] rawKeyData = "LONGTOP.COM.CDWEI".getBytes();

    DESKeySpec dks = new DESKeySpec(rawKeyData);

    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    SecretKey key = keyFactory.generateSecret(dks);

    Cipher cipher = Cipher.getInstance("DES");

    cipher.init(1, key, sr);

    byte[] encryptedData = cipher.doFinal(data);

    return encryptedData;
  }

  public static byte[] decode(byte[] encryptedData)
    throws Exception
  {
    if ((encryptedData == null) || (encryptedData.length == 0)) {
      return encryptedData;
    }

    SecureRandom sr = new SecureRandom();

    byte[] rawKeyData = "LONGTOP.COM.CDWEI".getBytes();

    DESKeySpec dks = new DESKeySpec(rawKeyData);

    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    SecretKey key = keyFactory.generateSecret(dks);

    Cipher cipher = Cipher.getInstance("DES");

    cipher.init(2, key, sr);

    byte[] decryptedData = cipher.doFinal(encryptedData);

    return decryptedData;
  }
}