加密系列 | DES加密和解密算法详解&代码示例

算法简介

---

对称加密也就是密钥加密。对称加密和解密使用同一个密钥：

• 加密时，我们用这个密钥初始化密码算法，密码算法对经过它的数据进行加密；
• 解密时，密码算法用同一个密钥初始化，密码算法对经过它的数据进行解密。

加密的强度依赖于密钥的长度。一般的对称密钥长度在40-128位之间，有些算法可能更长。

建议使用128位以上的对称加密算法，如：DESede(TripleDES)、Blowfish、AES。

对称加密比不对称加密(如公钥加密)要快的多，比较适合于大量数据加/解密的情况下(如文件加密)。

算法详解

---

Cipher cip = Cipher.getInstance(“DES/ECB/NoPadding”);

参数是要使用的算法，共分为三段(/分隔)。

第一段是算法名字

第二段是算法使用的模式

模式规定了 Cipher 如何应用加密算法。改变模式可以允许一个块加密程序变为流加密程序。

• 分组加密每次加密一个数据组，这个组的位数可以是随意的，一般是64或128位；
• 流加密每次可以加密或解密一个字节的数据，使其更适合网络通信等。

常用的模式：

• ECB（电码本）：最简单的模式，同样的明文总是加密成相同的密文分组；
• CBC（密码分组链接）：同样的明文分组不一定加密成同样的密文块；
• CFB（密码反馈）：工作方式与CBC类似，但它可执行更小的数据块，典型的有8位。也需要一个IV；
• OFB（输出反馈）：在传输中能给数据提供更好的保护，防止数据丢失，其他与CFB类似。密文中一位出错，也只造成明文中的一位出错。其他方式会造成整个块丢失。也需要一个IV。

CBC使用前一个分组的信息加密当前的分组，这个方法存在的问题是相同的信息仍旧加密成相同的密文，因为所有的分组是同时变成密文分组。为了解决这个问题需要一个IV(初始化向量)，IV仅仅是一个初始化加密程序的随机数，它无需秘密保存，但对每一个信息来说它都是不同的。通过这种方式，既使有两条相同的信息，只要它们的IV不同，那么它们加密后的密文也是不同的。所以一个初始化向量就象是口令加密中的盐。

第三段是填充符

大多数算法支持两种填充符：

1. No padding 即没有填充，这就要求加密以一个完整的块结束，而没有多余的数据；
2. RKCS#5 padding 工作方式为：一个未被填满的字节被赋予一个指定的数据，这个数值的大小就是块未被写满的字节数。

例如，一个8字节的块，其中仅有3个字节写满了数据，那么就需要对5个节字填充，而这5个字节都被赋予数值’5’，这是因为有5个字节需要填充。如果数据长度正好为8字节的倍数，那么就需要在数据结尾处加一个完整的填序块(既8个为’8’的字节)。解密后，这个填充块必须被移除。

代码示例

---

DES/ECB/NoPadding

import java.security.Key;
import java.security.SecureRandom;

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

import org.apache.commons.codec.binary.Base64;

/**
 * DES加密 解密算法
 * 
 * @author peipei3514
 * @date 2017-8-11 上午10:12:50
 */
public class DESUtil {

	/** 算法名称 */
	public static final String KEY_ALGORITHM = "DES";
	/** 算法名称/加密模式/填充方式 */
	public static final String CIPHER_ALGORITHM = "DES/ECB/NoPadding";
	/** 字符编码 ： 字符串转字节或字节转字符串时 一定要加上编码，否则可能出现乱码*/
	private final static String ENCODE = "UTF-8";
	/**
	 * 加解密密钥
	 * 
	 * Creates a DESKeySpec object using the first 8 bytes in key as the key
	 * material for the DES key. The bytes that constitute the DES key are those
	 * between key[0] and key[7] inclusive.
	 * 
	 * 使用前8个字节(bytes)作为DES密钥的关键材料,创建一个DESKeySpec对象。 构成DES密钥的字节是键[0]和键[7]之间的字节。
	 */
	private final static String DEFAULT_KEY = "A1B2C3D4E5F60708";

	/** 获取秘钥对象 */
	private static SecretKey keyGenerator(String keyStr) throws Exception {

		byte input[] = HexStringToBytes(keyStr);
		// 从原始密钥数据创建DESKeySpec对象
		DESKeySpec desKey = new DESKeySpec(input);
		// 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
		SecretKey securekey = keyFactory.generateSecret(desKey);

		return securekey;
	}

	private static int parse(char c) {
		if (c >= 'a')
			return (c - 'a' + 10) & 0x0f;
		if (c >= 'A')
			return (c - 'A' + 10) & 0x0f;
		return (c - '0') & 0x0f;
	}

	/** 从十六进制字符串到字节(二进制 )数组转换 */
	private static byte[] HexStringToBytes(String hexstr) {
		byte[] results = new byte[hexstr.length() / 2];

		for (int i = 0; i < results.length; i++) {
			char c0 = hexstr.charAt(i * 2 + 0);
			char c1 = hexstr.charAt(i * 2 + 1);
			results[i] = (byte) ((parse(c0) << 4) | parse(c1));
		}

		return results;
	}

	/** 加密数据 */
	public static String encrypt(String data) throws Exception {
		// 获取秘钥对象
		Key deskey = keyGenerator(DEFAULT_KEY);
		// 实例化Cipher对象，它用于完成实际的加密操作
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
		// 生成一个可信任的随机数源
		SecureRandom random = new SecureRandom();
		// 用密钥初始化Cipher对象，设置为加密模式
		cipher.init(Cipher.ENCRYPT_MODE, deskey, random);
		// 执行加密操作
		byte[] results = cipher.doFinal(data.getBytes(ENCODE));

		// 执行加密操作。加密后的结果通常都会用Base64编码进行传输
		return Base64.encodeBase64String(results);
	}

	/** 解密数据 */
	public static String decrypt(String data) throws Exception {
		// 获取秘钥对象
		Key deskey = keyGenerator(DEFAULT_KEY);
		// 实例化Cipher对象，它用于完成实际的解密操作
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
		// 初始化Cipher对象，设置为解密模式
		cipher.init(Cipher.DECRYPT_MODE, deskey);
		// Base64解码
		byte[] results = Base64.decodeBase64(data);
		// 执行解密操作
		results = cipher.doFinal(results);
		// 变成字符串
		return new String(results, ENCODE);
	}

	public static void main(String[] args) throws Exception {
		String source = "12345678";
		System.out.println("原文: " + source);
		String encryptData = encrypt(source);
		System.out.println("加密后: " + encryptData);
		String decryptData = decrypt(encryptData);
		System.out.println("解密后: " + decryptData);
	}
}

这种加密方式有两种限制：

• 密钥必须是16位的；
• 待加密内容的长度必须是16的倍数。

如果不是16的倍数，就会出如下异常：

javax.crypto.IllegalBlockSizeException: Input length not multiple of 16 bytes
        at com.sun.crypto.provider.SunJCE_f.a(DashoA13*..)
        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
        at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
        at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA13*..)
        at javax.crypto.Cipher.doFinal(DashoA13*..)

要解决如上异常，可以通过补全传入加密内容等方式进行避免。

---

DES/CBC/PKCS5Padding

import java.security.Key;

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

import org.apache.commons.codec.binary.Base64;

/**
 * DES加密 解密算法
 * 
 * @author peipei3514
 * @date 2017-8-11 上午10:12:50
 */
public class DESUtil {

	/** 算法名称 */
	public static final String KEY_ALGORITHM = "DES";
	/** 算法名称/加密模式/填充方式 */
	public static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
	/** 字符编码 ： 字符串转字节或字节转字符串时 一定要加上编码，否则可能出现乱码*/
	private final static String ENCODE = "UTF-8";
	/**
	 * 加解密密钥


	 * 
	 * Creates a DESKeySpec object using the first 8 bytes in key as the key
	 * material for the DES key. 
The bytes that constitute the DES key are those
	 * between key[0] and key[7] inclusive.


	 * 
	 * 使用前8个字节(bytes)作为DES密钥的关键材料,创建一个DESKeySpec对象。 构成DES密钥的字节是键[0]和键[7]之间的字节。
	 */
	private final static String DEFAULT_KEY = "A1B2C3D4E5F60708";
	
	/** Wrong IV length: must be 8 bytes long */
	private static String DES_IV = "JM23456*";

	/** 获取秘钥对象 */
	private static SecretKey keyGenerator(String keyStr) throws Exception {

		byte input[] = HexStringToBytes(keyStr);
		// 从原始密钥数据创建DESKeySpec对象
		DESKeySpec desKey = new DESKeySpec(input);
		// 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
		SecretKey securekey = keyFactory.generateSecret(desKey);

		return securekey;
	}

	private static int parse(char c) {
		if (c >= 'a')
			return (c - 'a' + 10) & 0x0f;
		if (c >= 'A')
			return (c - 'A' + 10) & 0x0f;
		return (c - '0') & 0x0f;
	}

	/** 从十六进制字符串到字节(二进制 )数组转换 */
	private static byte[] HexStringToBytes(String hexstr) {
		byte[] results = new byte[hexstr.length() / 2];

		for (int i = 0; i < results.length; i++) {
			char c0 = hexstr.charAt(i * 2 + 0);
			char c1 = hexstr.charAt(i * 2 + 1);
			results[i] = (byte) ((parse(c0) << 4) | parse(c1));
		}

		return results;
	}

	/** 加密数据 */
	public static String encrypt(String data) throws Exception {
		// 获取秘钥对象
		Key deskey = keyGenerator(DEFAULT_KEY);
		// 实例化Cipher对象，它用于完成实际的加密操作
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
		// 生成初始化向量
		IvParameterSpec iv = new IvParameterSpec(DES_IV.getBytes("UTF-8"));
		// 用密钥初始化Cipher对象，设置为加密模式
		cipher.init(Cipher.ENCRYPT_MODE, deskey, iv);
		// 执行加密操作
		byte[] results = cipher.doFinal(data.getBytes(ENCODE));

		// 执行加密操作。加密后的结果通常都会用Base64编码进行传输
		return Base64.encodeBase64String(results);
	}

	/** 解密数据 */
	public static String decrypt(String data) throws Exception {
		// 获取秘钥对象
		Key deskey = keyGenerator(DEFAULT_KEY);
		// 实例化Cipher对象，它用于完成实际的解密操作
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
		// 生成初始化向量
		IvParameterSpec iv = new IvParameterSpec(DES_IV.getBytes("UTF-8"));
		// 初始化Cipher对象，设置为解密模式
		cipher.init(Cipher.DECRYPT_MODE, deskey, iv);
		// Base64解码
		byte[] results = Base64.decodeBase64(data);
		// 执行解密操作
		results = cipher.doFinal(results);
		// 变成字符串
		return new String(results, ENCODE);
	}

	public static void main(String[] args) throws Exception {
		String source = "123456";
		System.out.println("原文: " + source);
		String encryptData = encrypt(source);
		System.out.println("加密后: " + encryptData);
		String decryptData = decrypt(encryptData);
		System.out.println("解密后: " + decryptData);
	}
}