工作中经常会接触到一些加密算法，比如说base64、MD5、DES、AES等等，那么这些算法到底有什么区别以及具体的应用场景是什么呢，下面就做个简要的梳理。
一、什么是加/解密，目的是什么？
所谓加密，就是对原来为明文的文件或数据按某种算法进行处理，使其成为不可读的一段代码，通常称为 “密文”。目的就是保护数据不被非法窃取、阅读。
所谓解密，也就是加密的逆过程，即将该密文信息转化为其原来数据的过程。
举个例子：小王想给他的妻子写一封信，如果在邮寄的过程中，被他人截获那么就显而易见的将信息泄露掉。相反如果小王根据一个密码本将信的内容加密，比如每一个汉字对应一个编码，那么即使被别人截获，因为没有密码本那么信息也不会泄露，小王的妻子拿到加密后的信件后，用密码本再一一翻译成可读的文本，这个过程就是解密。
二、什么是加/解密算法
加密/解密过程中，使用到的算法就是加密/解密算法。
三、加/解密算法的分类
根据加/解密过程是否可逆，算法可以分为可逆加密算法和不可逆加密算法。
可逆算法包括：DES、3DES、AES、RSA、DSA
不可逆加密算法包括：SHA-1、MD5
对于可逆加密，如果没有秘钥，任何人拿到了密文后通过对应的可逆算法都可以解密，这是不安全的。所以引入了秘钥，加密的时候加入了秘钥，接收方解密时需提供秘钥，这样不知道秘钥就无法解密。
根据加解密使用的秘钥是否相同，算法可以分为对称加密算法和非对称加密算法。
对称加解密使用的秘钥是一致的，非对称加解密使用的秘钥是不一致的。
四、不可逆算法
4.1 MD5加密算法
MD5 用的是哈希函数。严格来说，MD5不是一种加密算法而是摘要算法。无论是多长的输入，MD5 都会输出长度为 128bits 的一个串 (通常用 16 进制 表示为 32 个字符)。完整的md5一般是32位，国内常见的一种是动网的16位（也就是只取32位md5的中间16位），另外有一种是变化过的md5，特征是全是数字，长度可能是20位或者19。
它的典型应用是对一段信息产生信息摘要，以 防止被篡改。
防止被篡改的意思是，发送方用此算法对一段信息产生一个摘要串，接收方也用此算法产生一个摘要串，然后比较这两个摘要串的内容是否一致，如果不一致我们就认为此信息在传输的过程中可能发生了篡改。
那么有没有可能我修改了信息内容，修改后的内容产生的md5与修改之前是一致的呢？md5防止篡改的关键在于，它的碰撞算法以前一直没有找到，所谓碰撞算法，就是修改原来的文件，同时保持修改后的文件和原文件md5一致。
不过后来，我国山东大学的杨教授搞定了碰撞算法。所以md5作为防篡改，已经不可靠了。类似的，sha1的碰撞算法，最近也被攻克。
public static String getMd5(String source) throws NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("md5");
byte[] bytes = source.getBytes();
byte[] targetBytes = digest.digest(bytes);
char [] characters = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
StringBuilder builder = new StringBuilder();
for (byte b : targetBytes) {
int high = (b >> 4) & 15;
int low = b & 15;
char highChar = characters[high];
char lowChar = characters[low];
builder.append(highChar).append(lowChar);
}
return builder.toString();
}
4.2 SHA-1加密算法
SHA1 是和 MD5 一样流行的 消息摘要算法，然而 SHA1 比 MD5 的 安全性更强。对于长度小于 2 ^ 64 位的消息，SHA1 会产生一个 160 位(40个字符)的 消息摘要。基于 MD5、SHA1 的信息摘要特性以及 不可逆 (一般而言)，可以被应用在检查 文件完整性 以及 数字签名 等场景。
public static String shaEncode(String inStr) throws Exception {
MessageDigest sha = null;
try {
sha = MessageDigest.getInstance("SHA");
} catch (Exception e) {
System.out.println(e.toString());
e.printStackTrace();
return "";
}
byte[] byteArray = inStr.getBytes("UTF-8");
byte[] md5Bytes = sha.digest(byteArray);
StringBuffer hexValue = new StringBuffer();
for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes[i]) & 0xff;
if (val < 16) {
hexValue.append("0");
}
hexValue.append(Integer.toHexString(val));
}
return hexValue.toString();
}
五、对称加密算法
5.1 DES算法
DES（Data Encryption Standard）是一种分组密码算法，明文按 64 位进行分组，密钥长 64 位，密钥事实上是 56 位参与 DES 运算（第8、16、24、32、40、48、56、64 位是校验位）分组后的明文组和 56 位的密钥按位替代或交换的方法形成密文组，之后按照顺序将密文组连在一起，各段数据之间互不影响。标准的DES密钥长度为64bit，即8个字符，超过8个字符则舍弃后面。比如：用abcdefgh与abcdefghi加密是一样的结果。又因为有校验位的存在，所以用12345678与13345678进行加密是一样的。
如果密钥长度不足，会以指定的填充方式（ 比如PKCS7Padding ）方式补足位
关于数据补位参考：https://www.cnblogs.com/Lawson/archive/2012/05/20/2510781.html
因此，破译 DES 加密算法实际上就是 搜索密钥的编码。对于56 位长度的密钥 来说，如果用穷举法来进行搜索的话，其运算次数为 2 ^ 56 次=非常大的一个数。
des原理描述
https://blog.csdn.net/qq_32445015/article/details/80184954
package com.inspur.incloudmanager.controller.util;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.Key;
import java.util.Base64;
public class DESUtil {
private final static String IV_PARAMETER = "12345678";
private static final String ALGORITHM = "DES";
private static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding";
private static final String CHARSET = "utf-8";
private static Key generateKey(String password) throws Exception {
DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
return keyFactory.generateSecret(dks);
}
public static String encrypt(String password, String data) {
if (password== null || password.length() < 8) {
throw new RuntimeException("加密失败，key不能小于8位");
}
if (data == null)
return null;
try {
Key secretKey = generateKey(password);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
return new String(Base64.getEncoder().encode(bytes));
} catch (Exception e) {
e.printStackTrace();
return data;
}
}
public static String decrypt(String password, String data) {
if (password== null || password.length() < 8) {
throw new RuntimeException("加密失败，key不能小于8位");
}
if (data == null)
return null;
try {
Key secretKey = generateKey(password);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
} catch (Exception e) {
e.printStackTrace();
return data;
}
}
}
5.2 3DES算法
3DES（又叫Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。密钥长度是128位，192位(bit)，如果密码位数少于等于64位，加密结果与DES相同。原版DES容易被破解，新的3DES出现，增加了加密安全性,避免被暴力破解。它同样是对称性加密，同样涉及到加密编码方式，及填充方式。包括3DES-ECB,3DES-CBC,3DES-CTR,3DES-OFB,3DES-CFB
public static String threedesencrypt(String key,String text) {
try {
byte[] src = text.getBytes();
DESedeKeySpec spec = new DESedeKeySpec(convert(key.getBytes()));
SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
SecretKey secretKey = factory.generateSecret(spec);
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] res = cipher.doFinal(src);
return new String(Base64.getEncoder().encode(res), "utf-8");
} catch (Exception e) {
System.out.println("error");
}
return null;
}
private static byte[] convert(byte[] sources){
byte[] ret = new byte[24];
if(sources.length < 24){
for(int i = 0; i < 24;i++){
if(i < sources.length){
ret[i] = sources[i];
}else{
ret[i] = 0;
}
}
}else{
ret = sources;
}
return ret;
}
5.3 AES算法
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），是一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。
那么为什么原来的DES会被取代呢，原因就在于其使用56位密钥，比较容易被破解。而AES可以使用128、192、和256位密钥，并且用128位分组加密和解密数据，相对来说安全很多。完善的加密算法在理论上是无法破解的，除非使用穷尽法。使用穷尽法破解密钥长度在128位以上的加密数据是不现实的，仅存在理论上的可能性。统计显示，即使使用目前世界上运算速度最快的计算机，穷尽128位密钥也要花上几十亿年的时间，更不用说去破解采用256位密钥长度的AES算法了。
package com.inspur.incloudmanager.controller.util;
import org.springframework.util.Base64Utils;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.logging.Level;
import java.util.logging.Logger;
public class AESUtil{
private static final String KEY_ALGORITHM = "AES";
private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
public static String encrypt(String content, String key) {
try {
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
byte[] byteContent = content.getBytes("utf-8");
cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));
byte[] result = cipher.doFinal(byteContent);
return Base64Utils.encodeToString(result);
} catch (Exception ex) {
Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
public static String decrypt(String content, String key) {
try {
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
byte[] result = cipher.doFinal(Base64Utils.decodeFromString(content));
return new String(result, "utf-8");
} catch (Exception ex) {
Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
private static SecretKeySpec getSecretKey(final String key) {
KeyGenerator kg = null;
try {
kg = KeyGenerator.getInstance(KEY_ALGORITHM);
kg.init(128, new SecureRandom(key.getBytes()));
SecretKey secretKey = kg.generateKey();
return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
public static void main(String[] args) {
String content = "Inspur1!";
String key = "wang";
System.out.println("content:" + content);
String s1 = AESUtil.encrypt(content, key);
System.out.println("s1:" + s1);
System.out.println("s2:"+AESUtil.decrypt(s1, key));
}
}
指定秘钥
public class AESUtil{
private static final String KEY_ALGORITHM = "AES";
private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
public static String encrypt(String content, String key) {
try {
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
byte[] byteContent = content.getBytes("utf-8");
SecretKeySpec aeskey = new SecretKeySpec(convert(key.getBytes("utf-8")), "AES");
cipher.init(Cipher.ENCRYPT_MODE, aeskey);
byte[] result = cipher.doFinal(byteContent);
return Base64Utils.encodeToString(result);
} catch (Exception ex) {
Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
public static String decrypt(String content, String key) {
try {
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
SecretKeySpec aeskey = new SecretKeySpec(convert(key.getBytes("UTF-8")), "AES");
cipher.init(Cipher.DECRYPT_MODE, aeskey);
byte[] result = cipher.doFinal(Base64Utils.decodeFromString(content));
return new String(result, "utf-8");
} catch (Exception ex) {
Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
private static byte[] convert(byte[] sources){
byte[] ret = new byte[32];
if(sources.length > 32){
for(int i = 0; i < 32;i++){
ret[i] = sources[i];
}
}else{
ret = sources;
}
return ret;
}
public static void main(String[] args) {
String content = "Inspur1!";
String key = "inclouqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq";
System.out.println("content:" + content);
String s1 = AESUtil.encrypt(content, key);
System.out.println("s1:" + s1);
System.out.println("s2:"+AESUtil.decrypt(s1, key));
}
}
六、非对称加密算法
6.1 RSA算法
import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
public class RSA {
private static final String KEY_ALGORITHM = "RSA";
private static final int KEY_SIZE = 512;
private static final String CHARSET = "UTF-8";
public static KeyPair getKeyPair() throws Exception {
return getKeyPair(null);
}
public static KeyPair getKeyPair(String password) throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
if(password == null){
keyPairGenerator.initialize(KEY_SIZE);
}else {
SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed(password.getBytes(CHARSET));
keyPairGenerator.initialize(KEY_SIZE, secureRandom);
}
return keyPairGenerator.generateKeyPair();
}
public static byte[] getPrivateKeyBytes(KeyPair keyPair) {
return keyPair.getPrivate().getEncoded();
}
public static String getPrivateKey(KeyPair keyPair) {
return Base64.getEncoder().encodeToString(getPrivateKeyBytes(keyPair));
}
public static byte[] getPublicKeyBytes(KeyPair keyPair) {
return keyPair.getPublic().getEncoded();
}
public static String getPublicKey(KeyPair keyPair) {
return Base64.getEncoder().encodeToString(getPublicKeyBytes(keyPair));
}
public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey key = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
return cipher.doFinal(data);
}
public static String encryptByPrivateKey(String data, String privateKey) throws Exception {
byte[] key = Base64.getDecoder().decode(privateKey);
return Base64.getEncoder().encodeToString(encryptByPrivateKey(data.getBytes(CHARSET), key));
}
public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey key = keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
return cipher.doFinal(data);
}
public static String encryptByPublicKey(String data, String publicKey) throws Exception {
byte[] key = Base64.getDecoder().decode(publicKey);
return Base64.getEncoder().encodeToString(encryptByPublicKey(data.getBytes(CHARSET), key));
}
public static byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey key = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
return cipher.doFinal(data);
}
public static String decryptByPrivateKey(String data, String privateKey) throws Exception {
byte[] key = Base64.getDecoder().decode(privateKey);
return new String(decryptByPrivateKey(Base64.getDecoder().decode(data), key), CHARSET);
}
public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey key = keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
return cipher.doFinal(data);
}
public static String decryptByPublicKey(String data, String publicKey) throws Exception {
byte[] key = Base64.getDecoder().decode(publicKey);
return new String(decryptByPublicKey(Base64.getDecoder().decode(data), key), CHARSET);
}
public static void main(String[] args) throws Exception {
KeyPair keyPair = RSA.getKeyPair();
String publicKey = RSA.getPublicKey(keyPair);
String privateKey = RSA.getPrivateKey(keyPair);
System.out.println("公钥：\n" + publicKey);
System.out.println("私钥：\n" + privateKey);
String data = "RSA 加解密测试!";
{
System.out.println("\n===========私钥加密，公钥解密==============");
String s1 = RSA.encryptByPrivateKey(data, privateKey);
System.out.println("加密后的数据:" + s1);
String s2 = RSA.decryptByPublicKey(s1, publicKey);
System.out.println("解密后的数据:" + s2 + "\n\n");
}
{
System.out.println("\n===========公钥加密，私钥解密==============");
String s1 = RSA.encryptByPublicKey(data, publicKey);
System.out.println("加密后的数据:" + s1);
String s2 = RSA.decryptByPrivateKey(s1, privateKey);
System.out.println("解密后的数据:" + s2 + "\n\n");
}
}
}
声明：本文章主要将几种常用的加密算法及其java实现统一整理，便于以后查看。大多数是转载参考网上的内容。如有侵权请告知。
参考文章列表如下：
https://blog.csdn.net/u013314786/article/details/80324461
