13种加密与解密算法【一】

二次信任 提交于 2020-04-04 12:57:47

这15种加密解密算法分别是:散列哈希[MD5、SHA1、CRC32],对称[DES,3DES(TDEA、Triple DES),AES、,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));
}

13种加密与解密算法【一】

【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);
        }

13种加密与解密算法【一】

【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;
        }

13种加密与解密算法【一】
【对称之AES小 demo】

        String rule = "genzhe ganjuezou yongyuanbuhuitou";
        String afteraes = AESEncode(str, rule);
        AESDncode(rule, afteraes);

13种加密与解密算法【一】

【4、对称之DES加密解密】

【原理】DES使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的分组密码,使用称为 Feistel 的技术,其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能,然后将输出与另一半进行"异或"运算;接着交换这两半,这一过程会继续下去,但最后一个循环不交换。DES 使用 16 个循环,使用异或,置换,代换,移位操作四种基本运算。
13种加密与解密算法【一】
【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);

13种加密与解密算法【一】

【对称之3DES加密解密】

为解决DES存在的问题,出现了3DES,也称为Triple DES。3DES为DES向AES过度的加密算法,它使用3条56位的密钥对数据进行三次加密。为了兼容普通的DES,3DES并没有直接使用 加密->加密->加密 的方式,而是采用了加密->解密->加密 的方式。
13种加密与解密算法【一】
【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);

13种加密与解密算法【一】

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!