一、什么是对称加密？
对称加密指的就是加密和解密使用同一个秘钥的加密方式。对称加密只有一个秘钥，作为私钥。
常见的对称加密算法：DES，AES，3DES等等。
二、加密算法（DES）
1、什么是DES算法？
DES（Data Encryption Standard，即数据加密标准），是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。
2、DES算法是怎么加密的？
DES是将明文按64位进行分组，密钥长64位，密钥是利用56+8奇偶校验位（第8,16,24,32,40,48,56,64）=64位的密钥对以64位为单位的块数据进行加解密。参与DES运算（第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组。
DES算法的加密密钥是根据用户输入的密码生成的,该算法把64位密码中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作为奇偶校验位,在计算密钥时要忽略这8位.如果输入的密码只是在这8位上有区别的话,那么操作后的结果将是一样的。
DES是一种对称密码，加密过程和解密过程使用相同的密钥。DES是一种迭代算法。DES对明文中的每个分组的加密都包含16轮，且每轮的操作完全相同。每轮都会使用不同的子密钥，并且子密钥Ki都从主密钥推导而来。
直接上代码：
DESUtil：
import org.apache.tomcat.util.codec.binary.Base64;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.IvParameterSpec;
/**
* DES加密算法工具类
*/
public class DESUtil {
/**
* CFB
*/
public static final String CFB = "CFB";
/**
* OFB
*/
public static final String OFB = "OFB";
/**
* CBC
*/
public static final String CBC = "CBC";
/**
* iv向量
*/
private static final byte[] DESIV = {(byte) 0xCE, (byte) 0x35, (byte) 0x5,
(byte) 0xD, (byte) 0x98, (byte) 0x91, (byte) 0x8, (byte) 0xA};
/**
* AlgorithmParameterSpec
*/
private static AlgorithmParameterSpec IV = null;
/**
* SHA1PRNG
*/
private static final String SHA1PRNG = "SHA1PRNG";
/**
* DES默认模式
*/
private static final String DES = "DES";
/**
* CBC加密模式
*/
private static final String DES_CBC_PKCS5PADDING = "DES/CBC/PKCS5Padding";
/**
* OFB加密模式
*/
private static final String DES_OFB_PKCS5PADDING = "DES/OFB/PKCS5Padding";
/**
* CFB加密模式
*/
private static final String DES_CFB_PKCS5_PADDING = "DES/CFB/PKCS5Padding";
/**
* 加密模式
*/
private static final int ENCRYPT_MODE = 1;
/**
* 解密模式
*/
private static final int DECRYPT_MODE = 2;
/**
* 密钥
*/
private Key key;
public DesUtil(String str) {
getKey(str);
}
public Key getKey() {
return key;
}
public void setKey(Key key) {
this.key = key;
}
/**
* 通过密钥获得key
*
* @param secretKey 密钥
*/
public void getKey(String secretKey) {
try {
SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
secureRandom.setSeed(secretKey.getBytes());
KeyGenerator generator;
try {
generator = KeyGenerator.getInstance(DES);
generator.init(secureRandom);
IV = new IvParameterSpec(DESIV);
this.key = generator.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
} catch (Exception e) {
throw new RuntimeException("Error in getKey(String secretKey), Cause: " + e);
}
}
/**
* 字符串des加密
*
* @param data 需要加密的字符串
* @param encryptType 加密模式 (ECB/CBC/OFB/CFB)
* @return 加密结果
* @throws Exception 异常
*/
public String encrypt(String data, String encryptType) throws Exception {
Cipher cipher = getPattern(encryptType, ENCRYPT_MODE);
byte[] pasByte = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
return Base64.encodeBase64String(pasByte);
}
/**
* 字符串des解密
*
* @param data 需要解密的字符串
* @param decryptType 解密模式 (ECB/CBC/OFB/CFB)
* @return 解密结果
* @throws Exception 异常
*/
public String decrypt(String data, String decryptType) throws Exception {
Cipher cipher = getPattern(decryptType, DECRYPT_MODE);
byte[] pasByte = cipher.doFinal(Base64.decodeBase64(data));
return new String(pasByte, StandardCharsets.UTF_8);
}
/**
* 初始化cipher
*
* @param type 加密/解密模式 (ECB/CBC/OFB/CFB)
* @param cipherMode cipher工作模式 1：加密； 2：解密
* @return cipher
* @throws Exception 异常
*/
private Cipher getPattern(String type, int cipherMode) throws Exception {
Cipher cipher;
switch (type) {
case CBC:
cipher = Cipher.getInstance(DES_CBC_PKCS5PADDING);
cipher.init(cipherMode, key, IV);
break;
case OFB:
cipher = Cipher.getInstance(DES_OFB_PKCS5PADDING);
cipher.init(cipherMode, key, IV);
break;
case CFB:
cipher = Cipher.getInstance(DES_CFB_PKCS5_PADDING);
cipher.init(cipherMode, key, IV);
break;
default:
cipher = Cipher.getInstance(DES);
cipher.init(cipherMode, key);
break;
}
return cipher;
}
/**
* 文件 file 进行加密并保存目标文件 destFile 中
*
* @param file 要加密的文件 如 c:/test/file.txt
* @param destFile 加密后存放的文件名 如 c:/ 加密后文件 .txt
* @param encryptType 加密模式 (ECB/CBC/OFB/CFB)
* @return 加密结果 0：异常 1：加密成功； 5：未找到需要加密的文件
*/
public int encryptFile(String file, String destFile, String encryptType) {
int result = 0;
try {
Cipher cipher = getPattern(encryptType, ENCRYPT_MODE);
InputStream is = new FileInputStream(file);
OutputStream out = new FileOutputStream(destFile);
CipherInputStream cis = new CipherInputStream(is, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = cis.read(buffer)) > 0) {
out.write(buffer, 0, r);
}
cis.close();
is.close();
out.close();
result = 1;
} catch (FileNotFoundException e) {
result = 5;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 文件 file 进行解密并保存目标文件 destFile 中
*
* @param file 要解密的文件 如 c:/test/file.txt
* @param destFile 解密后存放的文件名 如 c:/ 解密后文件 .txt
* @param decryptType 解密模式 (ECB/CBC/OFB/CFB)
* @return 解密结果 0：解密异常；1：解密正常；5：未找到需要解密的文件
*/
public int decryptFile(String file, String destFile, String decryptType) {
int result = 0;
try {
Cipher cipher = getPattern(decryptType, DECRYPT_MODE);
InputStream is = new FileInputStream(file);
OutputStream out = new FileOutputStream(destFile);
CipherOutputStream cos = new CipherOutputStream(out, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = is.read(buffer)) >= 0) {
cos.write(buffer, 0, r);
}
cos.close();
out.close();
is.close();
result = 1;
} catch (FileNotFoundException e) {
result = 5;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
}写个测试的main方法：
public static void main(String[] args) throws Exception {
String testString = "HelloWorld";
System.out.println("加密前：" + testString);
String key = "ABCDEFGHIJK";
DesUtil desUtil = new DesUtil(key);
String encryptStr = desUtil.encrypt(testString, "CBC");
System.out.println("加密后：" + encryptStr);
String decryptStr = desUtil.decrypt(encryptStr, "CBC");
System.out.println("解密后：" + decryptStr);
}结果：
