几种常见的加密算法

墨蓝 2023-06-29 13:58 121阅读 0赞

#  一、概念 #

[数据加密][Link 1]的基本过程就是对原来为明文的文件或数据按某种[算法][Link 2]进行处理，使其成为不可读的一段代码为“密文”，使其只能在输入相应的[密钥][Link 3]之后才能显示出原容，通过这样的途径来达到保护数据不被非法人窃取、阅读的目的。 该过程的逆过程为解密，即将该[编码][Link 4]信息转化为其原来数据的过程。

简单来说，就是把某一段数据（明文），按照“某种规则”转换成另外一段不可读的数据（密文）。这里选定的“规则”，就是加密算法。理所当然，当别人拿到“密文”，解析出“明文”的难度取决于加密算法的破解难度。

# 二、几种常见的加密算法 #

##   1、Base64算法 ##

原码

/**
     *  Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一。
     */
    public class Base64Util {
    
        /*
            我们知道Java中是用"8个二进制数字"表示一个实际的字节。
            比如：我要用Base64编码一个字符串“abc”，实际算法如下：
            'a','b','c'的ASCII标准编码分别为（十进制）97,98,99,因此用二进制表示“abc”字符串就是：
            01100001，01100010，01100011           ---3组，每组8字节
            Base64的原理：将这三组8字节，分成4组6字节
            011000，010110， 001001，100011         ---4组，每组6字节
            高位补0
            00011000，00010110， 00001001，00100011
            这四个二进制数组对应十进制的数值分别是：24，22，9，35，RFC2045（Base64解码表）分别为：Y,W,J,j
            即："abc"经过Base64编码后，为"YWJj"。这个过程是可逆的。
            ---每次Base64编码都会扩容33%
         */
    
        /**
         * Base64编码
         * @param message 待Base64编码的字符串
         * @return 编码后的字符串
         */
        public static String encode(String message){
            if (message == null){
                return null;
            }
            byte[] bytes = message.getBytes();
            byte[] result = Base64.encodeBase64(bytes);
            return new String(result);
        }
    
        /**
         * Base64解码
         * @param message 待Base64解码的字符串
         * @return 解码后的字符串
         */
        public static String decode(String message){
            if (message == null){
                return null;
            }
            byte[] bytes = message.getBytes();
            byte[] result = Base64.decodeBase64(bytes);
            return new String(result);
        }
    }

例子：

public class Base64Test {
        public static void main(String[] args){
            String str  = "1234" ;
            System.out.println("加密前: " + str );
            String str1=  Base64Util.encodeToString(str);
            System.out.println("加密后: " + str1 );
            String str2 = Base64Util.decodeToString(str1);
            System.out.println(" 解密后 " +str2);
        }
    }

![20200113102813760.png][]

特点：

1、将数据按照 3个字节一组的形式进行处理，每三个字节在编码之后被转换为4个字节。

即：如果一个数据有6个字节，可编码后将包含6/3\*4=8个字节

2、当数据的长度无法满足3的倍数的情况下，最后的数据需要进行填充操作，即补“=” ，这里“=”是填充字符，不要理解为第65个字符

Base64算法的实现原理是公开的（工具类源码中有解释），对于开发人员来说，拿到密文，很容易就能够解析成明文。因此严格来说，Base64不能称之为加密算法，仅仅是一种编码方式。它常常用于发送Http请求时对URL中参数的编码，保证不是一眼就看出来了这些参数的意义。

## 2、MD5算法 ##

原理

MD5算法的原理可简要的叙述为：MD5码以512位分组来处理输入的信息，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位[散列值][Link 5]。

MD5算法总结  
MD5,是一种信息摘要算法。简单来说，就是把一段信息（明文），通过一种有损的方式压缩成定长的字符（32位密文）。因为这种压缩方式是会损失信息的，所以是无法还原出“明文”的。虽然无法从数学上破解MD5算法，但由于现在计算机具备强大的计算能力，还是可以通过“穷举法”破解该算法。如果想用该算法加密，还可以通过“加盐”的方式提高解密难度。该算法允许多传一个参数"salt",指定通过MD5加密的次数，这样是能够提高解密难度的。

应用场景

**   用于密码管理、电子签名、**

## SHA算法 ##

public class SHAUtil {
        /*
            SHA与MD5均有MD4导出，因此强度和特性比较相似的，都是不可逆的算法。
            SHA与MD5的不同：
            1.对强行攻击的安全性，SHA-1摘要比MD5摘长，对强行攻击有更大的强度。
            2.对密码分析的安全性，由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这样的攻击。
            3.在相同的硬件上，SHA-1的运行速度比MD5慢。
         */
    
        /**
         * SHA加密，即安全散列算法加密
         * @param bytes 要加密的信息
         * @return 40位字符
         */
        public static String encrypt(byte[] bytes){
            try {
                MessageDigest messageDigest = MessageDigest.getInstance("SHA");
                byte[] resultBytes = messageDigest.digest(bytes);
                return Hex.encodeHexString(resultBytes);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy_size_16_color_FFFFFF_t_70][]

**   安全散列算法**（英语：Secure Hash Algorithm，缩写为SHA）是一个[密码散列函数][Link 6]家族，是[FIPS][]所认证的安全[散列算法][Link 7]。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。

SHA家族的五个算法，分别是[SHA-1][]、SHA-224、SHA-256、SHA-384，和SHA-512，由[美国国家安全局][Link 8]（NSA）所设计，并由美国国家标准与技术研究院（NIST）发布；是美国的政府标准。后四者有时并称为SHA-2。SHA-1在许多安全协定中广为使用，包括[TLS][]和[SSL][]、[PGP][]、[SSH][]、S/MIME和IPsec，曾被视为是[MD5][]（更早之前被广为使用的杂凑函数）的后继者。但SHA-1的安全性如今被密码学家严重质疑；虽然至今尚未出现对SHA-2有效的攻击，它的算法跟SHA-1基本上仍然相似；因此有些人开始发展其他替代的杂凑算法。 \[1\]

总结

SHA，安全散列算法。与MD5算法的特点是一致的，不过生成的密文长度是40位，因此更难破解。

## AES算法 ##

AES技术是一种对称的分组加密技术，使用128位分组加密数据，提供比WEP/TKIPS的RC4算法更高的加密强度。AES的加密码表和解密码表是分开的，并且支持子密钥加密，这种做法优于以前用一个特殊的密钥解密的做法。AES算法支持任意分组大小，初始时间快。特别是它具有的并行性可以有效地利用处理器资源。

AES具有应用范围广、等待时间短、相对容易隐藏、吞吐量高等优点，在性能等各方面都优于WEP算法。利用此算法加密，WLAN的安全性将会获得大幅度提高。AES算法已经在802.11i标准中得到最终确认，成为取代WEP的新一代的加密算法。但是由于AES算法对硬件要求比较高，因此AES无法通过在原有设备上升级固件实现，必须重新设计芯片

源码

import org.apache.commons.codec.binary.Base64;
    import org.springframework.util.StringUtils;
    import sun.security.provider.SecureRandom;
    
    import javax.crypto.*;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    /**
     * @ClassName AESUtil
     * @Description TODO
     * @Date 2020/1/13/01311:24
     * @Version 1.0
     **/
    public class AESUtil {
         /*
            AES加密算法作为新一代的数据加密标准汇聚了强安全性、高性能、高效率、易用和灵活等优点。
            AES设计有三个密钥长度：128，192，256 位。
            相对而言，AES的128密钥比DES的56密钥强了1021倍
         */
    
        /**
         * 用户自定义的密钥，由前后端协商确定
         * ！！！（不应该在加解密方法的参数中暴露），AES的安全性，取决于密钥的安全性。
         */
        private static final String KEY = "agdfscxcvz";
        /**
         * AES:算法，ECB:模式，PKCS5Padding:补码方式
         */
        private static final String ALGORITHM = "AES/ECB/PKCS5Padding";
    
        /**
         * AES加密
         * @param message 要加密的信息
         * @return 加密后的字符串
         */
        public static String encrypt(String message){
            return doAES(message,KEY, Cipher.ENCRYPT_MODE);
        }
    
        /**
         * AES解密
         * @param message 要解密的信息
         * @return 解密后的字符串
         */
        public static String decrypt(String message){
            return doAES(message,KEY,Cipher.DECRYPT_MODE);
        }
    
        /**
         * 加密或解密的实际操作过程
         * @param message 待处理的信息
         * @param key AES加解密过程需要的密钥
         * @param mode 加解密mode
         * @return 加密或解密后的信息
         */
        private static String doAES(String message,String key, int mode){
            try {
                if (StringUtils.isBlank(message) || StringUtils.isBlank(key)){
                    return null;
                }
                // 由于AES算法要求密钥的长度为16的倍数，（1,2,3,4）步的目的: 把用户自定义的密钥替换成16位的密钥
    
                // 1. 构造密钥生成器，指定为AES算法
                KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
                // 2. 根据用户自定义密钥对应的字节数组，生成一个128位的随机源（只能是128 or 192 or 256中的一个）
                keyGenerator.init(128, new SecureRandom(key.getBytes()));
                // 3. 生成AES算法的原始对称密钥
                SecretKey secretKey = keyGenerator.generateKey();
                // 4. 获取原始对称密钥的字节数组
                byte[] enCodeFormat = secretKey.getEncoded();
    
                // 5. 根据字节数组生成AES密钥
                SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat,"AES");
                // 6.根据指定算法AES自成密码器
                Cipher cipher = Cipher.getInstance(ALGORITHM);
                // 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
                cipher.init(mode, secretKeySpec);
    
                if (mode == Cipher.ENCRYPT_MODE) {
                    byte[] content = message.getBytes();
                    byte[] result = cipher.doFinal(content);
                    // !!! 加密，AES加密后的结果默认是Base64格式的字节数组
                    return Base64.encodeBase64String(result);
                } else {
                    byte[] content = Base64.decodeBase64(message);
                    byte[] result = cipher.doFinal(content);
                    return new String(result);
                }
            } catch (NoSuchAlgorithmException | BadPaddingException | IllegalBlockSizeException | NoSuchPaddingException | InvalidKeyException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

测试效果如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy_size_16_color_FFFFFF_t_70 1][]

总结

AES，高级加密标准，对称算法。它的原理是：加密方和解密方保有同一个16位长的密钥，使用AES算法加解密时需要传入该密钥参数，通过Java实现AES算法提供的工具包加密后返回的是一个Base64格式的字节数组。因此为保证密文“可读性”，需要在加密后对密文进行Base64编码，解密前进行Base64解码成密文。AES算法的安全性，取决于密钥的安全性。因此一定不要在加解密的URL中传入该密钥参数，不然没有意义。一般的做法是：前后端协商好密钥，或者通过不对称加密的方式传递密钥。

## RSA算法 ##

源码

package com.common;/**
     * Created by Administrator on 2020/1/13/013.
     */
    
    import org.apache.commons.codec.binary.Hex;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @ClassName RSAUtil
     * @Description TODO
     * @Author yb
     * @Date 2020/1/13/01314:25
     * @Version 1.0
     **/
    public class RSAUtil {
        /*
            RSA算法，需要两个密钥来进行加密和解密，分别是公钥和私钥。
            需要注意的一点，这个公钥和私钥必须是一对的，如果用公钥对数据进行加密，那么只有使用对应的私钥才能解密，反之亦然。
            由于加密和解密使用的是两个不同的密钥，因此，这种算法叫做非对称加密算法。
    
            其算法具体实现基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。
         */
    //
    //    private static RSAPublicKey rsaPublicKey;
    //    private static RSAPrivateKey rsaPrivateKey;
    
        public static Map<String,Object> generateKey(){
            try {
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                // ‘512’，表示生成的是128位字符
                keyPairGenerator.initialize(512);
                KeyPair keyPair = keyPairGenerator.generateKeyPair();
                RSAPublicKey rsaPublicKey = (RSAPublicKey)keyPair.getPublic();
                RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
                Map<String,Object> keyPairs = new HashMap<>();
                keyPairs.put("publicKey",rsaPublicKey);
                keyPairs.put("privateKey",rsaPrivateKey);
                return keyPairs;
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * RSA私钥加密
         * @param message 要加密的信息
         * @return 加密后的字符串
         */
        public static String encrypt(String message, RSAPrivateKey rsaPrivateKey){
            try {
                PKCS8EncodedKeySpec pkcs8EncodedKeySpec
                        = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                byte[] resultBytes = cipher.doFinal(message.getBytes());
                return Hex.encodeHexString(resultBytes);
            } catch (NoSuchAlgorithmException | InvalidKeySpecException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * RSA公钥解密
         * @param message 要解密的信息
         * @return 解密后的字符串
         */
        public static String decrypt(String message, RSAPublicKey rsaPublicKey){
            try {
                X509EncodedKeySpec x509EncodedKeySpec =
                        new X509EncodedKeySpec(rsaPublicKey.getEncoded());
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                byte[] resultBytes = cipher.doFinal(Hex.decodeHex(message.toCharArray()));
                return new String(resultBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy_size_16_color_FFFFFF_t_70 2][]

总结

RSA算法，是一种非常常用的不对称加密算法。不对称加密算法指的是：需要两个密钥来进行加密和解密，分别是公钥和私钥（公钥和私钥必须是一对）。其算法具体实现基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

java-web项目使用RSA算法加密的场景再现：

为每个客户(User)生成一对密钥(keyPairs)，  
将公钥(publicKey)通过URL接口向前端公开，私钥(userId:privateKey)保存在数据库或redis中，  
然后前端客户可以通过公钥加密自己的信息（前端用JS进行RSA公钥加密），后端通过该用户对应的私钥解析出用户信息(后端用Java进行RSA私钥解密)，再将用户信息保存在数据库。  
这样能够防止HTTP被劫持导致用户信息被泄露

[Link 1]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%8A%A0%E5%AF%86/11048982
[Link 2]: https://baike.baidu.com/item/%E7%AE%97%E6%B3%95/209025
[Link 3]: https://baike.baidu.com/item/%E5%AF%86%E9%92%A5/101144
[Link 4]: https://baike.baidu.com/item/%E7%BC%96%E7%A0%81/80092
[20200113102813760.png]: https://img-blog.csdnimg.cn/20200113102813760.png
[Link 5]: https://baike.baidu.com/item/%E6%95%A3%E5%88%97%E5%80%BC/10398613
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200113111152337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy,size_16,color_FFFFFF,t_70
[Link 6]: https://baike.baidu.com/item/%E5%AF%86%E7%A0%81%E6%95%A3%E5%88%97%E5%87%BD%E6%95%B0
[FIPS]: https://baike.baidu.com/item/FIPS
[Link 7]: https://baike.baidu.com/item/%E6%95%A3%E5%88%97%E7%AE%97%E6%B3%95
[SHA-1]: https://baike.baidu.com/item/SHA-1
[Link 8]: https://baike.baidu.com/item/%E7%BE%8E%E5%9B%BD%E5%9B%BD%E5%AE%B6%E5%AE%89%E5%85%A8%E5%B1%80
[TLS]: https://baike.baidu.com/item/TLS
[SSL]: https://baike.baidu.com/item/SSL
[PGP]: https://baike.baidu.com/item/PGP
[SSH]: https://baike.baidu.com/item/SSH
[MD5]: https://baike.baidu.com/item/MD5
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200113112847990.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200113144310523.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3liNTQ2ODIyNjEy,size_16,color_FFFFFF,t_70