Java加密与解密之对称加密DES

DES算法与DESede算法统称DES系列算法，DES算法是对称加密算法中的典型算法。
由于DES的密钥长度的不满足，才衍生出了DESede算法，对应中文“三重DES”。

对称加密会有 工作模式和填充方式两个概念

工作模式：ECB，CBC，CFB，OFB，CTR等

填充方式：NoPadding，PKCS5Padding，PKCS7Padding等

对于这两个概念大家可以在网上自行查阅。

DES算法密钥比较短，只有56位相对其它对称加密来说是不是特别的安全。由于DES算法具有半公开性质，被怀疑存在美国国家安全局安置的后门，受到各大密码学机构的强烈质疑。

Java8中对DES支持情况

密钥长度：56

工作模式：ECB，CBC，PCBC，CTR，CTS，CFB，CFB8至CFB128，OFB，OFB8至OFB128

填充方式：NoPadding，PKCS5Padding，ISO10126Padding。

一般我们使用对称加密算法时，我们是很少指定工作模式和填充方式的。所以这里也不必太在意这里的工作模式和填充方式。

代码示例：

每行代码都有注释，这里就不再叙述了，下面也给出文字代码，方便复制吧

package com.pack.security.des;

import java.nio.charset.Charset;
import java.security.Key;
import java.util.Base64;

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

public class DesMain {
	
	/**
	 * @author xg
	 * @throws Exception 
	 * @return byte[] 生成的密钥
	 * @desc
	 *     初始化对称加密DES密钥
	 */
	public static byte[] initDESKey() throws Exception { 
		KeyGenerator keyGenerator = KeyGenerator.getInstance("DES") ;
		// 初始化长度
		keyGenerator.init(56) ;
		// 生成密钥
		SecretKey secretKey = keyGenerator.generateKey() ;
		// 获取密钥
		return secretKey.getEncoded() ;
	}
	
	/**
	 * @author xg
	 * @param key 密钥字节数组
	 * @return Key({@link Key})
	 * @throws Exception 
	 * @desc
	 *     将二进制数据转化成密钥
	 */
	public static Key convertDESKey(byte[] key) throws Exception {
		// 实例化DES密钥材料
		DESKeySpec desKeySpec = new DESKeySpec(key) ;
		// 实例化密钥工厂
		SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES") ;
		// 生成密钥
		return secretKeyFactory.generateSecret(desKeySpec) ;
	}
	
	/**
	 * @author xg
	 * @param data 要加密的数据
	 * @param secretKey(@link Key) 密钥
	 * @throws Exception 
	 * @return byte[] 加密后的数据
	 * @desc
	 *     加密数据
	 */
	public static byte[] encodeByDES(byte[] data, Key key) throws Exception {
		Cipher cipher = Cipher.getInstance("DES") ;
		// 初始化，设置为加密模式
		cipher.init(Cipher.ENCRYPT_MODE, key) ;
		// 返回加密数据
		return cipher.doFinal(data) ;
	}
	
	/**
	 *	

	 *     解密数据
	 *  
	 *	@author xg
	 *	@param data 加密的数据
	 *	@param key 密钥
	 *	@return byte[] 解密后的数据
	 *	@throws Exception
	 */
	public static byte[] decodeByDES(byte[] data, Key key) throws Exception {
		Cipher cipher = Cipher.getInstance("DES") ; 
		// 初始化，设置为解密模式
		cipher.init(Cipher.DECRYPT_MODE, key) ;
		// 返回解密数据
		return cipher.doFinal(data) ;
	}
	public static void main(String[] args) throws Exception {
		String message = "DES对称加密解密" ;
		byte[] data = message.getBytes(Charset.forName("UTF-8")) ;
		byte[] key = initDESKey() ;
		String strKey = Base64.getEncoder().encodeToString(key) ;
		String encryptedStr = Base64.getEncoder().encodeToString(encodeByDES(data, convertDESKey(key))) ;
		System.out.println("加密后的数据：" + encryptedStr) ;
		System.out.println("解密后数据为：" + new String(decodeByDES(Base64.getDecoder().decode(encryptedStr.getBytes("UTF-8")), 
				convertDESKey(Base64.getDecoder().decode(strKey.getBytes("UTF-8")))), "UTF-8")) ;
	}
	
}

三重DES（DESede）

DESede也称为Triple DES，DESede是DES算法的改进版本，是的安全强度增强了，但同时该算法的处理速度变慢了，密钥的计算时间较长。

密钥长度：112或168位。

代码示例：

package com.pack.security.des;

import java.security.Key;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;

public class DESedeDemo {
	
	// 密钥算法
	public static final String ALGORITHM = "DESede" ;
	// 加解密算法
	public static final String CIPHER_ALGORITHM = "DESede/CBC/PKCS5Padding" ;

	public static byte[] initKey() throws Exception {
		// 实例化密钥生成器
		KeyGenerator gen = KeyGenerator.getInstance(ALGORITHM) ;
		// 设置密钥的长度 java8 支持 112和168位
		gen.init(112) ;
		// 生成密钥
		SecretKey key = gen.generateKey() ;
		return key.getEncoded() ;
	}
	
	/**
	 *	

	 *     加密数据
	 *  
	 *	@author xg
	 *	@param key 密钥
	 *	@param datas 将要加密的数据
	 *	@return String 返回Base64编码后的字符串
	 *	@throws Exception
	 */
	public static String encodeData(Key key, byte[] datas) throws Exception {
		// 实例化
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM) ;
		// 初始化当前加解密模式（这里加密）
		cipher.init(Cipher.ENCRYPT_MODE, key) ;
		// 生成加密后的数据
		byte[] bs = cipher.doFinal() ;
		return Base64.getEncoder().encodeToString(bs) ;
	}
	
	/**
	 *	

	 *     解密数据
	 *  
	 *	@author xg
	 *	@param key 密钥
	 *	@param datas 加密后的数据
	 *	@return String 返回解密后的数据
	 */
	public static String decodeData(Key key, byte[] datas) throws Exception {
		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM) ;
		// 初始化，设置为解密模式
		cipher.init(Cipher.DECRYPT_MODE, key) ;
		// 返回解密数据
		byte[] bs = cipher.doFinal(datas) ;
		return Base64.getEncoder().encodeToString(bs) ;
	}
	
	/**
	 *	

	 *     将字节数组转换成Key
	 *  
	 *	@author xg
	 *	@param key
	 *	@return Key
	 *	@throws Exception
	 */
	public static Key toKey(byte[] key) throws Exception {
		// 实例化密钥材料
		DESedeKeySpec dks = new DESedeKeySpec(key) ;
		// 实例化密钥工厂
		SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM) ;
		// 生成密钥
		return factory.generateSecret(dks) ;
	}
	
	public static void main(String[] args) throws Exception {
		byte[] b = initKey() ;
		Key key = toKey(b) ;
		String datas = "DESede加密解密" ;
		String encodeStr = encodeData(key, datas.getBytes()) ;
		System.out.println("加密后的数据：" + encodeStr) ;
		System.out.println("解密后的数据：" + decodeData(key, encodeStr.getBytes())) ;
	}
	
}