这15种加密解密算法分别是：散列哈希[MD5、SHA1、CRC32]，对称[DES，3DES，AES、TDEA，Blowfish，RC4、RC5，IDEA]，Base64、Rabbit、Escape、摩尔斯电码。
【三种分类】
1、对称加密：密钥只有一个，解密、解密都是这个密码，加解密速度快，典型的对称加密有DES、AES、RC4等
2、非对称加密:密钥成对出现，分别为公钥和私钥，从公钥无法推知私钥，反之，从私钥也无法推知公钥，加密和解密使用不同的密钥，公钥加密需要私钥解密，反之，私钥加密需要公钥解密。非对称加密速度较慢，典型的非对称算法有：RSA,DSA,DSS.
3、Hash算法，这是一种不可逆的算法，它常用于验证数据的完整性。
【1、MD5加密解密】
md5是不可逆的，md5没有解密的方法，最好的反驳就是：数据源是无穷尽的，而 MD5密文是有限的。这里的加密解密是对md5算法先加密后解密，而不是对md5解密。
md5加密原理
MD5以512位分组来处理输入的信息，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。
// MD5加密，32位
public static String MD5(String str) {
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance("MD5");
} catch (Exception e) {
System.out.println(e.toString());
e.printStackTrace();
return "";
}
char[] charArray = str.toCharArray();
byte[] byteArray = new byte[charArray.length];
for (int i = 0; i < charArray.length; i++){
byteArray[i] = (byte) charArray[i];
}
byte[] md5Bytes = md5.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();
}md5解密
MD5加密不可逆，怎么解密呢？记得wann yaosh吗，对就是那样的原理：只不过是大数据查询的一个碰撞而已，比如，有一台服务器存储了大量key以及key的MD5编码的信息，那么就可以拿着数据去进行比对。
【MD5小 demo】
public static void main(String args[]) {
String str = "Frozen——test：redant want tobe enrich";
//Md5加密
testMd5(str);
}
public static void testMd5(String str){
System.out.println("MD5后：" + MD5(str));
}
【2、Base64加密解密】
Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2049，上面有MIME的详细规范。
Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息。采用Base64编码具有不可读性，需要解码后才能阅读。
很简单的算法，没得说：
【Base64小 demo】
//Base64加密解密
public static void base64(String str) throws Exception {
byte[] bytes = str.getBytes();
//Base64 加密
String encoded = Base64.getEncoder().encodeToString(bytes);
System.out.println("Base 64 加密后：" + encoded);
//Base64 解密
byte[] decoded = Base64.getDecoder().decode(encoded);
String decodeStr = new String(decoded);
System.out.println("Base 64 解密后：" + decodeStr);
//另一种写法：
String frozen = (new BASE64Encoder()).encodeBuffer(str.getBytes());
System.out.println("另一种写法 加密后：" + frozen);
String defrozen = new String((new BASE64Decoder()).decodeBuffer(frozen));
System.out.println("另一种写法 解密后：" + defrozen);
}
【3、对称之AES加密解密】
需要对加密和解密使用相同密钥的加密算法。由于其速度快，对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密，所谓对称加密就是加密和解密都是使用《同一个密钥》。
【AES加密过程】
/**
* @param content 需要加密的内容
* @param str 指定规则，用于产生密钥生成器
* @return AES加密后
* @throws Exception 异常
*/
public static String AESEncode1(String content, String str) throws Exception{
//1.构造密钥生成器，指定为AES算法,不区分大小写
KeyGenerator keygen=KeyGenerator.getInstance("AES");
//2.根据str规则初始化密钥生成器
//生成一个128位的随机源,根据传入的字节数组
keygen.init(128, new SecureRandom(str.getBytes()));
//3.产生原始对称密钥
SecretKey original_key = keygen.generateKey();
//4.获得原始对称密钥的字节数组
byte [] raw=original_key.getEncoded();
//5.根据字节数组生成AES密钥
SecretKey key=new SecretKeySpec(raw, "AES");
//6.根据指定算法AES自成密码器
Cipher cipher = Cipher.getInstance("AES");
//7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
cipher.init(Cipher.ENCRYPT_MODE, key);
//8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
byte [] byte_encode=content.getBytes("utf-8");
//9.根据密码器的初始化方式--加密：将数据加密
byte [] byte_AES = cipher.doFinal(byte_encode);
//10.将加密后的数据转换为字符串
String AES_encode = new String(new BASE64Encoder().encode(byte_AES));
System.out.println("对称之AES加密之后" + AES_encode);
//11.将字符串返回
return AES_encode;
}【AES 解密过程】
/**
* @param encodeRules 密钥规则，同加密一样。都是一样的规则
* @param content 需要解密的内容
* @return AES解密之后的内容
* @throws Exception 异常
*/
public static String AESDncode(String encodeRules, String content) throws Exception{
//1.构造密钥生成器，指定为AES算法,不区分大小写
KeyGenerator keygen=KeyGenerator.getInstance("AES");
//2.根据ecnodeRules规则初始化密钥生成器
//生成一个128位的随机源,根据传入的字节数组
keygen.init(128, new SecureRandom(encodeRules.getBytes()));
//3.产生原始对称密钥
SecretKey original_key=keygen.generateKey();
//4.获得原始对称密钥的字节数组
byte [] raw=original_key.getEncoded();
//5.根据字节数组生成AES密钥
SecretKey key=new SecretKeySpec(raw, "AES");
//6.根据指定算法AES自成密码器
Cipher cipher=Cipher.getInstance("AES");
//7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
cipher.init(Cipher.DECRYPT_MODE, key);
//8.将加密并编码后的内容解码成字节数组
byte [] byte_content= new BASE64Decoder().decodeBuffer(content);
//9进行解密
byte [] byte_decode=cipher.doFinal(byte_content);
String AES_decode = new String(byte_decode,"utf-8");
System.out.println("对称之AES解密之后："+ AES_decode);
return AES_decode;
}
【对称之AES小 demo】
String rule = "genzhe ganjuezou yongyuanbuhuitou";
String afteraes = AESEncode(str, rule);
AESDncode(rule, afteraes);
【4、对称之DES加密解密】
【原理】DES使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行"异或"运算;接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用 16 个循环，使用异或，置换，代换，移位操作四种基本运算。
【DES加密】
/**
* 生成java.security.key
* @param password 自定义密码规则【对称本质所在】
* @return
* @throws Exception
*/
private static Key generateKey(String password) throws Exception {
//设置编码
DESKeySpec dks = new DESKeySpec(password.getBytes("utf-8"));
//密钥算法
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
return keyFactory.generateSecret(dks);
}
/**
* DES加密字符串
* @param IV_PARAMETER 偏移量 固定8位字节
* @param password 加密密码
* @param data 待加密字符串
* @return
*/
public static String desencrypt(String IV_PARAMETER, 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("DES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes("utf-8"));
cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
byte[] bytes = cipher.doFinal(data.getBytes("utf-8"));
//JDK1.8及以上可直接使用Base64，JDK1.7及以下可以使用BASE64Encoder
//Android平台可以使用android.util.Base64
String after = new String(Base64.getEncoder().encode(bytes));
System.out.println("对称之DES加密后的字符: "+ after);
return after;
} catch (Exception e) {
e.printStackTrace();
return data;
}
}【DES解密】
/**
* DES解密字符串
* @param password 解密密码，长度不能够小于8位
* @param data 待解密字符串
* @param IV_PARAMETER 自定义密钥，对称的精髓所在
* @return 解密后内容
*/
public static String desdecrypt(String IV_PARAMETER, 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("DES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes("utf-8"));
cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
String str = new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes("utf-8"))), "utf-8");
System.out.println("对称之DES解密之后的字符串："+ str);
return str;
} catch (Exception e) {
e.printStackTrace();
return data;
}
}**【对称之DES小 demo】
String afterdes = desencrypt("123asd45","qweqeqoieqeoiqeoiqoieqoie", str);
desdecrypt("123asd45","qweqeqoieqeoiqeoiqoieqoie", afterdes);
【对称之3DES加密解密】
为解决DES存在的问题，出现了3DES，也称为Triple DES。3DES为DES向AES过度的加密算法，它使用3条56位的密钥对数据进行三次加密。为了兼容普通的DES，3DES并没有直接使用 加密->加密->加密 的方式，而是采用了加密->解密->加密 的方式。
【3DES加密】
/**
* 获取key
* @param key
* @return
*/
public static byte[] hex(String key){
String f = DigestUtils.md5Hex(key);
byte[] bkeys = new String(f).getBytes();
byte[] enk = new byte[24];
for (int i=0;i<24;i++){
enk[i] = bkeys[i];
}
return enk;
}
/**
* 3DES加密
* @param key 密钥
* @param srcStr 需要加密的字符串
* @return
*/
public static String encode3Des(String key, String srcStr){
byte[] keybyte = hex(key);
byte[] src = srcStr.getBytes();
try {
//生成密钥
SecretKey deskey = new SecretKeySpec(keybyte, "DESede");
//加密
Cipher c1 = Cipher.getInstance("DESede");
c1.init(Cipher.ENCRYPT_MODE, deskey);
String pwd = (new BASE64Encoder()).encodeBuffer(c1.doFinal(src));
System.out.println("对称之3DES加密后的字符串："+pwd);
return pwd;
}catch(Exception e){
e.printStackTrace();
}
return null;
}【3DES解密】
/**
* 3DES解密
* @param key 加密密钥
* @param desStr 需要解密的字符串
* @return
*/
public static String decode3Des(String key, String desStr){
byte[] keybyte = hex(key);
try {
byte[] src = (new BASE64Decoder()).decodeBuffer(desStr);
//生成密钥
SecretKey deskey = new SecretKeySpec(keybyte, "DESede");
//解密
Cipher c1 = Cipher.getInstance("DESede");
c1.init(Cipher.DECRYPT_MODE, deskey);
String pwd = new String(c1.doFinal(src));
System.out.print("对称之3DES解密后的字符串："+pwd);
return pwd;
}catch(Exception e){
e.printStackTrace();
}
return null;
}【对称之3DES小 demo】
//key，随便写，怎么写都是对的
String after3des = encode3Des("1qwew", str);
decode3Des("1qwew", after3des);
原文地址：https://blog.51cto.com/13479739/2484361
时间： 2024-10-24 19:08:56