采用DES加密解密实现接口的通信加密认证

DES全称Data Encryption Standard，是一种使用密匙加密的块算法。现在认为是一种不安全的加密算法，因为现在已经有用穷举法攻破DES密码的报道了。尽管如此，该加密算法还是运用非常普遍，是一种标准的加密算法。3DES是DES的加强版本。

方式一：DES加密后把二进制字节转化成十六进制字符。

package com.zzstxx.des.utils;

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

/**
 * DES加密介绍 DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，
 * 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，
 * 24小时内即可被破解。虽然如此，在某些简单应用中，我们还是可以使用DES加密算法，本文简单讲解DES的JAVA实现 。
 * 注意：DES加密和解密过程中，密钥长度都必须是8的倍数
 */
public class Des {

	/**
	 * 加密
	 * 
	 * @param data 要加密的的二进制字节内容
	 * @param sKey 秘钥
	 * @return 二进制加密后的数据
	 */
	public static byte[] encrypt(byte[] data, String sKey) {
		try {
			byte[] key = sKey.getBytes();
			// 初始化向量
			DESKeySpec desKey = new DESKeySpec(key);
			// 创建一个密匙工厂，然后用它把DESKeySpec转换成securekey
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
			SecretKey securekey = keyFactory.generateSecret(desKey);
			// Cipher对象实际完成加密操作
			Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
			// 用密匙初始化Cipher对象
			cipher.init(Cipher.ENCRYPT_MODE, securekey);
			// 现在，获取数据并加密
			// 正式执行加密操作
			return cipher.doFinal(data);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 解密
	 * 
	 * @param src 要解密的的二进制字节内容
	 * @param sKey 秘钥
	 * @return
	 * @throws Exception
	 */
	public static byte[] decrypt(byte[] src, String sKey) throws Exception {
		byte[] key = sKey.getBytes();
		// 初始化向量
		// 创建一个DESKeySpec对象
		DESKeySpec desKey = new DESKeySpec(key);
		// 创建一个密匙工厂
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
		// 将DESKeySpec对象转换成SecretKey对象
		SecretKey securekey = keyFactory.generateSecret(desKey);
		// Cipher对象实际完成解密操作
		Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
		// 用密匙初始化Cipher对象
		cipher.init(Cipher.DECRYPT_MODE, securekey);
		// 真正开始解密操作
		return cipher.doFinal(src);
	}

	/**
	 * 将二进制转换成16进制
	 * 
	 * @param buf
	 * @return
	 */
	public static String parseByte2HexStr(byte buf[]) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < buf.length; i++) {
			String hex = Integer.toHexString(buf[i] & 0xFF);
			if (hex.length() == 1) {
				hex = '0' + hex;
			}
			sb.append(hex.toUpperCase());
		}
		return sb.toString();
	}

	/**
	 * 将16进制转换为二进制
	 * 
	 * @param hexStr
	 * @return
	 */
	public static byte[] parseHexStr2Byte(String hexStr) {
		if (hexStr.length() < 1)
			return null;
		byte[] result = new byte[hexStr.length() / 2];
		for (int i = 0; i < hexStr.length() / 2; i++) {
			int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
			int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
					16);
			result[i] = (byte) (high * 16 + low);
		}
		return result;
	}
}

 

package com.zzstxx.des.utils;

import java.nio.charset.Charset;

public class DesUtil {

	/**
	 * 加密
	 * 
	 * @param srcStr
	 * @param charset
	 * @param sKey
	 * @return
	 */
	public static String encrypt(String srcStr, Charset charset, String sKey) {
		byte[] src = srcStr.getBytes(charset);
		byte[] buf = Des.encrypt(src, sKey);
		return Des.parseByte2HexStr(buf);
	}

	/**
	 * 解密
	 * 
	 * @param hexStr
	 * @param sKey
	 * @return
	 * @throws Exception
	 */
	public static String decrypt(String hexStr, Charset charset, String sKey)
			throws Exception {
		byte[] src = Des.parseHexStr2Byte(hexStr);
		byte[] buf = Des.decrypt(src, sKey);
		return new String(buf, charset);
	}
	
	public static void main(String[] args) {
		String SKEY = "AAAAAAAA";
		Charset CHARSET = Charset.forName("UTF-8");
        String encryptResult = DesUtil.encrypt("testId=5b714cf6c203d2cac578c72f&timestamp=1534153697365", CHARSET, SKEY);
        System.out.println("加密后的字符串："+encryptResult);
        String decryResult = "";
        try {
            decryResult = DesUtil.decrypt(encryptResult, CHARSET, SKEY);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        System.out.println("解密后的字符串："+decryResult);
	}
}

 方式二：DES加密后把二进制字节经过base64加密后作为结果。

package com.zzstxx.des.test;

import java.security.SecureRandom;

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

public class DESUtil {

	/*
	 * 密码，长度要是8的倍数 注意此处为简单密码 简单应用
	 * 要求不高时可用此密码DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，
	 * 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力， 24小时内即可被破解。
	 */
	private static String password = "9588888888880288";

	// 测试
	public static void main(String args[]) {
		// 待加密内容
		String str = "testId=5b714cf6c203d2cac578c72f&timestamp=1534153697365";
		String result = DESUtil.encrypt(str);
		System.out.println("加密后：" + result);
		// 直接将如上内容解密
		try {
			String decryResult = DESUtil.decryptor(result);
			System.out.println("解密后：" + new String(decryResult));
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}

	/**
	 * 
	 * @Method: encrypt
	 * @Description: 加密数据
	 * @param data
	 * @return
	 * @throws Exception
	 * @date 2016年7月26日
	 */
	public static String encrypt(String data) { // 对string进行BASE64Encoder转换
		byte[] bt = encryptByKey(data.getBytes(), password);
		String strs = new String(Base64Utils.encode(bt));
		return strs;
	}

	/**
	 * 
	 * @Method: encrypt
	 * @Description: 解密数据
	 * @param data
	 * @return
	 * @throws Exception
	 * @date 2016年7月26日
	 */
	public static String decryptor(String data) throws Exception { // 对string进行BASE64Encoder转换
		byte[] bt = decrypt(Base64Utils.decode1(data), password);
		String strs = new String(bt);
		return strs;
	}

	/**
	 * 加密
	 * 
	 * @param datasource
	 *            byte[]
	 * @param password
	 *            String
	 * @return byte[]
	 */
	private static byte[] encryptByKey(byte[] datasource, String key) {
		try {
			SecureRandom random = new SecureRandom();

			DESKeySpec desKey = new DESKeySpec(key.getBytes());
			// 创建一个密匙工厂，然后用它把DESKeySpec转换成
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
			SecretKey securekey = keyFactory.generateSecret(desKey);
			// Cipher对象实际完成加密操作
			Cipher cipher = Cipher.getInstance("DES");
			// 用密匙初始化Cipher对象
			cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
			// 现在，获取数据并加密
			// 正式执行加密操作
			return cipher.doFinal(datasource);
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 解密
	 * 
	 * @param src
	 *            byte[]
	 * @param password
	 *            String
	 * @return byte[]
	 * @throws Exception
	 */
	private static byte[] decrypt(byte[] src, String key) throws Exception {
		// DES算法要求有一个可信任的随机数源
		SecureRandom random = new SecureRandom();
		// 创建一个DESKeySpec对象
		DESKeySpec desKey = new DESKeySpec(key.getBytes());
		// 创建一个密匙工厂
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
		// 将DESKeySpec对象转换成SecretKey对象
		SecretKey securekey = keyFactory.generateSecret(desKey);
		// Cipher对象实际完成解密操作
		Cipher cipher = Cipher.getInstance("DES");
		// 用密匙初始化Cipher对象
		cipher.init(Cipher.DECRYPT_MODE, securekey, random);
		// 真正开始解密操作
		return cipher.doFinal(src);
	}
}