15种加密与解密算法

Posted 2020-11-28

这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);